webrtc/call/bitrate_estimator_tests.cc
Artem Titov f92cc6d7b4 Reland: FrameGeneratorCapturer: don't generate video before Start is called
It is partial reland, which adds call to Start() to all relevant places,
but doesn't actually switches frame generator to not produce frames from
the moment it was created.

Bug: b/272350185
Change-Id: I6e3bd7af6f5cd8d9baff79c2aada7b2ddfae1c8d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/310782
Reviewed-by: Mirko Bonadei <mbonadei@webrtc.org>
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Reviewed-by: Florent Castelli <orphis@webrtc.org>
Commit-Queue: Artem Titov <titovartem@webrtc.org>
Reviewed-by: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#40379}
2023-06-29 14:47:05 +00:00

329 lines
12 KiB
C++

/*
* 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 <cstddef>
#include <functional>
#include <list>
#include <memory>
#include <string>
#include "absl/strings/string_view.h"
#include "api/test/create_frame_generator.h"
#include "call/call.h"
#include "call/simulated_network.h"
#include "rtc_base/checks.h"
#include "rtc_base/event.h"
#include "rtc_base/logging.h"
#include "rtc_base/synchronization/mutex.h"
#include "rtc_base/task_queue_for_test.h"
#include "rtc_base/thread_annotations.h"
#include "test/call_test.h"
#include "test/encoder_settings.h"
#include "test/fake_decoder.h"
#include "test/fake_encoder.h"
#include "test/frame_generator_capturer.h"
#include "test/gtest.h"
#include "test/video_test_constants.h"
namespace webrtc {
namespace {
// Note: If you consider to re-use this class, think twice and instead consider
// writing tests that don't depend on the logging system.
class LogObserver {
public:
LogObserver() { rtc::LogMessage::AddLogToStream(&callback_, rtc::LS_INFO); }
~LogObserver() { rtc::LogMessage::RemoveLogToStream(&callback_); }
void PushExpectedLogLine(absl::string_view expected_log_line) {
callback_.PushExpectedLogLine(expected_log_line);
}
bool Wait() { return callback_.Wait(); }
private:
class Callback : public rtc::LogSink {
public:
void OnLogMessage(const std::string& message) override {
OnLogMessage(absl::string_view(message));
}
void OnLogMessage(absl::string_view message) override {
MutexLock lock(&mutex_);
// Ignore log lines that are due to missing AST extensions, these are
// logged when we switch back from AST to TOF until the wrapping bitrate
// estimator gives up on using AST.
if (message.find("BitrateEstimator") != absl::string_view::npos &&
message.find("packet is missing") == absl::string_view::npos) {
received_log_lines_.push_back(std::string(message));
}
int num_popped = 0;
while (!received_log_lines_.empty() && !expected_log_lines_.empty()) {
std::string a = received_log_lines_.front();
std::string b = expected_log_lines_.front();
received_log_lines_.pop_front();
expected_log_lines_.pop_front();
num_popped++;
EXPECT_TRUE(a.find(b) != absl::string_view::npos) << a << " != " << b;
}
if (expected_log_lines_.empty()) {
if (num_popped > 0) {
done_.Set();
}
return;
}
}
bool Wait() {
return done_.Wait(test::VideoTestConstants::kDefaultTimeout);
}
void PushExpectedLogLine(absl::string_view expected_log_line) {
MutexLock lock(&mutex_);
expected_log_lines_.emplace_back(expected_log_line);
}
private:
typedef std::list<std::string> Strings;
Mutex mutex_;
Strings received_log_lines_ RTC_GUARDED_BY(mutex_);
Strings expected_log_lines_ RTC_GUARDED_BY(mutex_);
rtc::Event done_;
};
Callback callback_;
};
} // namespace
static const int kTOFExtensionId = 4;
static const int kASTExtensionId = 5;
class BitrateEstimatorTest : public test::CallTest {
public:
BitrateEstimatorTest() : receive_config_(nullptr) {}
virtual ~BitrateEstimatorTest() { EXPECT_TRUE(streams_.empty()); }
virtual void SetUp() {
SendTask(task_queue(), [this]() {
RegisterRtpExtension(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
RegisterRtpExtension(
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId));
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), /*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
VideoSendStream::Config video_send_config(send_transport_.get());
video_send_config.rtp.ssrcs.push_back(
test::VideoTestConstants::kVideoSendSsrcs[0]);
video_send_config.encoder_settings.encoder_factory =
&fake_encoder_factory_;
video_send_config.encoder_settings.bitrate_allocator_factory =
bitrate_allocator_factory_.get();
video_send_config.rtp.payload_name = "FAKE";
video_send_config.rtp.payload_type =
test::VideoTestConstants::kFakeVideoSendPayloadType;
SetVideoSendConfig(video_send_config);
VideoEncoderConfig video_encoder_config;
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
SetVideoEncoderConfig(video_encoder_config);
receive_config_ =
VideoReceiveStreamInterface::Config(receive_transport_.get());
// receive_config_.decoders will be set by every stream separately.
receive_config_.rtp.remote_ssrc = GetVideoSendConfig()->rtp.ssrcs[0];
receive_config_.rtp.local_ssrc =
test::VideoTestConstants::kReceiverLocalVideoSsrc;
});
}
virtual void TearDown() {
SendTask(task_queue(), [this]() {
for (auto* stream : streams_) {
stream->StopSending();
delete stream;
}
streams_.clear();
DestroyCalls();
});
}
protected:
friend class Stream;
class Stream {
public:
explicit Stream(BitrateEstimatorTest* test)
: test_(test),
is_sending_receiving_(false),
send_stream_(nullptr),
frame_generator_capturer_(),
decoder_factory_(
[]() { return std::make_unique<test::FakeDecoder>(); }) {
test_->GetVideoSendConfig()->rtp.ssrcs[0]++;
send_stream_ = test_->sender_call_->CreateVideoSendStream(
test_->GetVideoSendConfig()->Copy(),
test_->GetVideoEncoderConfig()->Copy());
RTC_DCHECK_EQ(1, test_->GetVideoEncoderConfig()->number_of_streams);
frame_generator_capturer_ =
std::make_unique<test::FrameGeneratorCapturer>(
test->clock_,
test::CreateSquareFrameGenerator(
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight, absl::nullopt,
absl::nullopt),
test::VideoTestConstants::kDefaultFramerate,
*test->task_queue_factory_);
frame_generator_capturer_->Init();
frame_generator_capturer_->Start();
send_stream_->SetSource(frame_generator_capturer_.get(),
DegradationPreference::MAINTAIN_FRAMERATE);
send_stream_->Start();
VideoReceiveStreamInterface::Decoder decoder;
test_->receive_config_.decoder_factory = &decoder_factory_;
decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type;
decoder.video_format =
SdpVideoFormat(test_->GetVideoSendConfig()->rtp.payload_name);
test_->receive_config_.decoders.clear();
test_->receive_config_.decoders.push_back(decoder);
test_->receive_config_.rtp.remote_ssrc =
test_->GetVideoSendConfig()->rtp.ssrcs[0];
test_->receive_config_.rtp.local_ssrc++;
test_->receive_config_.renderer = &test->fake_renderer_;
video_receive_stream_ = test_->receiver_call_->CreateVideoReceiveStream(
test_->receive_config_.Copy());
video_receive_stream_->Start();
is_sending_receiving_ = true;
}
~Stream() {
EXPECT_FALSE(is_sending_receiving_);
test_->sender_call_->DestroyVideoSendStream(send_stream_);
frame_generator_capturer_.reset(nullptr);
send_stream_ = nullptr;
if (video_receive_stream_) {
test_->receiver_call_->DestroyVideoReceiveStream(video_receive_stream_);
video_receive_stream_ = nullptr;
}
}
void StopSending() {
if (is_sending_receiving_) {
send_stream_->Stop();
if (video_receive_stream_) {
video_receive_stream_->Stop();
}
is_sending_receiving_ = false;
}
}
private:
BitrateEstimatorTest* test_;
bool is_sending_receiving_;
VideoSendStream* send_stream_;
VideoReceiveStreamInterface* video_receive_stream_;
std::unique_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
test::FunctionVideoDecoderFactory decoder_factory_;
};
LogObserver receiver_log_;
VideoReceiveStreamInterface::Config receive_config_;
std::vector<Stream*> streams_;
};
static const char* kAbsSendTimeLog =
"RemoteBitrateEstimatorAbsSendTime: Instantiating.";
static const char* kSingleStreamLog =
"RemoteBitrateEstimatorSingleStream: Instantiating.";
TEST_F(BitrateEstimatorTest, InstantiatesTOFPerDefaultForVideo) {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
streams_.push_back(new Stream(this));
});
EXPECT_TRUE(receiver_log_.Wait());
}
TEST_F(BitrateEstimatorTest, ImmediatelySwitchToASTForVideo) {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
streams_.push_back(new Stream(this));
});
EXPECT_TRUE(receiver_log_.Wait());
}
TEST_F(BitrateEstimatorTest, SwitchesToASTForVideo) {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
streams_.push_back(new Stream(this));
});
EXPECT_TRUE(receiver_log_.Wait());
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
streams_.push_back(new Stream(this));
});
EXPECT_TRUE(receiver_log_.Wait());
}
// This test is flaky. See webrtc:5790.
TEST_F(BitrateEstimatorTest, DISABLED_SwitchesToASTThenBackToTOFForVideo) {
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions.push_back(
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId));
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
receiver_log_.PushExpectedLogLine(kSingleStreamLog);
streams_.push_back(new Stream(this));
});
EXPECT_TRUE(receiver_log_.Wait());
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kAbsSendTimeUri, kASTExtensionId);
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
receiver_log_.PushExpectedLogLine("Switching to absolute send time RBE.");
streams_.push_back(new Stream(this));
});
EXPECT_TRUE(receiver_log_.Wait());
SendTask(task_queue(), [this]() {
GetVideoSendConfig()->rtp.extensions[0] =
RtpExtension(RtpExtension::kTimestampOffsetUri, kTOFExtensionId);
receiver_log_.PushExpectedLogLine(kAbsSendTimeLog);
receiver_log_.PushExpectedLogLine(
"WrappingBitrateEstimator: Switching to transmission time offset RBE.");
streams_.push_back(new Stream(this));
streams_[0]->StopSending();
streams_[1]->StopSending();
});
EXPECT_TRUE(receiver_log_.Wait());
}
} // namespace webrtc