mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Format the rest

Browse source 
git ls-files | grep -e  "\(\.h\|\.cc\)$" | grep -vE "^(rtc_base|sdk|modules|api|call|common_audio|examples|media|net|p2p|pc)/" | xargs clang-format -i ; git cl format
after landing: add to .git-blame-ignore-revs

Bug: webrtc:15082
Change-Id: I9c7fc4e6fbb023809fb22a89a78be713de6990d3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/302063
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Commit-Queue: Mirko Bonadei <mbonadei@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#39978}
This commit is contained in:
Jared Siskin 2023-05-03 12:06:14 +03:00 committed by WebRTC LUCI CQ
parent bceec84aee
commit 7220ee97aa
24 changed files with 319 additions and 325 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
rtc_tools/rtc_event_log_visualizer/plot_protobuf.cc
View file

@ -24,8 +24,6 @@ ProtobufPlot::~ProtobufPlot() {}
void ProtobufPlot::Draw() {}
ProtobufPlotCollection::ProtobufPlotCollection() {}
ProtobufPlotCollection::~ProtobufPlotCollection() {}

76
system_wrappers/include/metrics.h
View file

@ -32,8 +32,8 @@ namespace webrtc {
namespace metrics_impl {
template <typename... Ts>
void NoOp(const Ts&...) {}
}
}
} // namespace metrics_impl
} // namespace webrtc
#if RTC_METRICS_ENABLED
#define EXPECT_METRIC_EQ(val1, val2) EXPECT_EQ(val1, val2)
@ -46,12 +46,16 @@ void NoOp(const Ts&...) {}
#define EXPECT_METRIC_THAT(value, matcher) EXPECT_THAT(value, matcher)
#else
#define EXPECT_METRIC_EQ(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
#define EXPECT_METRIC_EQ_WAIT(val1, val2, timeout) webrtc::metrics_impl::NoOp(val1, val2, timeout)
#define EXPECT_METRIC_EQ_WAIT(val1, val2, timeout) \
webrtc::metrics_impl::NoOp(val1, val2, timeout)
#define EXPECT_METRIC_GT(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
#define EXPECT_METRIC_LE(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
#define EXPECT_METRIC_TRUE(condition) webrtc::metrics_impl::NoOp(condition || true)
#define EXPECT_METRIC_FALSE(condition) webrtc::metrics_impl::NoOp(condition && false)
#define EXPECT_METRIC_THAT(value, matcher) webrtc::metrics_impl::NoOp(value, testing::_)
#define EXPECT_METRIC_TRUE(condition) \
webrtc::metrics_impl::NoOp(condition || true)
#define EXPECT_METRIC_FALSE(condition) \
webrtc::metrics_impl::NoOp(condition && false)
#define EXPECT_METRIC_THAT(value, matcher) \
webrtc::metrics_impl::NoOp(value, testing::_)
#endif
#if RTC_METRICS_ENABLED
@ -278,17 +282,23 @@ void NoOp(const Ts&...) {}
// This section defines no-op alternatives to the metrics macros when
// RTC_METRICS_ENABLED is defined.
#define RTC_HISTOGRAM_COUNTS_100(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_100(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_200(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_200(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_500(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_500(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_1000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_1000(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_10000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_10000(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_100000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_100000(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count) \
webrtc::metrics_impl::NoOp(name, sample, min, max, bucket_count)
@ -296,31 +306,41 @@ void NoOp(const Ts&...) {}
#define RTC_HISTOGRAM_COUNTS_LINEAR(name, sample, min, max, bucket_count) \
webrtc::metrics_impl::NoOp(name, sample, min, max, bucket_count)
#define RTC_HISTOGRAM_COUNTS_SPARSE_100(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_100(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_200(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_200(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_500(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_500(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_1000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_1000(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_10000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_10000(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_100000(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE_100000(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_COUNTS_SPARSE(name, sample, min, max, bucket_count) \
webrtc::metrics_impl::NoOp(name, sample, min, max, bucket_count)
#define RTC_HISTOGRAM_PERCENTAGE_SPARSE(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_PERCENTAGE_SPARSE(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_BOOLEAN_SPARSE(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_BOOLEAN_SPARSE(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_ENUMERATION_SPARSE(name, sample, boundary) \
webrtc::metrics_impl::NoOp(name, sample, boundary)
#define RTC_HISTOGRAM_PERCENTAGE(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_PERCENTAGE(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_BOOLEAN(name, sample) webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_BOOLEAN(name, sample) \
webrtc::metrics_impl::NoOp(name, sample)
#define RTC_HISTOGRAM_ENUMERATION(name, sample, boundary) \
webrtc::metrics_impl::NoOp(name, sample, boundary)
@ -332,11 +352,14 @@ void NoOp(const Ts&...) {}
#define RTC_HISTOGRAM_COMMON_BLOCK_SLOW(name, sample, factory_get_invocation) \
webrtc::metrics_impl::NoOp(name, sample, factory_get_invocation)
#define RTC_HISTOGRAMS_COUNTS_100(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COUNTS_100(index, name, sample) \
webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COUNTS_200(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COUNTS_200(index, name, sample) \
webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COUNTS_500(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COUNTS_500(index, name, sample) \
webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COUNTS_1000(index, name, sample) \
webrtc::metrics_impl::NoOp(index, name, sample)
@ -350,7 +373,8 @@ void NoOp(const Ts&...) {}
#define RTC_HISTOGRAMS_ENUMERATION(index, name, sample, boundary) \
webrtc::metrics_impl::NoOp(index, name, sample, boundary)
#define RTC_HISTOGRAMS_PERCENTAGE(index, name, sample) webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_PERCENTAGE(index, name, sample) \
webrtc::metrics_impl::NoOp(index, name, sample)
#define RTC_HISTOGRAMS_COMMON(index, name, sample, macro_invocation) \
webrtc::metrics_impl::NoOp(index, name, sample, macro_invocation)

1
test/call_test.h
View file

@ -233,7 +233,6 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
test::FakeVideoRenderer fake_renderer_;
private:
absl::optional<RtpExtension> GetRtpExtensionByUri(
const std::string& uri) const;

2
test/fake_encoder.cc
View file

@ -261,7 +261,7 @@ void FakeEncoder::SetRatesLocked(const RateControlParameters& parameters) {
uint32_t bitrate = current_rate_settings_.bitrate.GetBitrate(
spatial_idx, temporal_idx);
bitrate = static_cast<uint32_t>(
(bitrate * int64_t{max_target_bitrate_kbps_}) /
(bitrate* int64_t{max_target_bitrate_kbps_}) /
allocated_bitrate_kbps);
current_rate_settings_.bitrate.SetBitrate(spatial_idx, temporal_idx,
bitrate);

4
test/fuzzers/agc_fuzzer.cc
View file

@ -92,8 +92,8 @@ void FuzzGainController(test::FuzzDataHelper* fuzz_data, GainControlImpl* gci) {
FuzzGainControllerConfig(fuzz_data, gci);
// The audio buffer is used for both capture and render.
AudioBuffer audio(sample_rate_hz, num_channels, sample_rate_hz,
num_channels, sample_rate_hz, num_channels);
AudioBuffer audio(sample_rate_hz, num_channels, sample_rate_hz, num_channels,
sample_rate_hz, num_channels);
std::vector<int16_t> packed_render_audio(samples_per_frame);

3
test/fuzzers/rtp_depacketizer_av1_assemble_frame_fuzzer.cc
View file

@ -7,14 +7,13 @@
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/source/video_rtp_depacketizer_av1.h"
#include <stddef.h>
#include <stdint.h>
#include <vector>
#include "api/array_view.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer_av1.h"
#include "test/fuzzers/fuzz_data_helper.h"
namespace webrtc {

53
test/network/cross_traffic.cc
View file

@ -142,33 +142,32 @@ TcpMessageRouteImpl::TcpMessageRouteImpl(Clock* clock,
void TcpMessageRouteImpl::SendMessage(size_t size,
std::function<void()> on_received) {
task_queue_->PostTask(
[this, size, handler = std::move(on_received)] {
// If we are currently sending a message we won't reset the connection,
// we'll act as if the messages are sent in the same TCP stream. This is
// intended to simulate recreation of a TCP session for each message
// in the typical case while avoiding the complexity overhead of
// maintaining multiple virtual TCP sessions in parallel.
if (pending_.empty() && in_flight_.empty()) {
cwnd_ = 10;
ssthresh_ = INFINITY;
}
int64_t data_left = static_cast<int64_t>(size);
int64_t kMaxPacketSize = 1200;
int64_t kMinPacketSize = 4;
Message message{std::move(handler)};
while (data_left > 0) {
int64_t packet_size = std::min(data_left, kMaxPacketSize);
int fragment_id = next_fragment_id_++;
pending_.push_back(MessageFragment{
fragment_id,
static_cast<size_t>(std::max(kMinPacketSize, packet_size))});
message.pending_fragment_ids.insert(fragment_id);
data_left -= packet_size;
}
messages_.emplace_back(message);
SendPackets(clock_->CurrentTime());
});
task_queue_->PostTask([this, size, handler = std::move(on_received)] {
// If we are currently sending a message we won't reset the connection,
// we'll act as if the messages are sent in the same TCP stream. This is
// intended to simulate recreation of a TCP session for each message
// in the typical case while avoiding the complexity overhead of
// maintaining multiple virtual TCP sessions in parallel.
if (pending_.empty() && in_flight_.empty()) {
cwnd_ = 10;
ssthresh_ = INFINITY;
}
int64_t data_left = static_cast<int64_t>(size);
int64_t kMaxPacketSize = 1200;
int64_t kMinPacketSize = 4;
Message message{std::move(handler)};
while (data_left > 0) {
int64_t packet_size = std::min(data_left, kMaxPacketSize);
int fragment_id = next_fragment_id_++;
pending_.push_back(MessageFragment{
fragment_id,
static_cast<size_t>(std::max(kMinPacketSize, packet_size))});
message.pending_fragment_ids.insert(fragment_id);
data_left -= packet_size;
}
messages_.emplace_back(message);
SendPackets(clock_->CurrentTime());
});
}
void TcpMessageRouteImpl::OnRequest(TcpPacket packet_info) {

2
test/network/fake_network_socket_server.cc
View file

@ -113,7 +113,6 @@ void FakeNetworkSocket::OnPacketReceived(EmulatedIpPacket packet) {
socket_server_->WakeUp();
}
rtc::SocketAddress FakeNetworkSocket::GetLocalAddress() const {
RTC_DCHECK_RUN_ON(thread_);
return local_addr_;
@ -317,6 +316,5 @@ void FakeNetworkSocketServer::WakeUp() {
wakeup_.Set();
}
} // namespace test
} // namespace webrtc

1
test/network/fake_network_socket_server.h
View file

@ -32,7 +32,6 @@ class FakeNetworkSocketServer : public rtc::SocketServer {
explicit FakeNetworkSocketServer(EndpointsContainer* endpoints_controller);
~FakeNetworkSocketServer() override;
// rtc::SocketFactory methods:
rtc::Socket* CreateSocket(int family, int type) override;

4
test/network/traffic_route.cc
View file

@ -32,9 +32,7 @@ class ActionReceiver : public EmulatedNetworkReceiverInterface {
explicit ActionReceiver(std::function<void()> action) : action_(action) {}
~ActionReceiver() override = default;
void OnPacketReceived(EmulatedIpPacket packet) override {
action_();
}
void OnPacketReceived(EmulatedIpPacket packet) override { action_(); }
private:
std::function<void()> action_;

2
test/peer_scenario/peer_scenario_client.cc
View file

@ -106,7 +106,7 @@ class LambdaPeerConnectionObserver final : public PeerConnectionObserver {
handler(candidates);
}
void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface> >&
const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
streams) override {
for (const auto& handler : handlers_->on_add_track)
handler(receiver, streams);

3
test/peer_scenario/tests/remote_estimate_test.cc
View file

@ -61,7 +61,8 @@ TEST(RemoteEstimateEndToEnd, OfferedCapabilityIsInAnswer) {
}
TEST(RemoteEstimateEndToEnd, AudioUsesAbsSendTimeExtension) {
// Defined before PeerScenario so it gets destructed after, to avoid use after free.
// Defined before PeerScenario so it gets destructed after, to avoid use after
// free.
std::atomic<bool> received_abs_send_time(false);
PeerScenario s(*test_info_);

1
test/scenario/performance_stats.h
View file

@ -37,7 +37,6 @@ struct VideoFramePair {
int repeated = 0;
};
struct VideoFramesStats {
int count = 0;
SampleStats<double> pixels;

1
test/scenario/video_stream_unittest.cc
View file

@ -106,7 +106,6 @@ TEST(VideoStreamTest, ReceivesVp8SimulcastFrames) {
c->encoder.simulcast_streams = {webrtc::ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T1};
});
s.RunFor(kRunTime);
}

1
test/testsupport/file_utils.cc
View file

@ -10,7 +10,6 @@
#include "test/testsupport/file_utils.h"
#if defined(WEBRTC_POSIX)
#include <unistd.h>
#endif

3
test/video_encoder_proxy_factory.h
View file

@ -37,8 +37,7 @@ class VideoEncoderProxyFactory : public VideoEncoderFactory {
: encoder_(encoder),
encoder_selector_(encoder_selector),
num_simultaneous_encoder_instances_(0),
max_num_simultaneous_encoder_instances_(0) {
}
max_num_simultaneous_encoder_instances_(0) {}
// Unused by tests.
std::vector<SdpVideoFormat> GetSupportedFormats() const override {

104
video/end_to_end_tests/call_operation_tests.cc
View file

@ -98,38 +98,37 @@ TEST_F(CallOperationEndToEndTest, RendersSingleDelayedFrame) {
test::FrameForwarder frame_forwarder;
SendTask(
task_queue(), [this, &renderer, &frame_forwarder]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
SendTask(task_queue(), [this, &renderer, &frame_forwarder]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer;
video_receive_configs_[0].renderer = &renderer;
CreateVideoStreams();
Start();
CreateVideoStreams();
Start();
// Create frames that are smaller than the send width/height, this is
// done to check that the callbacks are done after processing video.
std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
absl::nullopt));
GetVideoSendStream()->SetSource(
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
// Create frames that are smaller than the send width/height, this is
// done to check that the callbacks are done after processing video.
std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
absl::nullopt));
GetVideoSendStream()->SetSource(&frame_forwarder,
DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect)
.build();
frame_forwarder.IncomingCapturedFrame(frame);
});
test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect)
.build();
frame_forwarder.IncomingCapturedFrame(frame);
});
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";
@ -159,35 +158,34 @@ TEST_F(CallOperationEndToEndTest, TransmitsFirstFrame) {
std::unique_ptr<test::DirectTransport> sender_transport;
std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask(
task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
SendTask(task_queue(), [this, &renderer, &frame_generator,
&frame_forwarder]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer;
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer;
CreateVideoStreams();
Start();
CreateVideoStreams();
Start();
frame_generator = test::CreateSquareFrameGenerator(
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight, absl::nullopt,
absl::nullopt);
GetVideoSendStream()->SetSource(
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect)
.build();
frame_forwarder.IncomingCapturedFrame(frame);
});
frame_generator = test::CreateSquareFrameGenerator(
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight, absl::nullopt, absl::nullopt);
GetVideoSendStream()->SetSource(&frame_forwarder,
DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect)
.build();
frame_forwarder.IncomingCapturedFrame(frame);
});
EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render.";

27
video/end_to_end_tests/network_state_tests.cc
View file

@ -94,23 +94,20 @@ void NetworkStateEndToEndTest::VerifyNewVideoSendStreamsRespectNetworkState(
Transport* transport) {
test::VideoEncoderProxyFactory encoder_factory(encoder);
SendTask(task_queue(),
[this, network_to_bring_up, &encoder_factory, transport]() {
CreateSenderCall(Call::Config(send_event_log_.get()));
sender_call_->SignalChannelNetworkState(network_to_bring_up,
kNetworkUp);
SendTask(task_queue(), [this, network_to_bring_up, &encoder_factory,
transport]() {
CreateSenderCall(Call::Config(send_event_log_.get()));
sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
CreateSendConfig(1, 0, 0, transport);
GetVideoSendConfig()->encoder_settings.encoder_factory =
&encoder_factory;
CreateVideoStreams();
CreateFrameGeneratorCapturer(
test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
CreateSendConfig(1, 0, 0, transport);
GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
CreateVideoStreams();
CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start();
});
Start();
});
SleepMs(kSilenceTimeoutMs);

64
video/end_to_end_tests/ssrc_tests.cc
View file

@ -95,43 +95,41 @@ TEST_F(SsrcEndToEndTest, UnknownRtpPacketTriggersUndemuxablePacketHandler) {
std::unique_ptr<test::DirectTransport> receive_transport;
std::unique_ptr<PacketInputObserver> input_observer;
SendTask(
task_queue(),
[this, &send_transport, &receive_transport, &input_observer]() {
CreateCalls();
SendTask(task_queue(), [this, &send_transport, &receive_transport,
&input_observer]() {
CreateCalls();
send_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions());
receive_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>(
BuiltInNetworkBehaviorConfig())),
receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions());
input_observer =
std::make_unique<PacketInputObserver>(receiver_call_->Receiver());
send_transport->SetReceiver(input_observer.get());
receive_transport->SetReceiver(sender_call_->Receiver());
send_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions());
receive_transport = std::make_unique<test::DirectTransport>(
task_queue(),
std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(),
std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions());
input_observer =
std::make_unique<PacketInputObserver>(receiver_call_->Receiver());
send_transport->SetReceiver(input_observer.get());
receive_transport->SetReceiver(sender_call_->Receiver());
CreateSendConfig(1, 0, 0, send_transport.get());
CreateMatchingReceiveConfigs(receive_transport.get());
CreateSendConfig(1, 0, 0, send_transport.get());
CreateMatchingReceiveConfigs(receive_transport.get());
CreateVideoStreams();
CreateFrameGeneratorCapturer(
test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start();
CreateVideoStreams();
CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start();
receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
video_receive_streams_.clear();
});
receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
video_receive_streams_.clear();
});
// Wait() waits for a received packet.
EXPECT_TRUE(input_observer->Wait());

63
video/end_to_end_tests/stats_tests.cc
View file

@ -516,42 +516,39 @@ TEST_F(StatsEndToEndTest, MAYBE_ContentTypeSwitches) {
VideoEncoderConfig encoder_config_with_screenshare;
SendTask(
task_queue(), [this, &test, &send_config, &recv_config,
&encoder_config_with_screenshare]() {
CreateSenderCall(send_config);
CreateReceiverCall(recv_config);
CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
CreateSendTransport(test.GetReceiveTransportConfig(), &test);
SendTask(task_queue(), [this, &test, &send_config, &recv_config,
&encoder_config_with_screenshare]() {
CreateSenderCall(send_config);
CreateReceiverCall(recv_config);
CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
CreateSendTransport(test.GetReceiveTransportConfig(), &test);
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs();
// Modify send and receive configs.
GetVideoSendConfig()->rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].renderer = &test;
// RTT needed for RemoteNtpTimeEstimator for the receive stream.
video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report =
true;
// Start with realtime video.
GetVideoEncoderConfig()->content_type =
VideoEncoderConfig::ContentType::kRealtimeVideo;
// Encoder config for the second part of the test uses screenshare.
encoder_config_with_screenshare = GetVideoEncoderConfig()->Copy();
encoder_config_with_screenshare.content_type =
VideoEncoderConfig::ContentType::kScreen;
// Modify send and receive configs.
GetVideoSendConfig()->rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].renderer = &test;
// RTT needed for RemoteNtpTimeEstimator for the receive stream.
video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = true;
// Start with realtime video.
GetVideoEncoderConfig()->content_type =
VideoEncoderConfig::ContentType::kRealtimeVideo;
// Encoder config for the second part of the test uses screenshare.
encoder_config_with_screenshare = GetVideoEncoderConfig()->Copy();
encoder_config_with_screenshare.content_type =
VideoEncoderConfig::ContentType::kScreen;
CreateVideoStreams();
CreateFrameGeneratorCapturer(
test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start();
});
CreateVideoStreams();
CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start();
});
test.PerformTest();

24
video/picture_id_tests.cc
View file

@ -255,19 +255,17 @@ void PictureIdTest::SetupEncoder(VideoEncoderFactory* encoder_factory,
observer_.reset(
new PictureIdObserver(PayloadStringToCodecType(payload_name)));
SendTask(
task_queue(), [this, encoder_factory, payload_name]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0,
send_transport_.get());
GetVideoSendConfig()->encoder_settings.encoder_factory =
encoder_factory;
GetVideoSendConfig()->rtp.payload_name = payload_name;
GetVideoEncoderConfig()->codec_type =
PayloadStringToCodecType(payload_name);
SetVideoEncoderConfig(/* number_of_streams */ 1);
});
SendTask(task_queue(), [this, encoder_factory, payload_name]() {
CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), observer_.get());
CreateSendConfig(test::VideoTestConstants::kNumSimulcastStreams, 0, 0,
send_transport_.get());
GetVideoSendConfig()->encoder_settings.encoder_factory = encoder_factory;
GetVideoSendConfig()->rtp.payload_name = payload_name;
GetVideoEncoderConfig()->codec_type =
PayloadStringToCodecType(payload_name);
SetVideoEncoderConfig(/* number_of_streams */ 1);
});
}
void PictureIdTest::SetVideoEncoderConfig(int num_streams) {

3
video/send_statistics_proxy.cc
View file

@ -743,8 +743,7 @@ VideoSendStream::Stats SendStatisticsProxy::GetStats() {
PurgeOldStats();
stats_.input_frame_rate =
uma_container_->input_frame_rate_tracker_.ComputeRate();
stats_.frames =
uma_container_->input_frame_rate_tracker_.TotalSampleCount();
stats_.frames = uma_container_->input_frame_rate_tracker_.TotalSampleCount();
stats_.content_type =
content_type_ == VideoEncoderConfig::ContentType::kRealtimeVideo
? VideoContentType::UNSPECIFIED

75
video/video_send_stream_tests.cc
View file

@ -1644,35 +1644,33 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
new_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20);
BitrateConstraints bitrate_config;
SendTask(task_queue_,
[this, &new_route, &bitrate_config]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_);
call_->GetTransportControllerSend()->OnNetworkRouteChanged(
"transport", new_route);
bitrate_config.start_bitrate_bps = kStartBitrateBps;
call_->GetTransportControllerSend()->SetSdpBitrateParameters(
bitrate_config);
});
SendTask(task_queue_, [this, &new_route, &bitrate_config]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_);
call_->GetTransportControllerSend()->OnNetworkRouteChanged("transport",
new_route);
bitrate_config.start_bitrate_bps = kStartBitrateBps;
call_->GetTransportControllerSend()->SetSdpBitrateParameters(
bitrate_config);
});
EXPECT_TRUE(Wait())
<< "Timed out while waiting for start bitrate to be exceeded.";
SendTask(
task_queue_, [this, &new_route, &bitrate_config]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_);
bitrate_config.start_bitrate_bps = -1;
bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
call_->GetTransportControllerSend()->SetSdpBitrateParameters(
bitrate_config);
// TODO(holmer): We should set the last sent packet id here and
// verify that we correctly ignore any packet loss reported prior to
// that id.
new_route.local = rtc::RouteEndpoint::CreateWithNetworkId(
new_route.local.network_id() + 1);
call_->GetTransportControllerSend()->OnNetworkRouteChanged(
"transport", new_route);
EXPECT_GE(call_->GetStats().send_bandwidth_bps, kStartBitrateBps);
});
SendTask(task_queue_, [this, &new_route, &bitrate_config]() {
RTC_DCHECK_RUN_ON(&task_queue_thread_);
bitrate_config.start_bitrate_bps = -1;
bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
call_->GetTransportControllerSend()->SetSdpBitrateParameters(
bitrate_config);
// TODO(holmer): We should set the last sent packet id here and
// verify that we correctly ignore any packet loss reported prior to
// that id.
new_route.local = rtc::RouteEndpoint::CreateWithNetworkId(
new_route.local.network_id() + 1);
call_->GetTransportControllerSend()->OnNetworkRouteChanged("transport",
new_route);
EXPECT_GE(call_->GetStats().send_bandwidth_bps, kStartBitrateBps);
});
}
private:
@ -3276,8 +3274,8 @@ class Vp9HeaderObserver : public test::SendTest {
// | P_DIFF | R times
// +-+-+-+-+-+-+-+-+
void VerifySsData(const RTPVideoHeaderVP9& vp9) const {
EXPECT_TRUE(vp9.ss_data_available); // V
EXPECT_EQ(params_.num_spatial_layers, // N_S + 1
EXPECT_TRUE(vp9.ss_data_available); // V
EXPECT_EQ(params_.num_spatial_layers, // N_S + 1
vp9.num_spatial_layers);
EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1
@ -4013,18 +4011,17 @@ TEST_F(VideoSendStreamTest, SwitchesToScreenshareAndBack) {
auto reset_fun = [this](const VideoSendStream::Config& send_stream_config,
const VideoEncoderConfig& encoder_config,
test::BaseTest* test) {
SendTask(task_queue(),
[this, &send_stream_config, &encoder_config, &test]() {
Stop();
DestroyVideoSendStreams();
SetVideoSendConfig(send_stream_config);
SetVideoEncoderConfig(encoder_config);
CreateVideoSendStreams();
SetVideoDegradation(DegradationPreference::MAINTAIN_RESOLUTION);
test->OnVideoStreamsCreated(GetVideoSendStream(),
video_receive_streams_);
Start();
});
SendTask(task_queue(), [this, &send_stream_config, &encoder_config,
&test]() {
Stop();
DestroyVideoSendStreams();
SetVideoSendConfig(send_stream_config);
SetVideoEncoderConfig(encoder_config);
CreateVideoSendStreams();
SetVideoDegradation(DegradationPreference::MAINTAIN_RESOLUTION);
test->OnVideoStreamsCreated(GetVideoSendStream(), video_receive_streams_);
Start();
});
};
ContentSwitchTest<decltype(reset_fun)> test(&reset_fun, task_queue());
RunBaseTest(&test);

125
video/video_stream_encoder.cc
View file

@ -785,31 +785,30 @@ void VideoStreamEncoder::Stop() {
rtc::Event shutdown_event;
absl::Cleanup shutdown = [&shutdown_event] { shutdown_event.Set(); };
encoder_queue_.PostTask(
[this, shutdown = std::move(shutdown)] {
RTC_DCHECK_RUN_ON(&encoder_queue_);
if (resource_adaptation_processor_) {
stream_resource_manager_.StopManagedResources();
for (auto* constraint : adaptation_constraints_) {
video_stream_adapter_->RemoveAdaptationConstraint(constraint);
}
for (auto& resource : additional_resources_) {
stream_resource_manager_.RemoveResource(resource);
}
additional_resources_.clear();
video_stream_adapter_->RemoveRestrictionsListener(this);
video_stream_adapter_->RemoveRestrictionsListener(
&stream_resource_manager_);
resource_adaptation_processor_->RemoveResourceLimitationsListener(
&stream_resource_manager_);
stream_resource_manager_.SetAdaptationProcessor(nullptr, nullptr);
resource_adaptation_processor_.reset();
}
rate_allocator_ = nullptr;
ReleaseEncoder();
encoder_ = nullptr;
frame_cadence_adapter_ = nullptr;
});
encoder_queue_.PostTask([this, shutdown = std::move(shutdown)] {
RTC_DCHECK_RUN_ON(&encoder_queue_);
if (resource_adaptation_processor_) {
stream_resource_manager_.StopManagedResources();
for (auto* constraint : adaptation_constraints_) {
video_stream_adapter_->RemoveAdaptationConstraint(constraint);
}
for (auto& resource : additional_resources_) {
stream_resource_manager_.RemoveResource(resource);
}
additional_resources_.clear();
video_stream_adapter_->RemoveRestrictionsListener(this);
video_stream_adapter_->RemoveRestrictionsListener(
&stream_resource_manager_);
resource_adaptation_processor_->RemoveResourceLimitationsListener(
&stream_resource_manager_);
stream_resource_manager_.SetAdaptationProcessor(nullptr, nullptr);
resource_adaptation_processor_.reset();
}
rate_allocator_ = nullptr;
ReleaseEncoder();
encoder_ = nullptr;
frame_cadence_adapter_ = nullptr;
});
shutdown_event.Wait(rtc::Event::kForever);
}
@ -915,48 +914,48 @@ void VideoStreamEncoder::ConfigureEncoder(VideoEncoderConfig config,
size_t max_data_payload_length,
SetParametersCallback callback) {
RTC_DCHECK_RUN_ON(worker_queue_);
encoder_queue_.PostTask(
[this, config = std::move(config), max_data_payload_length,
callback = std::move(callback)]() mutable {
RTC_DCHECK_RUN_ON(&encoder_queue_);
RTC_DCHECK(sink_);
RTC_LOG(LS_INFO) << "ConfigureEncoder requested.";
encoder_queue_.PostTask([this, config = std::move(config),
max_data_payload_length,
callback = std::move(callback)]() mutable {
RTC_DCHECK_RUN_ON(&encoder_queue_);
RTC_DCHECK(sink_);
RTC_LOG(LS_INFO) << "ConfigureEncoder requested.";
// Set up the frame cadence adapter according to if we're going to do
// screencast. The final number of spatial layers is based on info
// in `send_codec_`, which is computed based on incoming frame
// dimensions which can only be determined later.
//
// Note: zero-hertz mode isn't enabled by this alone. Constraints also
// have to be set up with min_fps = 0 and max_fps > 0.
if (config.content_type == VideoEncoderConfig::ContentType::kScreen) {
frame_cadence_adapter_->SetZeroHertzModeEnabled(
FrameCadenceAdapterInterface::ZeroHertzModeParams{});
} else {
frame_cadence_adapter_->SetZeroHertzModeEnabled(absl::nullopt);
}
// Set up the frame cadence adapter according to if we're going to do
// screencast. The final number of spatial layers is based on info
// in `send_codec_`, which is computed based on incoming frame
// dimensions which can only be determined later.
//
// Note: zero-hertz mode isn't enabled by this alone. Constraints also
// have to be set up with min_fps = 0 and max_fps > 0.
if (config.content_type == VideoEncoderConfig::ContentType::kScreen) {
frame_cadence_adapter_->SetZeroHertzModeEnabled(
FrameCadenceAdapterInterface::ZeroHertzModeParams{});
} else {
frame_cadence_adapter_->SetZeroHertzModeEnabled(absl::nullopt);
}
pending_encoder_creation_ =
(!encoder_ || encoder_config_.video_format != config.video_format ||
max_data_payload_length_ != max_data_payload_length);
encoder_config_ = std::move(config);
max_data_payload_length_ = max_data_payload_length;
pending_encoder_reconfiguration_ = true;
pending_encoder_creation_ =
(!encoder_ || encoder_config_.video_format != config.video_format ||
max_data_payload_length_ != max_data_payload_length);
encoder_config_ = std::move(config);
max_data_payload_length_ = max_data_payload_length;
pending_encoder_reconfiguration_ = true;
// Reconfigure the encoder now if the frame resolution is known.
// Otherwise, the reconfiguration is deferred until the next frame to
// minimize the number of reconfigurations. The codec configuration
// depends on incoming video frame size.
if (last_frame_info_) {
if (callback) {
encoder_configuration_callbacks_.push_back(std::move(callback));
}
// Reconfigure the encoder now if the frame resolution is known.
// Otherwise, the reconfiguration is deferred until the next frame to
// minimize the number of reconfigurations. The codec configuration
// depends on incoming video frame size.
if (last_frame_info_) {
if (callback) {
encoder_configuration_callbacks_.push_back(std::move(callback));
}
ReconfigureEncoder();
} else {
webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
}
});
ReconfigureEncoder();
} else {
webrtc::InvokeSetParametersCallback(callback, webrtc::RTCError::OK());
}
});
}
// We should reduce the number of 'full' ReconfigureEncoder(). If only need