Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 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_IMPL2_H_ |
| 12 | #define MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL2_H_ |
| 13 | |
| 14 | #include <stddef.h> |
| 15 | #include <stdint.h> |
| 16 | |
| 17 | #include <memory> |
| 18 | #include <set> |
| 19 | #include <string> |
| 20 | #include <vector> |
| 21 | |
Ali Tofigh | d14e889 | 2022-05-13 11:42:16 +0200 | [diff] [blame] | 22 | #include "absl/strings/string_view.h" |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 23 | #include "absl/types/optional.h" |
| 24 | #include "api/rtp_headers.h" |
Artem Titov | d15a575 | 2021-02-10 14:31:24 +0100 | [diff] [blame] | 25 | #include "api/sequence_checker.h" |
Artem Titov | c374d11 | 2022-06-16 21:27:45 +0200 | [diff] [blame] | 26 | #include "api/task_queue/pending_task_safety_flag.h" |
Tomas Gunnarsson | 473bbd8 | 2020-06-27 17:44:55 +0200 | [diff] [blame] | 27 | #include "api/task_queue/task_queue_base.h" |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 28 | #include "api/units/time_delta.h" |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 29 | #include "api/video/video_bitrate_allocation.h" |
| 30 | #include "modules/include/module_fec_types.h" |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 31 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" // RTCPPacketType |
Erik Språng | bfcfe03 | 2021-08-04 14:45:32 +0200 | [diff] [blame] | 32 | #include "modules/rtp_rtcp/source/packet_sequencer.h" |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 33 | #include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h" |
| 34 | #include "modules/rtp_rtcp/source/rtcp_receiver.h" |
| 35 | #include "modules/rtp_rtcp/source/rtcp_sender.h" |
| 36 | #include "modules/rtp_rtcp/source/rtp_packet_history.h" |
| 37 | #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" |
| 38 | #include "modules/rtp_rtcp/source/rtp_sender.h" |
| 39 | #include "modules/rtp_rtcp/source/rtp_sender_egress.h" |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 40 | #include "rtc_base/gtest_prod_util.h" |
Markus Handell | f7303e6 | 2020-07-09 01:34:42 +0200 | [diff] [blame] | 41 | #include "rtc_base/synchronization/mutex.h" |
Mirko Bonadei | 20e4c80 | 2020-11-23 11:07:42 +0100 | [diff] [blame] | 42 | #include "rtc_base/system/no_unique_address.h" |
Tomas Gunnarsson | ba0ba71 | 2020-07-01 08:53:21 +0200 | [diff] [blame] | 43 | #include "rtc_base/task_utils/repeating_task.h" |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 44 | #include "rtc_base/thread_annotations.h" |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 45 | |
| 46 | namespace webrtc { |
| 47 | |
| 48 | class Clock; |
| 49 | struct PacedPacketInfo; |
| 50 | struct RTPVideoHeader; |
| 51 | |
Tomas Gunnarsson | f25761d | 2020-06-03 22:55:33 +0200 | [diff] [blame] | 52 | class ModuleRtpRtcpImpl2 final : public RtpRtcpInterface, |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 53 | public RTCPReceiver::ModuleRtpRtcp { |
| 54 | public: |
Tomas Gunnarsson | f25761d | 2020-06-03 22:55:33 +0200 | [diff] [blame] | 55 | explicit ModuleRtpRtcpImpl2( |
| 56 | const RtpRtcpInterface::Configuration& configuration); |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 57 | ~ModuleRtpRtcpImpl2() override; |
| 58 | |
Niels Moller | 2accc7d | 2021-01-12 15:54:16 +0000 | [diff] [blame] | 59 | // This method is provided to easy with migrating away from the |
| 60 | // RtpRtcp::Create factory method. Since this is an internal implementation |
| 61 | // detail though, creating an instance of ModuleRtpRtcpImpl2 directly should |
| 62 | // be fine. |
| 63 | static std::unique_ptr<ModuleRtpRtcpImpl2> Create( |
| 64 | const Configuration& configuration); |
| 65 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 66 | // Receiver part. |
| 67 | |
| 68 | // Called when we receive an RTCP packet. |
| 69 | void IncomingRtcpPacket(const uint8_t* incoming_packet, |
| 70 | size_t incoming_packet_length) override; |
| 71 | |
| 72 | void SetRemoteSSRC(uint32_t ssrc) override; |
| 73 | |
Tommi | 08be9ba | 2021-06-15 23:01:57 +0200 | [diff] [blame] | 74 | void SetLocalSsrc(uint32_t local_ssrc) override; |
| 75 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 76 | // Sender part. |
| 77 | void RegisterSendPayloadFrequency(int payload_type, |
| 78 | int payload_frequency) override; |
| 79 | |
| 80 | int32_t DeRegisterSendPayload(int8_t payload_type) override; |
| 81 | |
| 82 | void SetExtmapAllowMixed(bool extmap_allow_mixed) override; |
| 83 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 84 | void RegisterRtpHeaderExtension(absl::string_view uri, int id) override; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 85 | void DeregisterSendRtpHeaderExtension(absl::string_view uri) override; |
| 86 | |
| 87 | bool SupportsPadding() const override; |
| 88 | bool SupportsRtxPayloadPadding() const override; |
| 89 | |
| 90 | // Get start timestamp. |
| 91 | uint32_t StartTimestamp() const override; |
| 92 | |
| 93 | // Configure start timestamp, default is a random number. |
| 94 | void SetStartTimestamp(uint32_t timestamp) override; |
| 95 | |
| 96 | uint16_t SequenceNumber() const override; |
| 97 | |
| 98 | // Set SequenceNumber, default is a random number. |
| 99 | void SetSequenceNumber(uint16_t seq) override; |
| 100 | |
| 101 | void SetRtpState(const RtpState& rtp_state) override; |
| 102 | void SetRtxState(const RtpState& rtp_state) override; |
| 103 | RtpState GetRtpState() const override; |
| 104 | RtpState GetRtxState() const override; |
| 105 | |
Ivo Creusen | 8c40d51 | 2021-07-13 12:53:22 +0000 | [diff] [blame] | 106 | void SetNonSenderRttMeasurement(bool enabled) override; |
| 107 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 108 | uint32_t SSRC() const override { return rtcp_sender_.SSRC(); } |
| 109 | |
Tommi | 08be9ba | 2021-06-15 23:01:57 +0200 | [diff] [blame] | 110 | // Semantically identical to `SSRC()` but must be called on the packet |
| 111 | // delivery thread/tq and returns the ssrc that maps to |
| 112 | // RtpRtcpInterface::Configuration::local_media_ssrc. |
| 113 | uint32_t local_media_ssrc() const; |
| 114 | |
Ali Tofigh | d14e889 | 2022-05-13 11:42:16 +0200 | [diff] [blame] | 115 | void SetMid(absl::string_view mid) override; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 116 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 117 | RTCPSender::FeedbackState GetFeedbackState(); |
| 118 | |
| 119 | void SetRtxSendStatus(int mode) override; |
| 120 | int RtxSendStatus() const override; |
| 121 | absl::optional<uint32_t> RtxSsrc() const override; |
| 122 | |
| 123 | void SetRtxSendPayloadType(int payload_type, |
| 124 | int associated_payload_type) override; |
| 125 | |
| 126 | absl::optional<uint32_t> FlexfecSsrc() const override; |
| 127 | |
| 128 | // Sends kRtcpByeCode when going from true to false. |
| 129 | int32_t SetSendingStatus(bool sending) override; |
| 130 | |
| 131 | bool Sending() const override; |
| 132 | |
| 133 | // Drops or relays media packets. |
| 134 | void SetSendingMediaStatus(bool sending) override; |
| 135 | |
| 136 | bool SendingMedia() const override; |
| 137 | |
| 138 | bool IsAudioConfigured() const override; |
| 139 | |
| 140 | void SetAsPartOfAllocation(bool part_of_allocation) override; |
| 141 | |
| 142 | bool OnSendingRtpFrame(uint32_t timestamp, |
| 143 | int64_t capture_time_ms, |
| 144 | int payload_type, |
| 145 | bool force_sender_report) override; |
| 146 | |
| 147 | bool TrySendPacket(RtpPacketToSend* packet, |
| 148 | const PacedPacketInfo& pacing_info) override; |
| 149 | |
Erik Språng | 1d50cb6 | 2020-07-02 17:41:32 +0200 | [diff] [blame] | 150 | void SetFecProtectionParams(const FecProtectionParams& delta_params, |
| 151 | const FecProtectionParams& key_params) override; |
| 152 | |
| 153 | std::vector<std::unique_ptr<RtpPacketToSend>> FetchFecPackets() override; |
| 154 | |
Erik Språng | 5045949 | 2022-09-08 16:53:06 +0200 | [diff] [blame] | 155 | void OnAbortedRetransmissions( |
| 156 | rtc::ArrayView<const uint16_t> sequence_numbers) override; |
| 157 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 158 | void OnPacketsAcknowledged( |
| 159 | rtc::ArrayView<const uint16_t> sequence_numbers) override; |
| 160 | |
| 161 | std::vector<std::unique_ptr<RtpPacketToSend>> GeneratePadding( |
| 162 | size_t target_size_bytes) override; |
| 163 | |
| 164 | std::vector<RtpSequenceNumberMap::Info> GetSentRtpPacketInfos( |
| 165 | rtc::ArrayView<const uint16_t> sequence_numbers) const override; |
| 166 | |
| 167 | size_t ExpectedPerPacketOverhead() const override; |
| 168 | |
Erik Språng | b6bbdeb | 2021-08-13 16:12:41 +0200 | [diff] [blame] | 169 | void OnPacketSendingThreadSwitched() override; |
| 170 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 171 | // RTCP part. |
| 172 | |
| 173 | // Get RTCP status. |
| 174 | RtcpMode RTCP() const override; |
| 175 | |
| 176 | // Configure RTCP status i.e on/off. |
| 177 | void SetRTCPStatus(RtcpMode method) override; |
| 178 | |
| 179 | // Set RTCP CName. |
Ali Tofigh | d14e889 | 2022-05-13 11:42:16 +0200 | [diff] [blame] | 180 | int32_t SetCNAME(absl::string_view c_name) override; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 181 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 182 | // Get remote NTP. |
| 183 | int32_t RemoteNTP(uint32_t* received_ntp_secs, |
| 184 | uint32_t* received_ntp_frac, |
| 185 | uint32_t* rtcp_arrival_time_secs, |
| 186 | uint32_t* rtcp_arrival_time_frac, |
| 187 | uint32_t* rtcp_timestamp) const override; |
| 188 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 189 | // Get RoundTripTime. |
| 190 | int32_t RTT(uint32_t remote_ssrc, |
| 191 | int64_t* rtt, |
| 192 | int64_t* avg_rtt, |
| 193 | int64_t* min_rtt, |
| 194 | int64_t* max_rtt) const override; |
| 195 | |
| 196 | int64_t ExpectedRetransmissionTimeMs() const override; |
| 197 | |
| 198 | // Force a send of an RTCP packet. |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 199 | // Normal SR and RR are triggered via the task queue that's current when this |
| 200 | // object is created. |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 201 | int32_t SendRTCP(RTCPPacketType rtcpPacketType) override; |
| 202 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 203 | void GetSendStreamDataCounters( |
| 204 | StreamDataCounters* rtp_counters, |
| 205 | StreamDataCounters* rtx_counters) const override; |
| 206 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 207 | // A snapshot of the most recent Report Block with additional data of |
| 208 | // interest to statistics. Used to implement RTCRemoteInboundRtpStreamStats. |
| 209 | // Within this list, the ReportBlockData::RTCPReportBlock::source_ssrc(), |
| 210 | // which is the SSRC of the corresponding outbound RTP stream, is unique. |
| 211 | std::vector<ReportBlockData> GetLatestReportBlockData() const override; |
Alessio Bazzica | bc1c93d | 2021-03-12 17:45:26 +0100 | [diff] [blame] | 212 | absl::optional<SenderReportStats> GetSenderReportStats() const override; |
Ivo Creusen | 2562cf0 | 2021-09-03 14:51:22 +0000 | [diff] [blame] | 213 | absl::optional<NonSenderRttStats> GetNonSenderRttStats() const override; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 214 | |
| 215 | // (REMB) Receiver Estimated Max Bitrate. |
| 216 | void SetRemb(int64_t bitrate_bps, std::vector<uint32_t> ssrcs) override; |
| 217 | void UnsetRemb() override; |
| 218 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 219 | void SetTmmbn(std::vector<rtcp::TmmbItem> bounding_set) override; |
| 220 | |
| 221 | size_t MaxRtpPacketSize() const override; |
| 222 | |
| 223 | void SetMaxRtpPacketSize(size_t max_packet_size) override; |
| 224 | |
| 225 | // (NACK) Negative acknowledgment part. |
| 226 | |
| 227 | // Send a Negative acknowledgment packet. |
| 228 | // TODO(philipel): Deprecate SendNACK and use SendNack instead. |
| 229 | int32_t SendNACK(const uint16_t* nack_list, uint16_t size) override; |
| 230 | |
| 231 | void SendNack(const std::vector<uint16_t>& sequence_numbers) override; |
| 232 | |
| 233 | // Store the sent packets, needed to answer to a negative acknowledgment |
| 234 | // requests. |
| 235 | void SetStorePacketsStatus(bool enable, uint16_t number_to_store) override; |
| 236 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 237 | void SendCombinedRtcpPacket( |
| 238 | std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets) override; |
| 239 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 240 | // Video part. |
| 241 | int32_t SendLossNotification(uint16_t last_decoded_seq_num, |
| 242 | uint16_t last_received_seq_num, |
| 243 | bool decodability_flag, |
| 244 | bool buffering_allowed) override; |
| 245 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 246 | RtpSendRates GetSendRates() const override; |
| 247 | |
| 248 | void OnReceivedNack( |
| 249 | const std::vector<uint16_t>& nack_sequence_numbers) override; |
| 250 | void OnReceivedRtcpReportBlocks( |
| 251 | const ReportBlockList& report_blocks) override; |
| 252 | void OnRequestSendReport() override; |
| 253 | |
| 254 | void SetVideoBitrateAllocation( |
| 255 | const VideoBitrateAllocation& bitrate) override; |
| 256 | |
| 257 | RTPSender* RtpSender() override; |
| 258 | const RTPSender* RtpSender() const override; |
| 259 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 260 | private: |
| 261 | FRIEND_TEST_ALL_PREFIXES(RtpRtcpImpl2Test, Rtt); |
| 262 | FRIEND_TEST_ALL_PREFIXES(RtpRtcpImpl2Test, RttForReceiverOnly); |
| 263 | |
Erik Språng | 54abf98 | 2021-08-13 17:25:44 +0200 | [diff] [blame] | 264 | struct RtpSenderContext { |
Tomas Gunnarsson | f25761d | 2020-06-03 22:55:33 +0200 | [diff] [blame] | 265 | explicit RtpSenderContext(const RtpRtcpInterface::Configuration& config); |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 266 | // Storage of packets, for retransmissions and padding, if applicable. |
| 267 | RtpPacketHistory packet_history; |
Erik Språng | b6bbdeb | 2021-08-13 16:12:41 +0200 | [diff] [blame] | 268 | SequenceChecker sequencing_checker; |
Erik Språng | bfcfe03 | 2021-08-04 14:45:32 +0200 | [diff] [blame] | 269 | // Handles sequence number assignment and padding timestamp generation. |
Erik Språng | b6bbdeb | 2021-08-13 16:12:41 +0200 | [diff] [blame] | 270 | PacketSequencer sequencer RTC_GUARDED_BY(sequencing_checker); |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 271 | // Handles final time timestamping/stats/etc and handover to Transport. |
| 272 | RtpSenderEgress packet_sender; |
| 273 | // If no paced sender configured, this class will be used to pass packets |
Artem Titov | 913cfa7 | 2021-07-28 23:57:33 +0200 | [diff] [blame] | 274 | // from `packet_generator_` to `packet_sender_`. |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 275 | RtpSenderEgress::NonPacedPacketSender non_paced_sender; |
| 276 | // Handles creation of RTP packets to be sent. |
| 277 | RTPSender packet_generator; |
| 278 | }; |
| 279 | |
| 280 | void set_rtt_ms(int64_t rtt_ms); |
| 281 | int64_t rtt_ms() const; |
| 282 | |
| 283 | bool TimeToSendFullNackList(int64_t now) const; |
| 284 | |
Tomas Gunnarsson | ba0ba71 | 2020-07-01 08:53:21 +0200 | [diff] [blame] | 285 | // Called on a timer, once a second, on the worker_queue_, to update the RTT, |
| 286 | // check if we need to send RTCP report, send TMMBR updates and fire events. |
| 287 | void PeriodicUpdate(); |
| 288 | |
Niels Möller | af6ea0c | 2020-11-20 12:21:21 +0100 | [diff] [blame] | 289 | // Returns true if the module is configured to store packets. |
| 290 | bool StorePackets() const; |
| 291 | |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 292 | // Used from RtcpSenderMediator to maybe send rtcp. |
| 293 | void MaybeSendRtcp() RTC_RUN_ON(worker_queue_); |
| 294 | |
Artem Titov | 913cfa7 | 2021-07-28 23:57:33 +0200 | [diff] [blame] | 295 | // Called when `rtcp_sender_` informs of the next RTCP instant. The method may |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 296 | // be called on various sequences, and is called under a RTCPSenderLock. |
| 297 | void ScheduleRtcpSendEvaluation(TimeDelta duration); |
| 298 | |
| 299 | // Helper method combating too early delayed calls from task queues. |
| 300 | // TODO(bugs.webrtc.org/12889): Consider removing this function when the issue |
| 301 | // is resolved. |
| 302 | void MaybeSendRtcpAtOrAfterTimestamp(Timestamp execution_time) |
| 303 | RTC_RUN_ON(worker_queue_); |
| 304 | |
Artem Titov | 913cfa7 | 2021-07-28 23:57:33 +0200 | [diff] [blame] | 305 | // Schedules a call to MaybeSendRtcpAtOrAfterTimestamp delayed by `duration`. |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 306 | void ScheduleMaybeSendRtcpAtOrAfterTimestamp(Timestamp execution_time, |
| 307 | TimeDelta duration); |
| 308 | |
Tomas Gunnarsson | 473bbd8 | 2020-06-27 17:44:55 +0200 | [diff] [blame] | 309 | TaskQueueBase* const worker_queue_; |
Erik Språng | b6bbdeb | 2021-08-13 16:12:41 +0200 | [diff] [blame] | 310 | RTC_NO_UNIQUE_ADDRESS SequenceChecker rtcp_thread_checker_; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 311 | |
| 312 | std::unique_ptr<RtpSenderContext> rtp_sender_; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 313 | RTCPSender rtcp_sender_; |
| 314 | RTCPReceiver rtcp_receiver_; |
| 315 | |
| 316 | Clock* const clock_; |
| 317 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 318 | uint16_t packet_overhead_; |
| 319 | |
| 320 | // Send side |
| 321 | int64_t nack_last_time_sent_full_ms_; |
| 322 | uint16_t nack_last_seq_number_sent_; |
| 323 | |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 324 | RtcpRttStats* const rtt_stats_; |
Tomas Gunnarsson | ba0ba71 | 2020-07-01 08:53:21 +0200 | [diff] [blame] | 325 | RepeatingTaskHandle rtt_update_task_ RTC_GUARDED_BY(worker_queue_); |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 326 | |
| 327 | // The processed RTT from RtcpRttStats. |
Markus Handell | f7303e6 | 2020-07-09 01:34:42 +0200 | [diff] [blame] | 328 | mutable Mutex mutex_rtt_; |
Niels Möller | cd98213 | 2020-11-26 16:19:56 +0100 | [diff] [blame] | 329 | int64_t rtt_ms_ RTC_GUARDED_BY(mutex_rtt_); |
Markus Handell | 885d538 | 2021-06-21 18:57:36 +0200 | [diff] [blame] | 330 | |
| 331 | RTC_NO_UNIQUE_ADDRESS ScopedTaskSafety task_safety_; |
Tommi | 3a5742c | 2020-05-20 09:32:51 +0200 | [diff] [blame] | 332 | }; |
| 333 | |
| 334 | } // namespace webrtc |
| 335 | |
| 336 | #endif // MODULES_RTP_RTCP_SOURCE_RTP_RTCP_IMPL2_H_ |