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 WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_PACKET_SENDER_H_
12#define WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_PACKET_SENDER_H_
13
14#include <list>
15#include <limits>
16#include <set>
17#include <string>
18
19#include "webrtc/base/constructormagic.h"
20#include "webrtc/base/scoped_ptr.h"
21#include "webrtc/modules/include/module.h"
22#include "webrtc/modules/remote_bitrate_estimator/test/bwe.h"
23#include "webrtc/modules/remote_bitrate_estimator/test/bwe_test_framework.h"
24
25namespace webrtc {
26namespace testing {
27namespace bwe {
28
29class MetricRecorder;
30
31class PacketSender : public PacketProcessor {
32 public:
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) {}
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
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
66class 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
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
85  void Pause() override;
86  void Resume(int64_t paused_time_ms) override;
87
88 protected:
89  void ProcessFeedbackAndGeneratePackets(int64_t time_ms,
90                                         std::list<FeedbackPacket*>* feedbacks,
91                                         Packets* generated);
92
93  VideoSource* source_;
94  rtc::scoped_ptr<BweSender> bwe_;
95  int64_t start_of_run_ms_;
96  std::list<Module*> modules_;
97
98 private:
99  uint32_t previous_sending_bitrate_;
100  RTC_DISALLOW_COPY_AND_ASSIGN(VideoSender);
101};
102
103class PacedVideoSender : public VideoSender, public PacedSender::Callback {
104 public:
105  PacedVideoSender(PacketProcessorListener* listener,
106                   VideoSource* source,
107                   BandwidthEstimatorType estimator);
108  virtual ~PacedVideoSender();
109
110  void RunFor(int64_t time_ms, Packets* in_out) override;
111
112  // Implements PacedSender::Callback.
113  bool TimeToSendPacket(uint32_t ssrc,
114                        uint16_t sequence_number,
115                        int64_t capture_time_ms,
116                        bool retransmission) override;
117  size_t TimeToSendPadding(size_t bytes) override;
118
119  // Implements BitrateObserver.
120  void OnNetworkChanged(uint32_t target_bitrate_bps,
121                        uint8_t fraction_lost,
122                        int64_t rtt) override;
123
124 private:
125  int64_t TimeUntilNextProcess(const std::list<Module*>& modules);
126  void CallProcess(const std::list<Module*>& modules);
127  void QueuePackets(Packets* batch, int64_t end_of_batch_time_us);
128
129  PacedSender pacer_;
130  Packets queue_;
131  Packets pacer_queue_;
132
133  RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(PacedVideoSender);
134};
135
136class TcpSender : public PacketSender {
137 public:
138  TcpSender(PacketProcessorListener* listener, int flow_id, int64_t offset_ms);
139  TcpSender(PacketProcessorListener* listener,
140            int flow_id,
141            int64_t offset_ms,
142            int send_limit_bytes);
143  virtual ~TcpSender() {}
144
145  void RunFor(int64_t time_ms, Packets* in_out) override;
146  int GetFeedbackIntervalMs() const override { return 10; }
147
148  uint32_t TargetBitrateKbps() override;
149
150 private:
151  struct InFlight {
152   public:
153    explicit InFlight(const MediaPacket& packet)
154        : sequence_number(packet.header().sequenceNumber),
155          time_ms(packet.send_time_ms()) {}
156
157    InFlight(uint16_t seq_num, int64_t now_ms)
158        : sequence_number(seq_num), time_ms(now_ms) {}
159
160    bool operator<(const InFlight& rhs) const {
161      return sequence_number < rhs.sequence_number;
162    }
163
164    uint16_t sequence_number;  // Sequence number of a packet in flight, or a
165                               // packet which has just been acked.
166    int64_t time_ms;  // Time of when the packet left the sender, or when the
167                      // ack was received.
168  };
169
170  void SendPackets(Packets* in_out);
171  void UpdateCongestionControl(const FeedbackPacket* fb);
172  int TriggerTimeouts();
173  void HandleLoss();
174  Packets GeneratePackets(size_t num_packets);
175  void UpdateSendBitrateEstimate(size_t num_packets);
176
177  float cwnd_;
178  int ssthresh_;
179  std::set<InFlight> in_flight_;
180  bool ack_received_;
181  uint16_t last_acked_seq_num_;
182  uint16_t next_sequence_number_;
183  int64_t offset_ms_;
184  int64_t last_reduction_time_ms_;
185  int64_t last_rtt_ms_;
186  int total_sent_bytes_;
187  int send_limit_bytes_;  // Initialized by default as kNoLimit.
188  int64_t last_generated_packets_ms_;
189  size_t num_recent_sent_packets_;
190  uint32_t bitrate_kbps_;
191};
192}  // namespace bwe
193}  // namespace testing
194}  // namespace webrtc
195#endif  // WEBRTC_MODULES_REMOTE_BITRATE_ESTIMATOR_TEST_PACKET_SENDER_H_
196