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