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_REMOTE_BITRATE_ESTIMATOR_TEST_PACKET_SENDER_H_ 12 #define MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_PACKET_SENDER_H_ 13 14 #include <list> 15 #include <limits> 16 #include <memory> 17 #include <set> 18 #include <string> 19 20 #include "modules/include/module.h" 21 #include "modules/remote_bitrate_estimator/test/bwe.h" 22 #include "modules/remote_bitrate_estimator/test/bwe_test_framework.h" 23 #include "rtc_base/constructormagic.h" 24 25 namespace webrtc { 26 namespace testing { 27 namespace bwe { 28 29 class MetricRecorder; 30 31 class PacketSender : public PacketProcessor { 32 public: PacketSender(PacketProcessorListener * listener,int flow_id)33 PacketSender(PacketProcessorListener* listener, int flow_id) 34 : PacketProcessor(listener, flow_id, kSender), 35 running_(true), 36 // For Packet::send_time_us() to be comparable with timestamps from 37 // clock_, the clock of the PacketSender and the Source must be aligned. 38 // We assume that both start at time 0. 39 clock_(0), 40 metric_recorder_(nullptr) {} ~PacketSender()41 virtual ~PacketSender() {} 42 // Call GiveFeedback() with the returned interval in milliseconds, provided 43 // there is a new estimate available. 44 // Note that changing the feedback interval affects the timing of when the 45 // output of the estimators is sampled and therefore the baseline files may 46 // have to be regenerated. 47 virtual int GetFeedbackIntervalMs() const = 0; 48 void SetSenderTimestamps(Packets* in_out); 49 TargetBitrateKbps()50 virtual uint32_t TargetBitrateKbps() { return 0; } 51 52 virtual void Pause(); 53 virtual void Resume(int64_t paused_time_ms); 54 55 void set_metric_recorder(MetricRecorder* metric_recorder); 56 virtual void RecordBitrate(); 57 58 protected: 59 bool running_; // Initialized by default as true. 60 SimulatedClock clock_; 61 62 private: 63 MetricRecorder* metric_recorder_; 64 }; 65 66 class VideoSender : public PacketSender, public BitrateObserver { 67 public: 68 VideoSender(PacketProcessorListener* listener, 69 VideoSource* source, 70 BandwidthEstimatorType estimator); 71 virtual ~VideoSender(); 72 73 int GetFeedbackIntervalMs() const override; 74 void RunFor(int64_t time_ms, Packets* in_out) override; 75 source()76 virtual VideoSource* source() const { return source_; } 77 78 uint32_t TargetBitrateKbps() override; 79 80 // Implements BitrateObserver. 81 void OnNetworkChanged(uint32_t target_bitrate_bps, 82 uint8_t fraction_lost, 83 int64_t rtt) override; 84 void Pause() override; 85 void Resume(int64_t paused_time_ms) override; 86 87 protected: 88 void ProcessFeedbackAndGeneratePackets(int64_t time_ms, 89 std::list<FeedbackPacket*>* feedbacks, 90 Packets* generated); 91 92 VideoSource* source_; 93 std::unique_ptr<BweSender> bwe_; 94 int64_t start_of_run_ms_; 95 std::list<Module*> modules_; 96 97 private: 98 uint32_t previous_sending_bitrate_; 99 RTC_DISALLOW_COPY_AND_ASSIGN(VideoSender); 100 }; 101 102 class PacedVideoSender : public VideoSender, public PacedSender::PacketSender { 103 public: 104 PacedVideoSender(PacketProcessorListener* listener, 105 VideoSource* source, 106 BandwidthEstimatorType estimator); 107 virtual ~PacedVideoSender(); 108 109 void RunFor(int64_t time_ms, Packets* in_out) override; 110 111 // Implements PacedSender::Callback. 112 bool TimeToSendPacket(uint32_t ssrc, 113 uint16_t sequence_number, 114 int64_t capture_time_ms, 115 bool retransmission, 116 const PacedPacketInfo& pacing_info) override; 117 size_t TimeToSendPadding(size_t bytes, 118 const PacedPacketInfo& pacing_info) override; 119 120 // Implements BitrateObserver. 121 void OnNetworkChanged(uint32_t target_bitrate_bps, 122 uint8_t fraction_lost, 123 int64_t rtt) override; 124 125 void OnNetworkChanged(uint32_t bitrate_for_encoder_bps, 126 uint32_t bitrate_for_pacer_bps, 127 bool in_probe_rtt, 128 int64_t rtt, 129 uint64_t congestion_window) override; pacer_queue_size_in_bytes()130 size_t pacer_queue_size_in_bytes() override { 131 return pacer_queue_size_in_bytes_; 132 } 133 void OnBytesAcked(size_t bytes) override; 134 135 private: 136 int64_t TimeUntilNextProcess(const std::list<Module*>& modules); 137 void CallProcess(const std::list<Module*>& modules); 138 void QueuePackets(Packets* batch, int64_t end_of_batch_time_us); 139 140 size_t pacer_queue_size_in_bytes_ = 0; 141 std::unique_ptr<Pacer> pacer_; 142 Packets queue_; 143 Packets pacer_queue_; 144 145 RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(PacedVideoSender); 146 }; 147 148 class TcpSender : public PacketSender { 149 public: 150 TcpSender(PacketProcessorListener* listener, int flow_id, int64_t offset_ms); 151 TcpSender(PacketProcessorListener* listener, 152 int flow_id, 153 int64_t offset_ms, 154 int send_limit_bytes); ~TcpSender()155 virtual ~TcpSender() {} 156 157 void RunFor(int64_t time_ms, Packets* in_out) override; GetFeedbackIntervalMs()158 int GetFeedbackIntervalMs() const override { return 10; } 159 160 uint32_t TargetBitrateKbps() override; 161 162 private: 163 struct InFlight { 164 public: InFlightInFlight165 explicit InFlight(const MediaPacket& packet) 166 : sequence_number(packet.header().sequenceNumber), 167 time_ms(packet.send_time_ms()) {} 168 InFlightInFlight169 InFlight(uint16_t seq_num, int64_t now_ms) 170 : sequence_number(seq_num), time_ms(now_ms) {} 171 172 bool operator<(const InFlight& rhs) const { 173 return sequence_number < rhs.sequence_number; 174 } 175 176 uint16_t sequence_number; // Sequence number of a packet in flight, or a 177 // packet which has just been acked. 178 int64_t time_ms; // Time of when the packet left the sender, or when the 179 // ack was received. 180 }; 181 182 void SendPackets(Packets* in_out); 183 void UpdateCongestionControl(const FeedbackPacket* fb); 184 int TriggerTimeouts(); 185 void HandleLoss(); 186 Packets GeneratePackets(size_t num_packets); 187 void UpdateSendBitrateEstimate(size_t num_packets); 188 189 float cwnd_; 190 int ssthresh_; 191 std::set<InFlight> in_flight_; 192 bool ack_received_; 193 uint16_t last_acked_seq_num_; 194 uint16_t next_sequence_number_; 195 int64_t offset_ms_; 196 int64_t last_reduction_time_ms_; 197 int64_t last_rtt_ms_; 198 int total_sent_bytes_; 199 int send_limit_bytes_; // Initialized by default as kNoLimit. 200 int64_t last_generated_packets_ms_; 201 size_t num_recent_sent_packets_; 202 uint32_t bitrate_kbps_; 203 }; 204 } // namespace bwe 205 } // namespace testing 206 } // namespace webrtc 207 #endif // MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_PACKET_SENDER_H_ 208