From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../modules/rtp_rtcp/include/flexfec_receiver.h | 82 ++++ .../modules/rtp_rtcp/include/flexfec_sender.h | 104 +++++ .../modules/rtp_rtcp/include/receive_statistics.h | 83 ++++ .../rtp_rtcp/include/recovered_packet_receiver.h | 30 ++ .../rtp_rtcp/include/remote_ntp_time_estimator.h | 74 ++++ .../modules/rtp_rtcp/include/report_block_data.cc | 42 ++ .../modules/rtp_rtcp/include/report_block_data.h | 123 ++++++ .../modules/rtp_rtcp/include/rtcp_statistics.h | 77 ++++ .../libwebrtc/modules/rtp_rtcp/include/rtp_cvo.h | 56 +++ .../rtp_rtcp/include/rtp_header_extension_map.h | 75 ++++ .../modules/rtp_rtcp/include/rtp_packet_sender.h | 40 ++ .../libwebrtc/modules/rtp_rtcp/include/rtp_rtcp.h | 38 ++ .../modules/rtp_rtcp/include/rtp_rtcp_defines.cc | 75 ++++ .../modules/rtp_rtcp/include/rtp_rtcp_defines.h | 428 +++++++++++++++++++++ 14 files changed, 1327 insertions(+) create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_receiver.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_sender.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/receive_statistics.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/recovered_packet_receiver.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/remote_ntp_time_estimator.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.cc create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtcp_statistics.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtp_cvo.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtp_packet_sender.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp.h create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.cc create mode 100644 third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h (limited to 'third_party/libwebrtc/modules/rtp_rtcp/include') diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_receiver.h b/third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_receiver.h new file mode 100644 index 0000000000..b6a33882d1 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_receiver.h @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_ +#define MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_ + +#include + +#include + +#include "api/sequence_checker.h" +#include "api/units/timestamp.h" +#include "modules/rtp_rtcp/include/recovered_packet_receiver.h" +#include "modules/rtp_rtcp/source/forward_error_correction.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "modules/rtp_rtcp/source/ulpfec_receiver.h" +#include "rtc_base/system/no_unique_address.h" +#include "rtc_base/thread_annotations.h" + +namespace webrtc { + +class Clock; + +class FlexfecReceiver { + public: + /* Mozilla: Avoid this since it could use GetRealTimeClock(). + FlexfecReceiver(uint32_t ssrc, + uint32_t protected_media_ssrc, + RecoveredPacketReceiver* recovered_packet_receiver); + */ + FlexfecReceiver(Clock* clock, + uint32_t ssrc, + uint32_t protected_media_ssrc, + RecoveredPacketReceiver* recovered_packet_receiver); + ~FlexfecReceiver(); + + // Inserts a received packet (can be either media or FlexFEC) into the + // internal buffer, and sends the received packets to the erasure code. + // All newly recovered packets are sent back through the callback. + void OnRtpPacket(const RtpPacketReceived& packet); + + // Returns a counter describing the added and recovered packets. + FecPacketCounter GetPacketCounter() const; + + // Protected to aid testing. + protected: + std::unique_ptr AddReceivedPacket( + const RtpPacketReceived& packet); + void ProcessReceivedPacket( + const ForwardErrorCorrection::ReceivedPacket& received_packet); + + private: + // Config. + const uint32_t ssrc_; + const uint32_t protected_media_ssrc_; + + // Erasure code interfacing and callback. + std::unique_ptr erasure_code_ + RTC_GUARDED_BY(sequence_checker_); + ForwardErrorCorrection::RecoveredPacketList recovered_packets_ + RTC_GUARDED_BY(sequence_checker_); + RecoveredPacketReceiver* const recovered_packet_receiver_; + + // Logging and stats. + Clock* const clock_; + Timestamp last_recovered_packet_ RTC_GUARDED_BY(sequence_checker_) = + Timestamp::MinusInfinity(); + FecPacketCounter packet_counter_ RTC_GUARDED_BY(sequence_checker_); + + RTC_NO_UNIQUE_ADDRESS SequenceChecker sequence_checker_; +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_FLEXFEC_RECEIVER_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_sender.h b/third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_sender.h new file mode 100644 index 0000000000..8f21ab7517 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/flexfec_sender.h @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_FLEXFEC_SENDER_H_ +#define MODULES_RTP_RTCP_INCLUDE_FLEXFEC_SENDER_H_ + +#include +#include +#include + +#include "absl/strings/string_view.h" +#include "api/array_view.h" +#include "api/rtp_parameters.h" +#include "api/units/timestamp.h" +#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" +#include "modules/rtp_rtcp/source/rtp_header_extension_size.h" +#include "modules/rtp_rtcp/source/ulpfec_generator.h" +#include "modules/rtp_rtcp/source/video_fec_generator.h" +#include "rtc_base/bitrate_tracker.h" +#include "rtc_base/random.h" +#include "rtc_base/synchronization/mutex.h" + +namespace webrtc { + +class Clock; +class RtpPacketToSend; + +// Note that this class is not thread safe, and thus requires external +// synchronization. Currently, this is done using the lock in PayloadRouter. + +class FlexfecSender : public VideoFecGenerator { + public: + FlexfecSender(int payload_type, + uint32_t ssrc, + uint32_t protected_media_ssrc, + absl::string_view mid, + const std::vector& rtp_header_extensions, + rtc::ArrayView extension_sizes, + const RtpState* rtp_state, + Clock* clock); + ~FlexfecSender(); + + FecType GetFecType() const override { + return VideoFecGenerator::FecType::kFlexFec; + } + absl::optional FecSsrc() override { return ssrc_; } + + // Sets the FEC rate, max frames sent before FEC packets are sent, + // and what type of generator matrices are used. + void SetProtectionParameters(const FecProtectionParams& delta_params, + const FecProtectionParams& key_params) override; + + // Adds a media packet to the internal buffer. When enough media packets + // have been added, the FEC packets are generated and stored internally. + // These FEC packets are then obtained by calling GetFecPackets(). + void AddPacketAndGenerateFec(const RtpPacketToSend& packet) override; + + // Returns generated FlexFEC packets. + std::vector> GetFecPackets() override; + + // Returns the overhead, per packet, for FlexFEC. + size_t MaxPacketOverhead() const override; + + DataRate CurrentFecRate() const override; + + // Only called on the VideoSendStream queue, after operation has shut down. + absl::optional GetRtpState() override; + + private: + // Utility. + Clock* const clock_; + Random random_; + Timestamp last_generated_packet_ = Timestamp::MinusInfinity(); + + // Config. + const int payload_type_; + const uint32_t timestamp_offset_; + const uint32_t ssrc_; + const uint32_t protected_media_ssrc_; + // MID value to send in the MID header extension. + const std::string mid_; + // Sequence number of next packet to generate. + uint16_t seq_num_; + + // Implementation. + UlpfecGenerator ulpfec_generator_; + const RtpHeaderExtensionMap rtp_header_extension_map_; + const size_t header_extensions_size_; + + mutable Mutex mutex_; + BitrateTracker fec_bitrate_ RTC_GUARDED_BY(mutex_); +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_FLEXFEC_SENDER_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/receive_statistics.h b/third_party/libwebrtc/modules/rtp_rtcp/include/receive_statistics.h new file mode 100644 index 0000000000..827fd3a7a8 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/receive_statistics.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_RECEIVE_STATISTICS_H_ +#define MODULES_RTP_RTCP_INCLUDE_RECEIVE_STATISTICS_H_ + +#include +#include +#include + +#include "absl/types/optional.h" +#include "call/rtp_packet_sink_interface.h" +#include "modules/rtp_rtcp/include/rtcp_statistics.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" +#include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" + +namespace webrtc { + +class Clock; + +class ReceiveStatisticsProvider { + public: + virtual ~ReceiveStatisticsProvider() = default; + // Collects receive statistic in a form of rtcp report blocks. + // Returns at most `max_blocks` report blocks. + virtual std::vector RtcpReportBlocks( + size_t max_blocks) = 0; +}; + +class StreamStatistician { + public: + virtual ~StreamStatistician(); + + virtual RtpReceiveStats GetStats() const = 0; + + // Returns average over the stream life time. + virtual absl::optional GetFractionLostInPercent() const = 0; + + // TODO(bugs.webrtc.org/10679): Delete, migrate users to the above GetStats + // method (and extend RtpReceiveStats if needed). + // Gets receive stream data counters. + virtual StreamDataCounters GetReceiveStreamDataCounters() const = 0; + + virtual uint32_t BitrateReceived() const = 0; +}; + +class ReceiveStatistics : public ReceiveStatisticsProvider, + public RtpPacketSinkInterface { + public: + ~ReceiveStatistics() override = default; + + // Returns a thread-safe instance of ReceiveStatistics. + // https://chromium.googlesource.com/chromium/src/+/lkgr/docs/threading_and_tasks.md#threading-lexicon + static std::unique_ptr Create(Clock* clock); + // Returns a thread-compatible instance of ReceiveStatistics. + static std::unique_ptr CreateThreadCompatible( + Clock* clock); + + // Returns a pointer to the statistician of an ssrc. + virtual StreamStatistician* GetStatistician(uint32_t ssrc) const = 0; + + // TODO(bugs.webrtc.org/10669): Deprecated, delete as soon as downstream + // projects are updated. This method sets the max reordering threshold of all + // current and future streams. + virtual void SetMaxReorderingThreshold(int max_reordering_threshold) = 0; + + // Sets the max reordering threshold in number of packets. + virtual void SetMaxReorderingThreshold(uint32_t ssrc, + int max_reordering_threshold) = 0; + // Detect retransmissions, enabling updates of the retransmitted counters. The + // default is false. + virtual void EnableRetransmitDetection(uint32_t ssrc, bool enable) = 0; +}; + +} // namespace webrtc +#endif // MODULES_RTP_RTCP_INCLUDE_RECEIVE_STATISTICS_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/recovered_packet_receiver.h b/third_party/libwebrtc/modules/rtp_rtcp/include/recovered_packet_receiver.h new file mode 100644 index 0000000000..4e92c486e2 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/recovered_packet_receiver.h @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2022 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ +#ifndef MODULES_RTP_RTCP_INCLUDE_RECOVERED_PACKET_RECEIVER_H_ +#define MODULES_RTP_RTCP_INCLUDE_RECOVERED_PACKET_RECEIVER_H_ + +#include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "rtc_base/checks.h" + +namespace webrtc { + +// Callback interface for packets recovered by FlexFEC or ULPFEC. In +// the FlexFEC case, the implementation should be able to demultiplex +// the recovered RTP packets based on SSRC. +class RecoveredPacketReceiver { + public: + virtual void OnRecoveredPacket(const RtpPacketReceived& packet) = 0; + + protected: + virtual ~RecoveredPacketReceiver() = default; +}; + +} // namespace webrtc +#endif // MODULES_RTP_RTCP_INCLUDE_RECOVERED_PACKET_RECEIVER_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/remote_ntp_time_estimator.h b/third_party/libwebrtc/modules/rtp_rtcp/include/remote_ntp_time_estimator.h new file mode 100644 index 0000000000..01d0c85f94 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/remote_ntp_time_estimator.h @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_REMOTE_NTP_TIME_ESTIMATOR_H_ +#define MODULES_RTP_RTCP_INCLUDE_REMOTE_NTP_TIME_ESTIMATOR_H_ + +#include + +#include "absl/types/optional.h" +#include "api/units/time_delta.h" +#include "api/units/timestamp.h" +#include "rtc_base/numerics/moving_percentile_filter.h" +#include "system_wrappers/include/rtp_to_ntp_estimator.h" + +namespace webrtc { + +class Clock; + +// RemoteNtpTimeEstimator can be used to estimate a given RTP timestamp's NTP +// time in local timebase. +// Note that it needs to be trained with at least 2 RTCP SR (by calling +// `UpdateRtcpTimestamp`) before it can be used. +class RemoteNtpTimeEstimator { + public: + explicit RemoteNtpTimeEstimator(Clock* clock); + RemoteNtpTimeEstimator(const RemoteNtpTimeEstimator&) = delete; + RemoteNtpTimeEstimator& operator=(const RemoteNtpTimeEstimator&) = delete; + ~RemoteNtpTimeEstimator() = default; + + // Updates the estimator with round trip time `rtt` and + // new NTP time <-> RTP timestamp mapping from an RTCP sender report. + bool UpdateRtcpTimestamp(TimeDelta rtt, + NtpTime sender_send_time, + uint32_t rtp_timestamp); + + // Estimates the NTP timestamp in local timebase from `rtp_timestamp`. + // Returns the NTP timestamp in ms when success. -1 if failed. + int64_t Estimate(uint32_t rtp_timestamp) { + NtpTime ntp_time = EstimateNtp(rtp_timestamp); + if (!ntp_time.Valid()) { + return -1; + } + return ntp_time.ToMs(); + } + + // Estimates the NTP timestamp in local timebase from `rtp_timestamp`. + // Returns invalid NtpTime (i.e. NtpTime(0)) on failure. + NtpTime EstimateNtp(uint32_t rtp_timestamp); + + // Estimates the offset between the remote clock and the + // local one. This is equal to local NTP clock - remote NTP clock. + // The offset is returned in ntp time resolution, i.e. 1/2^32 sec ~= 0.2 ns. + // Returns nullopt on failure. + absl::optional EstimateRemoteToLocalClockOffset(); + + private: + Clock* clock_; + // Offset is measured with the same precision as NtpTime: in 1/2^32 seconds ~= + // 0.2 ns. + MovingMedianFilter ntp_clocks_offset_estimator_; + RtpToNtpEstimator rtp_to_ntp_; + Timestamp last_timing_log_ = Timestamp::MinusInfinity(); +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_REMOTE_NTP_TIME_ESTIMATOR_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.cc b/third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.cc new file mode 100644 index 0000000000..0d4fed043f --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.cc @@ -0,0 +1,42 @@ +/* + * Copyright 2019 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/rtp_rtcp/include/report_block_data.h" + +#include "rtc_base/checks.h" + +namespace webrtc { + +TimeDelta ReportBlockData::jitter(int rtp_clock_rate_hz) const { + RTC_DCHECK_GT(rtp_clock_rate_hz, 0); + // Conversion to TimeDelta and division are swapped to avoid conversion + // to/from floating point types. + return TimeDelta::Seconds(jitter()) / rtp_clock_rate_hz; +} + +void ReportBlockData::SetReportBlock(uint32_t sender_ssrc, + const rtcp::ReportBlock& report_block, + Timestamp report_block_timestamp_utc) { + sender_ssrc_ = sender_ssrc; + source_ssrc_ = report_block.source_ssrc(); + fraction_lost_raw_ = report_block.fraction_lost(); + cumulative_lost_ = report_block.cumulative_lost(); + extended_highest_sequence_number_ = report_block.extended_high_seq_num(); + jitter_ = report_block.jitter(); + report_block_timestamp_utc_ = report_block_timestamp_utc; +} + +void ReportBlockData::AddRoundTripTimeSample(TimeDelta rtt) { + last_rtt_ = rtt; + sum_rtt_ += rtt; + ++num_rtts_; +} + +} // namespace webrtc diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.h b/third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.h new file mode 100644 index 0000000000..9987fc46b9 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/report_block_data.h @@ -0,0 +1,123 @@ +/* + * Copyright 2019 The WebRTC Project Authors. All rights reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_REPORT_BLOCK_DATA_H_ +#define MODULES_RTP_RTCP_INCLUDE_REPORT_BLOCK_DATA_H_ + +#include "api/units/time_delta.h" +#include "api/units/timestamp.h" +#include "modules/rtp_rtcp/source/rtcp_packet/report_block.h" + +namespace webrtc { + +// Represents fields and derived information received in RTCP report block +// attached to RTCP sender report or RTCP receiver report, as described in +// https://www.rfc-editor.org/rfc/rfc3550#section-6.4.1 +class ReportBlockData { + public: + ReportBlockData() = default; + + ReportBlockData(const ReportBlockData&) = default; + ReportBlockData& operator=(const ReportBlockData&) = default; + + // The SSRC identifier for the originator of this report block, + // i.e. remote receiver of the RTP stream. + uint32_t sender_ssrc() const { return sender_ssrc_; } + + // The SSRC identifier of the source to which the information in this + // reception report block pertains, i.e. local sender of the RTP stream. + uint32_t source_ssrc() const { return source_ssrc_; } + + // The fraction of RTP data packets from 'source_ssrc()' lost since the + // previous report block was sent. + // Fraction loss in range [0.0, 1.0]. + float fraction_lost() const { return fraction_lost_raw() / 256.0; } + + // Fraction loss as was written in the raw packet: range is [0, 255] where 0 + // represents no loss, and 255 represents 99.6% loss (255/256 * 100%). + uint8_t fraction_lost_raw() const { return fraction_lost_raw_; } + + // The total number of RTP data packets from 'source_ssrc()' that have been + // lost since the beginning of reception. This number is defined to be the + // number of packets expected less the number of packets actually received, + // where the number of packets received includes any which are late or + // duplicates. Thus, packets that arrive late are not counted as lost, and the + // loss may be negative if there are duplicates. + int cumulative_lost() const { return cumulative_lost_; } + + // The low 16 bits contain the highest sequence number received in an RTP data + // packet from 'source_ssrc()', and the most significant 16 bits extend that + // sequence number with the corresponding count of sequence number cycles. + uint32_t extended_highest_sequence_number() const { + return extended_highest_sequence_number_; + } + + // An estimate of the statistical variance of the RTP data packet interarrival + // time, measured in RTP timestamp units. The interarrival jitter J is defined + // to be the mean deviation (smoothed absolute value) of the difference D in + // packet spacing at the receiver compared to the sender for a pair of + // packets. + uint32_t jitter() const { return jitter_; } + + // Jitter converted to common time units. + TimeDelta jitter(int rtp_clock_rate_hz) const; + + // Time in utc epoch (Jan 1st, 1970) the report block was received. + Timestamp report_block_timestamp_utc() const { + return report_block_timestamp_utc_; + } + + // Round Trip Time measurments for given (sender_ssrc, source_ssrc) pair. + // Min, max, sum, number of measurements are since beginning of the call. + TimeDelta last_rtt() const { return last_rtt_; } + TimeDelta sum_rtts() const { return sum_rtt_; } + size_t num_rtts() const { return num_rtts_; } + bool has_rtt() const { return num_rtts_ != 0; } + + void set_sender_ssrc(uint32_t ssrc) { sender_ssrc_ = ssrc; } + void set_source_ssrc(uint32_t ssrc) { source_ssrc_ = ssrc; } + void set_fraction_lost_raw(uint8_t lost) { fraction_lost_raw_ = lost; } + void set_cumulative_lost(int lost) { cumulative_lost_ = lost; } + void set_extended_highest_sequence_number(uint32_t sn) { + extended_highest_sequence_number_ = sn; + } + void set_jitter(uint32_t jitter) { jitter_ = jitter; } + void set_report_block_timestamp_utc(Timestamp arrival_time) { + report_block_timestamp_utc_ = arrival_time; + } + + void SetReportBlock(uint32_t sender_ssrc, + const rtcp::ReportBlock& report_block, + Timestamp report_block_timestamp_utc); + void AddRoundTripTimeSample(TimeDelta rtt); + + private: + uint32_t sender_ssrc_ = 0; + uint32_t source_ssrc_ = 0; + uint8_t fraction_lost_raw_ = 0; + int32_t cumulative_lost_ = 0; + uint32_t extended_highest_sequence_number_ = 0; + uint32_t jitter_ = 0; + Timestamp report_block_timestamp_utc_ = Timestamp::Zero(); + TimeDelta last_rtt_ = TimeDelta::Zero(); + TimeDelta sum_rtt_ = TimeDelta::Zero(); + size_t num_rtts_ = 0; +}; + +class ReportBlockDataObserver { + public: + virtual ~ReportBlockDataObserver() = default; + + virtual void OnReportBlockDataUpdated(ReportBlockData report_block_data) = 0; +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_REPORT_BLOCK_DATA_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtcp_statistics.h b/third_party/libwebrtc/modules/rtp_rtcp/include/rtcp_statistics.h new file mode 100644 index 0000000000..6d6246d8a8 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtcp_statistics.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2018 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_RTCP_STATISTICS_H_ +#define MODULES_RTP_RTCP_INCLUDE_RTCP_STATISTICS_H_ + +#include + +#include "absl/strings/string_view.h" + +namespace webrtc { + +// Statistics for RTCP packet types. +struct RtcpPacketTypeCounter { + RtcpPacketTypeCounter() + : nack_packets(0), + fir_packets(0), + pli_packets(0), + nack_requests(0), + unique_nack_requests(0) {} + + void Add(const RtcpPacketTypeCounter& other) { + nack_packets += other.nack_packets; + fir_packets += other.fir_packets; + pli_packets += other.pli_packets; + nack_requests += other.nack_requests; + unique_nack_requests += other.unique_nack_requests; + } + + void Subtract(const RtcpPacketTypeCounter& other) { + nack_packets -= other.nack_packets; + fir_packets -= other.fir_packets; + pli_packets -= other.pli_packets; + nack_requests -= other.nack_requests; + unique_nack_requests -= other.unique_nack_requests; + } + + int UniqueNackRequestsInPercent() const { + if (nack_requests == 0) { + return 0; + } + return static_cast((unique_nack_requests * 100.0f / nack_requests) + + 0.5f); + } + + uint32_t nack_packets; // Number of RTCP NACK packets. + uint32_t fir_packets; // Number of RTCP FIR packets. + uint32_t pli_packets; // Number of RTCP PLI packets. + uint32_t nack_requests; // Number of NACKed RTP packets. + uint32_t unique_nack_requests; // Number of unique NACKed RTP packets. +}; + +class RtcpPacketTypeCounterObserver { + public: + virtual ~RtcpPacketTypeCounterObserver() {} + virtual void RtcpPacketTypesCounterUpdated( + uint32_t ssrc, + const RtcpPacketTypeCounter& packet_counter) = 0; +}; + +// Invoked for each cname passed in RTCP SDES blocks. +class RtcpCnameCallback { + public: + virtual ~RtcpCnameCallback() = default; + + virtual void OnCname(uint32_t ssrc, absl::string_view cname) = 0; +}; + +} // namespace webrtc +#endif // MODULES_RTP_RTCP_INCLUDE_RTCP_STATISTICS_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_cvo.h b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_cvo.h new file mode 100644 index 0000000000..497946d6a7 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_cvo.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ +#ifndef MODULES_RTP_RTCP_INCLUDE_RTP_CVO_H_ +#define MODULES_RTP_RTCP_INCLUDE_RTP_CVO_H_ + +#include "api/video/video_rotation.h" +#include "rtc_base/checks.h" + +namespace webrtc { + +// Please refer to http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/ +// 12.07.00_60/ts_126114v120700p.pdf Section 7.4.5. The rotation of a frame is +// the clockwise angle the frames must be rotated in order to display the frames +// correctly if the display is rotated in its natural orientation. +inline uint8_t ConvertVideoRotationToCVOByte(VideoRotation rotation) { + switch (rotation) { + case kVideoRotation_0: + return 0; + case kVideoRotation_90: + return 1; + case kVideoRotation_180: + return 2; + case kVideoRotation_270: + return 3; + } + RTC_DCHECK_NOTREACHED(); + return 0; +} + +inline VideoRotation ConvertCVOByteToVideoRotation(uint8_t cvo_byte) { + // CVO byte: |0 0 0 0 C F R R|. + const uint8_t rotation_bits = cvo_byte & 0x3; + switch (rotation_bits) { + case 0: + return kVideoRotation_0; + case 1: + return kVideoRotation_90; + case 2: + return kVideoRotation_180; + case 3: + return kVideoRotation_270; + default: + RTC_DCHECK_NOTREACHED(); + return kVideoRotation_0; + } +} + +} // namespace webrtc +#endif // MODULES_RTP_RTCP_INCLUDE_RTP_CVO_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h new file mode 100644 index 0000000000..ff1ea61f52 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_header_extension_map.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_RTP_HEADER_EXTENSION_MAP_H_ +#define MODULES_RTP_RTCP_INCLUDE_RTP_HEADER_EXTENSION_MAP_H_ + +#include + +#include + +#include "absl/strings/string_view.h" +#include "api/array_view.h" +#include "api/rtp_parameters.h" +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" +#include "rtc_base/checks.h" + +namespace webrtc { + +class RtpHeaderExtensionMap { + public: + static constexpr RTPExtensionType kInvalidType = kRtpExtensionNone; + static constexpr int kInvalidId = 0; + + RtpHeaderExtensionMap(); + explicit RtpHeaderExtensionMap(bool extmap_allow_mixed); + explicit RtpHeaderExtensionMap(rtc::ArrayView extensions); + + void Reset(rtc::ArrayView extensions); + + template + bool Register(int id) { + return Register(id, Extension::kId, Extension::Uri()); + } + bool RegisterByType(int id, RTPExtensionType type); + bool RegisterByUri(int id, absl::string_view uri); + + bool IsRegistered(RTPExtensionType type) const { + return GetId(type) != kInvalidId; + } + // Return kInvalidType if not found. + RTPExtensionType GetType(int id) const; + // Return kInvalidId if not found. + uint8_t GetId(RTPExtensionType type) const { + RTC_DCHECK_GT(type, kRtpExtensionNone); + RTC_DCHECK_LT(type, kRtpExtensionNumberOfExtensions); + return ids_[type]; + } + + void Deregister(absl::string_view uri); + + // Corresponds to the SDP attribute extmap-allow-mixed, see RFC8285. + // Set to true if it's allowed to mix one- and two-byte RTP header extensions + // in the same stream. + bool ExtmapAllowMixed() const { return extmap_allow_mixed_; } + void SetExtmapAllowMixed(bool extmap_allow_mixed) { + extmap_allow_mixed_ = extmap_allow_mixed; + } + + private: + bool Register(int id, RTPExtensionType type, absl::string_view uri); + + uint8_t ids_[kRtpExtensionNumberOfExtensions]; + bool extmap_allow_mixed_; +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_RTP_HEADER_EXTENSION_MAP_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_packet_sender.h b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_packet_sender.h new file mode 100644 index 0000000000..ebc65298a5 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_packet_sender.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2019 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_RTP_PACKET_SENDER_H_ +#define MODULES_RTP_RTCP_INCLUDE_RTP_PACKET_SENDER_H_ + +#include +#include + +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" +#include "modules/rtp_rtcp/source/rtp_packet_to_send.h" + +namespace webrtc { + +class RtpPacketSender { + public: + virtual ~RtpPacketSender() = default; + + // Insert a set of packets into queue, for eventual transmission. Based on the + // type of packets, they will be prioritized and scheduled relative to other + // packets and the current target send rate. + virtual void EnqueuePackets( + std::vector> packets) = 0; + + // Clear any pending packets with the given SSRC from the queue. + // TODO(crbug.com/1395081): Make pure virtual when downstream code has been + // updated. + virtual void RemovePacketsForSsrc(uint32_t ssrc) {} +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_RTP_PACKET_SENDER_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp.h b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp.h new file mode 100644 index 0000000000..e56d5ef637 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_ +#define MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_ + +#include + +#include "absl/base/attributes.h" +#include "modules/rtp_rtcp/source/rtp_rtcp_interface.h" + +namespace webrtc { + +class ABSL_DEPRECATED("") RtpRtcp : public RtpRtcpInterface { + public: + // Instantiates a deprecated version of the RtpRtcp module. + static std::unique_ptr ABSL_DEPRECATED("") + Create(const Configuration& configuration) { + return DEPRECATED_Create(configuration); + } + + static std::unique_ptr DEPRECATED_Create( + const Configuration& configuration); + + // Process any pending tasks such as timeouts. + virtual void Process() = 0; +}; + +} // namespace webrtc + +#endif // MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_H_ diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.cc b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.cc new file mode 100644 index 0000000000..0d91ab9546 --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.cc @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2017 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" + +#include + +#include + +#include "absl/algorithm/container.h" +#include "api/array_view.h" +#include "modules/rtp_rtcp/source/rtp_packet.h" +#include "modules/rtp_rtcp/source/rtp_packet_to_send.h" + +namespace webrtc { + +namespace { +constexpr size_t kMidRsidMaxSize = 16; + +// Check if passed character is a "token-char" from RFC 4566. +// https://datatracker.ietf.org/doc/html/rfc4566#section-9 +// token-char = %x21 / %x23-27 / %x2A-2B / %x2D-2E / %x30-39 +// / %x41-5A / %x5E-7E +bool IsTokenChar(char ch) { + return ch == 0x21 || (ch >= 0x23 && ch <= 0x27) || ch == 0x2a || ch == 0x2b || + ch == 0x2d || ch == 0x2e || (ch >= 0x30 && ch <= 0x39) || + (ch >= 0x41 && ch <= 0x5a) || (ch >= 0x5e && ch <= 0x7e); +} +} // namespace + +bool IsLegalMidName(absl::string_view name) { + return (name.size() <= kMidRsidMaxSize && !name.empty() && + absl::c_all_of(name, IsTokenChar)); +} + +bool IsLegalRsidName(absl::string_view name) { + return (name.size() <= kMidRsidMaxSize && !name.empty() && + absl::c_all_of(name, isalnum)); +} + +StreamDataCounters::StreamDataCounters() = default; + +RtpPacketCounter::RtpPacketCounter(const RtpPacket& packet) + : header_bytes(packet.headers_size()), + payload_bytes(packet.payload_size()), + padding_bytes(packet.padding_size()), + packets(1) {} + +RtpPacketCounter::RtpPacketCounter(const RtpPacketToSend& packet_to_send) + : RtpPacketCounter(static_cast(packet_to_send)) { + total_packet_delay = + packet_to_send.time_in_send_queue().value_or(TimeDelta::Zero()); +} + +void RtpPacketCounter::AddPacket(const RtpPacket& packet) { + ++packets; + header_bytes += packet.headers_size(); + padding_bytes += packet.padding_size(); + payload_bytes += packet.payload_size(); +} + +void RtpPacketCounter::AddPacket(const RtpPacketToSend& packet_to_send) { + AddPacket(static_cast(packet_to_send)); + total_packet_delay += + packet_to_send.time_in_send_queue().value_or(TimeDelta::Zero()); +} + +} // namespace webrtc diff --git a/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h new file mode 100644 index 0000000000..de85abd4ae --- /dev/null +++ b/third_party/libwebrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h @@ -0,0 +1,428 @@ +/* + * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#ifndef MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_DEFINES_H_ +#define MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_DEFINES_H_ + +#include + +#include +#include + +#include "absl/algorithm/container.h" +#include "absl/strings/string_view.h" +#include "absl/types/optional.h" +#include "absl/types/variant.h" +#include "api/array_view.h" +#include "api/audio_codecs/audio_format.h" +#include "api/rtp_headers.h" +#include "api/transport/network_types.h" +#include "api/units/data_rate.h" +#include "api/units/time_delta.h" +#include "api/units/timestamp.h" +#include "modules/rtp_rtcp/include/report_block_data.h" +#include "modules/rtp_rtcp/source/rtcp_packet/remote_estimate.h" +#include "system_wrappers/include/clock.h" + +#define RTCP_CNAME_SIZE 256 // RFC 3550 page 44, including null termination +#define IP_PACKET_SIZE 1500 // we assume ethernet + +namespace webrtc { +class RtpPacket; +class RtpPacketToSend; +namespace rtcp { +class TransportFeedback; +} + +const int kVideoPayloadTypeFrequency = 90000; + +// TODO(bugs.webrtc.org/6458): Remove this when all the depending projects are +// updated to correctly set rtp rate for RtcpSender. +const int kBogusRtpRateForAudioRtcp = 8000; + +// Minimum RTP header size in bytes. +const uint8_t kRtpHeaderSize = 12; + +bool IsLegalMidName(absl::string_view name); +bool IsLegalRsidName(absl::string_view name); + +// This enum must not have any gaps, i.e., all integers between +// kRtpExtensionNone and kRtpExtensionNumberOfExtensions must be valid enum +// entries. +enum RTPExtensionType : int { + kRtpExtensionNone, + kRtpExtensionTransmissionTimeOffset, + kRtpExtensionAudioLevel, + kRtpExtensionCsrcAudioLevel, + kRtpExtensionInbandComfortNoise, + kRtpExtensionAbsoluteSendTime, + kRtpExtensionAbsoluteCaptureTime, + kRtpExtensionVideoRotation, + kRtpExtensionTransportSequenceNumber, + kRtpExtensionTransportSequenceNumber02, + kRtpExtensionPlayoutDelay, + kRtpExtensionVideoContentType, + kRtpExtensionVideoLayersAllocation, + kRtpExtensionVideoTiming, + kRtpExtensionRtpStreamId, + kRtpExtensionRepairedRtpStreamId, + kRtpExtensionMid, + kRtpExtensionGenericFrameDescriptor, + kRtpExtensionGenericFrameDescriptor00 [[deprecated]] = + kRtpExtensionGenericFrameDescriptor, + kRtpExtensionDependencyDescriptor, + kRtpExtensionGenericFrameDescriptor02 [[deprecated]] = + kRtpExtensionDependencyDescriptor, + kRtpExtensionColorSpace, + kRtpExtensionVideoFrameTrackingId, + kRtpExtensionNumberOfExtensions // Must be the last entity in the enum. +}; + +enum RTCPAppSubTypes { kAppSubtypeBwe = 0x00 }; + +// TODO(sprang): Make this an enum class once rtcp_receiver has been cleaned up. +enum RTCPPacketType : uint32_t { + kRtcpReport = 0x0001, + kRtcpSr = 0x0002, + kRtcpRr = 0x0004, + kRtcpSdes = 0x0008, + kRtcpBye = 0x0010, + kRtcpPli = 0x0020, + kRtcpNack = 0x0040, + kRtcpFir = 0x0080, + kRtcpTmmbr = 0x0100, + kRtcpTmmbn = 0x0200, + kRtcpSrReq = 0x0400, + kRtcpLossNotification = 0x2000, + kRtcpRemb = 0x10000, + kRtcpTransmissionTimeOffset = 0x20000, + kRtcpXrReceiverReferenceTime = 0x40000, + kRtcpXrDlrrReportBlock = 0x80000, + kRtcpTransportFeedback = 0x100000, + kRtcpXrTargetBitrate = 0x200000 +}; + +enum class KeyFrameReqMethod : uint8_t { + kNone, // Don't request keyframes. + kPliRtcp, // Request keyframes through Picture Loss Indication. + kFirRtcp // Request keyframes through Full Intra-frame Request. +}; + +enum RtxMode { + kRtxOff = 0x0, + kRtxRetransmitted = 0x1, // Only send retransmissions over RTX. + kRtxRedundantPayloads = 0x2 // Preventively send redundant payloads + // instead of padding. +}; + +const size_t kRtxHeaderSize = 2; + +struct RtpState { + uint16_t sequence_number = 0; + uint32_t start_timestamp = 0; + uint32_t timestamp = 0; + Timestamp capture_time = Timestamp::MinusInfinity(); + Timestamp last_timestamp_time = Timestamp::MinusInfinity(); + bool ssrc_has_acked = false; +}; + +class RtcpIntraFrameObserver { + public: + virtual ~RtcpIntraFrameObserver() {} + + virtual void OnReceivedIntraFrameRequest(uint32_t ssrc) = 0; +}; + +// Observer for incoming LossNotification RTCP messages. +// See the documentation of LossNotification for details. +class RtcpLossNotificationObserver { + public: + virtual ~RtcpLossNotificationObserver() = default; + + virtual void OnReceivedLossNotification(uint32_t ssrc, + uint16_t seq_num_of_last_decodable, + uint16_t seq_num_of_last_received, + bool decodability_flag) = 0; +}; + +// Interface to watch incoming rtcp packets related to the link in general. +// All message handlers have default empty implementation. This way users only +// need to implement the ones they are interested in. +// All message handles pass `receive_time` parameter, which is receive time +// of the rtcp packet that triggered the update. +class NetworkLinkRtcpObserver { + public: + virtual ~NetworkLinkRtcpObserver() = default; + + virtual void OnTransportFeedback(Timestamp receive_time, + const rtcp::TransportFeedback& feedback) {} + virtual void OnReceiverEstimatedMaxBitrate(Timestamp receive_time, + DataRate bitrate) {} + + // Called on an RTCP packet with sender or receiver reports with non zero + // report blocks. Report blocks are combined from all reports into one array. + virtual void OnReport(Timestamp receive_time, + rtc::ArrayView report_blocks) {} + virtual void OnRttUpdate(Timestamp receive_time, TimeDelta rtt) {} +}; + +class RtcpEventObserver { + public: + virtual void OnRtcpBye() = 0; + virtual void OnRtcpTimeout() = 0; + + virtual ~RtcpEventObserver() {} +}; + +// NOTE! `kNumMediaTypes` must be kept in sync with RtpPacketMediaType! +static constexpr size_t kNumMediaTypes = 5; +enum class RtpPacketMediaType : size_t { + kAudio, // Audio media packets. + kVideo, // Video media packets. + kRetransmission, // Retransmisions, sent as response to NACK. + kForwardErrorCorrection, // FEC packets. + kPadding = kNumMediaTypes - 1, // RTX or plain padding sent to maintain BWE. + // Again, don't forget to update `kNumMediaTypes` if you add another value! +}; + +struct RtpPacketSendInfo { + uint16_t transport_sequence_number = 0; + absl::optional media_ssrc; + uint16_t rtp_sequence_number = 0; // Only valid if `media_ssrc` is set. + uint32_t rtp_timestamp = 0; + size_t length = 0; + absl::optional packet_type; + PacedPacketInfo pacing_info; +}; + +class NetworkStateEstimateObserver { + public: + virtual void OnRemoteNetworkEstimate(NetworkStateEstimate estimate) = 0; + virtual ~NetworkStateEstimateObserver() = default; +}; + +class TransportFeedbackObserver { + public: + virtual ~TransportFeedbackObserver() = default; + + virtual void OnAddPacket(const RtpPacketSendInfo& packet_info) = 0; +}; + +// Interface for PacketRouter to send rtcp feedback on behalf of +// congestion controller. +// TODO(bugs.webrtc.org/8239): Remove and use RtcpTransceiver directly +// when RtcpTransceiver always present in rtp transport. +class RtcpFeedbackSenderInterface { + public: + virtual ~RtcpFeedbackSenderInterface() = default; + virtual void SendCombinedRtcpPacket( + std::vector> rtcp_packets) = 0; + virtual void SetRemb(int64_t bitrate_bps, std::vector ssrcs) = 0; + virtual void UnsetRemb() = 0; +}; + +class StreamFeedbackObserver { + public: + struct StreamPacketInfo { + bool received; + + // `rtp_sequence_number` and `is_retransmission` are only valid if `ssrc` + // is populated. + absl::optional ssrc; + uint16_t rtp_sequence_number; + bool is_retransmission; + }; + virtual ~StreamFeedbackObserver() = default; + + virtual void OnPacketFeedbackVector( + std::vector packet_feedback_vector) = 0; +}; + +class StreamFeedbackProvider { + public: + virtual void RegisterStreamFeedbackObserver( + std::vector ssrcs, + StreamFeedbackObserver* observer) = 0; + virtual void DeRegisterStreamFeedbackObserver( + StreamFeedbackObserver* observer) = 0; + virtual ~StreamFeedbackProvider() = default; +}; + +class RtcpRttStats { + public: + virtual void OnRttUpdate(int64_t rtt) = 0; + + virtual int64_t LastProcessedRtt() const = 0; + + virtual ~RtcpRttStats() {} +}; + +struct RtpPacketCounter { + RtpPacketCounter() + : header_bytes(0), payload_bytes(0), padding_bytes(0), packets(0) {} + + explicit RtpPacketCounter(const RtpPacket& packet); + explicit RtpPacketCounter(const RtpPacketToSend& packet_to_send); + + void Add(const RtpPacketCounter& other) { + header_bytes += other.header_bytes; + payload_bytes += other.payload_bytes; + padding_bytes += other.padding_bytes; + packets += other.packets; + total_packet_delay += other.total_packet_delay; + } + + bool operator==(const RtpPacketCounter& other) const { + return header_bytes == other.header_bytes && + payload_bytes == other.payload_bytes && + padding_bytes == other.padding_bytes && packets == other.packets && + total_packet_delay == other.total_packet_delay; + } + + // Not inlined, since use of RtpPacket would result in circular includes. + void AddPacket(const RtpPacket& packet); + void AddPacket(const RtpPacketToSend& packet_to_send); + + size_t TotalBytes() const { + return header_bytes + payload_bytes + padding_bytes; + } + + size_t header_bytes; // Number of bytes used by RTP headers. + size_t payload_bytes; // Payload bytes, excluding RTP headers and padding. + size_t padding_bytes; // Number of padding bytes. + size_t packets; // Number of packets. + // The total delay of all `packets`. For RtpPacketToSend packets, this is + // `time_in_send_queue()`. For receive packets, this is zero. + webrtc::TimeDelta total_packet_delay = webrtc::TimeDelta::Zero(); +}; + +// Data usage statistics for a (rtp) stream. +struct StreamDataCounters { + StreamDataCounters(); + + void Add(const StreamDataCounters& other) { + transmitted.Add(other.transmitted); + retransmitted.Add(other.retransmitted); + fec.Add(other.fec); + if (other.first_packet_time < first_packet_time) { + // Use oldest time (excluding unsed value represented as plus infinity. + first_packet_time = other.first_packet_time; + } + } + + void MaybeSetFirstPacketTime(Timestamp now) { + if (first_packet_time == Timestamp::PlusInfinity()) { + first_packet_time = now; + } + } + + // Return time since first packet is send/received, or zero if such event + // haven't happen. + TimeDelta TimeSinceFirstPacket(Timestamp now) const { + return first_packet_time == Timestamp::PlusInfinity() + ? TimeDelta::Zero() + : now - first_packet_time; + } + + // Returns the number of bytes corresponding to the actual media payload (i.e. + // RTP headers, padding, retransmissions and fec packets are excluded). + // Note this function does not have meaning for an RTX stream. + size_t MediaPayloadBytes() const { + return transmitted.payload_bytes - retransmitted.payload_bytes - + fec.payload_bytes; + } + + // Time when first packet is sent/received. + Timestamp first_packet_time = Timestamp::PlusInfinity(); + + RtpPacketCounter transmitted; // Number of transmitted packets/bytes. + RtpPacketCounter retransmitted; // Number of retransmitted packets/bytes. + RtpPacketCounter fec; // Number of redundancy packets/bytes. +}; + +class RtpSendRates { + template + constexpr std::array make_zero_array( + std::index_sequence) { + return {{(static_cast(Is), DataRate::Zero())...}}; + } + + public: + RtpSendRates() + : send_rates_( + make_zero_array(std::make_index_sequence())) {} + RtpSendRates(const RtpSendRates& rhs) = default; + RtpSendRates& operator=(const RtpSendRates&) = default; + + DataRate& operator[](RtpPacketMediaType type) { + return send_rates_[static_cast(type)]; + } + const DataRate& operator[](RtpPacketMediaType type) const { + return send_rates_[static_cast(type)]; + } + DataRate Sum() const { + return absl::c_accumulate(send_rates_, DataRate::Zero()); + } + + private: + std::array send_rates_; +}; + +// Callback, called whenever byte/packet counts have been updated. +class StreamDataCountersCallback { + public: + virtual ~StreamDataCountersCallback() {} + + virtual void DataCountersUpdated(const StreamDataCounters& counters, + uint32_t ssrc) = 0; +}; + +// Information exposed through the GetStats api. +struct RtpReceiveStats { + // `packets_lost` and `jitter` are defined by RFC 3550, and exposed in the + // RTCReceivedRtpStreamStats dictionary, see + // https://w3c.github.io/webrtc-stats/#receivedrtpstats-dict* + int32_t packets_lost = 0; + // Interarrival jitter in samples. + uint32_t jitter = 0; + // Interarrival jitter in time. + webrtc::TimeDelta interarrival_jitter = webrtc::TimeDelta::Zero(); + + // Time of the last packet received in unix epoch, + // i.e. Timestamp::Zero() represents 1st Jan 1970 00:00 + absl::optional last_packet_received; + + // Counters exposed in RTCInboundRtpStreamStats, see + // https://w3c.github.io/webrtc-stats/#inboundrtpstats-dict* + RtpPacketCounter packet_counter; +}; + +// Callback, used to notify an observer whenever new rates have been estimated. +class BitrateStatisticsObserver { + public: + virtual ~BitrateStatisticsObserver() {} + + virtual void Notify(uint32_t total_bitrate_bps, + uint32_t retransmit_bitrate_bps, + uint32_t ssrc) = 0; +}; + +// Callback, used to notify an observer whenever a packet is sent to the +// transport. +class SendPacketObserver { + public: + virtual ~SendPacketObserver() = default; + virtual void OnSendPacket(absl::optional packet_id, + Timestamp capture_time, + uint32_t ssrc) = 0; +}; + +} // namespace webrtc +#endif // MODULES_RTP_RTCP_INCLUDE_RTP_RTCP_DEFINES_H_ -- cgit v1.2.3