1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
|
/*
* Copyright 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
// This file contains a class used for gathering statistics from an ongoing
// libjingle PeerConnection.
#ifndef PC_LEGACY_STATS_COLLECTOR_H_
#define PC_LEGACY_STATS_COLLECTOR_H_
#include <stdint.h>
#include <algorithm>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "absl/types/optional.h"
#include "api/field_trials_view.h"
#include "api/legacy_stats_types.h"
#include "api/media_stream_interface.h"
#include "api/peer_connection_interface.h"
#include "api/scoped_refptr.h"
#include "p2p/base/connection_info.h"
#include "p2p/base/port.h"
#include "pc/legacy_stats_collector_interface.h"
#include "pc/peer_connection_internal.h"
#include "pc/rtp_transceiver.h"
#include "pc/transport_stats.h"
#include "rtc_base/network_constants.h"
#include "rtc_base/ssl_certificate.h"
#include "rtc_base/thread_annotations.h"
namespace webrtc {
// Conversion function to convert candidate type string to the corresponding one
// from enum RTCStatsIceCandidateType.
const char* IceCandidateTypeToStatsType(const std::string& candidate_type);
// Conversion function to convert adapter type to report string which are more
// fitting to the general style of http://w3c.github.io/webrtc-stats. This is
// only used by stats collector.
const char* AdapterTypeToStatsType(rtc::AdapterType type);
// A mapping between track ids and their StatsReport.
typedef std::map<std::string, StatsReport*> TrackIdMap;
class LegacyStatsCollector : public LegacyStatsCollectorInterface {
public:
// The caller is responsible for ensuring that the pc outlives the
// LegacyStatsCollector instance.
explicit LegacyStatsCollector(PeerConnectionInternal* pc);
virtual ~LegacyStatsCollector();
// Adds a MediaStream with tracks that can be used as a `selector` in a call
// to GetStats.
void AddStream(MediaStreamInterface* stream);
void AddTrack(MediaStreamTrackInterface* track);
// Adds a local audio track that is used for getting some voice statistics.
void AddLocalAudioTrack(AudioTrackInterface* audio_track,
uint32_t ssrc) override;
// Removes a local audio tracks that is used for getting some voice
// statistics.
void RemoveLocalAudioTrack(AudioTrackInterface* audio_track,
uint32_t ssrc) override;
// Gather statistics from the session and store them for future use.
void UpdateStats(PeerConnectionInterface::StatsOutputLevel level);
// Gets a StatsReports of the last collected stats. Note that UpdateStats must
// be called before this function to get the most recent stats. `selector` is
// a track label or empty string. The most recent reports are stored in
// `reports`.
// TODO(tommi): Change this contract to accept a callback object instead
// of filling in `reports`. As is, there's a requirement that the caller
// uses `reports` immediately without allowing any async activity on
// the thread (message handling etc) and then discard the results.
void GetStats(MediaStreamTrackInterface* track,
StatsReports* reports) override;
// Prepare a local or remote SSRC report for the given ssrc. Used internally
// in the ExtractStatsFromList template.
StatsReport* PrepareReport(bool local,
uint32_t ssrc,
const std::string& track_id,
const StatsReport::Id& transport_id,
StatsReport::Direction direction);
StatsReport* PrepareADMReport();
// A track is invalid if there is no report data for it.
bool IsValidTrack(const std::string& track_id);
// Reset the internal cache timestamp to force an update of the stats next
// time UpdateStats() is called. This call needs to be made on the signaling
// thread and should be made every time configuration changes that affect
// stats have been made.
void InvalidateCache();
bool UseStandardBytesStats() const { return use_standard_bytes_stats_; }
private:
friend class LegacyStatsCollectorTest;
// Struct that's populated on the network thread and carries the values to
// the signaling thread where the stats are added to the stats reports.
struct TransportStats {
TransportStats() = default;
TransportStats(std::string transport_name,
cricket::TransportStats transport_stats)
: name(std::move(transport_name)), stats(std::move(transport_stats)) {}
TransportStats(TransportStats&&) = default;
TransportStats(const TransportStats&) = delete;
std::string name;
cricket::TransportStats stats;
std::unique_ptr<rtc::SSLCertificateStats> local_cert_stats;
std::unique_ptr<rtc::SSLCertificateStats> remote_cert_stats;
};
struct SessionStats {
SessionStats() = default;
SessionStats(SessionStats&&) = default;
SessionStats(const SessionStats&) = delete;
SessionStats& operator=(SessionStats&&) = default;
SessionStats& operator=(SessionStats&) = delete;
cricket::CandidateStatsList candidate_stats;
std::vector<TransportStats> transport_stats;
std::map<std::string, std::string> transport_names_by_mid;
};
// Overridden in unit tests to fake timing.
virtual double GetTimeNow();
bool CopySelectedReports(const std::string& selector, StatsReports* reports);
// Helper method for creating IceCandidate report. `is_local` indicates
// whether this candidate is local or remote.
StatsReport* AddCandidateReport(
const cricket::CandidateStats& candidate_stats,
bool local);
// Adds a report for this certificate and every certificate in its chain, and
// returns the leaf certificate's report (`cert_stats`'s report).
StatsReport* AddCertificateReports(
std::unique_ptr<rtc::SSLCertificateStats> cert_stats);
StatsReport* AddConnectionInfoReport(const std::string& content_name,
int component,
int connection_id,
const StatsReport::Id& channel_report_id,
const cricket::ConnectionInfo& info);
void ExtractDataInfo_n(StatsCollection* reports);
// Returns the `transport_names_by_mid` member from the SessionStats as
// gathered and used to populate the stats. Contains one synchronous hop
// to the network thread to get this information along with querying data
// channel stats at the same time and populating `reports_`.
std::map<std::string, std::string> ExtractSessionAndDataInfo();
void ExtractBweInfo();
void ExtractMediaInfo(
const std::map<std::string, std::string>& transport_names_by_mid);
void ExtractSenderInfo();
StatsReport* GetReport(const StatsReport::StatsType& type,
const std::string& id,
StatsReport::Direction direction);
// Helper method to get stats from the local audio tracks.
void UpdateStatsFromExistingLocalAudioTracks(bool has_remote_tracks);
void UpdateReportFromAudioTrack(AudioTrackInterface* track,
StatsReport* report,
bool has_remote_tracks);
// Helper method to update the timestamp of track records.
void UpdateTrackReports();
SessionStats ExtractSessionInfo_n(
const std::vector<rtc::scoped_refptr<
RtpTransceiverProxyWithInternal<RtpTransceiver>>>& transceivers,
absl::optional<std::string> sctp_transport_name,
absl::optional<std::string> sctp_mid);
void ExtractSessionInfo_s(SessionStats& session_stats);
// A collection for all of our stats reports.
StatsCollection reports_;
TrackIdMap track_ids_;
// Raw pointer to the peer connection the statistics are gathered from.
PeerConnectionInternal* const pc_;
int64_t cache_timestamp_ms_ RTC_GUARDED_BY(pc_->signaling_thread()) = 0;
double stats_gathering_started_;
const bool use_standard_bytes_stats_;
// TODO(tommi): We appear to be holding on to raw pointers to reference
// counted objects? We should be using scoped_refptr here.
typedef std::vector<std::pair<AudioTrackInterface*, uint32_t>>
LocalAudioTrackVector;
LocalAudioTrackVector local_audio_tracks_;
};
} // namespace webrtc
#endif // PC_LEGACY_STATS_COLLECTOR_H_
|
