Line data Source code
1 : /*
2 : * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 : *
4 : * Use of this source code is governed by a BSD-style license
5 : * that can be found in the LICENSE file in the root of the source
6 : * tree. An additional intellectual property rights grant can be found
7 : * in the file PATENTS. All contributing project authors may
8 : * be found in the AUTHORS file in the root of the source tree.
9 : */
10 :
11 : #ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
12 : #define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
13 :
14 : #include <map>
15 : #include <set>
16 : #include <string>
17 : #include <vector>
18 :
19 : #include "webrtc/base/criticalsection.h"
20 : #include "webrtc/base/thread_annotations.h"
21 : #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
22 : #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
23 : #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
24 : #include "webrtc/system_wrappers/include/ntp_time.h"
25 : #include "webrtc/typedefs.h"
26 :
27 : namespace webrtc {
28 : class VideoBitrateAllocationObserver;
29 : namespace rtcp {
30 : class CommonHeader;
31 : class ReportBlock;
32 : class Rrtr;
33 : class TargetBitrate;
34 : class TmmbItem;
35 : } // namespace rtcp
36 :
37 : class RTCPReceiver {
38 : public:
39 0 : class ModuleRtpRtcp {
40 : public:
41 : virtual void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) = 0;
42 : virtual void OnRequestSendReport() = 0;
43 : virtual void OnReceivedNack(
44 : const std::vector<uint16_t>& nack_sequence_numbers) = 0;
45 : virtual void OnReceivedRtcpReportBlocks(
46 : const ReportBlockList& report_blocks) = 0;
47 :
48 : virtual bool GetSendReportMetadata(const uint32_t send_report,
49 : uint64_t *time_of_send,
50 : uint32_t *packet_count,
51 : uint64_t *octet_count) = 0;
52 :
53 : protected:
54 0 : virtual ~ModuleRtpRtcp() = default;
55 : };
56 :
57 : RTCPReceiver(Clock* clock,
58 : bool receiver_only,
59 : RtcpPacketTypeCounterObserver* packet_type_counter_observer,
60 : RtcpBandwidthObserver* rtcp_bandwidth_observer,
61 : RtcpIntraFrameObserver* rtcp_intra_frame_observer,
62 : TransportFeedbackObserver* transport_feedback_observer,
63 : VideoBitrateAllocationObserver* bitrate_allocation_observer,
64 : ModuleRtpRtcp* owner);
65 : virtual ~RTCPReceiver();
66 :
67 : bool IncomingPacket(const uint8_t* packet, size_t packet_size);
68 :
69 : int64_t LastReceivedReceiverReport() const;
70 :
71 : void SetSsrcs(uint32_t main_ssrc, const std::set<uint32_t>& registered_ssrcs);
72 : void SetRemoteSSRC(uint32_t ssrc);
73 : uint32_t RemoteSSRC() const;
74 :
75 : // Get received cname.
76 : int32_t CNAME(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]) const;
77 :
78 : // Get received NTP.
79 : bool NTP(uint32_t* received_ntp_secs,
80 : uint32_t* received_ntp_frac,
81 : uint32_t* rtcp_arrival_time_secs,
82 : uint32_t* rtcp_arrival_time_frac,
83 : uint32_t* rtcp_timestamp) const;
84 :
85 : bool LastReceivedXrReferenceTimeInfo(rtcp::ReceiveTimeInfo* info) const;
86 :
87 : // Get rtt.
88 : int32_t RTT(uint32_t remote_ssrc,
89 : int64_t* last_rtt_ms,
90 : int64_t* avg_rtt_ms,
91 : int64_t* min_rtt_ms,
92 : int64_t* max_rtt_ms) const;
93 :
94 : int32_t SenderInfoReceived(RTCPSenderInfo* sender_info) const;
95 :
96 : void SetRtcpXrRrtrStatus(bool enable);
97 : bool GetAndResetXrRrRtt(int64_t* rtt_ms);
98 :
99 : // Get statistics.
100 : int32_t StatisticsReceived(std::vector<RTCPReportBlock>* receiveBlocks) const;
101 :
102 : // Returns true if we haven't received an RTCP RR for several RTCP
103 : // intervals, but only triggers true once.
104 : bool RtcpRrTimeout(int64_t rtcp_interval_ms);
105 :
106 : // Returns true if we haven't received an RTCP RR telling the receive side
107 : // has not received RTP packets for too long, i.e. extended highest sequence
108 : // number hasn't increased for several RTCP intervals. The function only
109 : // returns true once until a new RR is received.
110 : bool RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms);
111 :
112 : std::vector<rtcp::TmmbItem> TmmbrReceived();
113 :
114 : bool UpdateRTCPReceiveInformationTimers();
115 :
116 : std::vector<rtcp::TmmbItem> BoundingSet(bool* tmmbr_owner);
117 :
118 : void UpdateTmmbr();
119 :
120 : void RegisterRtcpStatisticsCallback(RtcpStatisticsCallback* callback);
121 : RtcpStatisticsCallback* GetRtcpStatisticsCallback();
122 :
123 : private:
124 : struct PacketInformation;
125 : struct ReceiveInformation;
126 : struct ReportBlockWithRtt;
127 : // Mapped by remote ssrc.
128 : using ReceivedInfoMap = std::map<uint32_t, ReceiveInformation>;
129 : // RTCP report blocks mapped by remote SSRC.
130 : using ReportBlockInfoMap = std::map<uint32_t, ReportBlockWithRtt>;
131 : // RTCP report blocks map mapped by source SSRC.
132 : using ReportBlockMap = std::map<uint32_t, ReportBlockInfoMap>;
133 :
134 : bool ParseCompoundPacket(const uint8_t* packet_begin,
135 : const uint8_t* packet_end,
136 : PacketInformation* packet_information);
137 :
138 : void TriggerCallbacksFromRtcpPacket(
139 : const PacketInformation& packet_information);
140 :
141 : void CreateReceiveInformation(uint32_t remote_ssrc)
142 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
143 : ReceiveInformation* GetReceiveInformation(uint32_t remote_ssrc)
144 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
145 :
146 : void HandleSenderReport(const rtcp::CommonHeader& rtcp_block,
147 : PacketInformation* packet_information)
148 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
149 :
150 : void HandleReceiverReport(const rtcp::CommonHeader& rtcp_block,
151 : PacketInformation* packet_information)
152 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
153 :
154 : void HandleReportBlock(const rtcp::ReportBlock& report_block,
155 : PacketInformation* packet_information,
156 : uint32_t remote_ssrc)
157 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
158 :
159 : void HandleSdes(const rtcp::CommonHeader& rtcp_block,
160 : PacketInformation* packet_information)
161 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
162 :
163 : void HandleXr(const rtcp::CommonHeader& rtcp_block,
164 : PacketInformation* packet_information)
165 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
166 :
167 : void HandleXrReceiveReferenceTime(uint32_t sender_ssrc,
168 : const rtcp::Rrtr& rrtr)
169 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
170 :
171 : void HandleXrDlrrReportBlock(const rtcp::ReceiveTimeInfo& rti)
172 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
173 :
174 : void HandleXrTargetBitrate(const rtcp::TargetBitrate& target_bitrate,
175 : PacketInformation* packet_information)
176 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
177 :
178 : void HandleNack(const rtcp::CommonHeader& rtcp_block,
179 : PacketInformation* packet_information)
180 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
181 :
182 : void HandleBye(const rtcp::CommonHeader& rtcp_block)
183 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
184 :
185 : void HandlePli(const rtcp::CommonHeader& rtcp_block,
186 : PacketInformation* packet_information)
187 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
188 :
189 : void HandleSli(const rtcp::CommonHeader& rtcp_block,
190 : PacketInformation* packet_information)
191 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
192 :
193 : void HandleRpsi(const rtcp::CommonHeader& rtcp_block,
194 : PacketInformation* packet_information)
195 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
196 :
197 : void HandlePsfbApp(const rtcp::CommonHeader& rtcp_block,
198 : PacketInformation* packet_information)
199 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
200 :
201 : void HandleTmmbr(const rtcp::CommonHeader& rtcp_block,
202 : PacketInformation* packet_information)
203 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
204 :
205 : void HandleTmmbn(const rtcp::CommonHeader& rtcp_block,
206 : PacketInformation* packet_information)
207 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
208 :
209 : void HandleSrReq(const rtcp::CommonHeader& rtcp_block,
210 : PacketInformation* packet_information)
211 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
212 :
213 : void HandleFir(const rtcp::CommonHeader& rtcp_block,
214 : PacketInformation* packet_information)
215 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
216 :
217 : void HandleTransportFeedback(const rtcp::CommonHeader& rtcp_block,
218 : PacketInformation* packet_information)
219 : EXCLUSIVE_LOCKS_REQUIRED(rtcp_receiver_lock_);
220 :
221 : Clock* const clock_;
222 : const bool receiver_only_;
223 : ModuleRtpRtcp* const rtp_rtcp_;
224 :
225 : rtc::CriticalSection feedbacks_lock_;
226 : RtcpBandwidthObserver* const rtcp_bandwidth_observer_;
227 : RtcpIntraFrameObserver* const rtcp_intra_frame_observer_;
228 : TransportFeedbackObserver* const transport_feedback_observer_;
229 : VideoBitrateAllocationObserver* const bitrate_allocation_observer_;
230 :
231 : rtc::CriticalSection rtcp_receiver_lock_;
232 : uint32_t main_ssrc_ GUARDED_BY(rtcp_receiver_lock_);
233 : uint32_t remote_ssrc_ GUARDED_BY(rtcp_receiver_lock_);
234 : std::set<uint32_t> registered_ssrcs_ GUARDED_BY(rtcp_receiver_lock_);
235 :
236 : // Received sender report.
237 : RTCPSenderInfo remote_sender_info_;
238 : // When did we receive the last send report.
239 : NtpTime last_received_sr_ntp_;
240 :
241 : // Received XR receive time report.
242 : rtcp::ReceiveTimeInfo remote_time_info_;
243 : // Time when the report was received.
244 : NtpTime last_received_xr_ntp_;
245 : // Estimated rtt, zero when there is no valid estimate.
246 : bool xr_rrtr_status_ GUARDED_BY(rtcp_receiver_lock_);
247 : int64_t xr_rr_rtt_ms_;
248 :
249 : // Received report blocks.
250 : ReportBlockMap received_report_blocks_ GUARDED_BY(rtcp_receiver_lock_);
251 : ReceivedInfoMap received_infos_ GUARDED_BY(rtcp_receiver_lock_);
252 : std::map<uint32_t, std::string> received_cnames_
253 : GUARDED_BY(rtcp_receiver_lock_);
254 :
255 : // The last time we received an RTCP RR.
256 : int64_t last_received_rr_ms_;
257 :
258 : // The time we last received an RTCP RR telling we have successfully
259 : // delivered RTP packet to the remote side.
260 : int64_t last_increased_sequence_number_ms_;
261 :
262 : RtcpStatisticsCallback* stats_callback_ GUARDED_BY(feedbacks_lock_);
263 :
264 : RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
265 : RtcpPacketTypeCounter packet_type_counter_;
266 :
267 : RTCPUtility::NackStats nack_stats_;
268 :
269 : size_t num_skipped_packets_;
270 : int64_t last_skipped_packets_warning_ms_;
271 : };
272 : } // namespace webrtc
273 : #endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_RECEIVER_H_
|
