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