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() {} void ProtobufPlot::Draw() {}
ProtobufPlotCollection::ProtobufPlotCollection() {} ProtobufPlotCollection::ProtobufPlotCollection() {}
ProtobufPlotCollection::~ProtobufPlotCollection() {} ProtobufPlotCollection::~ProtobufPlotCollection() {}

76
system_wrappers/include/metrics.h
View file

@ -32,8 +32,8 @@ namespace webrtc {
namespace metrics_impl { namespace metrics_impl {
template <typename... Ts> template <typename... Ts>
void NoOp(const Ts&...) {} void NoOp(const Ts&...) {}
} } // namespace metrics_impl
} } // namespace webrtc
#if RTC_METRICS_ENABLED #if RTC_METRICS_ENABLED
#define EXPECT_METRIC_EQ(val1, val2) EXPECT_EQ(val1, val2) #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) #define EXPECT_METRIC_THAT(value, matcher) EXPECT_THAT(value, matcher)
#else #else
#define EXPECT_METRIC_EQ(val1, val2) webrtc::metrics_impl::NoOp(val1, val2) #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_GT(val1, val2) webrtc::metrics_impl::NoOp(val1, val2)
#define EXPECT_METRIC_LE(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_TRUE(condition) \
#define EXPECT_METRIC_FALSE(condition) webrtc::metrics_impl::NoOp(condition && false) webrtc::metrics_impl::NoOp(condition || true)
#define EXPECT_METRIC_THAT(value, matcher) webrtc::metrics_impl::NoOp(value, testing::_) #define EXPECT_METRIC_FALSE(condition) \
webrtc::metrics_impl::NoOp(condition && false)
#define EXPECT_METRIC_THAT(value, matcher) \
webrtc::metrics_impl::NoOp(value, testing::_)
#endif #endif
#if RTC_METRICS_ENABLED #if RTC_METRICS_ENABLED
@ -278,17 +282,23 @@ void NoOp(const Ts&...) {}
// This section defines no-op alternatives to the metrics macros when // This section defines no-op alternatives to the metrics macros when
// RTC_METRICS_ENABLED is defined. // 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) \ #define RTC_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAM_COUNTS_LINEAR(name, sample, min, max, bucket_count) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAM_COUNTS_SPARSE(name, sample, min, max, bucket_count) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAM_ENUMERATION_SPARSE(name, sample, boundary) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAM_ENUMERATION(name, sample, boundary) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAM_COMMON_BLOCK_SLOW(name, sample, factory_get_invocation) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAMS_COUNTS_1000(index, name, sample) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAMS_ENUMERATION(index, name, sample, boundary) \
webrtc::metrics_impl::NoOp(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) \ #define RTC_HISTOGRAMS_COMMON(index, name, sample, macro_invocation) \
webrtc::metrics_impl::NoOp(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_; rtc::scoped_refptr<AudioEncoderFactory> audio_encoder_factory_;
test::FakeVideoRenderer fake_renderer_; test::FakeVideoRenderer fake_renderer_;
private: private:
absl::optional<RtpExtension> GetRtpExtensionByUri( absl::optional<RtpExtension> GetRtpExtensionByUri(
const std::string& uri) const; 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( uint32_t bitrate = current_rate_settings_.bitrate.GetBitrate(
spatial_idx, temporal_idx); spatial_idx, temporal_idx);
bitrate = static_cast<uint32_t>( bitrate = static_cast<uint32_t>(
(bitrate * int64_t{max_target_bitrate_kbps_}) / (bitrate* int64_t{max_target_bitrate_kbps_}) /
allocated_bitrate_kbps); allocated_bitrate_kbps);
current_rate_settings_.bitrate.SetBitrate(spatial_idx, temporal_idx, current_rate_settings_.bitrate.SetBitrate(spatial_idx, temporal_idx,
bitrate); 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); FuzzGainControllerConfig(fuzz_data, gci);
// The audio buffer is used for both capture and render. // The audio buffer is used for both capture and render.
AudioBuffer audio(sample_rate_hz, num_channels, sample_rate_hz, AudioBuffer audio(sample_rate_hz, num_channels, sample_rate_hz, num_channels,
num_channels, sample_rate_hz, num_channels); sample_rate_hz, num_channels);
std::vector<int16_t> packed_render_audio(samples_per_frame); 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 * in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree. * 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 <stddef.h>
#include <stdint.h> #include <stdint.h>
#include <vector> #include <vector>
#include "api/array_view.h" #include "api/array_view.h"
#include "modules/rtp_rtcp/source/video_rtp_depacketizer_av1.h"
#include "test/fuzzers/fuzz_data_helper.h" #include "test/fuzzers/fuzz_data_helper.h"
namespace webrtc { namespace webrtc {

53
test/network/cross_traffic.cc
View file

@ -142,33 +142,32 @@ TcpMessageRouteImpl::TcpMessageRouteImpl(Clock* clock,
void TcpMessageRouteImpl::SendMessage(size_t size, void TcpMessageRouteImpl::SendMessage(size_t size,
std::function<void()> on_received) { std::function<void()> on_received) {
task_queue_->PostTask( task_queue_->PostTask([this, size, handler = std::move(on_received)] {
[this, size, handler = std::move(on_received)] { // If we are currently sending a message we won't reset the connection,
// 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
// 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
// intended to simulate recreation of a TCP session for each message // in the typical case while avoiding the complexity overhead of
// in the typical case while avoiding the complexity overhead of // maintaining multiple virtual TCP sessions in parallel.
// maintaining multiple virtual TCP sessions in parallel. if (pending_.empty() && in_flight_.empty()) {
if (pending_.empty() && in_flight_.empty()) { cwnd_ = 10;
cwnd_ = 10; ssthresh_ = INFINITY;
ssthresh_ = INFINITY; }
} int64_t data_left = static_cast<int64_t>(size);
int64_t data_left = static_cast<int64_t>(size); int64_t kMaxPacketSize = 1200;
int64_t kMaxPacketSize = 1200; int64_t kMinPacketSize = 4;
int64_t kMinPacketSize = 4; Message message{std::move(handler)};
Message message{std::move(handler)}; while (data_left > 0) {
while (data_left > 0) { int64_t packet_size = std::min(data_left, kMaxPacketSize);
int64_t packet_size = std::min(data_left, kMaxPacketSize); int fragment_id = next_fragment_id_++;
int fragment_id = next_fragment_id_++; pending_.push_back(MessageFragment{
pending_.push_back(MessageFragment{ fragment_id,
fragment_id, static_cast<size_t>(std::max(kMinPacketSize, packet_size))});
static_cast<size_t>(std::max(kMinPacketSize, packet_size))}); message.pending_fragment_ids.insert(fragment_id);
message.pending_fragment_ids.insert(fragment_id); data_left -= packet_size;
data_left -= packet_size; }
} messages_.emplace_back(message);
messages_.emplace_back(message); SendPackets(clock_->CurrentTime());
SendPackets(clock_->CurrentTime()); });
});
} }
void TcpMessageRouteImpl::OnRequest(TcpPacket packet_info) { 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(); socket_server_->WakeUp();
} }
rtc::SocketAddress FakeNetworkSocket::GetLocalAddress() const { rtc::SocketAddress FakeNetworkSocket::GetLocalAddress() const {
RTC_DCHECK_RUN_ON(thread_); RTC_DCHECK_RUN_ON(thread_);
return local_addr_; return local_addr_;
@ -317,6 +316,5 @@ void FakeNetworkSocketServer::WakeUp() {
wakeup_.Set(); wakeup_.Set();
} }
} // namespace test } // namespace test
} // namespace webrtc } // 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); explicit FakeNetworkSocketServer(EndpointsContainer* endpoints_controller);
~FakeNetworkSocketServer() override; ~FakeNetworkSocketServer() override;
// rtc::SocketFactory methods: // rtc::SocketFactory methods:
rtc::Socket* CreateSocket(int family, int type) override; 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) {} explicit ActionReceiver(std::function<void()> action) : action_(action) {}
~ActionReceiver() override = default; ~ActionReceiver() override = default;
void OnPacketReceived(EmulatedIpPacket packet) override { void OnPacketReceived(EmulatedIpPacket packet) override { action_(); }
action_();
}
private: private:
std::function<void()> action_; 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); handler(candidates);
} }
void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver, void OnAddTrack(rtc::scoped_refptr<RtpReceiverInterface> receiver,
const std::vector<rtc::scoped_refptr<MediaStreamInterface> >& const std::vector<rtc::scoped_refptr<MediaStreamInterface>>&
streams) override { streams) override {
for (const auto& handler : handlers_->on_add_track) for (const auto& handler : handlers_->on_add_track)
handler(receiver, streams); handler(receiver, streams);

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

@ -61,7 +61,8 @@ TEST(RemoteEstimateEndToEnd, OfferedCapabilityIsInAnswer) {
} }
TEST(RemoteEstimateEndToEnd, AudioUsesAbsSendTimeExtension) { 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); std::atomic<bool> received_abs_send_time(false);
PeerScenario s(*test_info_); PeerScenario s(*test_info_);

1
test/scenario/performance_stats.h
View file

@ -37,7 +37,6 @@ struct VideoFramePair {
int repeated = 0; int repeated = 0;
}; };
struct VideoFramesStats { struct VideoFramesStats {
int count = 0; int count = 0;
SampleStats<double> pixels; 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, c->encoder.simulcast_streams = {webrtc::ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T1, webrtc::ScalabilityMode::kL1T1,
webrtc::ScalabilityMode::kL1T1}; webrtc::ScalabilityMode::kL1T1};
}); });
s.RunFor(kRunTime); s.RunFor(kRunTime);
} }

1
test/testsupport/file_utils.cc
View file

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

3
test/video_encoder_proxy_factory.h
View file

@ -37,8 +37,7 @@ class VideoEncoderProxyFactory : public VideoEncoderFactory {
: encoder_(encoder), : encoder_(encoder),
encoder_selector_(encoder_selector), encoder_selector_(encoder_selector),
num_simultaneous_encoder_instances_(0), num_simultaneous_encoder_instances_(0),
max_num_simultaneous_encoder_instances_(0) { max_num_simultaneous_encoder_instances_(0) {}
}
// Unused by tests. // Unused by tests.
std::vector<SdpVideoFormat> GetSupportedFormats() const override { 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; test::FrameForwarder frame_forwarder;
SendTask( SendTask(task_queue(), [this, &renderer, &frame_forwarder]() {
task_queue(), [this, &renderer, &frame_forwarder]() { CreateCalls();
CreateCalls(); CreateSendTransport(BuiltInNetworkBehaviorConfig(),
CreateSendTransport(BuiltInNetworkBehaviorConfig(), /*observer=*/nullptr);
/*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr); /*observer=*/nullptr);
CreateSendConfig(1, 0, 0); CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs(); CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer; video_receive_configs_[0].renderer = &renderer;
CreateVideoStreams(); CreateVideoStreams();
Start(); Start();
// Create frames that are smaller than the send width/height, this is // Create frames that are smaller than the send width/height, this is
// done to check that the callbacks are done after processing video. // done to check that the callbacks are done after processing video.
std::unique_ptr<test::FrameGeneratorInterface> frame_generator( std::unique_ptr<test::FrameGeneratorInterface> frame_generator(
test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt, test::CreateSquareFrameGenerator(kWidth, kHeight, absl::nullopt,
absl::nullopt)); absl::nullopt));
GetVideoSendStream()->SetSource( GetVideoSendStream()->SetSource(&frame_forwarder,
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE); DegradationPreference::MAINTAIN_FRAMERATE);
test::FrameGeneratorInterface::VideoFrameData frame_data = test::FrameGeneratorInterface::VideoFrameData frame_data =
frame_generator->NextFrame(); frame_generator->NextFrame();
VideoFrame frame = VideoFrame::Builder() VideoFrame frame = VideoFrame::Builder()
.set_video_frame_buffer(frame_data.buffer) .set_video_frame_buffer(frame_data.buffer)
.set_update_rect(frame_data.update_rect) .set_update_rect(frame_data.update_rect)
.build(); .build();
frame_forwarder.IncomingCapturedFrame(frame); frame_forwarder.IncomingCapturedFrame(frame);
}); });
EXPECT_TRUE(renderer.Wait()) EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render."; << "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> sender_transport;
std::unique_ptr<test::DirectTransport> receiver_transport; std::unique_ptr<test::DirectTransport> receiver_transport;
SendTask( SendTask(task_queue(), [this, &renderer, &frame_generator,
task_queue(), [this, &renderer, &frame_generator, &frame_forwarder]() { &frame_forwarder]() {
CreateCalls(); CreateCalls();
CreateSendTransport(BuiltInNetworkBehaviorConfig(), CreateSendTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr); /*observer=*/nullptr);
CreateReceiveTransport(BuiltInNetworkBehaviorConfig(), CreateReceiveTransport(BuiltInNetworkBehaviorConfig(),
/*observer=*/nullptr); /*observer=*/nullptr);
CreateSendConfig(1, 0, 0); CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs(); CreateMatchingReceiveConfigs();
video_receive_configs_[0].renderer = &renderer; video_receive_configs_[0].renderer = &renderer;
CreateVideoStreams(); CreateVideoStreams();
Start(); Start();
frame_generator = test::CreateSquareFrameGenerator( frame_generator = test::CreateSquareFrameGenerator(
test::VideoTestConstants::kDefaultWidth, test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight, absl::nullopt, test::VideoTestConstants::kDefaultHeight, absl::nullopt, absl::nullopt);
absl::nullopt); GetVideoSendStream()->SetSource(&frame_forwarder,
GetVideoSendStream()->SetSource( DegradationPreference::MAINTAIN_FRAMERATE);
&frame_forwarder, DegradationPreference::MAINTAIN_FRAMERATE); test::FrameGeneratorInterface::VideoFrameData frame_data =
test::FrameGeneratorInterface::VideoFrameData frame_data = frame_generator->NextFrame();
frame_generator->NextFrame(); VideoFrame frame = VideoFrame::Builder()
VideoFrame frame = VideoFrame::Builder() .set_video_frame_buffer(frame_data.buffer)
.set_video_frame_buffer(frame_data.buffer) .set_update_rect(frame_data.update_rect)
.set_update_rect(frame_data.update_rect) .build();
.build(); frame_forwarder.IncomingCapturedFrame(frame);
frame_forwarder.IncomingCapturedFrame(frame); });
});
EXPECT_TRUE(renderer.Wait()) EXPECT_TRUE(renderer.Wait())
<< "Timed out while waiting for the frame to render."; << "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) { Transport* transport) {
test::VideoEncoderProxyFactory encoder_factory(encoder); test::VideoEncoderProxyFactory encoder_factory(encoder);
SendTask(task_queue(), SendTask(task_queue(), [this, network_to_bring_up, &encoder_factory,
[this, network_to_bring_up, &encoder_factory, transport]() { transport]() {
CreateSenderCall(Call::Config(send_event_log_.get())); CreateSenderCall(Call::Config(send_event_log_.get()));
sender_call_->SignalChannelNetworkState(network_to_bring_up, sender_call_->SignalChannelNetworkState(network_to_bring_up, kNetworkUp);
kNetworkUp);
CreateSendConfig(1, 0, 0, transport); CreateSendConfig(1, 0, 0, transport);
GetVideoSendConfig()->encoder_settings.encoder_factory = GetVideoSendConfig()->encoder_settings.encoder_factory = &encoder_factory;
&encoder_factory; CreateVideoStreams();
CreateVideoStreams(); CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
CreateFrameGeneratorCapturer( test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultFramerate, test::VideoTestConstants::kDefaultHeight);
test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultHeight);
Start(); Start();
}); });
SleepMs(kSilenceTimeoutMs); 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<test::DirectTransport> receive_transport;
std::unique_ptr<PacketInputObserver> input_observer; std::unique_ptr<PacketInputObserver> input_observer;
SendTask( SendTask(task_queue(), [this, &send_transport, &receive_transport,
task_queue(), &input_observer]() {
[this, &send_transport, &receive_transport, &input_observer]() { CreateCalls();
CreateCalls();
send_transport = std::make_unique<test::DirectTransport>( send_transport = std::make_unique<test::DirectTransport>(
task_queue(), task_queue(),
std::make_unique<FakeNetworkPipe>( std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>( Clock::GetRealTimeClock(),
BuiltInNetworkBehaviorConfig())), std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
sender_call_.get(), payload_type_map_, GetRegisteredExtensions(), sender_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions()); GetRegisteredExtensions());
receive_transport = std::make_unique<test::DirectTransport>( receive_transport = std::make_unique<test::DirectTransport>(
task_queue(), task_queue(),
std::make_unique<FakeNetworkPipe>( std::make_unique<FakeNetworkPipe>(
Clock::GetRealTimeClock(), std::make_unique<SimulatedNetwork>( Clock::GetRealTimeClock(),
BuiltInNetworkBehaviorConfig())), std::make_unique<SimulatedNetwork>(BuiltInNetworkBehaviorConfig())),
receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(), receiver_call_.get(), payload_type_map_, GetRegisteredExtensions(),
GetRegisteredExtensions()); GetRegisteredExtensions());
input_observer = input_observer =
std::make_unique<PacketInputObserver>(receiver_call_->Receiver()); std::make_unique<PacketInputObserver>(receiver_call_->Receiver());
send_transport->SetReceiver(input_observer.get()); send_transport->SetReceiver(input_observer.get());
receive_transport->SetReceiver(sender_call_->Receiver()); receive_transport->SetReceiver(sender_call_->Receiver());
CreateSendConfig(1, 0, 0, send_transport.get()); CreateSendConfig(1, 0, 0, send_transport.get());
CreateMatchingReceiveConfigs(receive_transport.get()); CreateMatchingReceiveConfigs(receive_transport.get());
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer( CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultFramerate, test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultWidth, test::VideoTestConstants::kDefaultHeight);
test::VideoTestConstants::kDefaultHeight); Start();
Start();
receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]); receiver_call_->DestroyVideoReceiveStream(video_receive_streams_[0]);
video_receive_streams_.clear(); video_receive_streams_.clear();
}); });
// Wait() waits for a received packet. // Wait() waits for a received packet.
EXPECT_TRUE(input_observer->Wait()); 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; VideoEncoderConfig encoder_config_with_screenshare;
SendTask( SendTask(task_queue(), [this, &test, &send_config, &recv_config,
task_queue(), [this, &test, &send_config, &recv_config, &encoder_config_with_screenshare]() {
&encoder_config_with_screenshare]() { CreateSenderCall(send_config);
CreateSenderCall(send_config); CreateReceiverCall(recv_config);
CreateReceiverCall(recv_config); CreateReceiveTransport(test.GetReceiveTransportConfig(), &test);
CreateReceiveTransport(test.GetReceiveTransportConfig(), &test); CreateSendTransport(test.GetReceiveTransportConfig(), &test);
CreateSendTransport(test.GetReceiveTransportConfig(), &test);
receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp); receiver_call_->SignalChannelNetworkState(MediaType::VIDEO, kNetworkUp);
CreateSendConfig(1, 0, 0); CreateSendConfig(1, 0, 0);
CreateMatchingReceiveConfigs(); CreateMatchingReceiveConfigs();
// Modify send and receive configs. // Modify send and receive configs.
GetVideoSendConfig()->rtp.nack.rtp_history_ms = GetVideoSendConfig()->rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].rtp.nack.rtp_history_ms = video_receive_configs_[0].rtp.nack.rtp_history_ms =
test::VideoTestConstants::kNackRtpHistoryMs; test::VideoTestConstants::kNackRtpHistoryMs;
video_receive_configs_[0].renderer = &test; video_receive_configs_[0].renderer = &test;
// RTT needed for RemoteNtpTimeEstimator for the receive stream. // RTT needed for RemoteNtpTimeEstimator for the receive stream.
video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = video_receive_configs_[0].rtp.rtcp_xr.receiver_reference_time_report = true;
true; // Start with realtime video.
// Start with realtime video. GetVideoEncoderConfig()->content_type =
GetVideoEncoderConfig()->content_type = VideoEncoderConfig::ContentType::kRealtimeVideo;
VideoEncoderConfig::ContentType::kRealtimeVideo; // Encoder config for the second part of the test uses screenshare.
// Encoder config for the second part of the test uses screenshare. encoder_config_with_screenshare = GetVideoEncoderConfig()->Copy();
encoder_config_with_screenshare = GetVideoEncoderConfig()->Copy(); encoder_config_with_screenshare.content_type =
encoder_config_with_screenshare.content_type = VideoEncoderConfig::ContentType::kScreen;
VideoEncoderConfig::ContentType::kScreen;
CreateVideoStreams(); CreateVideoStreams();
CreateFrameGeneratorCapturer( CreateFrameGeneratorCapturer(test::VideoTestConstants::kDefaultFramerate,
test::VideoTestConstants::kDefaultFramerate, test::VideoTestConstants::kDefaultWidth,
test::VideoTestConstants::kDefaultWidth, test::VideoTestConstants::kDefaultHeight);
test::VideoTestConstants::kDefaultHeight); Start();
Start(); });
});
test.PerformTest(); test.PerformTest();

24
video/picture_id_tests.cc
View file

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

3
video/send_statistics_proxy.cc
View file

@ -743,8 +743,7 @@ VideoSendStream::Stats SendStatisticsProxy::GetStats() {
PurgeOldStats(); PurgeOldStats();
stats_.input_frame_rate = stats_.input_frame_rate =
uma_container_->input_frame_rate_tracker_.ComputeRate(); uma_container_->input_frame_rate_tracker_.ComputeRate();
stats_.frames = stats_.frames = uma_container_->input_frame_rate_tracker_.TotalSampleCount();
uma_container_->input_frame_rate_tracker_.TotalSampleCount();
stats_.content_type = stats_.content_type =
content_type_ == VideoEncoderConfig::ContentType::kRealtimeVideo content_type_ == VideoEncoderConfig::ContentType::kRealtimeVideo
? VideoContentType::UNSPECIFIED ? 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); new_route.remote = rtc::RouteEndpoint::CreateWithNetworkId(20);
BitrateConstraints bitrate_config; BitrateConstraints bitrate_config;
SendTask(task_queue_, SendTask(task_queue_, [this, &new_route, &bitrate_config]() {
[this, &new_route, &bitrate_config]() { RTC_DCHECK_RUN_ON(&task_queue_thread_);
RTC_DCHECK_RUN_ON(&task_queue_thread_); call_->GetTransportControllerSend()->OnNetworkRouteChanged("transport",
call_->GetTransportControllerSend()->OnNetworkRouteChanged( new_route);
"transport", new_route); bitrate_config.start_bitrate_bps = kStartBitrateBps;
bitrate_config.start_bitrate_bps = kStartBitrateBps; call_->GetTransportControllerSend()->SetSdpBitrateParameters(
call_->GetTransportControllerSend()->SetSdpBitrateParameters( bitrate_config);
bitrate_config); });
});
EXPECT_TRUE(Wait()) EXPECT_TRUE(Wait())
<< "Timed out while waiting for start bitrate to be exceeded."; << "Timed out while waiting for start bitrate to be exceeded.";
SendTask( SendTask(task_queue_, [this, &new_route, &bitrate_config]() {
task_queue_, [this, &new_route, &bitrate_config]() { RTC_DCHECK_RUN_ON(&task_queue_thread_);
RTC_DCHECK_RUN_ON(&task_queue_thread_); bitrate_config.start_bitrate_bps = -1;
bitrate_config.start_bitrate_bps = -1; bitrate_config.max_bitrate_bps = kNewMaxBitrateBps;
bitrate_config.max_bitrate_bps = kNewMaxBitrateBps; call_->GetTransportControllerSend()->SetSdpBitrateParameters(
call_->GetTransportControllerSend()->SetSdpBitrateParameters( bitrate_config);
bitrate_config); // TODO(holmer): We should set the last sent packet id here and
// TODO(holmer): We should set the last sent packet id here and // verify that we correctly ignore any packet loss reported prior to
// verify that we correctly ignore any packet loss reported prior to // that id.
// that id. new_route.local = rtc::RouteEndpoint::CreateWithNetworkId(
new_route.local = rtc::RouteEndpoint::CreateWithNetworkId( new_route.local.network_id() + 1);
new_route.local.network_id() + 1); call_->GetTransportControllerSend()->OnNetworkRouteChanged("transport",
call_->GetTransportControllerSend()->OnNetworkRouteChanged( new_route);
"transport", new_route); EXPECT_GE(call_->GetStats().send_bandwidth_bps, kStartBitrateBps);
EXPECT_GE(call_->GetStats().send_bandwidth_bps, kStartBitrateBps); });
});
} }
private: private:
@ -3276,8 +3274,8 @@ class Vp9HeaderObserver : public test::SendTest {
// | P_DIFF | R times // | P_DIFF | R times
// +-+-+-+-+-+-+-+-+ // +-+-+-+-+-+-+-+-+
void VerifySsData(const RTPVideoHeaderVP9& vp9) const { void VerifySsData(const RTPVideoHeaderVP9& vp9) const {
EXPECT_TRUE(vp9.ss_data_available); // V EXPECT_TRUE(vp9.ss_data_available); // V
EXPECT_EQ(params_.num_spatial_layers, // N_S + 1 EXPECT_EQ(params_.num_spatial_layers, // N_S + 1
vp9.num_spatial_layers); vp9.num_spatial_layers);
EXPECT_TRUE(vp9.spatial_layer_resolution_present); // Y:1 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, auto reset_fun = [this](const VideoSendStream::Config& send_stream_config,
const VideoEncoderConfig& encoder_config, const VideoEncoderConfig& encoder_config,
test::BaseTest* test) { test::BaseTest* test) {
SendTask(task_queue(), SendTask(task_queue(), [this, &send_stream_config, &encoder_config,
[this, &send_stream_config, &encoder_config, &test]() { &test]() {
Stop(); Stop();
DestroyVideoSendStreams(); DestroyVideoSendStreams();
SetVideoSendConfig(send_stream_config); SetVideoSendConfig(send_stream_config);
SetVideoEncoderConfig(encoder_config); SetVideoEncoderConfig(encoder_config);
CreateVideoSendStreams(); CreateVideoSendStreams();
SetVideoDegradation(DegradationPreference::MAINTAIN_RESOLUTION); SetVideoDegradation(DegradationPreference::MAINTAIN_RESOLUTION);
test->OnVideoStreamsCreated(GetVideoSendStream(), test->OnVideoStreamsCreated(GetVideoSendStream(), video_receive_streams_);
video_receive_streams_); Start();
Start(); });
});
}; };
ContentSwitchTest<decltype(reset_fun)> test(&reset_fun, task_queue()); ContentSwitchTest<decltype(reset_fun)> test(&reset_fun, task_queue());
RunBaseTest(&test); RunBaseTest(&test);

125
video/video_stream_encoder.cc
View file

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