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
|
/*
* Copyright (c) 2020 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.
*/
#ifndef VIDEO_RECEIVE_STATISTICS_PROXY_H_
#define VIDEO_RECEIVE_STATISTICS_PROXY_H_
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "absl/types/optional.h"
#include "api/sequence_checker.h"
#include "api/task_queue/pending_task_safety_flag.h"
#include "api/task_queue/task_queue_base.h"
#include "api/units/timestamp.h"
#include "api/video_codecs/video_decoder.h"
#include "call/video_receive_stream.h"
#include "modules/include/module_common_types.h"
#include "rtc_base/numerics/histogram_percentile_counter.h"
#include "rtc_base/numerics/moving_max_counter.h"
#include "rtc_base/numerics/sample_counter.h"
#include "rtc_base/rate_statistics.h"
#include "rtc_base/rate_tracker.h"
#include "rtc_base/system/no_unique_address.h"
#include "rtc_base/thread_annotations.h"
#include "video/stats_counter.h"
#include "video/video_quality_observer2.h"
#include "video/video_stream_buffer_controller.h"
namespace webrtc {
class Clock;
struct CodecSpecificInfo;
namespace internal {
// Declared in video_receive_stream2.h.
struct VideoFrameMetaData;
class ReceiveStatisticsProxy : public VideoStreamBufferControllerStatsObserver,
public RtcpCnameCallback,
public RtcpPacketTypeCounterObserver {
public:
ReceiveStatisticsProxy(uint32_t remote_ssrc,
Clock* clock,
TaskQueueBase* worker_thread);
~ReceiveStatisticsProxy() override;
VideoReceiveStreamInterface::Stats GetStats() const;
void OnDecodedFrame(const VideoFrame& frame,
absl::optional<uint8_t> qp,
TimeDelta decode_time,
VideoContentType content_type,
VideoFrameType frame_type);
// Called asyncronously on the worker thread as a result of a call to the
// above OnDecodedFrame method, which is called back on the thread where
// the actual decoding happens.
void OnDecodedFrame(const VideoFrameMetaData& frame_meta,
absl::optional<uint8_t> qp,
TimeDelta decode_time,
TimeDelta processing_delay,
TimeDelta assembly_time,
VideoContentType content_type,
VideoFrameType frame_type);
void OnSyncOffsetUpdated(int64_t video_playout_ntp_ms,
int64_t sync_offset_ms,
double estimated_freq_khz);
void OnRenderedFrame(const VideoFrameMetaData& frame_meta);
void OnIncomingPayloadType(int payload_type);
void OnDecoderInfo(const VideoDecoder::DecoderInfo& decoder_info);
void OnPreDecode(VideoCodecType codec_type, int qp);
void OnUniqueFramesCounted(int num_unique_frames);
// Indicates video stream has been paused (no incoming packets).
void OnStreamInactive();
// Implements VideoStreamBufferControllerStatsObserver.
void OnCompleteFrame(bool is_keyframe,
size_t size_bytes,
VideoContentType content_type) override;
void OnDroppedFrames(uint32_t frames_dropped) override;
void OnDecodableFrame(TimeDelta jitter_buffer_delay,
TimeDelta target_delay,
TimeDelta minimum_delay) override;
void OnDiscardedPackets(uint32_t packets_discarded) override;
void OnFrameBufferTimingsUpdated(int estimated_max_decode_time_ms,
int current_delay_ms,
int target_delay_ms,
int jitter_delay_ms,
int min_playout_delay_ms,
int render_delay_ms) override;
void OnTimingFrameInfoUpdated(const TimingFrameInfo& info) override;
// Implements RtcpCnameCallback.
void OnCname(uint32_t ssrc, absl::string_view cname) override;
// Implements RtcpPacketTypeCounterObserver.
void RtcpPacketTypesCounterUpdated(
uint32_t ssrc,
const RtcpPacketTypeCounter& packet_counter) override;
void OnRttUpdate(int64_t avg_rtt_ms);
// Notification methods that are used to check our internal state and validate
// threading assumptions. These are called by VideoReceiveStreamInterface.
void DecoderThreadStarting();
void DecoderThreadStopped();
// Produce histograms. Must be called after DecoderThreadStopped(), typically
// at the end of the call.
void UpdateHistograms(absl::optional<int> fraction_lost,
const StreamDataCounters& rtp_stats,
const StreamDataCounters* rtx_stats);
private:
struct QpCounters {
rtc::SampleCounter vp8;
};
struct ContentSpecificStats {
ContentSpecificStats();
~ContentSpecificStats();
void Add(const ContentSpecificStats& other);
rtc::SampleCounter e2e_delay_counter;
rtc::SampleCounter interframe_delay_counter;
int64_t flow_duration_ms = 0;
int64_t total_media_bytes = 0;
rtc::SampleCounter received_width;
rtc::SampleCounter received_height;
rtc::SampleCounter qp_counter;
FrameCounts frame_counts;
rtc::HistogramPercentileCounter interframe_delay_percentiles;
};
// Removes info about old frames and then updates the framerate.
void UpdateFramerate(int64_t now_ms) const;
absl::optional<int64_t> GetCurrentEstimatedPlayoutNtpTimestampMs(
int64_t now_ms) const;
Clock* const clock_;
const int64_t start_ms_;
// Note: The `stats_.rtp_stats` member is not used or populated by this class.
mutable VideoReceiveStreamInterface::Stats stats_
RTC_GUARDED_BY(main_thread_);
// Same as stats_.ssrc, but const (no lock required).
const uint32_t remote_ssrc_;
RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(main_thread_);
RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(main_thread_);
rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(main_thread_);
rtc::RateTracker render_pixel_tracker_ RTC_GUARDED_BY(main_thread_);
rtc::SampleCounter sync_offset_counter_ RTC_GUARDED_BY(main_thread_);
rtc::SampleCounter decode_time_counter_ RTC_GUARDED_BY(main_thread_);
rtc::SampleCounter jitter_delay_counter_ RTC_GUARDED_BY(main_thread_);
rtc::SampleCounter target_delay_counter_ RTC_GUARDED_BY(main_thread_);
rtc::SampleCounter current_delay_counter_ RTC_GUARDED_BY(main_thread_);
rtc::SampleCounter oneway_delay_counter_ RTC_GUARDED_BY(main_thread_);
std::unique_ptr<VideoQualityObserver> video_quality_observer_
RTC_GUARDED_BY(main_thread_);
mutable rtc::MovingMaxCounter<int> interframe_delay_max_moving_
RTC_GUARDED_BY(main_thread_);
std::map<VideoContentType, ContentSpecificStats> content_specific_stats_
RTC_GUARDED_BY(main_thread_);
MaxCounter freq_offset_counter_ RTC_GUARDED_BY(main_thread_);
QpCounters qp_counters_ RTC_GUARDED_BY(main_thread_);
int64_t avg_rtt_ms_ RTC_GUARDED_BY(main_thread_) = 0;
mutable std::map<int64_t, size_t> frame_window_ RTC_GUARDED_BY(main_thread_);
VideoContentType last_content_type_ RTC_GUARDED_BY(&main_thread_);
VideoCodecType last_codec_type_ RTC_GUARDED_BY(main_thread_);
absl::optional<int64_t> first_frame_received_time_ms_
RTC_GUARDED_BY(main_thread_);
absl::optional<int64_t> first_decoded_frame_time_ms_
RTC_GUARDED_BY(main_thread_);
absl::optional<int64_t> last_decoded_frame_time_ms_
RTC_GUARDED_BY(main_thread_);
size_t num_delayed_frames_rendered_ RTC_GUARDED_BY(main_thread_);
int64_t sum_missed_render_deadline_ms_ RTC_GUARDED_BY(main_thread_);
// Mutable because calling Max() on MovingMaxCounter is not const. Yet it is
// called from const GetStats().
mutable rtc::MovingMaxCounter<TimingFrameInfo> timing_frame_info_counter_
RTC_GUARDED_BY(main_thread_);
absl::optional<int> num_unique_frames_ RTC_GUARDED_BY(main_thread_);
absl::optional<int64_t> last_estimated_playout_ntp_timestamp_ms_
RTC_GUARDED_BY(main_thread_);
absl::optional<int64_t> last_estimated_playout_time_ms_
RTC_GUARDED_BY(main_thread_);
// The thread on which this instance is constructed and some of its main
// methods are invoked on such as GetStats().
TaskQueueBase* const worker_thread_;
ScopedTaskSafety task_safety_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker decode_queue_;
SequenceChecker main_thread_;
RTC_NO_UNIQUE_ADDRESS SequenceChecker incoming_render_queue_;
};
} // namespace internal
} // namespace webrtc
#endif // VIDEO_RECEIVE_STATISTICS_PROXY_H_
|
