diff options
Diffstat (limited to 'webrtc/modules/video_coding/media_optimization_unittest.cc')
| -rw-r--r-- | webrtc/modules/video_coding/media_optimization_unittest.cc | 154 |
1 files changed, 154 insertions, 0 deletions
diff --git a/webrtc/modules/video_coding/media_optimization_unittest.cc b/webrtc/modules/video_coding/media_optimization_unittest.cc new file mode 100644 index 0000000000..3f8ac5d075 --- /dev/null +++ b/webrtc/modules/video_coding/media_optimization_unittest.cc @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "testing/gtest/include/gtest/gtest.h" +#include "webrtc/modules/video_coding/media_optimization.h" +#include "webrtc/system_wrappers/include/clock.h" + +namespace webrtc { +namespace media_optimization { + +class TestMediaOptimization : public ::testing::Test { + protected: + enum { + kSampleRate = 90000 // RTP timestamps per second. + }; + + // Note: simulated clock starts at 1 seconds, since parts of webrtc use 0 as + // a special case (e.g. frame rate in media optimization). + TestMediaOptimization() + : clock_(1000), + media_opt_(&clock_), + frame_time_ms_(33), + next_timestamp_(0) {} + + // This method mimics what happens in VideoSender::AddVideoFrame. + void AddFrameAndAdvanceTime(uint32_t bitrate_bps, bool expect_frame_drop) { + bool frame_dropped = media_opt_.DropFrame(); + EXPECT_EQ(expect_frame_drop, frame_dropped); + if (!frame_dropped) { + size_t bytes_per_frame = bitrate_bps * frame_time_ms_ / (8 * 1000); + EncodedImage encoded_image; + encoded_image._length = bytes_per_frame; + encoded_image._timeStamp = next_timestamp_; + encoded_image._frameType = kVideoFrameKey; + ASSERT_EQ(VCM_OK, media_opt_.UpdateWithEncodedData(encoded_image)); + } + next_timestamp_ += frame_time_ms_ * kSampleRate / 1000; + clock_.AdvanceTimeMilliseconds(frame_time_ms_); + } + + SimulatedClock clock_; + MediaOptimization media_opt_; + int frame_time_ms_; + uint32_t next_timestamp_; +}; + +TEST_F(TestMediaOptimization, VerifyMuting) { + // Enable video suspension with these limits. + // Suspend the video when the rate is below 50 kbps and resume when it gets + // above 50 + 10 kbps again. + const uint32_t kThresholdBps = 50000; + const uint32_t kWindowBps = 10000; + media_opt_.SuspendBelowMinBitrate(kThresholdBps, kWindowBps); + + // The video should not be suspended from the start. + EXPECT_FALSE(media_opt_.IsVideoSuspended()); + + uint32_t target_bitrate_kbps = 100; + media_opt_.SetTargetRates(target_bitrate_kbps * 1000, + 0, // Lossrate. + 100, // RTT in ms. + nullptr, nullptr); + media_opt_.EnableFrameDropper(true); + for (int time = 0; time < 2000; time += frame_time_ms_) { + ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, false)); + } + + // Set the target rate below the limit for muting. + media_opt_.SetTargetRates(kThresholdBps - 1000, + 0, // Lossrate. + 100, // RTT in ms. + nullptr, nullptr); + // Expect the muter to engage immediately and stay muted. + // Test during 2 seconds. + for (int time = 0; time < 2000; time += frame_time_ms_) { + EXPECT_TRUE(media_opt_.IsVideoSuspended()); + ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, true)); + } + + // Set the target above the limit for muting, but not above the + // limit + window. + media_opt_.SetTargetRates(kThresholdBps + 1000, + 0, // Lossrate. + 100, // RTT in ms. + nullptr, nullptr); + // Expect the muter to stay muted. + // Test during 2 seconds. + for (int time = 0; time < 2000; time += frame_time_ms_) { + EXPECT_TRUE(media_opt_.IsVideoSuspended()); + ASSERT_NO_FATAL_FAILURE(AddFrameAndAdvanceTime(target_bitrate_kbps, true)); + } + + // Set the target above limit + window. + media_opt_.SetTargetRates(kThresholdBps + kWindowBps + 1000, + 0, // Lossrate. + 100, // RTT in ms. + nullptr, nullptr); + // Expect the muter to disengage immediately. + // Test during 2 seconds. + for (int time = 0; time < 2000; time += frame_time_ms_) { + EXPECT_FALSE(media_opt_.IsVideoSuspended()); + ASSERT_NO_FATAL_FAILURE( + AddFrameAndAdvanceTime((kThresholdBps + kWindowBps) / 1000, false)); + } +} + +TEST_F(TestMediaOptimization, ProtectsUsingFecBitrateAboveCodecMax) { + static const int kCodecBitrateBps = 100000; + static const int kMaxBitrateBps = 130000; + + class ProtectionCallback : public VCMProtectionCallback { + int ProtectionRequest(const FecProtectionParams* delta_params, + const FecProtectionParams* key_params, + uint32_t* sent_video_rate_bps, + uint32_t* sent_nack_rate_bps, + uint32_t* sent_fec_rate_bps) override { + *sent_video_rate_bps = kCodecBitrateBps; + *sent_nack_rate_bps = 0; + *sent_fec_rate_bps = fec_rate_bps_; + return 0; + } + + public: + uint32_t fec_rate_bps_; + } protection_callback; + + media_opt_.SetProtectionMethod(kFec); + media_opt_.SetEncodingData(kVideoCodecVP8, kCodecBitrateBps, kCodecBitrateBps, + 640, 480, 30, 1, 1000); + + // Using 10% of codec bitrate for FEC, should still be able to use all of it. + protection_callback.fec_rate_bps_ = kCodecBitrateBps / 10; + uint32_t target_bitrate = media_opt_.SetTargetRates( + kMaxBitrateBps, 0, 0, &protection_callback, nullptr); + + EXPECT_EQ(kCodecBitrateBps, static_cast<int>(target_bitrate)); + + // Using as much for codec bitrate as fec rate, new target rate should share + // both equally, but only be half of max (since that ceiling should be hit). + protection_callback.fec_rate_bps_ = kCodecBitrateBps; + target_bitrate = media_opt_.SetTargetRates(kMaxBitrateBps, 128, 100, + &protection_callback, nullptr); + EXPECT_EQ(kMaxBitrateBps / 2, static_cast<int>(target_bitrate)); +} + +} // namespace media_optimization +} // namespace webrtc |