packet_router.h (5396B)
1 /* 2 * Copyright (c) 2015 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_PACING_PACKET_ROUTER_H_ 12 #define MODULES_PACING_PACKET_ROUTER_H_ 13 14 #include <stddef.h> 15 #include <stdint.h> 16 17 #include <cstdint> 18 #include <list> 19 #include <memory> 20 #include <optional> 21 #include <set> 22 #include <unordered_map> 23 #include <vector> 24 25 #include "absl/functional/any_invocable.h" 26 #include "api/array_view.h" 27 #include "api/sequence_checker.h" 28 #include "api/transport/network_types.h" 29 #include "api/units/data_size.h" 30 #include "modules/pacing/pacing_controller.h" 31 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" 32 #include "modules/rtp_rtcp/source/rtcp_packet.h" 33 #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" 34 #include "rtc_base/thread_annotations.h" 35 36 namespace webrtc { 37 38 class RtpRtcpInterface; 39 40 // PacketRouter keeps track of rtp send modules to support the pacer. 41 // In addition, it handles feedback messages, which are sent on a send 42 // module if possible (sender report), otherwise on receive module 43 // (receiver report). For the latter case, we also keep track of the 44 // receive modules. 45 class PacketRouter : public PacingController::PacketSender { 46 public: 47 PacketRouter(); 48 ~PacketRouter() override; 49 50 PacketRouter(const PacketRouter&) = delete; 51 PacketRouter& operator=(const PacketRouter&) = delete; 52 53 // Callback is invoked after pacing, before a packet is forwarded to the 54 // sending rtp module. 55 void RegisterNotifyBweCallback( 56 absl::AnyInvocable<void(const RtpPacketToSend& packet, 57 const PacedPacketInfo& pacing_info)> callback); 58 59 // Ensures that PacketRouter generates transport sequence numbers for all RTP 60 // packets. If `send_rtp_packets_as_ect1` is true, packets will be requested 61 // to be sent as ect1. 62 void ConfigureForRfc8888Feedback(bool send_rtp_packets_as_ect1); 63 64 void AddSendRtpModule(RtpRtcpInterface* rtp_module, bool remb_candidate); 65 void RemoveSendRtpModule(RtpRtcpInterface* rtp_module); 66 67 bool SupportsRtxPayloadPadding() const; 68 69 void AddReceiveRtpModule(RtcpFeedbackSenderInterface* rtcp_sender, 70 bool remb_candidate); 71 void RemoveReceiveRtpModule(RtcpFeedbackSenderInterface* rtcp_sender); 72 73 void SendPacket(std::unique_ptr<RtpPacketToSend> packet, 74 const PacedPacketInfo& cluster_info) override; 75 std::vector<std::unique_ptr<RtpPacketToSend>> FetchFec() override; 76 std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding( 77 DataSize size) override; 78 void OnAbortedRetransmissions( 79 uint32_t ssrc, 80 ArrayView<const uint16_t> sequence_numbers) override; 81 std::optional<uint32_t> GetRtxSsrcForMedia(uint32_t ssrc) const override; 82 void OnBatchComplete() override; 83 84 // Send REMB feedback. 85 void SendRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs); 86 87 // Sends `packets` in one or more IP packets. 88 void SendCombinedRtcpPacket( 89 std::vector<std::unique_ptr<rtcp::RtcpPacket>> packets); 90 91 private: 92 void AddRembModuleCandidate(RtcpFeedbackSenderInterface* candidate_module, 93 bool media_sender); 94 void MaybeRemoveRembModuleCandidate( 95 RtcpFeedbackSenderInterface* candidate_module, 96 bool media_sender); 97 void UnsetActiveRembModule(); 98 void DetermineActiveRembModule(); 99 void AddSendRtpModuleToMap(RtpRtcpInterface* rtp_module, uint32_t ssrc); 100 void RemoveSendRtpModuleFromMap(uint32_t ssrc); 101 102 SequenceChecker thread_checker_; 103 // Ssrc to RtpRtcpInterface module; 104 std::unordered_map<uint32_t, RtpRtcpInterface*> send_modules_map_ 105 RTC_GUARDED_BY(thread_checker_); 106 std::list<RtpRtcpInterface*> send_modules_list_ 107 RTC_GUARDED_BY(thread_checker_); 108 // The last module used to send media. 109 RtpRtcpInterface* last_send_module_ RTC_GUARDED_BY(thread_checker_); 110 // Rtcp modules of the rtp receivers. 111 std::vector<RtcpFeedbackSenderInterface*> rtcp_feedback_senders_ 112 RTC_GUARDED_BY(thread_checker_); 113 114 // Candidates for the REMB module can be RTP sender/receiver modules, with 115 // the sender modules taking precedence. 116 std::vector<RtcpFeedbackSenderInterface*> sender_remb_candidates_ 117 RTC_GUARDED_BY(thread_checker_); 118 std::vector<RtcpFeedbackSenderInterface*> receiver_remb_candidates_ 119 RTC_GUARDED_BY(thread_checker_); 120 RtcpFeedbackSenderInterface* active_remb_module_ 121 RTC_GUARDED_BY(thread_checker_); 122 123 uint64_t transport_seq_ RTC_GUARDED_BY(thread_checker_); 124 bool use_cc_feedback_according_to_rfc8888_ RTC_GUARDED_BY(thread_checker_) = 125 false; 126 bool send_rtp_packets_as_ect1_ RTC_GUARDED_BY(thread_checker_) = false; 127 absl::AnyInvocable<void(RtpPacketToSend& packet, 128 const PacedPacketInfo& pacing_info)> 129 notify_bwe_callback_ RTC_GUARDED_BY(thread_checker_) = nullptr; 130 131 std::vector<std::unique_ptr<RtpPacketToSend>> pending_fec_packets_ 132 RTC_GUARDED_BY(thread_checker_); 133 std::set<RtpRtcpInterface*> modules_used_in_current_batch_ 134 RTC_GUARDED_BY(thread_checker_); 135 }; 136 } // namespace webrtc 137 #endif // MODULES_PACING_PACKET_ROUTER_H_