1/*
2 *  Copyright (c) 2014 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_VIDEO_RAMPUP_TESTS_H_
12#define WEBRTC_VIDEO_RAMPUP_TESTS_H_
13
14#include <map>
15#include <string>
16#include <vector>
17
18#include "webrtc/call.h"
19#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
20#include "webrtc/system_wrappers/interface/event_wrapper.h"
21#include "webrtc/system_wrappers/interface/scoped_ptr.h"
22#include "webrtc/test/call_test.h"
23#include "webrtc/video/transport_adapter.h"
24
25namespace webrtc {
26
27static const int kTransmissionTimeOffsetExtensionId = 6;
28static const int kAbsSendTimeExtensionId = 7;
29static const unsigned int kSingleStreamTargetBps = 1000000;
30
31class Clock;
32class CriticalSectionWrapper;
33class ReceiveStatistics;
34class RtpHeaderParser;
35class RTPPayloadRegistry;
36class RtpRtcp;
37
38class StreamObserver : public newapi::Transport, public RemoteBitrateObserver {
39 public:
40  typedef std::map<uint32_t, int> BytesSentMap;
41  typedef std::map<uint32_t, uint32_t> SsrcMap;
42  StreamObserver(const SsrcMap& rtx_media_ssrcs,
43                 newapi::Transport* feedback_transport,
44                 Clock* clock,
45                 RemoteBitrateEstimatorFactory* rbe_factory,
46                 RateControlType control_type);
47
48  void set_expected_bitrate_bps(unsigned int expected_bitrate_bps);
49
50  void set_start_bitrate_bps(unsigned int start_bitrate_bps);
51
52  virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
53                                       unsigned int bitrate) OVERRIDE;
54
55  virtual bool SendRtp(const uint8_t* packet, size_t length) OVERRIDE;
56
57  virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE;
58
59  EventTypeWrapper Wait();
60
61 private:
62  void ReportResult(const std::string& measurement,
63                    size_t value,
64                    const std::string& units);
65  void TriggerTestDone() EXCLUSIVE_LOCKS_REQUIRED(crit_);
66
67  Clock* const clock_;
68  const scoped_ptr<EventWrapper> test_done_;
69  const scoped_ptr<RtpHeaderParser> rtp_parser_;
70  scoped_ptr<RtpRtcp> rtp_rtcp_;
71  internal::TransportAdapter feedback_transport_;
72  const scoped_ptr<ReceiveStatistics> receive_stats_;
73  const scoped_ptr<RTPPayloadRegistry> payload_registry_;
74  scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
75
76  const scoped_ptr<CriticalSectionWrapper> crit_;
77  unsigned int expected_bitrate_bps_ GUARDED_BY(crit_);
78  unsigned int start_bitrate_bps_ GUARDED_BY(crit_);
79  SsrcMap rtx_media_ssrcs_ GUARDED_BY(crit_);
80  size_t total_sent_ GUARDED_BY(crit_);
81  size_t padding_sent_ GUARDED_BY(crit_);
82  size_t rtx_media_sent_ GUARDED_BY(crit_);
83  int total_packets_sent_ GUARDED_BY(crit_);
84  int padding_packets_sent_ GUARDED_BY(crit_);
85  int rtx_media_packets_sent_ GUARDED_BY(crit_);
86  int64_t test_start_ms_ GUARDED_BY(crit_);
87  int64_t ramp_up_finished_ms_ GUARDED_BY(crit_);
88};
89
90class LowRateStreamObserver : public test::DirectTransport,
91                              public RemoteBitrateObserver,
92                              public PacketReceiver {
93 public:
94  LowRateStreamObserver(newapi::Transport* feedback_transport,
95                        Clock* clock,
96                        size_t number_of_streams,
97                        bool rtx_used);
98
99  virtual void SetSendStream(const VideoSendStream* send_stream);
100
101  virtual void OnReceiveBitrateChanged(const std::vector<unsigned int>& ssrcs,
102                                       unsigned int bitrate);
103
104  virtual bool SendRtp(const uint8_t* data, size_t length) OVERRIDE;
105
106  virtual DeliveryStatus DeliverPacket(const uint8_t* packet,
107                                       size_t length) OVERRIDE;
108
109  virtual bool SendRtcp(const uint8_t* packet, size_t length) OVERRIDE;
110
111  // Produces a string similar to "1stream_nortx", depending on the values of
112  // number_of_streams_ and rtx_used_;
113  std::string GetModifierString();
114
115  // This method defines the state machine for the ramp up-down-up test.
116  void EvolveTestState(unsigned int bitrate_bps);
117
118  EventTypeWrapper Wait();
119
120 private:
121  static const unsigned int kHighBandwidthLimitBps = 80000;
122  static const unsigned int kExpectedHighBitrateBps = 60000;
123  static const unsigned int kLowBandwidthLimitBps = 20000;
124  static const unsigned int kExpectedLowBitrateBps = 20000;
125  enum TestStates { kFirstRampup, kLowRate, kSecondRampup };
126
127  Clock* const clock_;
128  const size_t number_of_streams_;
129  const bool rtx_used_;
130  const scoped_ptr<EventWrapper> test_done_;
131  const scoped_ptr<RtpHeaderParser> rtp_parser_;
132  scoped_ptr<RtpRtcp> rtp_rtcp_;
133  internal::TransportAdapter feedback_transport_;
134  const scoped_ptr<ReceiveStatistics> receive_stats_;
135  scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_;
136
137  scoped_ptr<CriticalSectionWrapper> crit_;
138  const VideoSendStream* send_stream_ GUARDED_BY(crit_);
139  FakeNetworkPipe::Config forward_transport_config_ GUARDED_BY(crit_);
140  TestStates test_state_ GUARDED_BY(crit_);
141  int64_t state_start_ms_ GUARDED_BY(crit_);
142  int64_t interval_start_ms_ GUARDED_BY(crit_);
143  unsigned int last_remb_bps_ GUARDED_BY(crit_);
144  size_t sent_bytes_ GUARDED_BY(crit_);
145  size_t total_overuse_bytes_ GUARDED_BY(crit_);
146  bool suspended_in_stats_ GUARDED_BY(crit_);
147};
148
149class RampUpTest : public test::CallTest {
150 protected:
151  void RunRampUpTest(bool rtx,
152                     size_t num_streams,
153                     unsigned int start_bitrate_bps,
154                     const std::string& extension_type);
155
156  void RunRampUpDownUpTest(size_t number_of_streams, bool rtx);
157};
158}  // namespace webrtc
159#endif  // WEBRTC_VIDEO_RAMPUP_TESTS_H_
160