blob: e7a3ac03e8ce81a4206b583bb2cf5e3ac02856f0 [file] [log] [blame]
Tommi3a5742c2020-05-20 09:32:51 +02001/*
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 MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL2_H_
12#define MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL2_H_
13
14#include <stddef.h>
15#include <stdint.h>
16
17#include <memory>
18#include <set>
19#include <string>
20#include <vector>
21
Ali Tofighd14e8892022-05-13 11:42:16 +020022#include "absl/strings/string_view.h"
Tommi3a5742c2020-05-20 09:32:51 +020023#include "absl/types/optional.h"
24#include "api/rtp_headers.h"
Artem Titovd15a5752021-02-10 14:31:24 +010025#include "api/sequence_checker.h"
Artem Titovc374d112022-06-16 21:27:45 +020026#include "api/task_queue/pending_task_safety_flag.h"
Tomas Gunnarsson473bbd82020-06-27 17:44:55 +020027#include "api/task_queue/task_queue_base.h"
Markus Handell885d5382021-06-21 18:57:36 +020028#include "api/units/time_delta.h"
Tommi3a5742c2020-05-20 09:32:51 +020029#include "api/video/video_bitrate_allocation.h"
30#include "modules/include/module_fec_types.h"
Tommi3a5742c2020-05-20 09:32:51 +020031#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" // RTCPPacketType
Erik Språngbfcfe032021-08-04 14:45:32 +020032#include "modules/rtp_rtcp/source/packet_sequencer.h"
Tommi3a5742c2020-05-20 09:32:51 +020033#include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
34#include "modules/rtp_rtcp/source/rtcp_receiver.h"
35#include "modules/rtp_rtcp/source/rtcp_sender.h"
36#include "modules/rtp_rtcp/source/rtp_packet_history.h"
37#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
38#include "modules/rtp_rtcp/source/rtp_sender.h"
39#include "modules/rtp_rtcp/source/rtp_sender_egress.h"
Tommi3a5742c2020-05-20 09:32:51 +020040#include "rtc_base/gtest_prod_util.h"
Markus Handellf7303e62020-07-09 01:34:42 +020041#include "rtc_base/synchronization/mutex.h"
Mirko Bonadei20e4c802020-11-23 11:07:42 +010042#include "rtc_base/system/no_unique_address.h"
Tomas Gunnarssonba0ba712020-07-01 08:53:21 +020043#include "rtc_base/task_utils/repeating_task.h"
Markus Handell885d5382021-06-21 18:57:36 +020044#include "rtc_base/thread_annotations.h"
Tommi3a5742c2020-05-20 09:32:51 +020045
46namespace webrtc {
47
48class Clock;
49struct PacedPacketInfo;
50struct RTPVideoHeader;
51
Tomas Gunnarssonf25761d2020-06-03 22:55:33 +020052class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface,
Tommi3a5742c2020-05-20 09:32:51 +020053 public RTCPReceiver::ModuleRtpRtcp {
54 public:
Tomas Gunnarssonf25761d2020-06-03 22:55:33 +020055 explicit ModuleRtpRtcpImpl2(
56 const RtpRtcpInterface::Configuration& configuration);
Tommi3a5742c2020-05-20 09:32:51 +020057 ~ModuleRtpRtcpImpl2() override;
58
Niels Moller2accc7d2021-01-12 15:54:16 +000059 // This method is provided to easy with migrating away from the
60 // RtpRtcp::Create factory method. Since this is an internal implementation
61 // detail though, creating an instance of ModuleRtpRtcpImpl2 directly should
62 // be fine.
63 static std::unique_ptr<ModuleRtpRtcpImpl2> Create(
64 const Configuration& configuration);
65
Tommi3a5742c2020-05-20 09:32:51 +020066 // Receiver part.
67
68 // Called when we receive an RTCP packet.
69 void IncomingRtcpPacket(const uint8_t* incoming_packet,
70 size_t incoming_packet_length) override;
71
72 void SetRemoteSSRC(uint32_t ssrc) override;
73
Tommi08be9ba2021-06-15 23:01:57 +020074 void SetLocalSsrc(uint32_t local_ssrc) override;
75
Tommi3a5742c2020-05-20 09:32:51 +020076 // Sender part.
77 void RegisterSendPayloadFrequency(int payload_type,
78 int payload_frequency) override;
79
80 int32_t DeRegisterSendPayload(int8_t payload_type) override;
81
82 void SetExtmapAllowMixed(bool extmap_allow_mixed) override;
83
Tommi3a5742c2020-05-20 09:32:51 +020084 void RegisterRtpHeaderExtension(absl::string_view uri, int id) override;
Tommi3a5742c2020-05-20 09:32:51 +020085 void DeregisterSendRtpHeaderExtension(absl::string_view uri) override;
86
87 bool SupportsPadding() const override;
88 bool SupportsRtxPayloadPadding() const override;
89
90 // Get start timestamp.
91 uint32_t StartTimestamp() const override;
92
93 // Configure start timestamp, default is a random number.
94 void SetStartTimestamp(uint32_t timestamp) override;
95
96 uint16_t SequenceNumber() const override;
97
98 // Set SequenceNumber, default is a random number.
99 void SetSequenceNumber(uint16_t seq) override;
100
101 void SetRtpState(const RtpState& rtp_state) override;
102 void SetRtxState(const RtpState& rtp_state) override;
103 RtpState GetRtpState() const override;
104 RtpState GetRtxState() const override;
105
Ivo Creusen8c40d512021-07-13 12:53:22 +0000106 void SetNonSenderRttMeasurement(bool enabled) override;
107
Tommi3a5742c2020-05-20 09:32:51 +0200108 uint32_t SSRC() const override { return rtcp_sender_.SSRC(); }
109
Tommi08be9ba2021-06-15 23:01:57 +0200110 // Semantically identical to `SSRC()` but must be called on the packet
111 // delivery thread/tq and returns the ssrc that maps to
112 // RtpRtcpInterface::Configuration::local_media_ssrc.
113 uint32_t local_media_ssrc() const;
114
Ali Tofighd14e8892022-05-13 11:42:16 +0200115 void SetMid(absl::string_view mid) override;
Tommi3a5742c2020-05-20 09:32:51 +0200116
Tommi3a5742c2020-05-20 09:32:51 +0200117 RTCPSender::FeedbackState GetFeedbackState();
118
119 void SetRtxSendStatus(int mode) override;
120 int RtxSendStatus() const override;
121 absl::optional<uint32_t> RtxSsrc() const override;
122
123 void SetRtxSendPayloadType(int payload_type,
124 int associated_payload_type) override;
125
126 absl::optional<uint32_t> FlexfecSsrc() const override;
127
128 // Sends kRtcpByeCode when going from true to false.
129 int32_t SetSendingStatus(bool sending) override;
130
131 bool Sending() const override;
132
133 // Drops or relays media packets.
134 void SetSendingMediaStatus(bool sending) override;
135
136 bool SendingMedia() const override;
137
138 bool IsAudioConfigured() const override;
139
140 void SetAsPartOfAllocation(bool part_of_allocation) override;
141
142 bool OnSendingRtpFrame(uint32_t timestamp,
143 int64_t capture_time_ms,
144 int payload_type,
145 bool force_sender_report) override;
146
147 bool TrySendPacket(RtpPacketToSend* packet,
148 const PacedPacketInfo& pacing_info) override;
149
Erik Språng1d50cb62020-07-02 17:41:32 +0200150 void SetFecProtectionParams(const FecProtectionParams& delta_params,
151 const FecProtectionParams& key_params) override;
152
153 std::vector<std::unique_ptr<RtpPacketToSend>> FetchFecPackets() override;
154
Erik Språng50459492022-09-08 16:53:06 +0200155 void OnAbortedRetransmissions(
156 rtc::ArrayView<const uint16_t> sequence_numbers) override;
157
Tommi3a5742c2020-05-20 09:32:51 +0200158 void OnPacketsAcknowledged(
159 rtc::ArrayView<const uint16_t> sequence_numbers) override;
160
161 std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
162 size_t target_size_bytes) override;
163
164 std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos(
165 rtc::ArrayView<const uint16_t> sequence_numbers) const override;
166
167 size_t ExpectedPerPacketOverhead() const override;
168
Erik Språngb6bbdeb2021-08-13 16:12:41 +0200169 void OnPacketSendingThreadSwitched() override;
170
Tommi3a5742c2020-05-20 09:32:51 +0200171 // RTCP part.
172
173 // Get RTCP status.
174 RtcpMode RTCP() const override;
175
176 // Configure RTCP status i.e on/off.
177 void SetRTCPStatus(RtcpMode method) override;
178
179 // Set RTCP CName.
Ali Tofighd14e8892022-05-13 11:42:16 +0200180 int32_t SetCNAME(absl::string_view c_name) override;
Tommi3a5742c2020-05-20 09:32:51 +0200181
Tommi3a5742c2020-05-20 09:32:51 +0200182 // Get remote NTP.
183 int32_t RemoteNTP(uint32_t* received_ntp_secs,
184 uint32_t* received_ntp_frac,
185 uint32_t* rtcp_arrival_time_secs,
186 uint32_t* rtcp_arrival_time_frac,
187 uint32_t* rtcp_timestamp) const override;
188
Tommi3a5742c2020-05-20 09:32:51 +0200189 // Get RoundTripTime.
190 int32_t RTT(uint32_t remote_ssrc,
191 int64_t* rtt,
192 int64_t* avg_rtt,
193 int64_t* min_rtt,
194 int64_t* max_rtt) const override;
195
196 int64_t ExpectedRetransmissionTimeMs() const override;
197
198 // Force a send of an RTCP packet.
Markus Handell885d5382021-06-21 18:57:36 +0200199 // Normal SR and RR are triggered via the task queue that's current when this
200 // object is created.
Tommi3a5742c2020-05-20 09:32:51 +0200201 int32_t SendRTCP(RTCPPacketType rtcpPacketType) override;
202
Tommi3a5742c2020-05-20 09:32:51 +0200203 void GetSendStreamDataCounters(
204 StreamDataCounters* rtp_counters,
205 StreamDataCounters* rtx_counters) const override;
206
Tommi3a5742c2020-05-20 09:32:51 +0200207 // A snapshot of the most recent Report Block with additional data of
208 // interest to statistics. Used to implement RTCRemoteInboundRtpStreamStats.
209 // Within this list, the ReportBlockData::RTCPReportBlock::source_ssrc(),
210 // which is the SSRC of the corresponding outbound RTP stream, is unique.
211 std::vector<ReportBlockData> GetLatestReportBlockData() const override;
Alessio Bazzicabc1c93d2021-03-12 17:45:26 +0100212 absl::optional<SenderReportStats> GetSenderReportStats() const override;
Ivo Creusen2562cf02021-09-03 14:51:22 +0000213 absl::optional<NonSenderRttStats> GetNonSenderRttStats() const override;
Tommi3a5742c2020-05-20 09:32:51 +0200214
215 // (REMB) Receiver Estimated Max Bitrate.
216 void SetRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs) override;
217 void UnsetRemb() override;
218
Tommi3a5742c2020-05-20 09:32:51 +0200219 void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) override;
220
221 size_t MaxRtpPacketSize() const override;
222
223 void SetMaxRtpPacketSize(size_t max_packet_size) override;
224
225 // (NACK) Negative acknowledgment part.
226
227 // Send a Negative acknowledgment packet.
228 // TODO(philipel): Deprecate SendNACK and use SendNack instead.
229 int32_t SendNACK(const uint16_t* nack_list, uint16_t size) override;
230
231 void SendNack(const std::vector<uint16_t>& sequence_numbers) override;
232
233 // Store the sent packets, needed to answer to a negative acknowledgment
234 // requests.
235 void SetStorePacketsStatus(bool enable, uint16_t number_to_store) override;
236
Tommi3a5742c2020-05-20 09:32:51 +0200237 void SendCombinedRtcpPacket(
238 std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) override;
239
Tommi3a5742c2020-05-20 09:32:51 +0200240 // Video part.
241 int32_t SendLossNotification(uint16_t last_decoded_seq_num,
242 uint16_t last_received_seq_num,
243 bool decodability_flag,
244 bool buffering_allowed) override;
245
Tommi3a5742c2020-05-20 09:32:51 +0200246 RtpSendRates GetSendRates() const override;
247
248 void OnReceivedNack(
249 const std::vector<uint16_t>& nack_sequence_numbers) override;
250 void OnReceivedRtcpReportBlocks(
251 const ReportBlockList& report_blocks) override;
252 void OnRequestSendReport() override;
253
254 void SetVideoBitrateAllocation(
255 const VideoBitrateAllocation& bitrate) override;
256
257 RTPSender* RtpSender() override;
258 const RTPSender* RtpSender() const override;
259
Tommi3a5742c2020-05-20 09:32:51 +0200260 private:
261 FRIEND_TEST_ALL_PREFIXES(RtpRtcpImpl2Test, Rtt);
262 FRIEND_TEST_ALL_PREFIXES(RtpRtcpImpl2Test, RttForReceiverOnly);
263
Erik Språng54abf982021-08-13 17:25:44 +0200264 struct RtpSenderContext {
Tomas Gunnarssonf25761d2020-06-03 22:55:33 +0200265 explicit RtpSenderContext(const RtpRtcpInterface::Configuration& config);
Tommi3a5742c2020-05-20 09:32:51 +0200266 // Storage of packets, for retransmissions and padding, if applicable.
267 RtpPacketHistory packet_history;
Erik Språngb6bbdeb2021-08-13 16:12:41 +0200268 SequenceChecker sequencing_checker;
Erik Språngbfcfe032021-08-04 14:45:32 +0200269 // Handles sequence number assignment and padding timestamp generation.
Erik Språngb6bbdeb2021-08-13 16:12:41 +0200270 PacketSequencer sequencer RTC_GUARDED_BY(sequencing_checker);
Tommi3a5742c2020-05-20 09:32:51 +0200271 // Handles final time timestamping/stats/etc and handover to Transport.
272 RtpSenderEgress packet_sender;
273 // If no paced sender configured, this class will be used to pass packets
Artem Titov913cfa72021-07-28 23:57:33 +0200274 // from `packet_generator_` to `packet_sender_`.
Tommi3a5742c2020-05-20 09:32:51 +0200275 RtpSenderEgress::NonPacedPacketSender non_paced_sender;
276 // Handles creation of RTP packets to be sent.
277 RTPSender packet_generator;
278 };
279
280 void set_rtt_ms(int64_t rtt_ms);
281 int64_t rtt_ms() const;
282
283 bool TimeToSendFullNackList(int64_t now) const;
284
Tomas Gunnarssonba0ba712020-07-01 08:53:21 +0200285 // Called on a timer, once a second, on the worker_queue_, to update the RTT,
286 // check if we need to send RTCP report, send TMMBR updates and fire events.
287 void PeriodicUpdate();
288
Niels Mölleraf6ea0c2020-11-20 12:21:21 +0100289 // Returns true if the module is configured to store packets.
290 bool StorePackets() const;
291
Markus Handell885d5382021-06-21 18:57:36 +0200292 // Used from RtcpSenderMediator to maybe send rtcp.
293 void MaybeSendRtcp() RTC_RUN_ON(worker_queue_);
294
Artem Titov913cfa72021-07-28 23:57:33 +0200295 // Called when `rtcp_sender_` informs of the next RTCP instant. The method may
Markus Handell885d5382021-06-21 18:57:36 +0200296 // be called on various sequences, and is called under a RTCPSenderLock.
297 void ScheduleRtcpSendEvaluation(TimeDelta duration);
298
299 // Helper method combating too early delayed calls from task queues.
300 // TODO(bugs.webrtc.org/12889): Consider removing this function when the issue
301 // is resolved.
302 void MaybeSendRtcpAtOrAfterTimestamp(Timestamp execution_time)
303 RTC_RUN_ON(worker_queue_);
304
Artem Titov913cfa72021-07-28 23:57:33 +0200305 // Schedules a call to MaybeSendRtcpAtOrAfterTimestamp delayed by `duration`.
Markus Handell885d5382021-06-21 18:57:36 +0200306 void ScheduleMaybeSendRtcpAtOrAfterTimestamp(Timestamp execution_time,
307 TimeDelta duration);
308
Tomas Gunnarsson473bbd82020-06-27 17:44:55 +0200309 TaskQueueBase* const worker_queue_;
Erik Språngb6bbdeb2021-08-13 16:12:41 +0200310 RTC_NO_UNIQUE_ADDRESS SequenceChecker rtcp_thread_checker_;
Tommi3a5742c2020-05-20 09:32:51 +0200311
312 std::unique_ptr<RtpSenderContext> rtp_sender_;
Tommi3a5742c2020-05-20 09:32:51 +0200313 RTCPSender rtcp_sender_;
314 RTCPReceiver rtcp_receiver_;
315
316 Clock* const clock_;
317
Tommi3a5742c2020-05-20 09:32:51 +0200318 uint16_t packet_overhead_;
319
320 // Send side
321 int64_t nack_last_time_sent_full_ms_;
322 uint16_t nack_last_seq_number_sent_;
323
Tommi3a5742c2020-05-20 09:32:51 +0200324 RtcpRttStats* const rtt_stats_;
Tomas Gunnarssonba0ba712020-07-01 08:53:21 +0200325 RepeatingTaskHandle rtt_update_task_ RTC_GUARDED_BY(worker_queue_);
Tommi3a5742c2020-05-20 09:32:51 +0200326
327 // The processed RTT from RtcpRttStats.
Markus Handellf7303e62020-07-09 01:34:42 +0200328 mutable Mutex mutex_rtt_;
Niels Möllercd982132020-11-26 16:19:56 +0100329 int64_t rtt_ms_ RTC_GUARDED_BY(mutex_rtt_);
Markus Handell885d5382021-06-21 18:57:36 +0200330
331 RTC_NO_UNIQUE_ADDRESS ScopedTaskSafety task_safety_;
Tommi3a5742c2020-05-20 09:32:51 +0200332};
333
334} // namespace webrtc
335
336#endif // MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL2_H_