1/*
2 *  Copyright (c) 2013 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#include "testing/gtest/include/gtest/gtest.h"
12#include "webrtc/modules/video_coding/media_optimization.h"
13#include "webrtc/system_wrappers/include/clock.h"
14
15namespace webrtc {
16namespace media_optimization {
17
18class TestMediaOptimization : public ::testing::Test {
19 protected:
20  enum {
21    kSampleRate = 90000  // RTP timestamps per second.
22  };
23
24  // Note: simulated clock starts at 1 seconds, since parts of webrtc use 0 as
25  // a special case (e.g. frame rate in media optimization).
26  TestMediaOptimization()
27      : clock_(1000),
28        media_opt_(&clock_),
29        frame_time_ms_(33),
30        next_timestamp_(0) {}
31
32  // This method mimics what happens in VideoSender::AddVideoFrame.
33  void AddFrameAndAdvanceTime(uint32_t bitrate_bps, bool expect_frame_drop) {
34    bool frame_dropped = media_opt_.DropFrame();
35    EXPECT_EQ(expect_frame_drop, frame_dropped);
36    if (!frame_dropped) {
37      size_t bytes_per_frame = bitrate_bps * frame_time_ms_ / (8 * 1000);
38      EncodedImage encoded_image;
39      encoded_image._length = bytes_per_frame;
40      encoded_image._timeStamp = next_timestamp_;
41      encoded_image._frameType = kVideoFrameKey;
42      ASSERT_EQ(VCM_OK, media_opt_.UpdateWithEncodedData(encoded_image));
43    }
44    next_timestamp_ += frame_time_ms_ * kSampleRate / 1000;
45    clock_.AdvanceTimeMilliseconds(frame_time_ms_);
46  }
47
48  SimulatedClock clock_;
49  MediaOptimization media_opt_;
50  int frame_time_ms_;
51  uint32_t next_timestamp_;
52};
53
54TEST_F(TestMediaOptimization, VerifyMuting) {
55  // Enable video suspension with these limits.
56  // Suspend the video when the rate is below 50 kbps and resume when it gets
57  // above 50 + 10 kbps again.
58  const uint32_t kThresholdBps = 50000;
59  const uint32_t kWindowBps = 10000;
60  media_opt_.SuspendBelowMinBitrate(kThresholdBps, kWindowBps);
61
62  // The video should not be suspended from the start.
63  EXPECT_FALSE(media_opt_.IsVideoSuspended());
64
65  uint32_t target_bitrate_kbps = 100;
66  media_opt_.SetTargetRates(target_bitrate_kbps * 1000,
67                            0,    // Lossrate.
68                            100,  // RTT in ms.
69                            nullptr, nullptr);
70  media_opt_.EnableFrameDropper(true);
71  for (int time = 0; time < 2000; time += frame_time_ms_) {
72    ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, false));
73  }
74
75  // Set the target rate below the limit for muting.
76  media_opt_.SetTargetRates(kThresholdBps - 1000,
77                            0,    // Lossrate.
78                            100,  // RTT in ms.
79                            nullptr, nullptr);
80  // Expect the muter to engage immediately and stay muted.
81  // Test during 2 seconds.
82  for (int time = 0; time < 2000; time += frame_time_ms_) {
83    EXPECT_TRUE(media_opt_.IsVideoSuspended());
84    ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, true));
85  }
86
87  // Set the target above the limit for muting, but not above the
88  // limit + window.
89  media_opt_.SetTargetRates(kThresholdBps + 1000,
90                            0,    // Lossrate.
91                            100,  // RTT in ms.
92                            nullptr, nullptr);
93  // Expect the muter to stay muted.
94  // Test during 2 seconds.
95  for (int time = 0; time < 2000; time += frame_time_ms_) {
96    EXPECT_TRUE(media_opt_.IsVideoSuspended());
97    ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, true));
98  }
99
100  // Set the target above limit + window.
101  media_opt_.SetTargetRates(kThresholdBps + kWindowBps + 1000,
102                            0,    // Lossrate.
103                            100,  // RTT in ms.
104                            nullptr, nullptr);
105  // Expect the muter to disengage immediately.
106  // Test during 2 seconds.
107  for (int time = 0; time < 2000; time += frame_time_ms_) {
108    EXPECT_FALSE(media_opt_.IsVideoSuspended());
109    ASSERT_NO_FATAL_FAILURE(
110        AddFrameAndAdvanceTime((kThresholdBps + kWindowBps) / 1000, false));
111  }
112}
113
114TEST_F(TestMediaOptimization, ProtectsUsingFecBitrateAboveCodecMax) {
115  static const int kCodecBitrateBps = 100000;
116  static const int kMaxBitrateBps = 130000;
117
118  class ProtectionCallback : public VCMProtectionCallback {
119    int ProtectionRequest(const FecProtectionParams* delta_params,
120                          const FecProtectionParams* key_params,
121                          uint32_t* sent_video_rate_bps,
122                          uint32_t* sent_nack_rate_bps,
123                          uint32_t* sent_fec_rate_bps) override {
124      *sent_video_rate_bps = kCodecBitrateBps;
125      *sent_nack_rate_bps = 0;
126      *sent_fec_rate_bps = fec_rate_bps_;
127      return 0;
128    }
129
130   public:
131    uint32_t fec_rate_bps_;
132  } protection_callback;
133
134  media_opt_.SetProtectionMethod(kFec);
135  media_opt_.SetEncodingData(kVideoCodecVP8, kCodecBitrateBps, kCodecBitrateBps,
136                             640, 480, 30, 1, 1000);
137
138  // Using 10% of codec bitrate for FEC, should still be able to use all of it.
139  protection_callback.fec_rate_bps_ = kCodecBitrateBps / 10;
140  uint32_t target_bitrate = media_opt_.SetTargetRates(
141      kMaxBitrateBps, 0, 0, &protection_callback, nullptr);
142
143  EXPECT_EQ(kCodecBitrateBps, static_cast<int>(target_bitrate));
144
145  // Using as much for codec bitrate as fec rate, new target rate should share
146  // both equally, but only be half of max (since that ceiling should be hit).
147  protection_callback.fec_rate_bps_ = kCodecBitrateBps;
148  target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 128, 100,
149                                             &protection_callback, nullptr);
150  EXPECT_EQ(kMaxBitrateBps / 2, static_cast<int>(target_bitrate));
151}
152
153}  // namespace media_optimization
154}  // namespace webrtc
155