rtcp_transceiver_impl.h (7324B)
1 /* 2 * Copyright (c) 2017 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_RTCP_TRANSCEIVER_IMPL_H_ 12 #define MODULES_RTP_RTCP_SOURCE_RTCP_TRANSCEIVER_IMPL_H_ 13 14 #include <cstddef> 15 #include <cstdint> 16 #include <functional> 17 #include <list> 18 #include <memory> 19 #include <optional> 20 #include <vector> 21 22 #include "api/array_view.h" 23 #include "api/units/time_delta.h" 24 #include "api/units/timestamp.h" 25 #include "modules/rtp_rtcp/include/report_block_data.h" 26 #include "modules/rtp_rtcp/source/rtcp_packet.h" 27 #include "modules/rtp_rtcp/source/rtcp_packet/common_header.h" 28 #include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h" 29 #include "modules/rtp_rtcp/source/rtcp_packet/remb.h" 30 #include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" 31 #include "modules/rtp_rtcp/source/rtcp_packet/target_bitrate.h" 32 #include "modules/rtp_rtcp/source/rtcp_transceiver_config.h" 33 #include "rtc_base/containers/flat_map.h" 34 #include "rtc_base/task_utils/repeating_task.h" 35 36 namespace webrtc { 37 // 38 // Manage incoming and outgoing rtcp messages for multiple BUNDLED streams. 39 // 40 // This class is not thread-safe. 41 class RtcpTransceiverImpl { 42 public: 43 explicit RtcpTransceiverImpl(const RtcpTransceiverConfig& config); 44 RtcpTransceiverImpl(const RtcpTransceiverImpl&) = delete; 45 RtcpTransceiverImpl& operator=(const RtcpTransceiverImpl&) = delete; 46 ~RtcpTransceiverImpl(); 47 48 void StopPeriodicTask() { periodic_task_handle_.Stop(); } 49 50 void AddMediaReceiverRtcpObserver(uint32_t remote_ssrc, 51 MediaReceiverRtcpObserver* observer); 52 void RemoveMediaReceiverRtcpObserver(uint32_t remote_ssrc, 53 MediaReceiverRtcpObserver* observer); 54 55 // Returns false on failure, e.g. when there is already an handler for the 56 // `local_ssrc`. 57 bool AddMediaSender(uint32_t local_ssrc, RtpStreamRtcpHandler* handler); 58 bool RemoveMediaSender(uint32_t local_ssrc); 59 60 void SetReadyToSend(bool ready); 61 62 void ReceivePacket(ArrayView<const uint8_t> packet, Timestamp now); 63 64 void SendCompoundPacket(); 65 66 void SetRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs); 67 void UnsetRemb(); 68 69 void SendNack(uint32_t ssrc, std::vector<uint16_t> sequence_numbers); 70 71 void SendPictureLossIndication(uint32_t ssrc); 72 // If new_request is true then requested sequence no. will increase for each 73 // requested ssrc. 74 void SendFullIntraRequest(ArrayView<const uint32_t> ssrcs, bool new_request); 75 76 // SendCombinedRtcpPacket ignores rtcp mode and does not send a compound 77 // message. https://tools.ietf.org/html/rfc4585#section-3.1 78 void SendCombinedRtcpPacket( 79 std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets); 80 81 private: 82 class PacketSender; 83 struct RemoteSenderState; 84 struct LocalSenderState; 85 struct RrtrTimes { 86 // Received remote NTP timestamp in compact representation. 87 uint32_t received_remote_mid_ntp_time; 88 89 // Local NTP time when the report was received in compact representation. 90 uint32_t local_receive_mid_ntp_time; 91 }; 92 93 void HandleReceivedPacket(const rtcp::CommonHeader& rtcp_packet_header, 94 Timestamp now, 95 std::vector<ReportBlockData>& report_blocks); 96 // Individual rtcp packet handlers. 97 void HandleBye(const rtcp::CommonHeader& rtcp_packet_header); 98 void HandleSenderReport(const rtcp::CommonHeader& rtcp_packet_header, 99 Timestamp now, 100 std::vector<ReportBlockData>& report_blocks); 101 void HandleReceiverReport(const rtcp::CommonHeader& rtcp_packet_header, 102 Timestamp now, 103 std::vector<ReportBlockData>& report_blocks); 104 void HandleReportBlocks(uint32_t sender_ssrc, 105 Timestamp now, 106 ArrayView<const rtcp::ReportBlock> rtcp_report_blocks, 107 std::vector<ReportBlockData>& report_blocks); 108 void HandlePayloadSpecificFeedback( 109 const rtcp::CommonHeader& rtcp_packet_header, 110 Timestamp now); 111 void HandleRtpFeedback(const rtcp::CommonHeader& rtcp_packet_header, 112 Timestamp now); 113 void HandleFir(const rtcp::CommonHeader& rtcp_packet_header); 114 void HandlePli(const rtcp::CommonHeader& rtcp_packet_header); 115 void HandleRemb(const rtcp::CommonHeader& rtcp_packet_header, Timestamp now); 116 void HandleNack(const rtcp::CommonHeader& rtcp_packet_header); 117 void HandleTransportFeedback(const rtcp::CommonHeader& rtcp_packet_header, 118 Timestamp now); 119 void HandleCongestionControlFeedback( 120 const rtcp::CommonHeader& rtcp_packet_header, 121 Timestamp now); 122 void HandleExtendedReports(const rtcp::CommonHeader& rtcp_packet_header, 123 Timestamp now); 124 // Extended Reports blocks handlers. 125 void HandleDlrr(const rtcp::Dlrr& dlrr, Timestamp now); 126 void HandleTargetBitrate(const rtcp::TargetBitrate& target_bitrate, 127 uint32_t remote_ssrc); 128 void ProcessReportBlocks(Timestamp now, 129 ArrayView<const ReportBlockData> report_blocks); 130 131 void ReschedulePeriodicCompoundPackets(); 132 void SchedulePeriodicCompoundPackets(TimeDelta delay); 133 // Appends RTCP sender and receiver reports to the `sender`. 134 // Both sender and receiver reports may have attached report blocks. 135 // Uses up to `config_.max_packet_size - reserved_bytes.per_packet` 136 // Returns list of sender ssrc in sender reports. 137 struct ReservedBytes { 138 size_t per_packet = 0; 139 size_t per_sender = 0; 140 }; 141 std::vector<uint32_t> FillReports(Timestamp now, 142 ReservedBytes reserved_bytes, 143 PacketSender& rtcp_sender); 144 145 // Creates compound RTCP packet, as defined in 146 // https://tools.ietf.org/html/rfc5506#section-2 147 void CreateCompoundPacket(Timestamp now, 148 size_t reserved_bytes, 149 PacketSender& rtcp_sender); 150 151 // Sends RTCP packets. 152 void SendPeriodicCompoundPacket(); 153 void SendImmediateFeedback(const rtcp::RtcpPacket& rtcp_packet); 154 // Generate Report Blocks to be send in Sender or Receiver Reports. 155 std::vector<rtcp::ReportBlock> CreateReportBlocks(Timestamp now, 156 size_t num_max_blocks); 157 158 const RtcpTransceiverConfig config_; 159 std::function<void(ArrayView<const uint8_t>)> rtcp_transport_; 160 161 bool ready_to_send_; 162 std::optional<rtcp::Remb> remb_; 163 // TODO(bugs.webrtc.org/8239): Remove entries from remote_senders_ that are no 164 // longer needed. 165 flat_map<uint32_t, RemoteSenderState> remote_senders_; 166 std::list<LocalSenderState> local_senders_; 167 flat_map<uint32_t, std::list<LocalSenderState>::iterator> 168 local_senders_by_ssrc_; 169 flat_map<uint32_t, RrtrTimes> received_rrtrs_; 170 RepeatingTaskHandle periodic_task_handle_; 171 }; 172 173 } // namespace webrtc 174 175 #endif // MODULES_RTP_RTCP_SOURCE_RTCP_TRANSCEIVER_IMPL_H_