| /* |
| * 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 API_TRANSPORT_NETWORK_TYPES_H_ |
| #define API_TRANSPORT_NETWORK_TYPES_H_ |
| #include <stdint.h> |
| |
| #include <vector> |
| |
| #include "absl/types/optional.h" |
| #include "api/units/data_rate.h" |
| #include "api/units/data_size.h" |
| #include "api/units/time_delta.h" |
| #include "api/units/timestamp.h" |
| |
| namespace webrtc { |
| |
| // Configuration |
| |
| // Represents constraints and rates related to the currently enabled streams. |
| // This is used as input to the congestion controller via the StreamsConfig |
| // struct. |
| struct BitrateAllocationLimits { |
| // The total minimum send bitrate required by all sending streams. |
| DataRate min_allocatable_rate = DataRate::Zero(); |
| // The total maximum allocatable bitrate for all currently available streams. |
| DataRate max_allocatable_rate = DataRate::Zero(); |
| // The max bitrate to use for padding. The sum of the per-stream max padding |
| // rate. |
| DataRate max_padding_rate = DataRate::Zero(); |
| }; |
| |
| // Use StreamsConfig for information about streams that is required for specific |
| // adjustments to the algorithms in network controllers. Especially useful |
| // for experiments. |
| struct StreamsConfig { |
| StreamsConfig(); |
| StreamsConfig(const StreamsConfig&); |
| ~StreamsConfig(); |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| absl::optional<bool> requests_alr_probing; |
| absl::optional<double> pacing_factor; |
| |
| // TODO(srte): Use BitrateAllocationLimits here. |
| absl::optional<DataRate> min_total_allocated_bitrate; |
| absl::optional<DataRate> max_padding_rate; |
| absl::optional<DataRate> max_total_allocated_bitrate; |
| }; |
| |
| struct TargetRateConstraints { |
| TargetRateConstraints(); |
| TargetRateConstraints(const TargetRateConstraints&); |
| ~TargetRateConstraints(); |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| absl::optional<DataRate> min_data_rate; |
| absl::optional<DataRate> max_data_rate; |
| // The initial bandwidth estimate to base target rate on. This should be used |
| // as the basis for initial OnTargetTransferRate and OnPacerConfig callbacks. |
| absl::optional<DataRate> starting_rate; |
| }; |
| |
| // Send side information |
| |
| struct NetworkAvailability { |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| bool network_available = false; |
| }; |
| |
| struct NetworkRouteChange { |
| NetworkRouteChange(); |
| NetworkRouteChange(const NetworkRouteChange&); |
| ~NetworkRouteChange(); |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| // The TargetRateConstraints are set here so they can be changed synchronously |
| // when network route changes. |
| TargetRateConstraints constraints; |
| }; |
| |
| struct PacedPacketInfo { |
| PacedPacketInfo(); |
| PacedPacketInfo(int probe_cluster_id, |
| int probe_cluster_min_probes, |
| int probe_cluster_min_bytes); |
| |
| bool operator==(const PacedPacketInfo& rhs) const; |
| |
| // TODO(srte): Move probing info to a separate, optional struct. |
| static constexpr int kNotAProbe = -1; |
| int send_bitrate_bps = -1; |
| int probe_cluster_id = kNotAProbe; |
| int probe_cluster_min_probes = -1; |
| int probe_cluster_min_bytes = -1; |
| int probe_cluster_bytes_sent = 0; |
| }; |
| |
| struct SentPacket { |
| Timestamp send_time = Timestamp::PlusInfinity(); |
| // Size of packet with overhead up to IP layer. |
| DataSize size = DataSize::Zero(); |
| // Size of preceeding packets that are not part of feedback. |
| DataSize prior_unacked_data = DataSize::Zero(); |
| // Probe cluster id and parameters including bitrate, number of packets and |
| // number of bytes. |
| PacedPacketInfo pacing_info; |
| // True if the packet is an audio packet, false for video, padding, RTX etc. |
| bool audio = false; |
| // Transport independent sequence number, any tracked packet should have a |
| // sequence number that is unique over the whole call and increasing by 1 for |
| // each packet. |
| int64_t sequence_number; |
| // Tracked data in flight when the packet was sent, excluding unacked data. |
| DataSize data_in_flight = DataSize::Zero(); |
| }; |
| |
| struct ReceivedPacket { |
| Timestamp send_time = Timestamp::MinusInfinity(); |
| Timestamp receive_time = Timestamp::PlusInfinity(); |
| DataSize size = DataSize::Zero(); |
| }; |
| |
| // Transport level feedback |
| |
| struct RemoteBitrateReport { |
| Timestamp receive_time = Timestamp::PlusInfinity(); |
| DataRate bandwidth = DataRate::Infinity(); |
| }; |
| |
| struct RoundTripTimeUpdate { |
| Timestamp receive_time = Timestamp::PlusInfinity(); |
| TimeDelta round_trip_time = TimeDelta::PlusInfinity(); |
| bool smoothed = false; |
| }; |
| |
| struct TransportLossReport { |
| Timestamp receive_time = Timestamp::PlusInfinity(); |
| Timestamp start_time = Timestamp::PlusInfinity(); |
| Timestamp end_time = Timestamp::PlusInfinity(); |
| uint64_t packets_lost_delta = 0; |
| uint64_t packets_received_delta = 0; |
| }; |
| |
| // Packet level feedback |
| |
| struct PacketResult { |
| class ReceiveTimeOrder { |
| public: |
| bool operator()(const PacketResult& lhs, const PacketResult& rhs); |
| }; |
| |
| PacketResult(); |
| PacketResult(const PacketResult&); |
| ~PacketResult(); |
| |
| inline bool IsReceived() const { return !receive_time.IsPlusInfinity(); } |
| |
| SentPacket sent_packet; |
| Timestamp receive_time = Timestamp::PlusInfinity(); |
| }; |
| |
| struct TransportPacketsFeedback { |
| TransportPacketsFeedback(); |
| TransportPacketsFeedback(const TransportPacketsFeedback& other); |
| ~TransportPacketsFeedback(); |
| |
| Timestamp feedback_time = Timestamp::PlusInfinity(); |
| Timestamp first_unacked_send_time = Timestamp::PlusInfinity(); |
| DataSize data_in_flight = DataSize::Zero(); |
| DataSize prior_in_flight = DataSize::Zero(); |
| std::vector<PacketResult> packet_feedbacks; |
| |
| // Arrival times for messages without send time information. |
| std::vector<Timestamp> sendless_arrival_times; |
| |
| std::vector<PacketResult> ReceivedWithSendInfo() const; |
| std::vector<PacketResult> LostWithSendInfo() const; |
| std::vector<PacketResult> PacketsWithFeedback() const; |
| std::vector<PacketResult> SortedByReceiveTime() const; |
| }; |
| |
| // Network estimation |
| |
| struct NetworkEstimate { |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| // Deprecated, use TargetTransferRate::target_rate instead. |
| DataRate bandwidth = DataRate::Infinity(); |
| TimeDelta round_trip_time = TimeDelta::PlusInfinity(); |
| TimeDelta bwe_period = TimeDelta::PlusInfinity(); |
| |
| float loss_rate_ratio = 0; |
| }; |
| |
| // Network control |
| |
| struct PacerConfig { |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| // Pacer should send at most data_window data over time_window duration. |
| DataSize data_window = DataSize::Infinity(); |
| TimeDelta time_window = TimeDelta::PlusInfinity(); |
| // Pacer should send at least pad_window data over time_window duration. |
| DataSize pad_window = DataSize::Zero(); |
| DataRate data_rate() const { return data_window / time_window; } |
| DataRate pad_rate() const { return pad_window / time_window; } |
| }; |
| |
| struct ProbeClusterConfig { |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| DataRate target_data_rate = DataRate::Zero(); |
| TimeDelta target_duration = TimeDelta::Zero(); |
| int32_t target_probe_count = 0; |
| int32_t id = 0; |
| }; |
| |
| struct TargetTransferRate { |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| // The estimate on which the target rate is based on. |
| NetworkEstimate network_estimate; |
| DataRate target_rate = DataRate::Zero(); |
| DataRate stable_target_rate = DataRate::Zero(); |
| double cwnd_reduce_ratio = 0; |
| }; |
| |
| // Contains updates of network controller comand state. Using optionals to |
| // indicate whether a member has been updated. The array of probe clusters |
| // should be used to send out probes if not empty. |
| struct NetworkControlUpdate { |
| NetworkControlUpdate(); |
| NetworkControlUpdate(const NetworkControlUpdate&); |
| ~NetworkControlUpdate(); |
| absl::optional<DataSize> congestion_window; |
| absl::optional<PacerConfig> pacer_config; |
| std::vector<ProbeClusterConfig> probe_cluster_configs; |
| absl::optional<TargetTransferRate> target_rate; |
| }; |
| |
| // Process control |
| struct ProcessInterval { |
| Timestamp at_time = Timestamp::PlusInfinity(); |
| absl::optional<DataSize> pacer_queue; |
| }; |
| |
| // Under development, subject to change without notice. |
| struct NetworkStateEstimate { |
| double confidence = NAN; |
| // The time the estimate was received/calculated. |
| Timestamp update_time = Timestamp::MinusInfinity(); |
| Timestamp last_receive_time = Timestamp::MinusInfinity(); |
| Timestamp last_send_time = Timestamp::MinusInfinity(); |
| |
| // Total estimated link capacity. |
| DataRate link_capacity = DataRate::MinusInfinity(); |
| // Used as a safe measure of available capacity. |
| DataRate link_capacity_lower = DataRate::MinusInfinity(); |
| // Used as limit for increasing bitrate. |
| DataRate link_capacity_upper = DataRate::MinusInfinity(); |
| |
| TimeDelta pre_link_buffer_delay = TimeDelta::MinusInfinity(); |
| TimeDelta post_link_buffer_delay = TimeDelta::MinusInfinity(); |
| TimeDelta propagation_delay = TimeDelta::MinusInfinity(); |
| |
| // Only for debugging |
| TimeDelta time_delta = TimeDelta::MinusInfinity(); |
| Timestamp last_feed_time = Timestamp::MinusInfinity(); |
| double cross_delay_rate = NAN; |
| double spike_delay_rate = NAN; |
| DataRate link_capacity_std_dev = DataRate::MinusInfinity(); |
| DataRate link_capacity_min = DataRate::MinusInfinity(); |
| double cross_traffic_ratio = NAN; |
| }; |
| } // namespace webrtc |
| |
| #endif // API_TRANSPORT_NETWORK_TYPES_H_ |