henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * libjingle |
jlmiller@webrtc.org | 5f93d0a | 2015-01-20 21:36:13 +0000 | [diff] [blame] | 3 | * Copyright 2012 Google Inc. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions are met: |
| 7 | * |
| 8 | * 1. Redistributions of source code must retain the above copyright notice, |
| 9 | * this list of conditions and the following disclaimer. |
| 10 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
| 11 | * this list of conditions and the following disclaimer in the documentation |
| 12 | * and/or other materials provided with the distribution. |
| 13 | * 3. The name of the author may not be used to endorse or promote products |
| 14 | * derived from this software without specific prior written permission. |
| 15 | * |
| 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| 17 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| 18 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| 19 | * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 20 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| 21 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| 22 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| 23 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| 24 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| 25 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | */ |
| 27 | |
| 28 | #include "talk/app/webrtc/statscollector.h" |
| 29 | |
| 30 | #include <utility> |
| 31 | #include <vector> |
| 32 | |
buildbot@webrtc.org | a09a999 | 2014-08-13 17:26:08 +0000 | [diff] [blame] | 33 | #include "talk/session/media/channel.h" |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 34 | #include "webrtc/base/base64.h" |
| 35 | #include "webrtc/base/scoped_ptr.h" |
| 36 | #include "webrtc/base/timing.h" |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 37 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 38 | using rtc::scoped_ptr; |
| 39 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 40 | namespace webrtc { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 41 | namespace { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 42 | |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 43 | // The following is the enum RTCStatsIceCandidateType from |
| 44 | // http://w3c.github.io/webrtc-stats/#rtcstatsicecandidatetype-enum such that |
| 45 | // our stats report for ice candidate type could conform to that. |
| 46 | const char STATSREPORT_LOCAL_PORT_TYPE[] = "host"; |
| 47 | const char STATSREPORT_STUN_PORT_TYPE[] = "serverreflexive"; |
| 48 | const char STATSREPORT_PRFLX_PORT_TYPE[] = "peerreflexive"; |
| 49 | const char STATSREPORT_RELAY_PORT_TYPE[] = "relayed"; |
| 50 | |
| 51 | // Strings used by the stats collector to report adapter types. This fits the |
| 52 | // general stype of http://w3c.github.io/webrtc-stats than what |
| 53 | // AdapterTypeToString does. |
| 54 | const char* STATSREPORT_ADAPTER_TYPE_ETHERNET = "lan"; |
| 55 | const char* STATSREPORT_ADAPTER_TYPE_WIFI = "wlan"; |
| 56 | const char* STATSREPORT_ADAPTER_TYPE_WWAN = "wwan"; |
| 57 | const char* STATSREPORT_ADAPTER_TYPE_VPN = "vpn"; |
phoglund@webrtc.org | 006521d | 2015-02-12 09:23:59 +0000 | [diff] [blame^] | 58 | const char* STATSREPORT_ADAPTER_TYPE_LOOPBACK = "loopback"; |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 59 | |
tommi@webrtc.org | 4721895 | 2014-07-15 19:22:37 +0000 | [diff] [blame] | 60 | bool GetTransportIdFromProxy(const cricket::ProxyTransportMap& map, |
| 61 | const std::string& proxy, |
| 62 | std::string* transport) { |
| 63 | // TODO(hta): Remove handling of empty proxy name once tests do not use it. |
| 64 | if (proxy.empty()) { |
| 65 | transport->clear(); |
| 66 | return true; |
| 67 | } |
| 68 | |
| 69 | cricket::ProxyTransportMap::const_iterator found = map.find(proxy); |
| 70 | if (found == map.end()) { |
| 71 | LOG(LS_ERROR) << "No transport ID mapping for " << proxy; |
| 72 | return false; |
| 73 | } |
| 74 | |
tommi@webrtc.org | 4721895 | 2014-07-15 19:22:37 +0000 | [diff] [blame] | 75 | // Component 1 is always used for RTP. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 76 | scoped_ptr<StatsReport::Id> id( |
| 77 | StatsReport::NewComponentId(found->second, 1)); |
| 78 | // TODO(tommi): Should |transport| simply be of type StatsReport::Id? |
| 79 | // When we support more value types than string (e.g. int, double, vector etc) |
| 80 | // we should also support a value type for Id. |
| 81 | *transport = id->ToString(); |
tommi@webrtc.org | 4721895 | 2014-07-15 19:22:37 +0000 | [diff] [blame] | 82 | return true; |
| 83 | } |
| 84 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 85 | void AddTrackReport(StatsCollection* reports, const std::string& track_id) { |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 86 | // Adds an empty track report. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 87 | rtc::scoped_ptr<StatsReport::Id> id( |
| 88 | StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack, track_id)); |
| 89 | StatsReport* report = reports->ReplaceOrAddNew(id.Pass()); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 90 | report->AddValue(StatsReport::kStatsValueNameTrackId, track_id); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 91 | } |
| 92 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 93 | template <class TrackVector> |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 94 | void CreateTrackReports(const TrackVector& tracks, StatsCollection* reports) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 95 | for (size_t j = 0; j < tracks.size(); ++j) { |
| 96 | webrtc::MediaStreamTrackInterface* track = tracks[j]; |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 97 | AddTrackReport(reports, track->id()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 98 | } |
| 99 | } |
| 100 | |
| 101 | void ExtractStats(const cricket::VoiceReceiverInfo& info, StatsReport* report) { |
| 102 | report->AddValue(StatsReport::kStatsValueNameAudioOutputLevel, |
| 103 | info.audio_level); |
| 104 | report->AddValue(StatsReport::kStatsValueNameBytesReceived, |
| 105 | info.bytes_rcvd); |
| 106 | report->AddValue(StatsReport::kStatsValueNameJitterReceived, |
| 107 | info.jitter_ms); |
jiayl@webrtc.org | 11aab0e | 2014-03-07 18:56:26 +0000 | [diff] [blame] | 108 | report->AddValue(StatsReport::kStatsValueNameJitterBufferMs, |
| 109 | info.jitter_buffer_ms); |
| 110 | report->AddValue(StatsReport::kStatsValueNamePreferredJitterBufferMs, |
| 111 | info.jitter_buffer_preferred_ms); |
| 112 | report->AddValue(StatsReport::kStatsValueNameCurrentDelayMs, |
| 113 | info.delay_estimate_ms); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 114 | report->AddValue(StatsReport::kStatsValueNameExpandRate, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 115 | rtc::ToString<float>(info.expand_rate)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 116 | report->AddValue(StatsReport::kStatsValueNamePacketsReceived, |
| 117 | info.packets_rcvd); |
| 118 | report->AddValue(StatsReport::kStatsValueNamePacketsLost, |
| 119 | info.packets_lost); |
buildbot@webrtc.org | 3e01e0b | 2014-05-13 17:54:10 +0000 | [diff] [blame] | 120 | report->AddValue(StatsReport::kStatsValueNameDecodingCTSG, |
| 121 | info.decoding_calls_to_silence_generator); |
| 122 | report->AddValue(StatsReport::kStatsValueNameDecodingCTN, |
| 123 | info.decoding_calls_to_neteq); |
| 124 | report->AddValue(StatsReport::kStatsValueNameDecodingNormal, |
| 125 | info.decoding_normal); |
| 126 | report->AddValue(StatsReport::kStatsValueNameDecodingPLC, |
| 127 | info.decoding_plc); |
| 128 | report->AddValue(StatsReport::kStatsValueNameDecodingCNG, |
| 129 | info.decoding_cng); |
| 130 | report->AddValue(StatsReport::kStatsValueNameDecodingPLCCNG, |
| 131 | info.decoding_plc_cng); |
buildbot@webrtc.org | b525a9d | 2014-06-03 09:42:15 +0000 | [diff] [blame] | 132 | report->AddValue(StatsReport::kStatsValueNameCaptureStartNtpTimeMs, |
| 133 | info.capture_start_ntp_time_ms); |
buildbot@webrtc.org | 7e71b77 | 2014-06-13 01:14:01 +0000 | [diff] [blame] | 134 | report->AddValue(StatsReport::kStatsValueNameCodecName, info.codec_name); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | void ExtractStats(const cricket::VoiceSenderInfo& info, StatsReport* report) { |
| 138 | report->AddValue(StatsReport::kStatsValueNameAudioInputLevel, |
| 139 | info.audio_level); |
| 140 | report->AddValue(StatsReport::kStatsValueNameBytesSent, |
| 141 | info.bytes_sent); |
| 142 | report->AddValue(StatsReport::kStatsValueNamePacketsSent, |
| 143 | info.packets_sent); |
henrike@webrtc.org | ffe2620 | 2014-03-19 22:20:10 +0000 | [diff] [blame] | 144 | report->AddValue(StatsReport::kStatsValueNamePacketsLost, |
| 145 | info.packets_lost); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 146 | report->AddValue(StatsReport::kStatsValueNameJitterReceived, |
| 147 | info.jitter_ms); |
| 148 | report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt_ms); |
| 149 | report->AddValue(StatsReport::kStatsValueNameEchoCancellationQualityMin, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 150 | rtc::ToString<float>(info.aec_quality_min)); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 151 | report->AddValue(StatsReport::kStatsValueNameEchoDelayMedian, |
| 152 | info.echo_delay_median_ms); |
| 153 | report->AddValue(StatsReport::kStatsValueNameEchoDelayStdDev, |
| 154 | info.echo_delay_std_ms); |
| 155 | report->AddValue(StatsReport::kStatsValueNameEchoReturnLoss, |
| 156 | info.echo_return_loss); |
| 157 | report->AddValue(StatsReport::kStatsValueNameEchoReturnLossEnhancement, |
| 158 | info.echo_return_loss_enhancement); |
| 159 | report->AddValue(StatsReport::kStatsValueNameCodecName, info.codec_name); |
wu@webrtc.org | 967bfff | 2013-09-19 05:49:50 +0000 | [diff] [blame] | 160 | report->AddBoolean(StatsReport::kStatsValueNameTypingNoiseState, |
| 161 | info.typing_noise_detected); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 162 | } |
| 163 | |
| 164 | void ExtractStats(const cricket::VideoReceiverInfo& info, StatsReport* report) { |
| 165 | report->AddValue(StatsReport::kStatsValueNameBytesReceived, |
| 166 | info.bytes_rcvd); |
| 167 | report->AddValue(StatsReport::kStatsValueNamePacketsReceived, |
| 168 | info.packets_rcvd); |
| 169 | report->AddValue(StatsReport::kStatsValueNamePacketsLost, |
| 170 | info.packets_lost); |
| 171 | |
| 172 | report->AddValue(StatsReport::kStatsValueNameFirsSent, |
| 173 | info.firs_sent); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 174 | report->AddValue(StatsReport::kStatsValueNamePlisSent, |
| 175 | info.plis_sent); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 176 | report->AddValue(StatsReport::kStatsValueNameNacksSent, |
| 177 | info.nacks_sent); |
| 178 | report->AddValue(StatsReport::kStatsValueNameFrameWidthReceived, |
| 179 | info.frame_width); |
| 180 | report->AddValue(StatsReport::kStatsValueNameFrameHeightReceived, |
| 181 | info.frame_height); |
| 182 | report->AddValue(StatsReport::kStatsValueNameFrameRateReceived, |
| 183 | info.framerate_rcvd); |
| 184 | report->AddValue(StatsReport::kStatsValueNameFrameRateDecoded, |
| 185 | info.framerate_decoded); |
| 186 | report->AddValue(StatsReport::kStatsValueNameFrameRateOutput, |
| 187 | info.framerate_output); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 188 | |
| 189 | report->AddValue(StatsReport::kStatsValueNameDecodeMs, |
| 190 | info.decode_ms); |
| 191 | report->AddValue(StatsReport::kStatsValueNameMaxDecodeMs, |
| 192 | info.max_decode_ms); |
| 193 | report->AddValue(StatsReport::kStatsValueNameCurrentDelayMs, |
| 194 | info.current_delay_ms); |
| 195 | report->AddValue(StatsReport::kStatsValueNameTargetDelayMs, |
| 196 | info.target_delay_ms); |
| 197 | report->AddValue(StatsReport::kStatsValueNameJitterBufferMs, |
| 198 | info.jitter_buffer_ms); |
| 199 | report->AddValue(StatsReport::kStatsValueNameMinPlayoutDelayMs, |
| 200 | info.min_playout_delay_ms); |
| 201 | report->AddValue(StatsReport::kStatsValueNameRenderDelayMs, |
| 202 | info.render_delay_ms); |
buildbot@webrtc.org | 0581f0b | 2014-05-06 21:36:31 +0000 | [diff] [blame] | 203 | |
| 204 | report->AddValue(StatsReport::kStatsValueNameCaptureStartNtpTimeMs, |
| 205 | info.capture_start_ntp_time_ms); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | void ExtractStats(const cricket::VideoSenderInfo& info, StatsReport* report) { |
| 209 | report->AddValue(StatsReport::kStatsValueNameBytesSent, |
| 210 | info.bytes_sent); |
| 211 | report->AddValue(StatsReport::kStatsValueNamePacketsSent, |
| 212 | info.packets_sent); |
henrike@webrtc.org | ffe2620 | 2014-03-19 22:20:10 +0000 | [diff] [blame] | 213 | report->AddValue(StatsReport::kStatsValueNamePacketsLost, |
| 214 | info.packets_lost); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 215 | |
| 216 | report->AddValue(StatsReport::kStatsValueNameFirsReceived, |
| 217 | info.firs_rcvd); |
henrike@webrtc.org | 704bf9e | 2014-02-27 17:52:04 +0000 | [diff] [blame] | 218 | report->AddValue(StatsReport::kStatsValueNamePlisReceived, |
| 219 | info.plis_rcvd); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 220 | report->AddValue(StatsReport::kStatsValueNameNacksReceived, |
| 221 | info.nacks_rcvd); |
wu@webrtc.org | 987f2c9 | 2014-03-28 16:22:19 +0000 | [diff] [blame] | 222 | report->AddValue(StatsReport::kStatsValueNameFrameWidthInput, |
| 223 | info.input_frame_width); |
| 224 | report->AddValue(StatsReport::kStatsValueNameFrameHeightInput, |
| 225 | info.input_frame_height); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 226 | report->AddValue(StatsReport::kStatsValueNameFrameWidthSent, |
wu@webrtc.org | 987f2c9 | 2014-03-28 16:22:19 +0000 | [diff] [blame] | 227 | info.send_frame_width); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 228 | report->AddValue(StatsReport::kStatsValueNameFrameHeightSent, |
wu@webrtc.org | 987f2c9 | 2014-03-28 16:22:19 +0000 | [diff] [blame] | 229 | info.send_frame_height); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 230 | report->AddValue(StatsReport::kStatsValueNameFrameRateInput, |
| 231 | info.framerate_input); |
| 232 | report->AddValue(StatsReport::kStatsValueNameFrameRateSent, |
| 233 | info.framerate_sent); |
| 234 | report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt_ms); |
| 235 | report->AddValue(StatsReport::kStatsValueNameCodecName, info.codec_name); |
mallinath@webrtc.org | 62451dc | 2013-12-13 12:29:34 +0000 | [diff] [blame] | 236 | report->AddBoolean(StatsReport::kStatsValueNameCpuLimitedResolution, |
| 237 | (info.adapt_reason & 0x1) > 0); |
| 238 | report->AddBoolean(StatsReport::kStatsValueNameBandwidthLimitedResolution, |
| 239 | (info.adapt_reason & 0x2) > 0); |
| 240 | report->AddBoolean(StatsReport::kStatsValueNameViewLimitedResolution, |
| 241 | (info.adapt_reason & 0x4) > 0); |
buildbot@webrtc.org | 71dffb7 | 2014-06-24 07:24:49 +0000 | [diff] [blame] | 242 | report->AddValue(StatsReport::kStatsValueNameAdaptationChanges, |
| 243 | info.adapt_changes); |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 +0000 | [diff] [blame] | 244 | report->AddValue(StatsReport::kStatsValueNameAvgEncodeMs, info.avg_encode_ms); |
| 245 | report->AddValue(StatsReport::kStatsValueNameCaptureJitterMs, |
| 246 | info.capture_jitter_ms); |
wu@webrtc.org | 9caf276 | 2013-12-11 18:25:07 +0000 | [diff] [blame] | 247 | report->AddValue(StatsReport::kStatsValueNameCaptureQueueDelayMsPerS, |
| 248 | info.capture_queue_delay_ms_per_s); |
| 249 | report->AddValue(StatsReport::kStatsValueNameEncodeUsagePercent, |
| 250 | info.encode_usage_percent); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 251 | } |
| 252 | |
| 253 | void ExtractStats(const cricket::BandwidthEstimationInfo& info, |
| 254 | double stats_gathering_started, |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 255 | PeerConnectionInterface::StatsOutputLevel level, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 256 | StatsReport* report) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 257 | ASSERT(report->type() == StatsReport::kStatsReportTypeBwe); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 258 | |
| 259 | // Clear out stats from previous GatherStats calls if any. |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 260 | if (report->timestamp() != stats_gathering_started) { |
| 261 | report->ResetValues(); |
| 262 | report->set_timestamp(stats_gathering_started); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 263 | } |
| 264 | |
| 265 | report->AddValue(StatsReport::kStatsValueNameAvailableSendBandwidth, |
| 266 | info.available_send_bandwidth); |
| 267 | report->AddValue(StatsReport::kStatsValueNameAvailableReceiveBandwidth, |
| 268 | info.available_recv_bandwidth); |
| 269 | report->AddValue(StatsReport::kStatsValueNameTargetEncBitrate, |
| 270 | info.target_enc_bitrate); |
| 271 | report->AddValue(StatsReport::kStatsValueNameActualEncBitrate, |
| 272 | info.actual_enc_bitrate); |
| 273 | report->AddValue(StatsReport::kStatsValueNameRetransmitBitrate, |
| 274 | info.retransmit_bitrate); |
| 275 | report->AddValue(StatsReport::kStatsValueNameTransmitBitrate, |
| 276 | info.transmit_bitrate); |
| 277 | report->AddValue(StatsReport::kStatsValueNameBucketDelay, |
| 278 | info.bucket_delay); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 279 | if (level >= PeerConnectionInterface::kStatsOutputLevelDebug) { |
| 280 | report->AddValue( |
| 281 | StatsReport::kStatsValueNameRecvPacketGroupPropagationDeltaSumDebug, |
| 282 | info.total_received_propagation_delta_ms); |
| 283 | if (info.recent_received_propagation_delta_ms.size() > 0) { |
| 284 | report->AddValue( |
| 285 | StatsReport::kStatsValueNameRecvPacketGroupPropagationDeltaDebug, |
| 286 | info.recent_received_propagation_delta_ms); |
| 287 | report->AddValue( |
| 288 | StatsReport::kStatsValueNameRecvPacketGroupArrivalTimeDebug, |
| 289 | info.recent_received_packet_group_arrival_time_ms); |
| 290 | } |
| 291 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 292 | } |
| 293 | |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 294 | void ExtractRemoteStats(const cricket::MediaSenderInfo& info, |
| 295 | StatsReport* report) { |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 296 | report->set_timestamp(info.remote_stats[0].timestamp); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 297 | // TODO(hta): Extract some stats here. |
| 298 | } |
| 299 | |
| 300 | void ExtractRemoteStats(const cricket::MediaReceiverInfo& info, |
| 301 | StatsReport* report) { |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 302 | report->set_timestamp(info.remote_stats[0].timestamp); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 303 | // TODO(hta): Extract some stats here. |
| 304 | } |
| 305 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 306 | // Template to extract stats from a data vector. |
sergeyu@chromium.org | 5bc25c4 | 2013-12-05 00:24:06 +0000 | [diff] [blame] | 307 | // In order to use the template, the functions that are called from it, |
| 308 | // ExtractStats and ExtractRemoteStats, must be defined and overloaded |
| 309 | // for each type. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 310 | template<typename T> |
| 311 | void ExtractStatsFromList(const std::vector<T>& data, |
| 312 | const std::string& transport_id, |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 313 | StatsCollector* collector, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 314 | StatsReport::Direction direction) { |
| 315 | for (const auto& d : data) { |
| 316 | uint32 ssrc = d.ssrc(); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 317 | // Each track can have stats for both local and remote objects. |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 318 | // TODO(hta): Handle the case of multiple SSRCs per object. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 319 | StatsReport* report = collector->PrepareReport(true, ssrc, transport_id, |
| 320 | direction); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 321 | if (report) |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 322 | ExtractStats(d, report); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 323 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 324 | if (!d.remote_stats.empty()) { |
| 325 | report = collector->PrepareReport(false, ssrc, transport_id, direction); |
| 326 | if (report) |
| 327 | ExtractRemoteStats(d, report); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 328 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 329 | } |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 330 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 331 | |
| 332 | } // namespace |
| 333 | |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 334 | const char* IceCandidateTypeToStatsType(const std::string& candidate_type) { |
| 335 | if (candidate_type == cricket::LOCAL_PORT_TYPE) { |
| 336 | return STATSREPORT_LOCAL_PORT_TYPE; |
| 337 | } |
| 338 | if (candidate_type == cricket::STUN_PORT_TYPE) { |
| 339 | return STATSREPORT_STUN_PORT_TYPE; |
| 340 | } |
| 341 | if (candidate_type == cricket::PRFLX_PORT_TYPE) { |
| 342 | return STATSREPORT_PRFLX_PORT_TYPE; |
| 343 | } |
| 344 | if (candidate_type == cricket::RELAY_PORT_TYPE) { |
| 345 | return STATSREPORT_RELAY_PORT_TYPE; |
| 346 | } |
| 347 | ASSERT(false); |
| 348 | return "unknown"; |
| 349 | } |
| 350 | |
| 351 | const char* AdapterTypeToStatsType(rtc::AdapterType type) { |
| 352 | switch (type) { |
| 353 | case rtc::ADAPTER_TYPE_UNKNOWN: |
| 354 | return "unknown"; |
| 355 | case rtc::ADAPTER_TYPE_ETHERNET: |
| 356 | return STATSREPORT_ADAPTER_TYPE_ETHERNET; |
| 357 | case rtc::ADAPTER_TYPE_WIFI: |
| 358 | return STATSREPORT_ADAPTER_TYPE_WIFI; |
| 359 | case rtc::ADAPTER_TYPE_CELLULAR: |
| 360 | return STATSREPORT_ADAPTER_TYPE_WWAN; |
| 361 | case rtc::ADAPTER_TYPE_VPN: |
| 362 | return STATSREPORT_ADAPTER_TYPE_VPN; |
phoglund@webrtc.org | 006521d | 2015-02-12 09:23:59 +0000 | [diff] [blame^] | 363 | case rtc::ADAPTER_TYPE_LOOPBACK: |
| 364 | return STATSREPORT_ADAPTER_TYPE_LOOPBACK; |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 365 | default: |
| 366 | ASSERT(false); |
| 367 | return ""; |
| 368 | } |
| 369 | } |
| 370 | |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 +0000 | [diff] [blame] | 371 | StatsCollector::StatsCollector(WebRtcSession* session) |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 372 | : session_(session), |
| 373 | stats_gathering_started_(0) { |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 +0000 | [diff] [blame] | 374 | ASSERT(session_); |
| 375 | } |
| 376 | |
| 377 | StatsCollector::~StatsCollector() { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 378 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 379 | } |
| 380 | |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 +0000 | [diff] [blame] | 381 | double StatsCollector::GetTimeNow() { |
| 382 | return rtc::Timing::WallTimeNow() * rtc::kNumMillisecsPerSec; |
| 383 | } |
| 384 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 385 | // Adds a MediaStream with tracks that can be used as a |selector| in a call |
| 386 | // to GetStats. |
| 387 | void StatsCollector::AddStream(MediaStreamInterface* stream) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 388 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 389 | ASSERT(stream != NULL); |
| 390 | |
| 391 | CreateTrackReports<AudioTrackVector>(stream->GetAudioTracks(), |
| 392 | &reports_); |
| 393 | CreateTrackReports<VideoTrackVector>(stream->GetVideoTracks(), |
| 394 | &reports_); |
| 395 | } |
| 396 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 397 | void StatsCollector::AddLocalAudioTrack(AudioTrackInterface* audio_track, |
| 398 | uint32 ssrc) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 399 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 400 | ASSERT(audio_track != NULL); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 401 | for (LocalAudioTrackVector::iterator it = local_audio_tracks_.begin(); |
| 402 | it != local_audio_tracks_.end(); ++it) { |
| 403 | ASSERT(it->first != audio_track || it->second != ssrc); |
| 404 | } |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 405 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 406 | local_audio_tracks_.push_back(std::make_pair(audio_track, ssrc)); |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 407 | |
| 408 | // Create the kStatsReportTypeTrack report for the new track if there is no |
| 409 | // report yet. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 410 | rtc::scoped_ptr<StatsReport::Id> id( |
| 411 | StatsReport::NewTypedId(StatsReport::kStatsReportTypeTrack, |
| 412 | audio_track->id())); |
| 413 | StatsReport* report = reports_.Find(*id.get()); |
| 414 | if (!report) { |
| 415 | report = reports_.InsertNew(id.Pass()); |
| 416 | report->AddValue(StatsReport::kStatsValueNameTrackId, audio_track->id()); |
| 417 | } |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 418 | } |
| 419 | |
| 420 | void StatsCollector::RemoveLocalAudioTrack(AudioTrackInterface* audio_track, |
| 421 | uint32 ssrc) { |
| 422 | ASSERT(audio_track != NULL); |
| 423 | for (LocalAudioTrackVector::iterator it = local_audio_tracks_.begin(); |
| 424 | it != local_audio_tracks_.end(); ++it) { |
| 425 | if (it->first == audio_track && it->second == ssrc) { |
| 426 | local_audio_tracks_.erase(it); |
| 427 | return; |
| 428 | } |
| 429 | } |
| 430 | |
| 431 | ASSERT(false); |
| 432 | } |
| 433 | |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 434 | void StatsCollector::GetStats(MediaStreamTrackInterface* track, |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 435 | StatsReports* reports) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 436 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 437 | ASSERT(reports != NULL); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 438 | ASSERT(reports->empty()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 439 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 440 | if (!track) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 441 | reports->reserve(reports_.size()); |
| 442 | for (auto* r : reports_) |
| 443 | reports->push_back(r); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 444 | return; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 445 | } |
| 446 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 447 | StatsReport* report = reports_.Find(StatsReport::NewTypedId( |
| 448 | StatsReport::kStatsReportTypeSession, session_->id())); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 449 | if (report) |
| 450 | reports->push_back(report); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 451 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 452 | report = reports_.Find(StatsReport::NewTypedId( |
| 453 | StatsReport::kStatsReportTypeTrack, track->id())); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 454 | |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 455 | if (!report) |
| 456 | return; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 457 | |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 458 | reports->push_back(report); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 459 | |
| 460 | std::string track_id; |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 461 | for (const auto* r : reports_) { |
| 462 | if (r->type() != StatsReport::kStatsReportTypeSsrc) |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 463 | continue; |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 464 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 465 | const StatsReport::Value* v = |
| 466 | r->FindValue(StatsReport::kStatsValueNameTrackId); |
| 467 | if (v && v->value == track->id()) |
| 468 | reports->push_back(r); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 469 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 470 | } |
| 471 | |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 472 | void |
| 473 | StatsCollector::UpdateStats(PeerConnectionInterface::StatsOutputLevel level) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 474 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 475 | double time_now = GetTimeNow(); |
| 476 | // Calls to UpdateStats() that occur less than kMinGatherStatsPeriod number of |
| 477 | // ms apart will be ignored. |
| 478 | const double kMinGatherStatsPeriod = 50; |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 479 | if (stats_gathering_started_ != 0 && |
| 480 | stats_gathering_started_ + kMinGatherStatsPeriod > time_now) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 481 | return; |
| 482 | } |
| 483 | stats_gathering_started_ = time_now; |
| 484 | |
| 485 | if (session_) { |
| 486 | ExtractSessionInfo(); |
| 487 | ExtractVoiceInfo(); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 488 | ExtractVideoInfo(level); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 489 | ExtractDataInfo(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 490 | } |
| 491 | } |
| 492 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 493 | StatsReport* StatsCollector::PrepareReport( |
| 494 | bool local, |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 495 | uint32 ssrc, |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 496 | const std::string& transport_id, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 497 | StatsReport::Direction direction) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 498 | ASSERT(session_->signaling_thread()->IsCurrent()); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 499 | const std::string ssrc_id = rtc::ToString<uint32>(ssrc); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 500 | rtc::scoped_ptr<StatsReport::Id> id(StatsReport::NewIdWithDirection( |
| 501 | local ? StatsReport::kStatsReportTypeSsrc : |
| 502 | StatsReport::kStatsReportTypeRemoteSsrc, |
| 503 | ssrc_id, direction)); |
| 504 | StatsReport* report = reports_.Find(*id.get()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 505 | |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 506 | // Use the ID of the track that is currently mapped to the SSRC, if any. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 507 | std::string track_id; |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 508 | if (!GetTrackIdBySsrc(ssrc, &track_id, direction)) { |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 509 | if (!report) { |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 510 | // The ssrc is not used by any track or existing report, return NULL |
| 511 | // in such case to indicate no report is prepared for the ssrc. |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 512 | return NULL; |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 513 | } |
| 514 | |
| 515 | // The ssrc is not used by any existing track. Keeps the old track id |
| 516 | // since we want to report the stats for inactive ssrc. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 517 | const StatsReport::Value* v = |
| 518 | report->FindValue(StatsReport::kStatsValueNameTrackId); |
| 519 | if (v) |
| 520 | track_id = v->value; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 521 | } |
| 522 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 523 | if (!report) { |
| 524 | report = reports_.InsertNew(id.Pass()); |
| 525 | } else { |
| 526 | // Clear out stats from previous GatherStats calls if any. |
| 527 | // This is required since the report will be returned for the new values. |
| 528 | // Having the old values in the report will lead to multiple values with |
| 529 | // the same name. |
| 530 | // TODO(tommi): This seems to be pretty wasteful if some of these values |
| 531 | // have not changed (we basically throw them away just to recreate them). |
| 532 | // Figure out a way to not have to do this while not breaking the existing |
| 533 | // functionality. |
| 534 | report->ResetValues(); |
| 535 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 536 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 537 | ASSERT(report->values().empty()); |
| 538 | // FYI - for remote reports, the timestamp will be overwritten later. |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 539 | report->set_timestamp(stats_gathering_started_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 540 | |
| 541 | report->AddValue(StatsReport::kStatsValueNameSsrc, ssrc_id); |
| 542 | report->AddValue(StatsReport::kStatsValueNameTrackId, track_id); |
| 543 | // Add the mapping of SSRC to transport. |
| 544 | report->AddValue(StatsReport::kStatsValueNameTransportId, |
| 545 | transport_id); |
| 546 | return report; |
| 547 | } |
| 548 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 549 | std::string StatsCollector::AddOneCertificateReport( |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 550 | const rtc::SSLCertificate* cert, const std::string& issuer_id) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 551 | ASSERT(session_->signaling_thread()->IsCurrent()); |
| 552 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 553 | // TODO(bemasc): Move this computation to a helper class that caches these |
| 554 | // values to reduce CPU use in GetStats. This will require adding a fast |
| 555 | // SSLCertificate::Equals() method to detect certificate changes. |
mallinath@webrtc.org | 19f27e6 | 2013-10-13 17:18:27 +0000 | [diff] [blame] | 556 | |
| 557 | std::string digest_algorithm; |
| 558 | if (!cert->GetSignatureDigestAlgorithm(&digest_algorithm)) |
| 559 | return std::string(); |
| 560 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 561 | rtc::scoped_ptr<rtc::SSLFingerprint> ssl_fingerprint( |
| 562 | rtc::SSLFingerprint::Create(digest_algorithm, cert)); |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 563 | |
| 564 | // SSLFingerprint::Create can fail if the algorithm returned by |
| 565 | // SSLCertificate::GetSignatureDigestAlgorithm is not supported by the |
| 566 | // implementation of SSLCertificate::ComputeDigest. This currently happens |
| 567 | // with MD5- and SHA-224-signed certificates when linked to libNSS. |
| 568 | if (!ssl_fingerprint) |
| 569 | return std::string(); |
| 570 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 571 | std::string fingerprint = ssl_fingerprint->GetRfc4572Fingerprint(); |
| 572 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 573 | rtc::Buffer der_buffer; |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 574 | cert->ToDER(&der_buffer); |
| 575 | std::string der_base64; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 576 | rtc::Base64::EncodeFromArray( |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 577 | der_buffer.data(), der_buffer.length(), &der_base64); |
| 578 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 579 | rtc::scoped_ptr<StatsReport::Id> id( |
| 580 | StatsReport::NewTypedId( |
| 581 | StatsReport::kStatsReportTypeCertificate, fingerprint)); |
| 582 | StatsReport* report = reports_.ReplaceOrAddNew(id.Pass()); |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 583 | report->set_timestamp(stats_gathering_started_); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 584 | report->AddValue(StatsReport::kStatsValueNameFingerprint, fingerprint); |
| 585 | report->AddValue(StatsReport::kStatsValueNameFingerprintAlgorithm, |
| 586 | digest_algorithm); |
| 587 | report->AddValue(StatsReport::kStatsValueNameDer, der_base64); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 588 | if (!issuer_id.empty()) |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 589 | report->AddValue(StatsReport::kStatsValueNameIssuerId, issuer_id); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 590 | // TODO(tommi): Can we avoid this? |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 591 | return report->id().ToString(); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 592 | } |
| 593 | |
| 594 | std::string StatsCollector::AddCertificateReports( |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 595 | const rtc::SSLCertificate* cert) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 596 | ASSERT(session_->signaling_thread()->IsCurrent()); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 597 | // Produces a chain of StatsReports representing this certificate and the rest |
| 598 | // of its chain, and adds those reports to |reports_|. The return value is |
| 599 | // the id of the leaf report. The provided cert must be non-null, so at least |
| 600 | // one report will always be provided and the returned string will never be |
| 601 | // empty. |
| 602 | ASSERT(cert != NULL); |
| 603 | |
| 604 | std::string issuer_id; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 605 | rtc::scoped_ptr<rtc::SSLCertChain> chain; |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 606 | if (cert->GetChain(chain.accept())) { |
| 607 | // This loop runs in reverse, i.e. from root to leaf, so that each |
| 608 | // certificate's issuer's report ID is known before the child certificate's |
| 609 | // report is generated. The root certificate does not have an issuer ID |
| 610 | // value. |
| 611 | for (ptrdiff_t i = chain->GetSize() - 1; i >= 0; --i) { |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 612 | const rtc::SSLCertificate& cert_i = chain->Get(i); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 613 | issuer_id = AddOneCertificateReport(&cert_i, issuer_id); |
| 614 | } |
| 615 | } |
| 616 | // Add the leaf certificate. |
| 617 | return AddOneCertificateReport(cert, issuer_id); |
| 618 | } |
| 619 | |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 620 | std::string StatsCollector::AddCandidateReport( |
| 621 | const cricket::Candidate& candidate, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 622 | bool local) { |
| 623 | scoped_ptr<StatsReport::Id> id( |
| 624 | StatsReport::NewCandidateId(local, candidate.id())); |
| 625 | StatsReport* report = reports_.Find(*id.get()); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 626 | if (!report) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 627 | report = reports_.InsertNew(id.Pass()); |
| 628 | report->set_timestamp(stats_gathering_started_); |
| 629 | if (local) { |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 630 | report->AddValue(StatsReport::kStatsValueNameCandidateNetworkType, |
| 631 | AdapterTypeToStatsType(candidate.network_type())); |
| 632 | } |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 633 | report->AddValue(StatsReport::kStatsValueNameCandidateIPAddress, |
| 634 | candidate.address().ipaddr().ToString()); |
| 635 | report->AddValue(StatsReport::kStatsValueNameCandidatePortNumber, |
| 636 | candidate.address().PortAsString()); |
| 637 | report->AddValue(StatsReport::kStatsValueNameCandidatePriority, |
| 638 | candidate.priority()); |
| 639 | report->AddValue(StatsReport::kStatsValueNameCandidateType, |
| 640 | IceCandidateTypeToStatsType(candidate.type())); |
| 641 | report->AddValue(StatsReport::kStatsValueNameCandidateTransportType, |
| 642 | candidate.protocol()); |
| 643 | } |
| 644 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 645 | // TODO(tommi): Necessary? |
| 646 | return report->id().ToString(); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 647 | } |
| 648 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 649 | void StatsCollector::ExtractSessionInfo() { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 650 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 651 | // Extract information from the base session. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 652 | rtc::scoped_ptr<StatsReport::Id> id( |
| 653 | StatsReport::NewTypedId( |
| 654 | StatsReport::kStatsReportTypeSession, session_->id())); |
| 655 | StatsReport* report = reports_.ReplaceOrAddNew(id.Pass()); |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 656 | report->set_timestamp(stats_gathering_started_); |
| 657 | report->ResetValues(); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 658 | report->AddBoolean(StatsReport::kStatsValueNameInitiator, |
| 659 | session_->initiator()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 660 | |
| 661 | cricket::SessionStats stats; |
| 662 | if (session_->GetStats(&stats)) { |
| 663 | // Store the proxy map away for use in SSRC reporting. |
| 664 | proxy_to_transport_ = stats.proxy_to_transport; |
| 665 | |
| 666 | for (cricket::TransportStatsMap::iterator transport_iter |
| 667 | = stats.transport_stats.begin(); |
| 668 | transport_iter != stats.transport_stats.end(); ++transport_iter) { |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 669 | // Attempt to get a copy of the certificates from the transport and |
| 670 | // expose them in stats reports. All channels in a transport share the |
| 671 | // same local and remote certificates. |
jiayl@webrtc.org | 06b04ec | 2014-07-24 20:41:20 +0000 | [diff] [blame] | 672 | // |
| 673 | // Note that Transport::GetIdentity and Transport::GetRemoteCertificate |
| 674 | // invoke method calls on the worker thread and block this thread, but |
| 675 | // messages are still processed on this thread, which may blow way the |
| 676 | // existing transports. So we cannot reuse |transport| after these calls. |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 677 | std::string local_cert_report_id, remote_cert_report_id; |
jiayl@webrtc.org | 06b04ec | 2014-07-24 20:41:20 +0000 | [diff] [blame] | 678 | |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 679 | cricket::Transport* transport = |
| 680 | session_->GetTransport(transport_iter->second.content_name); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 681 | rtc::scoped_ptr<rtc::SSLIdentity> identity; |
jiayl@webrtc.org | 06b04ec | 2014-07-24 20:41:20 +0000 | [diff] [blame] | 682 | if (transport && transport->GetIdentity(identity.accept())) { |
| 683 | local_cert_report_id = |
| 684 | AddCertificateReports(&(identity->certificate())); |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 685 | } |
jiayl@webrtc.org | 06b04ec | 2014-07-24 20:41:20 +0000 | [diff] [blame] | 686 | |
| 687 | transport = session_->GetTransport(transport_iter->second.content_name); |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 688 | rtc::scoped_ptr<rtc::SSLCertificate> cert; |
jiayl@webrtc.org | 06b04ec | 2014-07-24 20:41:20 +0000 | [diff] [blame] | 689 | if (transport && transport->GetRemoteCertificate(cert.accept())) { |
| 690 | remote_cert_report_id = AddCertificateReports(cert.get()); |
| 691 | } |
| 692 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 693 | for (cricket::TransportChannelStatsList::iterator channel_iter |
| 694 | = transport_iter->second.channel_stats.begin(); |
| 695 | channel_iter != transport_iter->second.channel_stats.end(); |
| 696 | ++channel_iter) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 697 | rtc::scoped_ptr<StatsReport::Id> id( |
| 698 | StatsReport::NewComponentId(transport_iter->second.content_name, |
| 699 | channel_iter->component)); |
| 700 | StatsReport* channel_report = reports_.ReplaceOrAddNew(id.Pass()); |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 701 | channel_report->set_timestamp(stats_gathering_started_); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 702 | channel_report->AddValue(StatsReport::kStatsValueNameComponent, |
| 703 | channel_iter->component); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 704 | if (!local_cert_report_id.empty()) { |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 705 | channel_report->AddValue( |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 706 | StatsReport::kStatsValueNameLocalCertificateId, |
| 707 | local_cert_report_id); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 708 | } |
| 709 | if (!remote_cert_report_id.empty()) { |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 710 | channel_report->AddValue( |
wu@webrtc.org | 4551b79 | 2013-10-09 15:37:36 +0000 | [diff] [blame] | 711 | StatsReport::kStatsValueNameRemoteCertificateId, |
| 712 | remote_cert_report_id); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 713 | } |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 714 | for (size_t i = 0; |
| 715 | i < channel_iter->connection_infos.size(); |
| 716 | ++i) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 717 | rtc::scoped_ptr<StatsReport::Id> id( |
| 718 | StatsReport::NewCandidatePairId(transport_iter->first, |
| 719 | channel_iter->component, static_cast<int>(i))); |
| 720 | StatsReport* report = reports_.ReplaceOrAddNew(id.Pass()); |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 721 | report->set_timestamp(stats_gathering_started_); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 722 | // Link from connection to its containing channel. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 723 | // TODO(tommi): Any way to avoid ToString here? |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 724 | report->AddValue(StatsReport::kStatsValueNameChannelId, |
tommi@webrtc.org | 8e327c4 | 2015-01-19 20:41:26 +0000 | [diff] [blame] | 725 | channel_report->id().ToString()); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 726 | |
| 727 | const cricket::ConnectionInfo& info = |
| 728 | channel_iter->connection_infos[i]; |
| 729 | report->AddValue(StatsReport::kStatsValueNameBytesSent, |
| 730 | info.sent_total_bytes); |
guoweis@webrtc.org | 930e004 | 2014-11-17 19:42:14 +0000 | [diff] [blame] | 731 | report->AddValue(StatsReport::kStatsValueNameSendPacketsDiscarded, |
| 732 | info.sent_discarded_packets); |
| 733 | report->AddValue(StatsReport::kStatsValueNamePacketsSent, |
| 734 | info.sent_total_packets); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 735 | report->AddValue(StatsReport::kStatsValueNameBytesReceived, |
| 736 | info.recv_total_bytes); |
| 737 | report->AddBoolean(StatsReport::kStatsValueNameWritable, |
| 738 | info.writable); |
| 739 | report->AddBoolean(StatsReport::kStatsValueNameReadable, |
| 740 | info.readable); |
| 741 | report->AddBoolean(StatsReport::kStatsValueNameActiveConnection, |
| 742 | info.best_connection); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 743 | report->AddValue(StatsReport::kStatsValueNameLocalCandidateId, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 744 | AddCandidateReport(info.local_candidate, true)); |
guoweis@webrtc.org | 950c518 | 2014-12-16 23:01:31 +0000 | [diff] [blame] | 745 | report->AddValue( |
| 746 | StatsReport::kStatsValueNameRemoteCandidateId, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 747 | AddCandidateReport(info.remote_candidate, false)); |
tommi@webrtc.org | 5b06b06 | 2014-08-15 08:38:30 +0000 | [diff] [blame] | 748 | report->AddValue(StatsReport::kStatsValueNameLocalAddress, |
| 749 | info.local_candidate.address().ToString()); |
| 750 | report->AddValue(StatsReport::kStatsValueNameRemoteAddress, |
| 751 | info.remote_candidate.address().ToString()); |
| 752 | report->AddValue(StatsReport::kStatsValueNameRtt, info.rtt); |
| 753 | report->AddValue(StatsReport::kStatsValueNameTransportType, |
| 754 | info.local_candidate.protocol()); |
| 755 | report->AddValue(StatsReport::kStatsValueNameLocalCandidateType, |
| 756 | info.local_candidate.type()); |
| 757 | report->AddValue(StatsReport::kStatsValueNameRemoteCandidateType, |
| 758 | info.remote_candidate.type()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 759 | } |
| 760 | } |
| 761 | } |
| 762 | } |
| 763 | } |
| 764 | |
| 765 | void StatsCollector::ExtractVoiceInfo() { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 766 | ASSERT(session_->signaling_thread()->IsCurrent()); |
| 767 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 768 | if (!session_->voice_channel()) { |
| 769 | return; |
| 770 | } |
| 771 | cricket::VoiceMediaInfo voice_info; |
| 772 | if (!session_->voice_channel()->GetStats(&voice_info)) { |
| 773 | LOG(LS_ERROR) << "Failed to get voice channel stats."; |
| 774 | return; |
| 775 | } |
| 776 | std::string transport_id; |
tommi@webrtc.org | 4721895 | 2014-07-15 19:22:37 +0000 | [diff] [blame] | 777 | if (!GetTransportIdFromProxy(proxy_to_transport_, |
| 778 | session_->voice_channel()->content_name(), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 779 | &transport_id)) { |
| 780 | LOG(LS_ERROR) << "Failed to get transport name for proxy " |
| 781 | << session_->voice_channel()->content_name(); |
| 782 | return; |
| 783 | } |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 784 | ExtractStatsFromList(voice_info.receivers, transport_id, this, |
| 785 | StatsReport::kReceive); |
| 786 | ExtractStatsFromList(voice_info.senders, transport_id, this, |
| 787 | StatsReport::kSend); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 788 | |
| 789 | UpdateStatsFromExistingLocalAudioTracks(); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 790 | } |
| 791 | |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 792 | void StatsCollector::ExtractVideoInfo( |
| 793 | PeerConnectionInterface::StatsOutputLevel level) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 794 | ASSERT(session_->signaling_thread()->IsCurrent()); |
| 795 | |
| 796 | if (!session_->video_channel()) |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 797 | return; |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 798 | |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 799 | cricket::StatsOptions options; |
| 800 | options.include_received_propagation_stats = |
| 801 | (level >= PeerConnectionInterface::kStatsOutputLevelDebug) ? |
| 802 | true : false; |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 803 | cricket::VideoMediaInfo video_info; |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 804 | if (!session_->video_channel()->GetStats(options, &video_info)) { |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 805 | LOG(LS_ERROR) << "Failed to get video channel stats."; |
| 806 | return; |
| 807 | } |
| 808 | std::string transport_id; |
tommi@webrtc.org | 4721895 | 2014-07-15 19:22:37 +0000 | [diff] [blame] | 809 | if (!GetTransportIdFromProxy(proxy_to_transport_, |
| 810 | session_->video_channel()->content_name(), |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 811 | &transport_id)) { |
| 812 | LOG(LS_ERROR) << "Failed to get transport name for proxy " |
| 813 | << session_->video_channel()->content_name(); |
| 814 | return; |
| 815 | } |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 816 | ExtractStatsFromList(video_info.receivers, transport_id, this, |
| 817 | StatsReport::kReceive); |
| 818 | ExtractStatsFromList(video_info.senders, transport_id, this, |
| 819 | StatsReport::kSend); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 820 | if (video_info.bw_estimations.size() != 1) { |
| 821 | LOG(LS_ERROR) << "BWEs count: " << video_info.bw_estimations.size(); |
| 822 | } else { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 823 | rtc::scoped_ptr<StatsReport::Id> report_id( |
| 824 | StatsReport::NewBandwidthEstimationId()); |
| 825 | StatsReport* report = reports_.FindOrAddNew(report_id.Pass()); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 826 | ExtractStats( |
wu@webrtc.org | b9a088b | 2014-02-13 23:18:49 +0000 | [diff] [blame] | 827 | video_info.bw_estimations[0], stats_gathering_started_, level, report); |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 828 | } |
| 829 | } |
| 830 | |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 831 | void StatsCollector::ExtractDataInfo() { |
| 832 | ASSERT(session_->signaling_thread()->IsCurrent()); |
| 833 | |
| 834 | for (const auto& dc : |
| 835 | session_->mediastream_signaling()->sctp_data_channels()) { |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 +0000 | [diff] [blame] | 836 | rtc::scoped_ptr<StatsReport::Id> id(StatsReport::NewTypedIntId( |
| 837 | StatsReport::kStatsReportTypeDataChannel, dc->id())); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 838 | StatsReport* report = reports_.ReplaceOrAddNew(id.Pass()); |
decurtis@webrtc.org | 322a564 | 2015-02-03 22:09:37 +0000 | [diff] [blame] | 839 | report->set_timestamp(stats_gathering_started_); |
decurtis@webrtc.org | 487a444 | 2015-01-15 22:55:07 +0000 | [diff] [blame] | 840 | report->AddValue(StatsReport::kStatsValueNameLabel, dc->label()); |
| 841 | report->AddValue(StatsReport::kStatsValueNameDataChannelId, dc->id()); |
| 842 | report->AddValue(StatsReport::kStatsValueNameProtocol, dc->protocol()); |
| 843 | report->AddValue(StatsReport::kStatsValueNameState, |
| 844 | DataChannelInterface::DataStateString(dc->state())); |
| 845 | } |
| 846 | } |
| 847 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 848 | StatsReport* StatsCollector::GetReport(const StatsReport::StatsType& type, |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 849 | const std::string& id, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 850 | StatsReport::Direction direction) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 851 | ASSERT(session_->signaling_thread()->IsCurrent()); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 852 | ASSERT(type == StatsReport::kStatsReportTypeSsrc || |
| 853 | type == StatsReport::kStatsReportTypeRemoteSsrc); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 854 | return reports_.Find(StatsReport::NewIdWithDirection(type, id, direction)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 855 | } |
| 856 | |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 857 | StatsReport* StatsCollector::GetOrCreateReport( |
| 858 | const StatsReport::StatsType& type, |
| 859 | const std::string& id, |
| 860 | StatsReport::Direction direction) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 861 | ASSERT(session_->signaling_thread()->IsCurrent()); |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 862 | ASSERT(type == StatsReport::kStatsReportTypeSsrc || |
| 863 | type == StatsReport::kStatsReportTypeRemoteSsrc); |
| 864 | StatsReport* report = GetReport(type, id, direction); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 865 | if (report == NULL) { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 866 | rtc::scoped_ptr<StatsReport::Id> report_id( |
| 867 | StatsReport::NewIdWithDirection(type, id, direction)); |
| 868 | report = reports_.InsertNew(report_id.Pass()); |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 869 | } |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 870 | |
wu@webrtc.org | 97077a3 | 2013-10-25 21:18:33 +0000 | [diff] [blame] | 871 | return report; |
| 872 | } |
| 873 | |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 874 | void StatsCollector::UpdateStatsFromExistingLocalAudioTracks() { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 875 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 876 | // Loop through the existing local audio tracks. |
| 877 | for (LocalAudioTrackVector::const_iterator it = local_audio_tracks_.begin(); |
| 878 | it != local_audio_tracks_.end(); ++it) { |
| 879 | AudioTrackInterface* track = it->first; |
| 880 | uint32 ssrc = it->second; |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 881 | std::string ssrc_id = rtc::ToString<uint32>(ssrc); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 882 | StatsReport* report = GetReport(StatsReport::kStatsReportTypeSsrc, |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 883 | ssrc_id, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 884 | StatsReport::kSend); |
henrike@webrtc.org | d3d6bce | 2014-03-10 20:41:22 +0000 | [diff] [blame] | 885 | if (report == NULL) { |
| 886 | // This can happen if a local audio track is added to a stream on the |
| 887 | // fly and the report has not been set up yet. Do nothing in this case. |
| 888 | LOG(LS_ERROR) << "Stats report does not exist for ssrc " << ssrc; |
| 889 | continue; |
| 890 | } |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 891 | |
| 892 | // The same ssrc can be used by both local and remote audio tracks. |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 893 | const StatsReport::Value* v = |
| 894 | report->FindValue(StatsReport::kStatsValueNameTrackId); |
| 895 | if (!v || v->value != track->id()) |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 896 | continue; |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 897 | |
| 898 | UpdateReportFromAudioTrack(track, report); |
| 899 | } |
| 900 | } |
| 901 | |
| 902 | void StatsCollector::UpdateReportFromAudioTrack(AudioTrackInterface* track, |
| 903 | StatsReport* report) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 904 | ASSERT(session_->signaling_thread()->IsCurrent()); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 905 | ASSERT(track != NULL); |
| 906 | if (report == NULL) |
| 907 | return; |
| 908 | |
| 909 | int signal_level = 0; |
| 910 | if (track->GetSignalLevel(&signal_level)) { |
| 911 | report->ReplaceValue(StatsReport::kStatsValueNameAudioInputLevel, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 912 | rtc::ToString<int>(signal_level)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 913 | } |
| 914 | |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 915 | rtc::scoped_refptr<AudioProcessorInterface> audio_processor( |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 916 | track->GetAudioProcessor()); |
| 917 | if (audio_processor.get() == NULL) |
| 918 | return; |
| 919 | |
| 920 | AudioProcessorInterface::AudioProcessorStats stats; |
| 921 | audio_processor->GetStats(&stats); |
| 922 | report->ReplaceValue(StatsReport::kStatsValueNameTypingNoiseState, |
| 923 | stats.typing_noise_detected ? "true" : "false"); |
| 924 | report->ReplaceValue(StatsReport::kStatsValueNameEchoReturnLoss, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 925 | rtc::ToString<int>(stats.echo_return_loss)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 926 | report->ReplaceValue( |
| 927 | StatsReport::kStatsValueNameEchoReturnLossEnhancement, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 928 | rtc::ToString<int>(stats.echo_return_loss_enhancement)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 929 | report->ReplaceValue(StatsReport::kStatsValueNameEchoDelayMedian, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 930 | rtc::ToString<int>(stats.echo_delay_median_ms)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 931 | report->ReplaceValue(StatsReport::kStatsValueNameEchoCancellationQualityMin, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 932 | rtc::ToString<float>(stats.aec_quality_min)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 933 | report->ReplaceValue(StatsReport::kStatsValueNameEchoDelayStdDev, |
buildbot@webrtc.org | d4e598d | 2014-07-29 17:36:52 +0000 | [diff] [blame] | 934 | rtc::ToString<int>(stats.echo_delay_std_ms)); |
henrike@webrtc.org | 40b3b68 | 2014-03-03 18:30:11 +0000 | [diff] [blame] | 935 | } |
| 936 | |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 937 | bool StatsCollector::GetTrackIdBySsrc(uint32 ssrc, std::string* track_id, |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 938 | StatsReport::Direction direction) { |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 939 | ASSERT(session_->signaling_thread()->IsCurrent()); |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 940 | if (direction == StatsReport::kSend) { |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 +0000 | [diff] [blame] | 941 | if (!session_->GetLocalTrackIdBySsrc(ssrc, track_id)) { |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 942 | LOG(LS_WARNING) << "The SSRC " << ssrc |
| 943 | << " is not associated with a sending track"; |
| 944 | return false; |
| 945 | } |
| 946 | } else { |
tommi@webrtc.org | 4fb7e25 | 2015-01-21 11:36:18 +0000 | [diff] [blame] | 947 | ASSERT(direction == StatsReport::kReceive); |
tommi@webrtc.org | 03505bc | 2014-07-14 20:15:26 +0000 | [diff] [blame] | 948 | if (!session_->GetRemoteTrackIdBySsrc(ssrc, track_id)) { |
xians@webrtc.org | 4cb0128 | 2014-06-12 14:57:05 +0000 | [diff] [blame] | 949 | LOG(LS_WARNING) << "The SSRC " << ssrc |
| 950 | << " is not associated with a receiving track"; |
| 951 | return false; |
| 952 | } |
| 953 | } |
| 954 | |
| 955 | return true; |
| 956 | } |
| 957 | |
tommi@webrtc.org | 69bc5a3 | 2014-12-15 09:44:48 +0000 | [diff] [blame] | 958 | void StatsCollector::ClearUpdateStatsCacheForTest() { |
xians@webrtc.org | 01bda20 | 2014-07-09 07:38:38 +0000 | [diff] [blame] | 959 | stats_gathering_started_ = 0; |
| 960 | } |
| 961 | |
henrike@webrtc.org | 28e2075 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 962 | } // namespace webrtc |