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 MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
12 #define MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
13 
14 #include <stddef.h>
15 #include <stdint.h>
16 
17 #include <memory>
18 #include <set>
19 #include <string>
20 #include <vector>
21 
22 #include "absl/types/optional.h"
23 #include "api/rtp_headers.h"
24 #include "api/video/video_bitrate_allocation.h"
25 #include "modules/include/module_fec_types.h"
26 #include "modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
27 #include "modules/rtp_rtcp/include/rtp_rtcp.h"
28 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"  // RTCPPacketType
29 #include "modules/rtp_rtcp/source/deprecated/deprecated_rtp_sender_egress.h"
30 #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
31 #include "modules/rtp_rtcp/source/rtcp_receiver.h"
32 #include "modules/rtp_rtcp/source/rtcp_sender.h"
33 #include "modules/rtp_rtcp/source/rtp_packet_history.h"
34 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
35 #include "modules/rtp_rtcp/source/rtp_sender.h"
36 #include "rtc_base/gtest_prod_util.h"
37 #include "rtc_base/synchronization/mutex.h"
38 
39 namespace webrtc {
40 
41 class Clock;
42 struct PacedPacketInfo;
43 struct RTPVideoHeader;
44 
45 // DEPRECATED.
46 class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
47  public:
48   explicit ModuleRtpRtcpImpl(
49       const RtpRtcpInterface::Configuration& configuration);
50   ~ModuleRtpRtcpImpl() override;
51 
52   // Returns the number of milliseconds until the module want a worker thread to
53   // call Process.
54   int64_t TimeUntilNextProcess() override;
55 
56   // Process any pending tasks such as timeouts.
57   void Process() override;
58 
59   // Receiver part.
60 
61   // Called when we receive an RTCP packet.
62   void IncomingRtcpPacket(const uint8_t* incoming_packet,
63                           size_t incoming_packet_length) override;
64 
65   void SetRemoteSSRC(uint32_t ssrc) override;
66 
67   // Sender part.
68   void RegisterSendPayloadFrequency(int payload_type,
69                                     int payload_frequency) override;
70 
71   int32_t DeRegisterSendPayload(int8_t payload_type) override;
72 
73   void SetExtmapAllowMixed(bool extmap_allow_mixed) override;
74 
75   // Register RTP header extension.
76   void RegisterRtpHeaderExtension(absl::string_view uri, int id) override;
77   int32_t DeregisterSendRtpHeaderExtension(RTPExtensionType type) override;
78   void DeregisterSendRtpHeaderExtension(absl::string_view uri) override;
79 
80   bool SupportsPadding() const override;
81   bool SupportsRtxPayloadPadding() const override;
82 
83   // Get start timestamp.
84   uint32_t StartTimestamp() const override;
85 
86   // Configure start timestamp, default is a random number.
87   void SetStartTimestamp(uint32_t timestamp) override;
88 
89   uint16_t SequenceNumber() const override;
90 
91   // Set SequenceNumber, default is a random number.
92   void SetSequenceNumber(uint16_t seq) override;
93 
94   void SetRtpState(const RtpState& rtp_state) override;
95   void SetRtxState(const RtpState& rtp_state) override;
96   RtpState GetRtpState() const override;
97   RtpState GetRtxState() const override;
98 
SSRC()99   uint32_t SSRC() const override { return rtcp_sender_.SSRC(); }
100 
101   void SetRid(const std::string& rid) override;
102 
103   void SetMid(const std::string& mid) override;
104 
105   void SetCsrcs(const std::vector<uint32_t>& csrcs) override;
106 
107   RTCPSender::FeedbackState GetFeedbackState();
108 
109   void SetRtxSendStatus(int mode) override;
110   int RtxSendStatus() const override;
111   absl::optional<uint32_t> RtxSsrc() const override;
112 
113   void SetRtxSendPayloadType(int payload_type,
114                              int associated_payload_type) override;
115 
116   absl::optional<uint32_t> FlexfecSsrc() const override;
117 
118   // Sends kRtcpByeCode when going from true to false.
119   int32_t SetSendingStatus(bool sending) override;
120 
121   bool Sending() const override;
122 
123   // Drops or relays media packets.
124   void SetSendingMediaStatus(bool sending) override;
125 
126   bool SendingMedia() const override;
127 
128   bool IsAudioConfigured() const override;
129 
130   void SetAsPartOfAllocation(bool part_of_allocation) override;
131 
132   bool OnSendingRtpFrame(uint32_t timestamp,
133                          int64_t capture_time_ms,
134                          int payload_type,
135                          bool force_sender_report) override;
136 
137   bool TrySendPacket(RtpPacketToSend* packet,
138                      const PacedPacketInfo& pacing_info) override;
139 
140   void SetFecProtectionParams(const FecProtectionParams& delta_params,
141                               const FecProtectionParams& key_params) override;
142 
143   std::vector<std::unique_ptr<RtpPacketToSend>> FetchFecPackets() override;
144 
145   void OnPacketsAcknowledged(
146       rtc::ArrayView<const uint16_t> sequence_numbers) override;
147 
148   std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding(
149       size_t target_size_bytes) override;
150 
151   std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos(
152       rtc::ArrayView<const uint16_t> sequence_numbers) const override;
153 
154   size_t ExpectedPerPacketOverhead() const override;
155 
156   // RTCP part.
157 
158   // Get RTCP status.
159   RtcpMode RTCP() const override;
160 
161   // Configure RTCP status i.e on/off.
162   void SetRTCPStatus(RtcpMode method) override;
163 
164   // Set RTCP CName.
165   int32_t SetCNAME(const char* c_name) override;
166 
167   // Get remote NTP.
168   int32_t RemoteNTP(uint32_t* received_ntp_secs,
169                     uint32_t* received_ntp_frac,
170                     uint32_t* rtcp_arrival_time_secs,
171                     uint32_t* rtcp_arrival_time_frac,
172                     uint32_t* rtcp_timestamp) const override;
173 
174   // Get RoundTripTime.
175   int32_t RTT(uint32_t remote_ssrc,
176               int64_t* rtt,
177               int64_t* avg_rtt,
178               int64_t* min_rtt,
179               int64_t* max_rtt) const override;
180 
181   int64_t ExpectedRetransmissionTimeMs() const override;
182 
183   // Force a send of an RTCP packet.
184   // Normal SR and RR are triggered via the process function.
185   int32_t SendRTCP(RTCPPacketType rtcpPacketType) override;
186 
187   void GetSendStreamDataCounters(
188       StreamDataCounters* rtp_counters,
189       StreamDataCounters* rtx_counters) const override;
190 
191   // A snapshot of the most recent Report Block with additional data of
192   // interest to statistics. Used to implement RTCRemoteInboundRtpStreamStats.
193   // Within this list, the ReportBlockData::RTCPReportBlock::source_ssrc(),
194   // which is the SSRC of the corresponding outbound RTP stream, is unique.
195   std::vector<ReportBlockData> GetLatestReportBlockData() const override;
196   absl::optional<SenderReportStats> GetSenderReportStats() const override;
197 
198   // (REMB) Receiver Estimated Max Bitrate.
199   void SetRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs) override;
200   void UnsetRemb() override;
201 
202   void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) override;
203 
204   size_t MaxRtpPacketSize() const override;
205 
206   void SetMaxRtpPacketSize(size_t max_packet_size) override;
207 
208   // (NACK) Negative acknowledgment part.
209 
210   // Send a Negative acknowledgment packet.
211   // TODO(philipel): Deprecate SendNACK and use SendNack instead.
212   int32_t SendNACK(const uint16_t* nack_list, uint16_t size) override;
213 
214   void SendNack(const std::vector<uint16_t>& sequence_numbers) override;
215 
216   // Store the sent packets, needed to answer to a negative acknowledgment
217   // requests.
218   void SetStorePacketsStatus(bool enable, uint16_t number_to_store) override;
219 
220   void SendCombinedRtcpPacket(
221       std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) override;
222 
223   // Video part.
224   int32_t SendLossNotification(uint16_t last_decoded_seq_num,
225                                uint16_t last_received_seq_num,
226                                bool decodability_flag,
227                                bool buffering_allowed) override;
228 
229   RtpSendRates GetSendRates() const override;
230 
231   void OnReceivedNack(
232       const std::vector<uint16_t>& nack_sequence_numbers) override;
233   void OnReceivedRtcpReportBlocks(
234       const ReportBlockList& report_blocks) override;
235   void OnRequestSendReport() override;
236 
237   void SetVideoBitrateAllocation(
238       const VideoBitrateAllocation& bitrate) override;
239 
240   RTPSender* RtpSender() override;
241   const RTPSender* RtpSender() const override;
242 
243  protected:
244   bool UpdateRTCPReceiveInformationTimers();
245 
rtp_sender()246   RTPSender* rtp_sender() {
247     return rtp_sender_ ? &rtp_sender_->packet_generator : nullptr;
248   }
rtp_sender()249   const RTPSender* rtp_sender() const {
250     return rtp_sender_ ? &rtp_sender_->packet_generator : nullptr;
251   }
252 
rtcp_sender()253   RTCPSender* rtcp_sender() { return &rtcp_sender_; }
rtcp_sender()254   const RTCPSender* rtcp_sender() const { return &rtcp_sender_; }
255 
rtcp_receiver()256   RTCPReceiver* rtcp_receiver() { return &rtcp_receiver_; }
rtcp_receiver()257   const RTCPReceiver* rtcp_receiver() const { return &rtcp_receiver_; }
258 
SetMediaHasBeenSent(bool media_has_been_sent)259   void SetMediaHasBeenSent(bool media_has_been_sent) {
260     rtp_sender_->packet_sender.SetMediaHasBeenSent(media_has_been_sent);
261   }
262 
clock()263   Clock* clock() const { return clock_; }
264 
265  private:
266   FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, Rtt);
267   FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, RttForReceiverOnly);
268 
269   struct RtpSenderContext {
270     explicit RtpSenderContext(const RtpRtcpInterface::Configuration& config);
271     // Storage of packets, for retransmissions and padding, if applicable.
272     RtpPacketHistory packet_history;
273     // Handles final time timestamping/stats/etc and handover to Transport.
274     DEPRECATED_RtpSenderEgress packet_sender;
275     // If no paced sender configured, this class will be used to pass packets
276     // from |packet_generator_| to |packet_sender_|.
277     DEPRECATED_RtpSenderEgress::NonPacedPacketSender non_paced_sender;
278     // Handles creation of RTP packets to be sent.
279     RTPSender packet_generator;
280   };
281 
282   void set_rtt_ms(int64_t rtt_ms);
283   int64_t rtt_ms() const;
284 
285   bool TimeToSendFullNackList(int64_t now) const;
286 
287   // Returns true if the module is configured to store packets.
288   bool StorePackets() const;
289 
290   // Returns current Receiver Reference Time Report (RTTR) status.
291   bool RtcpXrRrtrStatus() const;
292 
293   std::unique_ptr<RtpSenderContext> rtp_sender_;
294 
295   RTCPSender rtcp_sender_;
296   RTCPReceiver rtcp_receiver_;
297 
298   Clock* const clock_;
299 
300   int64_t last_bitrate_process_time_;
301   int64_t last_rtt_process_time_;
302   int64_t next_process_time_;
303   uint16_t packet_overhead_;
304 
305   // Send side
306   int64_t nack_last_time_sent_full_ms_;
307   uint16_t nack_last_seq_number_sent_;
308 
309   RemoteBitrateEstimator* const remote_bitrate_;
310 
311   RtcpRttStats* const rtt_stats_;
312 
313   // The processed RTT from RtcpRttStats.
314   mutable Mutex mutex_rtt_;
315   int64_t rtt_ms_ RTC_GUARDED_BY(mutex_rtt_);
316 };
317 
318 }  // namespace webrtc
319 
320 #endif  // MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL_H_
321