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