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

Rename VideoReceiveStream to VideoReceiveStreamInterface

Browse source 
Bug: webrtc:7484
Change-Id: I653cfe46486e0396897dd333069a894d67e3c07b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/262769
Commit-Queue: Tomas Gunnarsson <tommi@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36958}
This commit is contained in:
Tommi 2022-05-20 15:21:20 +02:00 committed by WebRTC LUCI CQ
parent d91996dd00
commit f6f4543304
76 changed files with 468 additions and 426 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
call/bitrate_estimator_tests.cc
View file

@ -141,7 +141,8 @@ class BitrateEstimatorTest : public test::CallTest {
test::FillEncoderConfiguration(kVideoCodecVP8, 1, &video_encoder_config);
SetVideoEncoderConfig(video_encoder_config);
receive_config_ = VideoReceiveStream::Config(receive_transport_.get());
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 = kReceiverLocalVideoSsrc;
@ -195,7 +196,7 @@ class BitrateEstimatorTest : public test::CallTest {
DegradationPreference::MAINTAIN_FRAMERATE);
send_stream_->Start();
VideoReceiveStream::Decoder decoder;
VideoReceiveStreamInterface::Decoder decoder;
test_->receive_config_.decoder_factory = &decoder_factory_;
decoder.payload_type = test_->GetVideoSendConfig()->rtp.payload_type;
decoder.video_format =
@ -237,7 +238,7 @@ class BitrateEstimatorTest : public test::CallTest {
BitrateEstimatorTest* test_;
bool is_sending_receiving_;
VideoSendStream* send_stream_;
VideoReceiveStream* video_receive_stream_;
VideoReceiveStreamInterface* video_receive_stream_;
std::unique_ptr<test::FrameGeneratorCapturer> frame_generator_capturer_;
test::FunctionVideoDecoderFactory decoder_factory_;
@ -246,7 +247,7 @@ class BitrateEstimatorTest : public test::CallTest {
LogObserver receiver_log_;
std::unique_ptr<test::DirectTransport> send_transport_;
std::unique_ptr<test::DirectTransport> receive_transport_;
VideoReceiveStream::Config receive_config_;
VideoReceiveStreamInterface::Config receive_config_;
std::vector<Stream*> streams_;
};

19
call/call.cc
View file

@ -99,7 +99,7 @@ const int* FindKeyByValue(const std::map<int, int>& m, int v) {
}
std::unique_ptr<rtclog::StreamConfig> CreateRtcLogStreamConfig(
const VideoReceiveStream::Config& config) {
const VideoReceiveStreamInterface::Config& config) {
auto rtclog_config = std::make_unique<rtclog::StreamConfig>();
rtclog_config->remote_ssrc = config.rtp.remote_ssrc;
rtclog_config->local_ssrc = config.rtp.local_ssrc;
@ -231,10 +231,10 @@ class Call final : public webrtc::Call,
std::unique_ptr<FecController> fec_controller) override;
void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
webrtc::VideoReceiveStream* CreateVideoReceiveStream(
webrtc::VideoReceiveStream::Config configuration) override;
webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
webrtc::VideoReceiveStreamInterface::Config configuration) override;
void DestroyVideoReceiveStream(
webrtc::VideoReceiveStream* receive_stream) override;
webrtc::VideoReceiveStreamInterface* receive_stream) override;
FlexfecReceiveStream* CreateFlexfecReceiveStream(
const FlexfecReceiveStream::Config config) override;
@ -267,7 +267,7 @@ class Call final : public webrtc::Call,
void OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
uint32_t local_ssrc) override;
void OnLocalSsrcUpdated(VideoReceiveStream& stream,
void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) override;
void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
uint32_t local_ssrc) override;
@ -1139,8 +1139,8 @@ void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
delete send_stream_impl;
}
webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
webrtc::VideoReceiveStream::Config configuration) {
webrtc::VideoReceiveStreamInterface* Call::CreateVideoReceiveStream(
webrtc::VideoReceiveStreamInterface::Config configuration) {
TRACE_EVENT0("webrtc", "Call::CreateVideoReceiveStream");
RTC_DCHECK_RUN_ON(worker_thread_);
@ -1183,7 +1183,7 @@ webrtc::VideoReceiveStream* Call::CreateVideoReceiveStream(
}
void Call::DestroyVideoReceiveStream(
webrtc::VideoReceiveStream* receive_stream) {
webrtc::VideoReceiveStreamInterface* receive_stream) {
TRACE_EVENT0("webrtc", "Call::DestroyVideoReceiveStream");
RTC_DCHECK_RUN_ON(worker_thread_);
RTC_DCHECK(receive_stream != nullptr);
@ -1392,7 +1392,8 @@ void Call::OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
: nullptr);
}
void Call::OnLocalSsrcUpdated(VideoReceiveStream& stream, uint32_t local_ssrc) {
void Call::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) {
RTC_DCHECK_RUN_ON(worker_thread_);
static_cast<VideoReceiveStream2&>(stream).SetLocalSsrc(local_ssrc);
}

10
call/call.h
View file

@ -119,12 +119,12 @@ class Call {
std::unique_ptr<FecController> fec_controller);
virtual void DestroyVideoSendStream(VideoSendStream* send_stream) = 0;
virtual VideoReceiveStream* CreateVideoReceiveStream(
VideoReceiveStream::Config configuration) = 0;
virtual VideoReceiveStreamInterface* CreateVideoReceiveStream(
VideoReceiveStreamInterface::Config configuration) = 0;
virtual void DestroyVideoReceiveStream(
VideoReceiveStream* receive_stream) = 0;
VideoReceiveStreamInterface* receive_stream) = 0;
// In order for a created VideoReceiveStream to be aware that it is
// In order for a created VideoReceiveStreamInterface to be aware that it is
// protected by a FlexfecReceiveStream, the latter should be created before
// the former.
virtual FlexfecReceiveStream* CreateFlexfecReceiveStream(
@ -166,7 +166,7 @@ class Call {
// send streams needs to be updated.
virtual void OnLocalSsrcUpdated(AudioReceiveStream& stream,
uint32_t local_ssrc) = 0;
virtual void OnLocalSsrcUpdated(VideoReceiveStream& stream,
virtual void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) = 0;
virtual void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
uint32_t local_ssrc) = 0;

34
call/call_perf_tests.cc
View file

@ -120,7 +120,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
if (!receive_stream_)
return;
VideoReceiveStream::Stats stats = receive_stream_->GetStats();
VideoReceiveStreamInterface::Stats stats = receive_stream_->GetStats();
if (stats.sync_offset_ms == std::numeric_limits<int>::max())
return;
@ -144,7 +144,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
sync_offset_ms_list_.push_back(stats.sync_offset_ms);
}
void set_receive_stream(VideoReceiveStream* receive_stream) {
void set_receive_stream(VideoReceiveStreamInterface* receive_stream) {
RTC_DCHECK_EQ(task_queue_, TaskQueueBase::Current());
// Note that receive_stream may be nullptr.
receive_stream_ = receive_stream;
@ -160,7 +160,7 @@ class VideoRtcpAndSyncObserver : public test::RtpRtcpObserver,
const std::string test_label_;
const int64_t creation_time_ms_;
int64_t first_time_in_sync_ = -1;
VideoReceiveStream* receive_stream_ = nullptr;
VideoReceiveStreamInterface* receive_stream_ = nullptr;
std::vector<double> sync_offset_ms_list_;
TaskQueueBase* const task_queue_;
};
@ -485,7 +485,7 @@ void CallPerfTest::TestCaptureNtpTime(
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
(*receive_configs)[0].renderer = this;
// Enable the receiver side rtt calculation.
@ -629,7 +629,7 @@ TEST_F(CallPerfTest, ReceivesCpuOveruseAndUnderuse) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {}
void PerformTest() override {
@ -702,9 +702,9 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
return SEND_PACKET;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
@ -712,7 +712,7 @@ void CallPerfTest::TestMinTransmitBitrate(bool pad_to_min_bitrate) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
if (pad_to_min_bitrate_) {
encoder_config->min_transmit_bitrate_bps = kMinTransmitBitrateBps;
@ -843,7 +843,7 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->encoder_settings.bitrate_allocator_factory =
@ -855,9 +855,9 @@ TEST_F(CallPerfTest, MAYBE_KeepsHighBitrateWhenReconfiguringSender) {
encoder_config_ = encoder_config->Copy();
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
@ -1094,9 +1094,9 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
bitrate_config->start_bitrate_bps = kMaxBitrate.bps() / 2;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
@ -1106,7 +1106,7 @@ void CallPerfTest::TestEncodeFramerate(VideoEncoderFactory* encoder_factory,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;

8
call/degraded_call.cc
View file

@ -237,13 +237,13 @@ void DegradedCall::DestroyVideoSendStream(VideoSendStream* send_stream) {
video_send_transport_adapters_.erase(send_stream);
}
VideoReceiveStream* DegradedCall::CreateVideoReceiveStream(
VideoReceiveStream::Config configuration) {
VideoReceiveStreamInterface* DegradedCall::CreateVideoReceiveStream(
VideoReceiveStreamInterface::Config configuration) {
return call_->CreateVideoReceiveStream(std::move(configuration));
}
void DegradedCall::DestroyVideoReceiveStream(
VideoReceiveStream* receive_stream) {
VideoReceiveStreamInterface* receive_stream) {
call_->DestroyVideoReceiveStream(receive_stream);
}
@ -305,7 +305,7 @@ void DegradedCall::OnLocalSsrcUpdated(AudioReceiveStream& stream,
call_->OnLocalSsrcUpdated(stream, local_ssrc);
}
void DegradedCall::OnLocalSsrcUpdated(VideoReceiveStream& stream,
void DegradedCall::OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) {
call_->OnLocalSsrcUpdated(stream, local_ssrc);
}

9
call/degraded_call.h
View file

@ -74,9 +74,10 @@ class DegradedCall : public Call, private PacketReceiver {
std::unique_ptr<FecController> fec_controller) override;
void DestroyVideoSendStream(VideoSendStream* send_stream) override;
VideoReceiveStream* CreateVideoReceiveStream(
VideoReceiveStream::Config configuration) override;
void DestroyVideoReceiveStream(VideoReceiveStream* receive_stream) override;
VideoReceiveStreamInterface* CreateVideoReceiveStream(
VideoReceiveStreamInterface::Config configuration) override;
void DestroyVideoReceiveStream(
VideoReceiveStreamInterface* receive_stream) override;
FlexfecReceiveStream* CreateFlexfecReceiveStream(
const FlexfecReceiveStream::Config config) override;
@ -101,7 +102,7 @@ class DegradedCall : public Call, private PacketReceiver {
int transport_overhead_per_packet) override;
void OnLocalSsrcUpdated(AudioReceiveStream& stream,
uint32_t local_ssrc) override;
void OnLocalSsrcUpdated(VideoReceiveStream& stream,
void OnLocalSsrcUpdated(VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) override;
void OnLocalSsrcUpdated(FlexfecReceiveStream& stream,
uint32_t local_ssrc) override;

6
call/rampup_tests.cc
View file

@ -103,7 +103,7 @@ void RampUpTester::ModifySenderBitrateConfig(
void RampUpTester::OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) {
const std::vector<VideoReceiveStreamInterface*>& receive_streams) {
send_stream_ = send_stream;
}
@ -154,7 +154,7 @@ class RampUpTester::VideoStreamFactory
void RampUpTester::ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) {
send_config->suspend_below_min_bitrate = true;
encoder_config->number_of_streams = num_video_streams_;
@ -214,7 +214,7 @@ void RampUpTester::ModifyVideoConfigs(
}
size_t i = 0;
for (VideoReceiveStream::Config& recv_config : *receive_configs) {
for (VideoReceiveStreamInterface::Config& recv_config : *receive_configs) {
recv_config.rtp.transport_cc = transport_cc;
recv_config.rtp.extensions = send_config->rtp.extensions;
recv_config.decoders.reserve(1);

8
call/rampup_tests.h
View file

@ -90,15 +90,15 @@ class RampUpTester : public test::EndToEndTest {
class VideoStreamFactory;
void ModifySenderBitrateConfig(BitrateConstraints* bitrate_config) override;
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override;
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override;
std::unique_ptr<test::PacketTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call) override;
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override;
void ModifyAudioConfigs(
AudioSendStream::Config* send_config,

4
call/syncable.h
View file

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
// Syncable is used by RtpStreamsSynchronizer in VideoReceiveStream, and
// implemented by AudioReceiveStream.
// Syncable is used by RtpStreamsSynchronizer in VideoReceiveStreamInterface,
// and implemented by AudioReceiveStream.
#ifndef CALL_SYNCABLE_H_
#define CALL_SYNCABLE_H_

50
call/video_receive_stream.cc
View file

@ -14,19 +14,20 @@
namespace webrtc {
VideoReceiveStream::Decoder::Decoder(SdpVideoFormat video_format,
int payload_type)
VideoReceiveStreamInterface::Decoder::Decoder(SdpVideoFormat video_format,
int payload_type)
: video_format(std::move(video_format)), payload_type(payload_type) {}
VideoReceiveStream::Decoder::Decoder() : video_format("Unset") {}
VideoReceiveStream::Decoder::Decoder(const Decoder&) = default;
VideoReceiveStream::Decoder::~Decoder() = default;
VideoReceiveStreamInterface::Decoder::Decoder() : video_format("Unset") {}
VideoReceiveStreamInterface::Decoder::Decoder(const Decoder&) = default;
VideoReceiveStreamInterface::Decoder::~Decoder() = default;
bool VideoReceiveStream::Decoder::operator==(const Decoder& other) const {
bool VideoReceiveStreamInterface::Decoder::operator==(
const Decoder& other) const {
return payload_type == other.payload_type &&
video_format == other.video_format;
}
std::string VideoReceiveStream::Decoder::ToString() const {
std::string VideoReceiveStreamInterface::Decoder::ToString() const {
char buf[1024];
rtc::SimpleStringBuilder ss(buf);
ss << "{payload_type: " << payload_type;
@ -45,13 +46,15 @@ std::string VideoReceiveStream::Decoder::ToString() const {
return ss.str();
}
VideoReceiveStream::Stats::Stats() = default;
VideoReceiveStream::Stats::~Stats() = default;
VideoReceiveStreamInterface::Stats::Stats() = default;
VideoReceiveStreamInterface::Stats::~Stats() = default;
std::string VideoReceiveStream::Stats::ToString(int64_t time_ms) const {
std::string VideoReceiveStreamInterface::Stats::ToString(
int64_t time_ms) const {
char buf[2048];
rtc::SimpleStringBuilder ss(buf);
ss << "VideoReceiveStream stats: " << time_ms << ", {ssrc: " << ssrc << ", ";
ss << "VideoReceiveStreamInterface stats: " << time_ms << ", {ssrc: " << ssrc
<< ", ";
ss << "total_bps: " << total_bitrate_bps << ", ";
ss << "width: " << width << ", ";
ss << "height: " << height << ", ";
@ -80,18 +83,19 @@ std::string VideoReceiveStream::Stats::ToString(int64_t time_ms) const {
return ss.str();
}
VideoReceiveStream::Config::Config(const Config&) = default;
VideoReceiveStream::Config::Config(Config&&) = default;
VideoReceiveStream::Config::Config(Transport* rtcp_send_transport,
VideoDecoderFactory* decoder_factory)
VideoReceiveStreamInterface::Config::Config(const Config&) = default;
VideoReceiveStreamInterface::Config::Config(Config&&) = default;
VideoReceiveStreamInterface::Config::Config(
Transport* rtcp_send_transport,
VideoDecoderFactory* decoder_factory)
: decoder_factory(decoder_factory),
rtcp_send_transport(rtcp_send_transport) {}
VideoReceiveStream::Config& VideoReceiveStream::Config::operator=(Config&&) =
default;
VideoReceiveStream::Config::Config::~Config() = default;
VideoReceiveStreamInterface::Config&
VideoReceiveStreamInterface::Config::operator=(Config&&) = default;
VideoReceiveStreamInterface::Config::Config::~Config() = default;
std::string VideoReceiveStream::Config::ToString() const {
std::string VideoReceiveStreamInterface::Config::ToString() const {
char buf[4 * 1024];
rtc::SimpleStringBuilder ss(buf);
ss << "{decoders: [";
@ -112,11 +116,11 @@ std::string VideoReceiveStream::Config::ToString() const {
return ss.str();
}
VideoReceiveStream::Config::Rtp::Rtp() = default;
VideoReceiveStream::Config::Rtp::Rtp(const Rtp&) = default;
VideoReceiveStream::Config::Rtp::~Rtp() = default;
VideoReceiveStreamInterface::Config::Rtp::Rtp() = default;
VideoReceiveStreamInterface::Config::Rtp::Rtp(const Rtp&) = default;
VideoReceiveStreamInterface::Config::Rtp::~Rtp() = default;
std::string VideoReceiveStream::Config::Rtp::ToString() const {
std::string VideoReceiveStreamInterface::Config::Rtp::ToString() const {
char buf[2 * 1024];
rtc::SimpleStringBuilder ss(buf);
ss << "{remote_ssrc: " << remote_ssrc;

16
call/video_receive_stream.h
View file

@ -39,7 +39,7 @@ namespace webrtc {
class RtpPacketSinkInterface;
class VideoDecoderFactory;
class VideoReceiveStream : public MediaReceiveStreamInterface {
class VideoReceiveStreamInterface : public MediaReceiveStreamInterface {
public:
// Class for handling moving in/out recording state.
struct RecordingState {
@ -48,11 +48,11 @@ class VideoReceiveStream : public MediaReceiveStreamInterface {
std::function<void(const RecordableEncodedFrame&)> callback)
: callback(std::move(callback)) {}
// Callback stored from the VideoReceiveStream. The VideoReceiveStream
// client should not interpret the attribute.
// Callback stored from the VideoReceiveStreamInterface. The
// VideoReceiveStreamInterface client should not interpret the attribute.
std::function<void(const RecordableEncodedFrame&)> callback;
// Memento of when a keyframe request was last sent. The VideoReceiveStream
// client should not interpret the attribute.
// Memento of when a keyframe request was last sent. The
// VideoReceiveStreamInterface client should not interpret the attribute.
absl::optional<int64_t> last_keyframe_request_ms;
};
@ -290,9 +290,13 @@ class VideoReceiveStream : public MediaReceiveStreamInterface {
virtual void GenerateKeyFrame() = 0;
protected:
virtual ~VideoReceiveStream() {}
virtual ~VideoReceiveStreamInterface() {}
};
// TODO(bugs.webrtc.org/7484): Remove this once downstream usage of the
// deprecated name is gone.
using VideoReceiveStream [[deprecated]] = VideoReceiveStreamInterface;
} // namespace webrtc
#endif // CALL_VIDEO_RECEIVE_STREAM_H_

19
media/engine/fake_webrtc_call.cc
View file

@ -364,11 +364,11 @@ void FakeVideoSendStream::InjectVideoSinkWants(
}
FakeVideoReceiveStream::FakeVideoReceiveStream(
webrtc::VideoReceiveStream::Config config)
webrtc::VideoReceiveStreamInterface::Config config)
: config_(std::move(config)), receiving_(false) {}
const webrtc::VideoReceiveStream::Config& FakeVideoReceiveStream::GetConfig()
const {
const webrtc::VideoReceiveStreamInterface::Config&
FakeVideoReceiveStream::GetConfig() const {
return config_;
}
@ -380,7 +380,8 @@ void FakeVideoReceiveStream::InjectFrame(const webrtc::VideoFrame& frame) {
config_.renderer->OnFrame(frame);
}
webrtc::VideoReceiveStream::Stats FakeVideoReceiveStream::GetStats() const {
webrtc::VideoReceiveStreamInterface::Stats FakeVideoReceiveStream::GetStats()
const {
return stats_;
}
@ -403,7 +404,7 @@ void FakeVideoReceiveStream::Stop() {
}
void FakeVideoReceiveStream::SetStats(
const webrtc::VideoReceiveStream::Stats& stats) {
const webrtc::VideoReceiveStreamInterface::Stats& stats) {
stats_ = stats;
}
@ -583,8 +584,8 @@ void FakeCall::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
}
}
webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
webrtc::VideoReceiveStream::Config config) {
webrtc::VideoReceiveStreamInterface* FakeCall::CreateVideoReceiveStream(
webrtc::VideoReceiveStreamInterface::Config config) {
video_receive_streams_.push_back(
new FakeVideoReceiveStream(std::move(config)));
++num_created_receive_streams_;
@ -592,7 +593,7 @@ webrtc::VideoReceiveStream* FakeCall::CreateVideoReceiveStream(
}
void FakeCall::DestroyVideoReceiveStream(
webrtc::VideoReceiveStream* receive_stream) {
webrtc::VideoReceiveStreamInterface* receive_stream) {
auto it = absl::c_find(video_receive_streams_,
static_cast<FakeVideoReceiveStream*>(receive_stream));
if (it == video_receive_streams_.end()) {
@ -714,7 +715,7 @@ void FakeCall::OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
fake_stream.SetLocalSsrc(local_ssrc);
}
void FakeCall::OnLocalSsrcUpdated(webrtc::VideoReceiveStream& stream,
void FakeCall::OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) {
auto& fake_stream = static_cast<FakeVideoReceiveStream&>(stream);
fake_stream.SetLocalSsrc(local_ssrc);

28
media/engine/fake_webrtc_call.h
View file

@ -15,7 +15,7 @@
// webrtc::AudioSendStream
// webrtc::AudioReceiveStream
// webrtc::VideoSendStream
// webrtc::VideoReceiveStream
// webrtc::VideoReceiveStreamInterface
#ifndef MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_
#define MEDIA_ENGINE_FAKE_WEBRTC_CALL_H_
@ -231,17 +231,19 @@ class FakeVideoSendStream final
int num_encoder_reconfigurations_ = 0;
};
class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
class FakeVideoReceiveStream final
: public webrtc::VideoReceiveStreamInterface {
public:
explicit FakeVideoReceiveStream(webrtc::VideoReceiveStream::Config config);
explicit FakeVideoReceiveStream(
webrtc::VideoReceiveStreamInterface::Config config);
const webrtc::VideoReceiveStream::Config& GetConfig() const;
const webrtc::VideoReceiveStreamInterface::Config& GetConfig() const;
bool IsReceiving() const;
void InjectFrame(const webrtc::VideoFrame& frame);
void SetStats(const webrtc::VideoReceiveStream::Stats& stats);
void SetStats(const webrtc::VideoReceiveStreamInterface::Stats& stats);
std::vector<webrtc::RtpSource> GetSources() const override {
return std::vector<webrtc::RtpSource>();
@ -269,7 +271,7 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
void GenerateKeyFrame() override {}
private:
// webrtc::VideoReceiveStream implementation.
// webrtc::VideoReceiveStreamInterface implementation.
void SetRtpExtensions(std::vector<webrtc::RtpExtension> extensions) override;
webrtc::RtpHeaderExtensionMap GetRtpExtensionMap() const override;
bool transport_cc() const override { return config_.rtp.transport_cc; }
@ -277,7 +279,7 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
void Start() override;
void Stop() override;
webrtc::VideoReceiveStream::Stats GetStats() const override;
webrtc::VideoReceiveStreamInterface::Stats GetStats() const override;
bool SetBaseMinimumPlayoutDelayMs(int delay_ms) override {
base_mininum_playout_delay_ms_ = delay_ms;
@ -288,9 +290,9 @@ class FakeVideoReceiveStream final : public webrtc::VideoReceiveStream {
return base_mininum_playout_delay_ms_;
}
webrtc::VideoReceiveStream::Config config_;
webrtc::VideoReceiveStreamInterface::Config config_;
bool receiving_;
webrtc::VideoReceiveStream::Stats stats_;
webrtc::VideoReceiveStreamInterface::Stats stats_;
int base_mininum_playout_delay_ms_ = 0;
};
@ -385,10 +387,10 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
webrtc::VideoEncoderConfig encoder_config) override;
void DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) override;
webrtc::VideoReceiveStream* CreateVideoReceiveStream(
webrtc::VideoReceiveStream::Config config) override;
webrtc::VideoReceiveStreamInterface* CreateVideoReceiveStream(
webrtc::VideoReceiveStreamInterface::Config config) override;
void DestroyVideoReceiveStream(
webrtc::VideoReceiveStream* receive_stream) override;
webrtc::VideoReceiveStreamInterface* receive_stream) override;
webrtc::FlexfecReceiveStream* CreateFlexfecReceiveStream(
const webrtc::FlexfecReceiveStream::Config config) override;
@ -420,7 +422,7 @@ class FakeCall final : public webrtc::Call, public webrtc::PacketReceiver {
int transport_overhead_per_packet) override;
void OnLocalSsrcUpdated(webrtc::AudioReceiveStream& stream,
uint32_t local_ssrc) override;
void OnLocalSsrcUpdated(webrtc::VideoReceiveStream& stream,
void OnLocalSsrcUpdated(webrtc::VideoReceiveStreamInterface& stream,
uint32_t local_ssrc) override;
void OnLocalSsrcUpdated(webrtc::FlexfecReceiveStream& stream,
uint32_t local_ssrc) override;

30
media/engine/webrtc_video_engine.cc
View file

@ -1467,7 +1467,7 @@ bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp,
for (uint32_t used_ssrc : sp.ssrcs)
receive_ssrcs_.insert(used_ssrc);
webrtc::VideoReceiveStream::Config config(this, decoder_factory_);
webrtc::VideoReceiveStreamInterface::Config config(this, decoder_factory_);
webrtc::FlexfecReceiveStream::Config flexfec_config(this);
ConfigureReceiverRtp(&config, &flexfec_config, sp);
@ -1489,7 +1489,7 @@ bool WebRtcVideoChannel::AddRecvStream(const StreamParams& sp,
}
void WebRtcVideoChannel::ConfigureReceiverRtp(
webrtc::VideoReceiveStream::Config* config,
webrtc::VideoReceiveStreamInterface::Config* config,
webrtc::FlexfecReceiveStream::Config* flexfec_config,
const StreamParams& sp) const {
uint32_t ssrc = sp.first_ssrc();
@ -2804,7 +2804,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::WebRtcVideoReceiveStream(
WebRtcVideoChannel* channel,
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
webrtc::VideoReceiveStreamInterface::Config config,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config)
@ -2832,7 +2832,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::~WebRtcVideoReceiveStream() {
call_->DestroyFlexfecReceiveStream(flexfec_stream_);
}
webrtc::VideoReceiveStream&
webrtc::VideoReceiveStreamInterface&
WebRtcVideoChannel::WebRtcVideoReceiveStream::stream() {
RTC_DCHECK(stream_);
return *stream_;
@ -2878,7 +2878,7 @@ bool WebRtcVideoChannel::WebRtcVideoReceiveStream::ConfigureCodecs(
std::map<int, int> rtx_associated_payload_types;
std::set<int> raw_payload_types;
std::vector<webrtc::VideoReceiveStream::Decoder> decoders;
std::vector<webrtc::VideoReceiveStreamInterface::Decoder> decoders;
for (const auto& recv_codec : recv_codecs) {
decoders.emplace_back(
webrtc::SdpVideoFormat(recv_codec.codec.name, recv_codec.codec.params),
@ -3028,11 +3028,12 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetRecvParameters(
void WebRtcVideoChannel::WebRtcVideoReceiveStream::RecreateReceiveStream() {
absl::optional<int> base_minimum_playout_delay_ms;
absl::optional<webrtc::VideoReceiveStream::RecordingState> recording_state;
absl::optional<webrtc::VideoReceiveStreamInterface::RecordingState>
recording_state;
if (stream_) {
base_minimum_playout_delay_ms = stream_->GetBaseMinimumPlayoutDelayMs();
recording_state = stream_->SetAndGetRecordingState(
webrtc::VideoReceiveStream::RecordingState(),
webrtc::VideoReceiveStreamInterface::RecordingState(),
/*generate_key_frame=*/false);
call_->DestroyVideoReceiveStream(stream_);
stream_ = nullptr;
@ -3047,7 +3048,7 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::RecreateReceiveStream() {
flexfec_stream_ = call_->CreateFlexfecReceiveStream(flexfec_config_);
}
webrtc::VideoReceiveStream::Config config = config_.Copy();
webrtc::VideoReceiveStreamInterface::Config config = config_.Copy();
config.rtp.protected_by_flexfec = (flexfec_stream_ != nullptr);
config.rtp.packet_sink_ = flexfec_stream_;
stream_ = call_->CreateVideoReceiveStream(std::move(config));
@ -3079,7 +3080,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::OnFrame(
estimated_remote_start_ntp_time_ms_ = frame.ntp_time_ms() - elapsed_time_ms;
if (sink_ == NULL) {
RTC_LOG(LS_WARNING) << "VideoReceiveStream not connected to a VideoSink.";
RTC_LOG(LS_WARNING)
<< "VideoReceiveStreamInterface not connected to a VideoSink.";
return;
}
@ -3121,7 +3123,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::SetSink(
std::string
WebRtcVideoChannel::WebRtcVideoReceiveStream::GetCodecNameFromPayloadType(
int payload_type) {
for (const webrtc::VideoReceiveStream::Decoder& decoder : config_.decoders) {
for (const webrtc::VideoReceiveStreamInterface::Decoder& decoder :
config_.decoders) {
if (decoder.payload_type == payload_type) {
return decoder.video_format.name;
}
@ -3135,7 +3138,7 @@ WebRtcVideoChannel::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
VideoReceiverInfo info;
info.ssrc_groups = stream_params_.ssrc_groups;
info.add_ssrc(config_.rtp.remote_ssrc);
webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
webrtc::VideoReceiveStreamInterface::Stats stats = stream_->GetStats();
info.decoder_implementation_name = stats.decoder_implementation_name;
if (stats.current_payload_type != -1) {
info.codec_payload_type = stats.current_payload_type;
@ -3218,7 +3221,8 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::
std::function<void(const webrtc::RecordableEncodedFrame&)> callback) {
if (stream_) {
stream_->SetAndGetRecordingState(
webrtc::VideoReceiveStream::RecordingState(std::move(callback)),
webrtc::VideoReceiveStreamInterface::RecordingState(
std::move(callback)),
/*generate_key_frame=*/true);
} else {
RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring setting encoded "
@ -3230,7 +3234,7 @@ void WebRtcVideoChannel::WebRtcVideoReceiveStream::
ClearRecordableEncodedFrameCallback() {
if (stream_) {
stream_->SetAndGetRecordingState(
webrtc::VideoReceiveStream::RecordingState(),
webrtc::VideoReceiveStreamInterface::RecordingState(),
/*generate_key_frame=*/false);
} else {
RTC_LOG(LS_ERROR) << "Absent receive stream; ignoring clearing encoded "

18
media/engine/webrtc_video_engine.h
View file

@ -246,8 +246,8 @@ class WebRtcVideoChannel : public VideoMediaChannel,
private:
class WebRtcVideoReceiveStream;
// Finds VideoReceiveStream corresponding to ssrc. Aware of unsignalled ssrc
// handling.
// Finds VideoReceiveStreamInterface corresponding to ssrc. Aware of
// unsignalled ssrc handling.
WebRtcVideoReceiveStream* FindReceiveStream(uint32_t ssrc)
RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);
@ -289,7 +289,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
absl::optional<std::vector<webrtc::RtpExtension>> rtp_header_extensions;
// Keep track of the FlexFEC payload type separately from `codec_settings`.
// This allows us to recreate the FlexfecReceiveStream separately from the
// VideoReceiveStream when the FlexFEC payload type is changed.
// VideoReceiveStreamInterface when the FlexFEC payload type is changed.
absl::optional<int> flexfec_payload_type;
};
@ -302,7 +302,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);
void ConfigureReceiverRtp(
webrtc::VideoReceiveStream::Config* config,
webrtc::VideoReceiveStreamInterface::Config* config,
webrtc::FlexfecReceiveStream::Config* flexfec_config,
const StreamParams& sp) const
RTC_EXCLUSIVE_LOCKS_REQUIRED(thread_checker_);
@ -428,7 +428,7 @@ class WebRtcVideoChannel : public VideoMediaChannel,
};
// Wrapper for the receiver part, contains configs etc. that are needed to
// reconstruct the underlying VideoReceiveStream.
// reconstruct the underlying VideoReceiveStreamInterface.
class WebRtcVideoReceiveStream
: public rtc::VideoSinkInterface<webrtc::VideoFrame> {
public:
@ -436,13 +436,13 @@ class WebRtcVideoChannel : public VideoMediaChannel,
WebRtcVideoChannel* channel,
webrtc::Call* call,
const StreamParams& sp,
webrtc::VideoReceiveStream::Config config,
webrtc::VideoReceiveStreamInterface::Config config,
bool default_stream,
const std::vector<VideoCodecSettings>& recv_codecs,
const webrtc::FlexfecReceiveStream::Config& flexfec_config);
~WebRtcVideoReceiveStream();
webrtc::VideoReceiveStream& stream();
webrtc::VideoReceiveStreamInterface& stream();
// Return value may be nullptr.
webrtc::FlexfecReceiveStream* flexfec_stream();
@ -503,9 +503,9 @@ class WebRtcVideoChannel : public VideoMediaChannel,
// Both `stream_` and `flexfec_stream_` are managed by `this`. They are
// destroyed by calling call_->DestroyVideoReceiveStream and
// call_->DestroyFlexfecReceiveStream, respectively.
webrtc::VideoReceiveStream* stream_;
webrtc::VideoReceiveStreamInterface* stream_;
const bool default_stream_;
webrtc::VideoReceiveStream::Config config_;
webrtc::VideoReceiveStreamInterface::Config config_;
webrtc::FlexfecReceiveStream::Config flexfec_config_;
webrtc::FlexfecReceiveStream* flexfec_stream_;

47
media/engine/webrtc_video_engine_unittest.cc
View file

@ -153,15 +153,16 @@ const int* FindKeyByValue(const std::map<int, int>& m, int v) {
return nullptr;
}
bool HasRtxReceiveAssociation(const webrtc::VideoReceiveStream::Config& config,
int payload_type) {
bool HasRtxReceiveAssociation(
const webrtc::VideoReceiveStreamInterface::Config& config,
int payload_type) {
return FindKeyByValue(config.rtp.rtx_associated_payload_types,
payload_type) != nullptr;
}
// Check that there's an Rtx payload type for each decoder.
bool VerifyRtxReceiveAssociations(
const webrtc::VideoReceiveStream::Config& config) {
const webrtc::VideoReceiveStreamInterface::Config& config) {
for (const auto& decoder : config.decoders) {
if (!HasRtxReceiveAssociation(config, decoder.payload_type))
return false;
@ -4098,7 +4099,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithoutSsrc) {
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
const FakeVideoReceiveStream& video_stream = *video_streams.front();
const webrtc::VideoReceiveStream::Config& video_config =
const webrtc::VideoReceiveStreamInterface::Config& video_config =
video_stream.GetConfig();
EXPECT_FALSE(video_config.rtp.protected_by_flexfec);
EXPECT_EQ(video_config.rtp.packet_sink_, nullptr);
@ -4122,7 +4123,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetDefaultRecvCodecsWithSsrc) {
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
const FakeVideoReceiveStream& video_stream = *video_streams.front();
const webrtc::VideoReceiveStream::Config& video_config =
const webrtc::VideoReceiveStreamInterface::Config& video_config =
video_stream.GetConfig();
EXPECT_TRUE(video_config.rtp.protected_by_flexfec);
EXPECT_NE(video_config.rtp.packet_sink_, nullptr);
@ -4144,7 +4145,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
const FakeVideoReceiveStream* video_stream = video_streams.front();
const webrtc::VideoReceiveStream::Config* video_config =
const webrtc::VideoReceiveStreamInterface::Config* video_config =
&video_stream->GetConfig();
EXPECT_FALSE(video_config->rtp.protected_by_flexfec);
EXPECT_EQ(video_config->rtp.packet_sink_, nullptr);
@ -4159,7 +4160,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
<< "Enabling FlexFEC should create FlexfecReceiveStream.";
EXPECT_EQ(1U, fake_call_->GetVideoReceiveStreams().size())
<< "Enabling FlexFEC should not create VideoReceiveStream.";
<< "Enabling FlexFEC should not create VideoReceiveStreamInterface.";
EXPECT_EQ(1U, fake_call_->GetFlexfecReceiveStreams().size())
<< "Enabling FlexFEC should create a single FlexfecReceiveStream.";
video_stream = video_streams.front();
@ -4187,7 +4188,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
fake_call_->GetVideoReceiveStreams();
ASSERT_EQ(1U, video_streams.size());
const FakeVideoReceiveStream* video_stream = video_streams.front();
const webrtc::VideoReceiveStream::Config* video_config =
const webrtc::VideoReceiveStreamInterface::Config* video_config =
&video_stream->GetConfig();
EXPECT_TRUE(video_config->rtp.protected_by_flexfec);
EXPECT_NE(video_config->rtp.packet_sink_, nullptr);
@ -4199,9 +4200,9 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest,
// Now the count of created streams will be 3 since the video stream had to
// be recreated on account of the flexfec stream being deleted.
EXPECT_EQ(3, fake_call_->GetNumCreatedReceiveStreams())
<< "Disabling FlexFEC should not recreate VideoReceiveStream.";
<< "Disabling FlexFEC should not recreate VideoReceiveStreamInterface.";
EXPECT_EQ(1U, fake_call_->GetVideoReceiveStreams().size())
<< "Disabling FlexFEC should not destroy VideoReceiveStream.";
<< "Disabling FlexFEC should not destroy VideoReceiveStreamInterface.";
EXPECT_TRUE(fake_call_->GetFlexfecReceiveStreams().empty())
<< "Disabling FlexFEC should destroy FlexfecReceiveStream.";
video_stream = video_streams.front();
@ -4309,7 +4310,7 @@ TEST_F(WebRtcVideoChannelFlexfecRecvTest, SetRecvCodecsWithFec) {
const std::vector<FakeVideoReceiveStream*>& video_streams =
fake_call_->GetVideoReceiveStreams();
const FakeVideoReceiveStream* video_stream = video_streams.front();
const webrtc::VideoReceiveStream::Config& video_stream_config =
const webrtc::VideoReceiveStreamInterface::Config& video_stream_config =
video_stream->GetConfig();
EXPECT_EQ(video_stream_config.rtp.local_ssrc,
flexfec_stream_config.rtp.local_ssrc);
@ -4840,7 +4841,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithPacketization) {
AddRecvStream(params);
ASSERT_THAT(fake_call_->GetVideoReceiveStreams(), testing::SizeIs(1));
const webrtc::VideoReceiveStream::Config& config =
const webrtc::VideoReceiveStreamInterface::Config& config =
fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
ASSERT_THAT(config.rtp.raw_payload_types, testing::SizeIs(1));
EXPECT_EQ(config.rtp.raw_payload_types.count(vp8_codec.id), 1U);
@ -4917,7 +4918,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
parameters.codecs.push_back(rtx_codec);
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
const webrtc::VideoReceiveStream::Config& config_before =
const webrtc::VideoReceiveStreamInterface::Config& config_before =
fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
EXPECT_EQ(1U, config_before.rtp.rtx_associated_payload_types.size());
const int* payload_type_before = FindKeyByValue(
@ -4930,7 +4931,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsWithChangedRtxPayloadType) {
parameters.codecs[1].id = kUnusedPayloadType2;
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
const webrtc::VideoReceiveStream::Config& config_after =
const webrtc::VideoReceiveStreamInterface::Config& config_after =
fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
EXPECT_EQ(1U, config_after.rtp.rtx_associated_payload_types.size());
const int* payload_type_after = FindKeyByValue(
@ -4960,7 +4961,7 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsRtxWithRtxTime) {
parameters.codecs.push_back(rtx_codec);
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
ASSERT_EQ(1U, fake_call_->GetVideoReceiveStreams().size());
const webrtc::VideoReceiveStream::Config& config =
const webrtc::VideoReceiveStreamInterface::Config& config =
fake_call_->GetVideoReceiveStreams()[0]->GetConfig();
const int kRtxTime = 343;
@ -5023,7 +5024,8 @@ TEST_F(WebRtcVideoChannelTest, SetRecvCodecsAcceptDefaultCodecs) {
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
FakeVideoReceiveStream* stream = AddRecvStream();
const webrtc::VideoReceiveStream::Config& config = stream->GetConfig();
const webrtc::VideoReceiveStreamInterface::Config& config =
stream->GetConfig();
EXPECT_EQ(engine_.recv_codecs()[0].name,
config.decoders[0].video_format.name);
EXPECT_EQ(engine_.recv_codecs()[0].id, config.decoders[0].payload_type);
@ -6082,7 +6084,7 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesSendRtcpPacketTypesCorrectly) {
TEST_F(WebRtcVideoChannelTest,
GetStatsTranslatesReceiveRtcpPacketTypesCorrectly) {
FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStream::Stats stats;
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.rtcp_packet_type_counts.fir_packets = 2;
stats.rtcp_packet_type_counts.nack_packets = 3;
stats.rtcp_packet_type_counts.pli_packets = 4;
@ -6100,7 +6102,7 @@ TEST_F(WebRtcVideoChannelTest,
TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStream::Stats stats;
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.decoder_implementation_name = "decoder_implementation_name";
stats.decode_ms = 2;
stats.max_decode_ms = 3;
@ -6157,7 +6159,7 @@ TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesDecodeStatsCorrectly) {
TEST_F(WebRtcVideoChannelTest,
GetStatsTranslatesInterFrameDelayStatsCorrectly) {
FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStream::Stats stats;
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.total_inter_frame_delay = 0.123;
stats.total_squared_inter_frame_delay = 0.00456;
stream->SetStats(stats);
@ -6172,7 +6174,7 @@ TEST_F(WebRtcVideoChannelTest,
TEST_F(WebRtcVideoChannelTest, GetStatsTranslatesReceivePacketStatsCorrectly) {
FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStream::Stats stats;
webrtc::VideoReceiveStreamInterface::Stats stats;
stats.rtp_stats.packet_counter.payload_bytes = 2;
stats.rtp_stats.packet_counter.header_bytes = 3;
stats.rtp_stats.packet_counter.padding_bytes = 4;
@ -6374,7 +6376,7 @@ TEST_F(WebRtcVideoChannelTest, ReportsSsrcGroupsInStats) {
TEST_F(WebRtcVideoChannelTest, MapsReceivedPayloadTypeToCodecName) {
FakeVideoReceiveStream* stream = AddRecvStream();
webrtc::VideoReceiveStream::Stats stats;
webrtc::VideoReceiveStreamInterface::Stats stats;
cricket::VideoMediaInfo info;
// Report no codec name before receiving.
@ -8489,7 +8491,8 @@ TEST_F(WebRtcVideoChannelTest, DISABLED_GetRtpReceiveFmtpSprop) {
EXPECT_TRUE(channel_->SetRecvParameters(parameters));
FakeVideoReceiveStream* recv_stream = AddRecvStream();
const webrtc::VideoReceiveStream::Config& cfg = recv_stream->GetConfig();
const webrtc::VideoReceiveStreamInterface::Config& cfg =
recv_stream->GetConfig();
webrtc::RtpParameters rtp_parameters =
channel_->GetRtpReceiveParameters(last_ssrc_);
ASSERT_EQ(2u, rtp_parameters.codecs.size());

2
modules/congestion_controller/goog_cc/goog_cc_network_control_unittest.cc
View file

@ -654,7 +654,7 @@ DataRate AverageBitrateAfterCrossInducedLoss(std::string name) {
// Querying the video stats from within the expected runtime environment
// (i.e. the TQ that belongs to the CallClient, not the Scenario TQ that
// we're currently on).
VideoReceiveStream::Stats video_receive_stats;
VideoReceiveStreamInterface::Stats video_receive_stats;
auto* video_stream = video->receive();
callee->SendTask([&video_stream, &video_receive_stats]() {
video_receive_stats = video_stream->GetStats();

2
modules/video_coding/video_receiver2.h
View file

@ -45,7 +45,7 @@ class VideoReceiver2 {
int32_t Decode(const webrtc::VCMEncodedFrame* frame);
// Notification methods that are used to check our internal state and validate
// threading assumptions. These are called by VideoReceiveStream.
// threading assumptions. These are called by VideoReceiveStreamInterface.
// See `IsDecoderThreadRunning()` for more details.
void DecoderThreadStarting();
void DecoderThreadStopped();

7
rtc_tools/video_replay.cc
View file

@ -388,7 +388,7 @@ class RtpReplayer final {
struct StreamState {
test::NullTransport transport;
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
std::vector<VideoReceiveStream*> receive_streams;
std::vector<VideoReceiveStreamInterface*> receive_streams;
std::unique_ptr<VideoDecoderFactory> decoder_factory;
};
@ -455,7 +455,8 @@ class RtpReplayer final {
stream_state->sinks.push_back(std::move(playback_video));
stream_state->sinks.push_back(std::move(file_passthrough));
// Setup the configuration from the flags.
VideoReceiveStream::Config receive_config(&(stream_state->transport));
VideoReceiveStreamInterface::Config receive_config(
&(stream_state->transport));
receive_config.rtp.remote_ssrc = Ssrc();
receive_config.rtp.local_ssrc = kReceiverLocalSsrc;
receive_config.rtp.rtx_ssrc = SsrcRtx();
@ -477,7 +478,7 @@ class RtpReplayer final {
receive_config.renderer = stream_state->sinks.back().get();
// Setup the receiving stream
VideoReceiveStream::Decoder decoder;
VideoReceiveStreamInterface::Decoder decoder;
decoder = test::CreateMatchingDecoder(MediaPayloadType(), Codec());
if (!DecoderBitstreamFilename().empty()) {
// Replace decoder with file writer if we're writing the bitstream to a

13
test/call_config_utils.cc
View file

@ -16,14 +16,15 @@
namespace webrtc {
namespace test {
// Deserializes a JSON representation of the VideoReceiveStream::Config back
// into a valid object. This will not initialize the decoders or the renderer.
VideoReceiveStream::Config ParseVideoReceiveStreamJsonConfig(
// Deserializes a JSON representation of the VideoReceiveStreamInterface::Config
// back into a valid object. This will not initialize the decoders or the
// renderer.
VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
webrtc::Transport* transport,
const Json::Value& json) {
auto receive_config = VideoReceiveStream::Config(transport);
auto receive_config = VideoReceiveStreamInterface::Config(transport);
for (const auto& decoder_json : json["decoders"]) {
VideoReceiveStream::Decoder decoder;
VideoReceiveStreamInterface::Decoder decoder;
decoder.video_format =
SdpVideoFormat(decoder_json["payload_name"].asString());
decoder.payload_type = decoder_json["payload_type"].asInt64();
@ -69,7 +70,7 @@ VideoReceiveStream::Config ParseVideoReceiveStreamJsonConfig(
}
Json::Value GenerateVideoReceiveStreamJsonConfig(
const VideoReceiveStream::Config& config) {
const VideoReceiveStreamInterface::Config& config) {
Json::Value root_json;
root_json["decoders"] = Json::Value(Json::arrayValue);

11
test/call_config_utils.h
View file

@ -17,15 +17,16 @@
namespace webrtc {
namespace test {
// Deserializes a JSON representation of the VideoReceiveStream::Config back
// into a valid object. This will not initialize the decoders or the renderer.
VideoReceiveStream::Config ParseVideoReceiveStreamJsonConfig(
// Deserializes a JSON representation of the VideoReceiveStreamInterface::Config
// back into a valid object. This will not initialize the decoders or the
// renderer.
VideoReceiveStreamInterface::Config ParseVideoReceiveStreamJsonConfig(
webrtc::Transport* transport,
const Json::Value& json);
// Serialize a VideoReceiveStream::Config into a Json object.
// Serialize a VideoReceiveStreamInterface::Config into a Json object.
Json::Value GenerateVideoReceiveStreamJsonConfig(
const VideoReceiveStream::Config& config);
const VideoReceiveStreamInterface::Config& config);
} // namespace test
} // namespace webrtc

6
test/call_config_utils_unittest.cc
View file

@ -17,9 +17,9 @@ namespace webrtc {
namespace test {
TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
VideoReceiveStream::Config recv_config(nullptr);
VideoReceiveStreamInterface::Config recv_config(nullptr);
VideoReceiveStream::Decoder decoder;
VideoReceiveStreamInterface::Decoder decoder;
decoder.payload_type = 10;
decoder.video_format.name = "test";
decoder.video_format.parameters["99"] = "b";
@ -37,7 +37,7 @@ TEST(CallConfigUtils, MarshalUnmarshalProcessSameObject) {
recv_config.rtp.rtx_associated_payload_types[10] = 10;
recv_config.rtp.extensions.emplace_back("uri", 128, true);
VideoReceiveStream::Config unmarshaled_config =
VideoReceiveStreamInterface::Config unmarshaled_config =
ParseVideoReceiveStreamJsonConfig(
nullptr, GenerateVideoReceiveStreamJsonConfig(recv_config));

21
test/call_test.cc
View file

@ -309,7 +309,7 @@ void CallTest::SetSendUlpFecConfig(VideoSendStream::Config* send_config) {
}
void CallTest::SetReceiveUlpFecConfig(
VideoReceiveStream::Config* receive_config) {
VideoReceiveStreamInterface::Config* receive_config) {
receive_config->rtp.red_payload_type = kRedPayloadType;
receive_config->rtp.ulpfec_payload_type = kUlpfecPayloadType;
receive_config->rtp.rtx_associated_payload_types[kRtxRedPayloadType] =
@ -353,7 +353,7 @@ void CallTest::CreateMatchingVideoReceiveConfigs(
}
void CallTest::AddMatchingVideoReceiveConfigs(
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport,
bool send_side_bwe,
@ -362,7 +362,7 @@ void CallTest::AddMatchingVideoReceiveConfigs(
bool receiver_reference_time_report,
int rtp_history_ms) {
RTC_DCHECK(!video_send_config.rtp.ssrcs.empty());
VideoReceiveStream::Config default_config(rtcp_send_transport);
VideoReceiveStreamInterface::Config default_config(rtcp_send_transport);
default_config.rtp.transport_cc = send_side_bwe;
default_config.rtp.local_ssrc = kReceiverLocalVideoSsrc;
for (const RtpExtension& extension : video_send_config.rtp.extensions)
@ -374,7 +374,8 @@ void CallTest::AddMatchingVideoReceiveConfigs(
default_config.renderer = &fake_renderer_;
for (size_t i = 0; i < video_send_config.rtp.ssrcs.size(); ++i) {
VideoReceiveStream::Config video_recv_config(default_config.Copy());
VideoReceiveStreamInterface::Config video_recv_config(
default_config.Copy());
video_recv_config.decoders.clear();
if (!video_send_config.rtp.rtx.ssrcs.empty()) {
video_recv_config.rtp.rtx_ssrc = video_send_config.rtp.rtx.ssrcs[i];
@ -382,7 +383,7 @@ void CallTest::AddMatchingVideoReceiveConfigs(
video_send_config.rtp.payload_type;
}
video_recv_config.rtp.remote_ssrc = video_send_config.rtp.ssrcs[i];
VideoReceiveStream::Decoder decoder;
VideoReceiveStreamInterface::Decoder decoder;
decoder.payload_type = video_send_config.rtp.payload_type;
decoder.video_format = SdpVideoFormat(video_send_config.rtp.payload_name);
@ -592,7 +593,7 @@ void CallTest::Start() {
void CallTest::StartVideoStreams() {
for (VideoSendStream* video_send_stream : video_send_streams_)
video_send_stream->Start();
for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
video_recv_stream->Start();
}
@ -608,7 +609,7 @@ void CallTest::Stop() {
void CallTest::StopVideoStreams() {
for (VideoSendStream* video_send_stream : video_send_streams_)
video_send_stream->Stop();
for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
video_recv_stream->Stop();
}
@ -621,7 +622,7 @@ void CallTest::DestroyStreams() {
DestroyVideoSendStreams();
for (VideoReceiveStream* video_recv_stream : video_receive_streams_)
for (VideoReceiveStreamInterface* video_recv_stream : video_receive_streams_)
receiver_call_->DestroyVideoReceiveStream(video_recv_stream);
for (FlexfecReceiveStream* flexfec_recv_stream : flexfec_receive_streams_)
@ -781,7 +782,7 @@ size_t BaseTest::GetNumFlexfecStreams() const {
void BaseTest::ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) {}
void BaseTest::ModifyVideoCaptureStartResolution(int* width,
@ -793,7 +794,7 @@ void BaseTest::ModifyVideoDegradationPreference(
void BaseTest::OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) {}
const std::vector<VideoReceiveStreamInterface*>& receive_streams) {}
void BaseTest::ModifyAudioConfigs(
AudioSendStream::Config* send_config,

13
test/call_test.h
View file

@ -99,7 +99,8 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
void SetSendFecConfig(std::vector<uint32_t> video_send_ssrcs);
void SetSendUlpFecConfig(VideoSendStream::Config* send_config);
void SetReceiveUlpFecConfig(VideoReceiveStream::Config* receive_config);
void SetReceiveUlpFecConfig(
VideoReceiveStreamInterface::Config* receive_config);
void CreateSendConfig(size_t num_video_streams,
size_t num_audio_streams,
size_t num_flexfec_streams,
@ -117,7 +118,7 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
bool receiver_reference_time_report,
int rtp_history_ms);
void AddMatchingVideoReceiveConfigs(
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
const VideoSendStream::Config& video_send_config,
Transport* rtcp_send_transport,
bool send_side_bwe,
@ -195,8 +196,8 @@ class CallTest : public ::testing::Test, public RtpPacketSinkInterface {
std::unique_ptr<Call> receiver_call_;
std::unique_ptr<PacketTransport> receive_transport_;
std::vector<VideoReceiveStream::Config> video_receive_configs_;
std::vector<VideoReceiveStream*> video_receive_streams_;
std::vector<VideoReceiveStreamInterface::Config> video_receive_configs_;
std::vector<VideoReceiveStreamInterface*> video_receive_streams_;
std::vector<AudioReceiveStream::Config> audio_receive_configs_;
std::vector<AudioReceiveStream*> audio_receive_streams_;
std::vector<FlexfecReceiveStream::Config> flexfec_receive_configs_;
@ -274,7 +275,7 @@ class BaseTest : public RtpRtcpObserver {
virtual void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config);
virtual void ModifyVideoCaptureStartResolution(int* width,
int* heigt,
@ -284,7 +285,7 @@ class BaseTest : public RtpRtcpObserver {
virtual void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams);
const std::vector<VideoReceiveStreamInterface*>& receive_streams);
virtual void ModifyAudioConfigs(
AudioSendStream::Config* send_config,

6
test/encoder_settings.cc
View file

@ -131,16 +131,16 @@ void FillEncoderConfiguration(VideoCodecType codec_type,
}
}
VideoReceiveStream::Decoder CreateMatchingDecoder(
VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
int payload_type,
const std::string& payload_name) {
VideoReceiveStream::Decoder decoder;
VideoReceiveStreamInterface::Decoder decoder;
decoder.payload_type = payload_type;
decoder.video_format = SdpVideoFormat(payload_name);
return decoder;
}
VideoReceiveStream::Decoder CreateMatchingDecoder(
VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
const VideoSendStream::Config& config) {
return CreateMatchingDecoder(config.rtp.payload_type,
config.rtp.payload_name);

4
test/encoder_settings.h
View file

@ -53,11 +53,11 @@ void FillEncoderConfiguration(VideoCodecType codec_type,
size_t num_streams,
VideoEncoderConfig* configuration);
VideoReceiveStream::Decoder CreateMatchingDecoder(
VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
int payload_type,
const std::string& payload_name);
VideoReceiveStream::Decoder CreateMatchingDecoder(
VideoReceiveStreamInterface::Decoder CreateMatchingDecoder(
const VideoSendStream::Config& config);
} // namespace test
} // namespace webrtc

14
test/fuzzers/utils/rtp_replayer.cc
View file

@ -34,7 +34,7 @@ void RtpReplayer::Replay(const std::string& replay_config_filepath,
const uint8_t* rtp_dump_data,
size_t rtp_dump_size) {
auto stream_state = std::make_unique<StreamState>();
std::vector<VideoReceiveStream::Config> receive_stream_configs =
std::vector<VideoReceiveStreamInterface::Config> receive_stream_configs =
ReadConfigFromFile(replay_config_filepath, &(stream_state->transport));
return Replay(std::move(stream_state), std::move(receive_stream_configs),
rtp_dump_data, rtp_dump_size);
@ -42,7 +42,7 @@ void RtpReplayer::Replay(const std::string& replay_config_filepath,
void RtpReplayer::Replay(
std::unique_ptr<StreamState> stream_state,
std::vector<VideoReceiveStream::Config> receive_stream_configs,
std::vector<VideoReceiveStreamInterface::Config> receive_stream_configs,
const uint8_t* rtp_dump_data,
size_t rtp_dump_size) {
RunLoop loop;
@ -83,9 +83,9 @@ void RtpReplayer::Replay(
}
}
std::vector<VideoReceiveStream::Config> RtpReplayer::ReadConfigFromFile(
const std::string& replay_config,
Transport* transport) {
std::vector<VideoReceiveStreamInterface::Config>
RtpReplayer::ReadConfigFromFile(const std::string& replay_config,
Transport* transport) {
Json::CharReaderBuilder factory;
std::unique_ptr<Json::CharReader> json_reader =
absl::WrapUnique(factory.newCharReader());
@ -99,7 +99,7 @@ std::vector<VideoReceiveStream::Config> RtpReplayer::ReadConfigFromFile(
return {};
}
std::vector<VideoReceiveStream::Config> receive_stream_configs;
std::vector<VideoReceiveStreamInterface::Config> receive_stream_configs;
receive_stream_configs.reserve(json_configs.size());
for (const auto& json : json_configs) {
receive_stream_configs.push_back(
@ -109,7 +109,7 @@ std::vector<VideoReceiveStream::Config> RtpReplayer::ReadConfigFromFile(
}
void RtpReplayer::SetupVideoStreams(
std::vector<VideoReceiveStream::Config>* receive_stream_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_stream_configs,
StreamState* stream_state,
Call* call) {
stream_state->decoder_factory = std::make_unique<InternalDecoderFactory>();

13
test/fuzzers/utils/rtp_replayer.h
View file

@ -44,7 +44,7 @@ class RtpReplayer final {
struct StreamState {
test::NullTransport transport;
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>> sinks;
std::vector<VideoReceiveStream*> receive_streams;
std::vector<VideoReceiveStreamInterface*> receive_streams;
std::unique_ptr<VideoDecoderFactory> decoder_factory;
};
@ -53,23 +53,24 @@ class RtpReplayer final {
const uint8_t* rtp_dump_data,
size_t rtp_dump_size);
// Construct an RtpReplayer from a set of VideoReceiveStream::Configs. Note
// the stream_state.transport must be set for each receiver stream.
// Construct an RtpReplayer from a set of
// VideoReceiveStreamInterface::Configs. Note the stream_state.transport must
// be set for each receiver stream.
static void Replay(
std::unique_ptr<StreamState> stream_state,
std::vector<VideoReceiveStream::Config> receive_stream_config,
std::vector<VideoReceiveStreamInterface::Config> receive_stream_config,
const uint8_t* rtp_dump_data,
size_t rtp_dump_size);
private:
// Reads the replay configuration from Json.
static std::vector<VideoReceiveStream::Config> ReadConfigFromFile(
static std::vector<VideoReceiveStreamInterface::Config> ReadConfigFromFile(
const std::string& replay_config,
Transport* transport);
// Configures the stream state based on the receiver configurations.
static void SetupVideoStreams(
std::vector<VideoReceiveStream::Config>* receive_stream_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_stream_configs,
StreamState* stream_state,
Call* call);

6
test/fuzzers/vp8_replay_fuzzer.cc
View file

@ -19,9 +19,9 @@ namespace webrtc {
void FuzzOneInput(const uint8_t* data, size_t size) {
auto stream_state = std::make_unique<test::RtpReplayer::StreamState>();
VideoReceiveStream::Config vp8_config(&(stream_state->transport));
VideoReceiveStreamInterface::Config vp8_config(&(stream_state->transport));
VideoReceiveStream::Decoder vp8_decoder;
VideoReceiveStreamInterface::Decoder vp8_decoder;
vp8_decoder.video_format = SdpVideoFormat("VP8");
vp8_decoder.payload_type = 125;
vp8_config.decoders.push_back(std::move(vp8_decoder));
@ -33,7 +33,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
vp8_config.rtp.nack.rtp_history_ms = 1000;
vp8_config.rtp.lntf.enabled = true;
std::vector<VideoReceiveStream::Config> replay_configs;
std::vector<VideoReceiveStreamInterface::Config> replay_configs;
replay_configs.push_back(std::move(vp8_config));
test::RtpReplayer::Replay(std::move(stream_state), std::move(replay_configs),

6
test/fuzzers/vp9_replay_fuzzer.cc
View file

@ -19,9 +19,9 @@ namespace webrtc {
void FuzzOneInput(const uint8_t* data, size_t size) {
auto stream_state = std::make_unique<test::RtpReplayer::StreamState>();
VideoReceiveStream::Config vp9_config(&(stream_state->transport));
VideoReceiveStreamInterface::Config vp9_config(&(stream_state->transport));
VideoReceiveStream::Decoder vp9_decoder;
VideoReceiveStreamInterface::Decoder vp9_decoder;
vp9_decoder.video_format = SdpVideoFormat("VP9");
vp9_decoder.payload_type = 124;
vp9_config.decoders.push_back(std::move(vp9_decoder));
@ -32,7 +32,7 @@ void FuzzOneInput(const uint8_t* data, size_t size) {
vp9_config.rtp.transport_cc = true;
vp9_config.rtp.nack.rtp_history_ms = 1000;
std::vector<VideoReceiveStream::Config> replay_configs;
std::vector<VideoReceiveStreamInterface::Config> replay_configs;
replay_configs.push_back(std::move(vp9_config));
test::RtpReplayer::Replay(std::move(stream_state), std::move(replay_configs),

3
test/scenario/stats_collection.cc
View file

@ -174,7 +174,8 @@ void VideoSendStatsCollector::AddStats(VideoSendStream::Stats sample,
last_update_ = at_time;
}
void VideoReceiveStatsCollector::AddStats(VideoReceiveStream::Stats sample) {
void VideoReceiveStatsCollector::AddStats(
VideoReceiveStreamInterface::Stats sample) {
if (sample.decode_ms > 0)
stats_.decode_time.AddSampleMs(sample.decode_ms);
if (sample.max_decode_ms > 0)

2
test/scenario/stats_collection.h
View file

@ -90,7 +90,7 @@ class VideoSendStatsCollector {
};
class VideoReceiveStatsCollector {
public:
void AddStats(VideoReceiveStream::Stats sample);
void AddStats(VideoReceiveStreamInterface::Stats sample);
CollectedVideoReceiveStats& stats() { return stats_; }
private:

2
test/scenario/stats_collection_unittest.cc
View file

@ -45,7 +45,7 @@ void CreateAnalyzedStream(Scenario* s,
// Querying the video stats from within the expected runtime environment
// (i.e. the TQ that belongs to the CallClient, not the Scenario TQ that
// we're currently on).
VideoReceiveStream::Stats video_receive_stats;
VideoReceiveStreamInterface::Stats video_receive_stats;
auto* video_stream = video->receive();
callee->SendTask([&video_stream, &video_receive_stats]() {
video_receive_stats = video_stream->GetStats();

12
test/scenario/video_stream.cc
View file

@ -317,16 +317,16 @@ std::unique_ptr<FrameGeneratorInterface> CreateFrameGenerator(
}
}
VideoReceiveStream::Config CreateVideoReceiveStreamConfig(
VideoReceiveStreamInterface::Config CreateVideoReceiveStreamConfig(
VideoStreamConfig config,
Transport* feedback_transport,
VideoDecoderFactory* decoder_factory,
VideoReceiveStream::Decoder decoder,
VideoReceiveStreamInterface::Decoder decoder,
rtc::VideoSinkInterface<VideoFrame>* renderer,
uint32_t local_ssrc,
uint32_t ssrc,
uint32_t rtx_ssrc) {
VideoReceiveStream::Config recv(feedback_transport);
VideoReceiveStreamInterface::Config recv(feedback_transport);
recv.rtp.transport_cc = config.stream.packet_feedback;
recv.rtp.local_ssrc = local_ssrc;
recv.rtp.extensions = GetVideoRtpExtensions(config);
@ -546,7 +546,7 @@ ReceiveVideoStream::ReceiveVideoStream(CallClient* receiver,
decoder_factory_ = std::make_unique<InternalDecoderFactory>();
}
VideoReceiveStream::Decoder decoder =
VideoReceiveStreamInterface::Decoder decoder =
CreateMatchingDecoder(CodecTypeToPayloadType(config.encoder.codec),
CodecTypeToPayloadString(config.encoder.codec));
size_t num_streams = 1;
@ -611,9 +611,9 @@ void ReceiveVideoStream::Stop() {
});
}
VideoReceiveStream::Stats ReceiveVideoStream::GetStats() const {
VideoReceiveStreamInterface::Stats ReceiveVideoStream::GetStats() const {
if (receive_streams_.empty())
return VideoReceiveStream::Stats();
return VideoReceiveStreamInterface::Stats();
// TODO(srte): Handle multiple receive streams.
return receive_streams_.back()->GetStats();
}

4
test/scenario/video_stream.h
View file

@ -81,7 +81,7 @@ class ReceiveVideoStream {
void Start();
void Stop();
VideoReceiveStream::Stats GetStats() const;
VideoReceiveStreamInterface::Stats GetStats() const;
private:
friend class Scenario;
@ -93,7 +93,7 @@ class ReceiveVideoStream {
Transport* feedback_transport,
VideoFrameMatcher* matcher);
std::vector<VideoReceiveStream*> receive_streams_;
std::vector<VideoReceiveStreamInterface*> receive_streams_;
FlexfecReceiveStream* flecfec_stream_ = nullptr;
FakeVideoRenderer fake_renderer_;
std::vector<std::unique_ptr<rtc::VideoSinkInterface<VideoFrame>>>

2
video/cpu_scaling_tests.cc
View file

@ -102,7 +102,7 @@ void CpuOveruseTest::RunTestAndCheckForAdaptation(
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
EXPECT_FALSE(encoder_config->simulcast_layers.empty());
encoder_config->simulcast_layers[0].max_framerate = kFps;

14
video/end_to_end_tests/bandwidth_tests.cc
View file

@ -50,7 +50,7 @@ TEST_F(BandwidthEndToEndTest, ReceiveStreamSendsRemb) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
@ -100,7 +100,7 @@ class BandwidthStatsTest : public test::EndToEndTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
if (!send_side_bwe_) {
@ -226,7 +226,7 @@ TEST_F(BandwidthEndToEndTest, RembWithSendSideBwe) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
ASSERT_EQ(1u, send_config->rtp.ssrcs.size());
sender_ssrc_ = send_config->rtp.ssrcs[0];
@ -328,15 +328,15 @@ TEST_F(BandwidthEndToEndTest, ReportsSetEncoderRates) {
CreateBuiltinVideoBitrateAllocatorFactory()),
bitrate_kbps_(0) {}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->encoder_settings.bitrate_allocator_factory =

2
video/end_to_end_tests/codec_tests.cc
View file

@ -71,7 +71,7 @@ class CodecObserver : public test::EndToEndTest,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = PayloadStringToCodecType(payload_name_);
send_config->encoder_settings.encoder_factory = encoder_factory_;

2
video/end_to_end_tests/config_tests.cc
View file

@ -73,7 +73,7 @@ TEST_F(ConfigEndToEndTest, VerifyDefaultSendConfigParameters) {
}
TEST_F(ConfigEndToEndTest, VerifyDefaultVideoReceiveConfigParameters) {
VideoReceiveStream::Config default_receive_config(nullptr);
VideoReceiveStreamInterface::Config default_receive_config(nullptr);
EXPECT_EQ(RtcpMode::kCompound, default_receive_config.rtp.rtcp_mode)
<< "Reduced-size RTCP require rtcp-rsize to be negotiated.";
EXPECT_FALSE(default_receive_config.rtp.lntf.enabled)

2
video/end_to_end_tests/extended_reports_tests.cc
View file

@ -173,7 +173,7 @@ class RtcpXrObserver : public test::EndToEndTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
if (enable_zero_target_bitrate_) {
// Configure VP8 to be able to use simulcast.

8
video/end_to_end_tests/fec_tests.cc
View file

@ -110,7 +110,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Use VP8 instead of FAKE, since the latter does not have PictureID
// in the packetization headers.
@ -118,7 +118,7 @@ TEST_F(FecEndToEndTest, ReceivesUlpfec) {
send_config->rtp.payload_name = "VP8";
send_config->rtp.payload_type = kVideoSendPayloadType;
encoder_config->codec_type = kVideoCodecVP8;
VideoReceiveStream::Decoder decoder =
VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(*send_config);
(*receive_configs)[0].decoder_factory = &decoder_factory_;
(*receive_configs)[0].decoders.clear();
@ -287,7 +287,7 @@ class FlexfecRenderObserver : public test::EndToEndTest,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
(*receive_configs)[0].rtp.local_ssrc = kVideoLocalSsrc;
(*receive_configs)[0].renderer = this;
@ -465,7 +465,7 @@ TEST_F(FecEndToEndTest, ReceivedUlpfecPacketsNotNacked) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Configure hybrid NACK/FEC.
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

4
video/end_to_end_tests/frame_encryption_tests.cc
View file

@ -35,7 +35,7 @@ class DecryptedFrameObserver : public test::EndToEndTest,
private:
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Use VP8 instead of FAKE.
send_config->encoder_settings.encoder_factory = &encoder_factory_;
@ -44,7 +44,7 @@ class DecryptedFrameObserver : public test::EndToEndTest,
send_config->frame_encryptor = new FakeFrameEncryptor();
send_config->crypto_options.sframe.require_frame_encryption = true;
encoder_config->codec_type = kVideoCodecVP8;
VideoReceiveStream::Decoder decoder =
VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(*send_config);
for (auto& recv_config : *receive_configs) {
recv_config.decoder_factory = &decoder_factory_;

2
video/end_to_end_tests/histogram_tests.cc
View file

@ -89,7 +89,7 @@ void HistogramTest::VerifyHistogramStats(bool use_rtx,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// NACK
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

6
video/end_to_end_tests/multi_codec_receive_tests.cc
View file

@ -186,8 +186,10 @@ void MultiCodecReceiveTest::ConfigureDecoders(
std::set<std::string> unique_payload_names;
for (const auto& config : configs)
if (unique_payload_names.insert(config.payload_name).second) {
VideoReceiveStream::Decoder decoder = test::CreateMatchingDecoder(
PayloadNameToPayloadType(config.payload_name), config.payload_name);
VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(
PayloadNameToPayloadType(config.payload_name),
config.payload_name);
video_receive_configs_[0].decoders.push_back(decoder);
}

9
video/end_to_end_tests/multi_stream_tester.cc
View file

@ -59,7 +59,7 @@ void MultiStreamTester::RunTest() {
std::unique_ptr<test::DirectTransport> receiver_transport;
VideoSendStream* send_streams[kNumStreams];
VideoReceiveStream* receive_streams[kNumStreams];
VideoReceiveStreamInterface* receive_streams[kNumStreams];
test::FrameGeneratorCapturer* frame_generators[kNumStreams];
test::FunctionVideoEncoderFactory encoder_factory(
[]() { return VP8Encoder::Create(); });
@ -99,11 +99,12 @@ void MultiStreamTester::RunTest() {
send_config.Copy(), encoder_config.Copy());
send_streams[i]->Start();
VideoReceiveStream::Config receive_config(receiver_transport.get());
VideoReceiveStreamInterface::Config receive_config(
receiver_transport.get());
receive_config.rtp.remote_ssrc = ssrc;
receive_config.rtp.local_ssrc = test::CallTest::kReceiverLocalVideoSsrc;
receive_config.decoder_factory = &decoder_factory;
VideoReceiveStream::Decoder decoder =
VideoReceiveStreamInterface::Decoder decoder =
test::CreateMatchingDecoder(send_config);
receive_config.decoders.push_back(decoder);
@ -152,7 +153,7 @@ void MultiStreamTester::UpdateSendConfig(
void MultiStreamTester::UpdateReceiveConfig(
size_t stream_index,
VideoReceiveStream::Config* receive_config) {}
VideoReceiveStreamInterface::Config* receive_config) {}
std::unique_ptr<test::DirectTransport> MultiStreamTester::CreateSendTransport(
TaskQueueBase* task_queue,

5
video/end_to_end_tests/multi_stream_tester.h
View file

@ -50,8 +50,9 @@ class MultiStreamTester {
VideoSendStream::Config* send_config,
VideoEncoderConfig* encoder_config,
test::FrameGeneratorCapturer** frame_generator);
virtual void UpdateReceiveConfig(size_t stream_index,
VideoReceiveStream::Config* receive_config);
virtual void UpdateReceiveConfig(
size_t stream_index,
VideoReceiveStreamInterface::Config* receive_config);
virtual std::unique_ptr<test::DirectTransport> CreateSendTransport(
TaskQueueBase* task_queue,
Call* sender_call);

2
video/end_to_end_tests/multi_stream_tests.cc
View file

@ -79,7 +79,7 @@ TEST(MultiStreamEndToEndTest, SendsAndReceivesMultipleStreams) {
void UpdateReceiveConfig(
size_t stream_index,
VideoReceiveStream::Config* receive_config) override {
VideoReceiveStreamInterface::Config* receive_config) override {
receive_config->renderer = observers_[stream_index].get();
}

2
video/end_to_end_tests/network_state_tests.cc
View file

@ -223,7 +223,7 @@ TEST_F(NetworkStateEndToEndTest, RespectsNetworkState) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
}

2
video/end_to_end_tests/resolution_bitrate_limits_tests.cc
View file

@ -126,7 +126,7 @@ class InitEncodeTest : public test::EndToEndTest,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;

14
video/end_to_end_tests/retransmission_tests.cc
View file

@ -105,7 +105,7 @@ TEST_F(RetransmissionEndToEndTest, ReceivesAndRetransmitsNack) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
@ -209,9 +209,9 @@ TEST_F(RetransmissionEndToEndTest,
explicit KeyframeRequestObserver(TaskQueueBase* task_queue)
: clock_(Clock::GetRealTimeClock()), task_queue_(task_queue) {}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
RTC_DCHECK_EQ(1, receive_streams.size());
send_stream_ = send_stream;
receive_stream_ = receive_streams[0];
@ -265,7 +265,7 @@ TEST_F(RetransmissionEndToEndTest,
private:
Clock* const clock_;
VideoSendStream* send_stream_;
VideoReceiveStream* receive_stream_;
VideoReceiveStreamInterface* receive_stream_;
TaskQueueBase* const task_queue_;
rtc::Event test_done_;
bool frame_decoded_ = false;
@ -331,7 +331,7 @@ void RetransmissionEndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = rtp_history_ms_;
(*receive_configs)[0].rtp.nack.rtp_history_ms = rtp_history_ms_;
@ -438,7 +438,7 @@ void RetransmissionEndToEndTest::DecodesRetransmittedFrame(bool enable_rtx,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

2
video/end_to_end_tests/rtp_rtcp_tests.cc
View file

@ -91,7 +91,7 @@ void RtpRtcpEndToEndTest::RespectsRtcpMode(RtcpMode rtcp_mode) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;

10
video/end_to_end_tests/ssrc_tests.cc
View file

@ -176,7 +176,7 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
encoder_config->max_bitrate_bps = 50000;
@ -190,9 +190,9 @@ void SsrcEndToEndTest::TestSendsSetSsrcs(size_t num_ssrcs,
encoder_config->number_of_streams = 1;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
@ -278,7 +278,7 @@ TEST_F(SsrcEndToEndTest, DISABLED_RedundantPayloadsTransmittedOnAllSsrcs) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
encoder_config->max_bitrate_bps = 50000;

46
video/end_to_end_tests/stats_tests.cc
View file

@ -88,7 +88,8 @@ TEST_F(StatsEndToEndTest, GetStats) {
bool CheckReceiveStats() {
for (size_t i = 0; i < receive_streams_.size(); ++i) {
VideoReceiveStream::Stats stats = receive_streams_[i]->GetStats();
VideoReceiveStreamInterface::Stats stats =
receive_streams_[i]->GetStats();
EXPECT_EQ(expected_receive_ssrcs_[i], stats.ssrc);
// Make sure all fields have been populated.
@ -243,7 +244,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Set low simulcast bitrates to not have to wait for bandwidth ramp-up.
encoder_config->max_bitrate_bps = 50000;
@ -281,9 +282,9 @@ TEST_F(StatsEndToEndTest, GetStats) {
size_t GetNumVideoStreams() const override { return kNumSimulcastStreams; }
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
receive_streams_ = receive_streams;
task_queue_ = TaskQueueBase::Current();
@ -327,7 +328,7 @@ TEST_F(StatsEndToEndTest, GetStats) {
}
test::FunctionVideoEncoderFactory encoder_factory_;
std::vector<VideoReceiveStream*> receive_streams_;
std::vector<VideoReceiveStreamInterface*> receive_streams_;
std::map<std::string, bool> receive_stats_filled_;
VideoSendStream* send_stream_ = nullptr;
@ -353,7 +354,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
private:
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
@ -365,9 +366,9 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
}
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
receive_streams_ = receive_streams;
task_queue_ = TaskQueueBase::Current();
}
@ -389,7 +390,7 @@ TEST_F(StatsEndToEndTest, TimingFramesAreReported) {
});
}
std::vector<VideoReceiveStream*> receive_streams_;
std::vector<VideoReceiveStreamInterface*> receive_streams_;
TaskQueueBase* task_queue_ = nullptr;
} test;
@ -404,9 +405,9 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
: EndToEndTest(kDefaultTimeoutMs), task_queue_(task_queue) {}
private:
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
receive_stream_ = receive_streams[0];
}
@ -416,7 +417,8 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
if (sent_rtp_ >= kNumRtpPacketsToSend) {
// Need to check the stats on the correct thread.
task_queue_->PostTask(ToQueuedTask(task_safety_flag_, [this]() {
VideoReceiveStream::Stats stats = receive_stream_->GetStats();
VideoReceiveStreamInterface::Stats stats =
receive_stream_->GetStats();
if (kNumRtpPacketsToSend == stats.rtp_stats.packet_counter.packets) {
observation_complete_.Set();
}
@ -432,7 +434,7 @@ TEST_F(StatsEndToEndTest, TestReceivedRtpPacketStats) {
<< "Timed out while verifying number of received RTP packets.";
}
VideoReceiveStream* receive_stream_ = nullptr;
VideoReceiveStreamInterface* receive_stream_ = nullptr;
uint32_t sent_rtp_ = 0;
TaskQueueBase* const task_queue_;
rtc::scoped_refptr<PendingTaskSafetyFlag> task_safety_flag_ =
@ -627,7 +629,7 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
stream_stats.rtcp_packet_type_counts.nack_packets;
}
for (const auto& receive_stream : receive_streams_) {
VideoReceiveStream::Stats stats = receive_stream->GetStats();
VideoReceiveStreamInterface::Stats stats = receive_stream->GetStats();
receive_stream_nack_packets +=
stats.rtcp_packet_type_counts.nack_packets;
}
@ -649,15 +651,15 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
(*receive_configs)[0].rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
receive_streams_ = receive_streams;
}
@ -672,7 +674,7 @@ TEST_F(StatsEndToEndTest, VerifyNackStats) {
uint64_t sent_rtp_packets_ RTC_GUARDED_BY(&mutex_) = 0;
uint16_t dropped_rtp_packet_ RTC_GUARDED_BY(&mutex_) = 0;
bool dropped_rtp_packet_requested_ RTC_GUARDED_BY(&mutex_) = false;
std::vector<VideoReceiveStream*> receive_streams_;
std::vector<VideoReceiveStreamInterface*> receive_streams_;
VideoSendStream* send_stream_ = nullptr;
absl::optional<int64_t> start_runtime_ms_;
TaskQueueBase* const task_queue_;

4
video/end_to_end_tests/transport_feedback_tests.cc
View file

@ -201,7 +201,7 @@ TEST(TransportFeedbackMultiStreamTest, AssignsTransportSequenceNumbers) {
void UpdateReceiveConfig(
size_t stream_index,
VideoReceiveStream::Config* receive_config) override {
VideoReceiveStreamInterface::Config* receive_config) override {
receive_config->rtp.nack.rtp_history_ms = kNackRtpHistoryMs;
receive_config->rtp.extensions.clear();
receive_config->rtp.extensions.push_back(
@ -292,7 +292,7 @@ class TransportFeedbackTester : public test::EndToEndTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
(*receive_configs)[0].rtp.transport_cc = feedback_enabled_;
}

8
video/frame_buffer_proxy.cc
View file

@ -166,10 +166,10 @@ Timestamp ReceiveTime(const EncodedFrame& frame) {
return *ts;
}
// Encapsulates use of the new frame buffer for use in VideoReceiveStream. This
// behaves the same as the FrameBuffer2Proxy but uses frame_buffer instead.
// Responsibilities from frame_buffer2, like stats, jitter and frame timing
// accounting are moved into this pro
// Encapsulates use of the new frame buffer for use in
// VideoReceiveStreamInterface. This behaves the same as the FrameBuffer2Proxy
// but uses frame_buffer instead. Responsibilities from frame_buffer2, like
// stats, jitter and frame timing accounting are moved into this pro
class FrameBuffer3Proxy : public FrameBufferProxy {
public:
FrameBuffer3Proxy(

2
video/quality_scaling_tests.cc
View file

@ -119,7 +119,7 @@ class ScalingObserver : public test::SendTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = payload_name_;

2
video/receive_statistics_proxy.cc
View file

@ -627,7 +627,7 @@ ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs(
return *last_estimated_playout_ntp_timestamp_ms_ + elapsed_ms;
}
VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
VideoReceiveStreamInterface::Stats ReceiveStatisticsProxy::GetStats() const {
MutexLock lock(&mutex_);
// Get current frame rates here, as only updating them on new frames prevents
// us from ever correctly displaying frame rate of 0.

6
video/receive_statistics_proxy.h
View file

@ -48,7 +48,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
const FieldTrialsView* field_trials = nullptr);
~ReceiveStatisticsProxy() = default;
VideoReceiveStream::Stats GetStats() const;
VideoReceiveStreamInterface::Stats GetStats() const;
void OnDecodedFrame(const VideoFrame& frame,
absl::optional<uint8_t> qp,
@ -94,7 +94,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
void OnRttUpdate(int64_t avg_rtt_ms, int64_t max_rtt_ms) override;
// Notification methods that are used to check our internal state and validate
// threading assumptions. These are called by VideoReceiveStream.
// threading assumptions. These are called by VideoReceiveStreamInterface.
void DecoderThreadStarting();
void DecoderThreadStopped();
@ -153,7 +153,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
int num_bad_states_ RTC_GUARDED_BY(mutex_);
int num_certain_states_ RTC_GUARDED_BY(mutex_);
// Note: The `stats_.rtp_stats` member is not used or populated by this class.
mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(mutex_);
mutable VideoReceiveStreamInterface::Stats stats_ RTC_GUARDED_BY(mutex_);
RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(mutex_);
RateStatistics renders_fps_estimator_ RTC_GUARDED_BY(mutex_);
rtc::RateTracker render_fps_tracker_ RTC_GUARDED_BY(mutex_);

6
video/receive_statistics_proxy2.cc
View file

@ -652,11 +652,11 @@ ReceiveStatisticsProxy::GetCurrentEstimatedPlayoutNtpTimestampMs(
return *last_estimated_playout_ntp_timestamp_ms_ + elapsed_ms;
}
VideoReceiveStream::Stats ReceiveStatisticsProxy::GetStats() const {
VideoReceiveStreamInterface::Stats ReceiveStatisticsProxy::GetStats() const {
RTC_DCHECK_RUN_ON(&main_thread_);
// Like VideoReceiveStream::GetStats, called on the worker thread from
// StatsCollector::ExtractMediaInfo via worker_thread()->Invoke().
// Like VideoReceiveStreamInterface::GetStats, called on the worker thread
// from StatsCollector::ExtractMediaInfo via worker_thread()->Invoke().
// WebRtcVideoChannel::GetStats(), GetVideoReceiverInfo.
// Get current frame rates here, as only updating them on new frames prevents

7
video/receive_statistics_proxy2.h
View file

@ -55,7 +55,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
const FieldTrialsView& field_trials);
~ReceiveStatisticsProxy() override;
VideoReceiveStream::Stats GetStats() const;
VideoReceiveStreamInterface::Stats GetStats() const;
void OnDecodedFrame(const VideoFrame& frame,
absl::optional<uint8_t> qp,
@ -111,7 +111,7 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
void OnRttUpdate(int64_t avg_rtt_ms);
// Notification methods that are used to check our internal state and validate
// threading assumptions. These are called by VideoReceiveStream.
// threading assumptions. These are called by VideoReceiveStreamInterface.
void DecoderThreadStarting();
void DecoderThreadStopped();
@ -168,7 +168,8 @@ class ReceiveStatisticsProxy : public VCMReceiveStatisticsCallback,
int num_bad_states_ RTC_GUARDED_BY(main_thread_);
int num_certain_states_ RTC_GUARDED_BY(main_thread_);
// Note: The `stats_.rtp_stats` member is not used or populated by this class.
mutable VideoReceiveStream::Stats stats_ RTC_GUARDED_BY(main_thread_);
mutable VideoReceiveStreamInterface::Stats stats_
RTC_GUARDED_BY(main_thread_);
// Same as stats_.ssrc, but const (no lock required).
const uint32_t remote_ssrc_;
RateStatistics decode_fps_estimator_ RTC_GUARDED_BY(main_thread_);

24
video/receive_statistics_proxy2_unittest.cc
View file

@ -54,7 +54,7 @@ class ReceiveStatisticsProxy2Test : public ::testing::Test {
protected:
// Convenience method to avoid too many explict flushes.
VideoReceiveStream::Stats FlushAndGetStats() {
VideoReceiveStreamInterface::Stats FlushAndGetStats() {
loop_.Flush();
return statistics_proxy_->GetStats();
}
@ -431,7 +431,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportInterframeDelayInWindow) {
TEST_F(ReceiveStatisticsProxy2Test, ReportsFreezeMetrics) {
const int64_t kFreezeDurationMs = 1000;
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(0u, stats.freeze_count);
EXPECT_FALSE(stats.total_freezes_duration_ms);
@ -452,7 +452,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsFreezeMetrics) {
}
TEST_F(ReceiveStatisticsProxy2Test, ReportsPauseMetrics) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.pause_count);
ASSERT_EQ(0u, stats.total_pauses_duration_ms);
@ -470,7 +470,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsPauseMetrics) {
}
TEST_F(ReceiveStatisticsProxy2Test, PauseBeforeFirstAndAfterLastFrameIgnored) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.pause_count);
ASSERT_EQ(0u, stats.total_pauses_duration_ms);
@ -493,7 +493,7 @@ TEST_F(ReceiveStatisticsProxy2Test, PauseBeforeFirstAndAfterLastFrameIgnored) {
}
TEST_F(ReceiveStatisticsProxy2Test, ReportsFramesDuration) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.total_frames_duration_ms);
webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@ -513,7 +513,7 @@ TEST_F(ReceiveStatisticsProxy2Test, ReportsFramesDuration) {
}
TEST_F(ReceiveStatisticsProxy2Test, ReportsSumSquaredFrameDurations) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.sum_squared_frame_durations);
webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@ -580,7 +580,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsOnCompleteFrame) {
const int kFrameSizeBytes = 1000;
statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
VideoContentType::UNSPECIFIED);
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(1, stats.network_frame_rate);
EXPECT_EQ(1, stats.frame_counts.key_frames);
EXPECT_EQ(0, stats.frame_counts.delta_frames);
@ -592,7 +592,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsOnDroppedFrame) {
statistics_proxy_->OnDroppedFrames(i);
dropped_frames += i;
}
VideoReceiveStream::Stats stats = FlushAndGetStats();
VideoReceiveStreamInterface::Stats stats = FlushAndGetStats();
EXPECT_EQ(dropped_frames, stats.frames_dropped);
}
@ -608,7 +608,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsDecodeTimingStats) {
statistics_proxy_->OnFrameBufferTimingsUpdated(
kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
kMinPlayoutDelayMs, kRenderDelayMs);
VideoReceiveStream::Stats stats = FlushAndGetStats();
VideoReceiveStreamInterface::Stats stats = FlushAndGetStats();
EXPECT_EQ(kMaxDecodeMs, stats.max_decode_ms);
EXPECT_EQ(kCurrentDelayMs, stats.current_delay_ms);
EXPECT_EQ(kTargetDelayMs, stats.target_delay_ms);
@ -626,7 +626,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsRtcpPacketTypeCounts) {
counter.pli_packets = kPliPackets;
counter.nack_packets = kNackPackets;
statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(kFirPackets, stats.rtcp_packet_type_counts.fir_packets);
EXPECT_EQ(kPliPackets, stats.rtcp_packet_type_counts.pli_packets);
EXPECT_EQ(kNackPackets, stats.rtcp_packet_type_counts.nack_packets);
@ -651,7 +651,7 @@ TEST_F(ReceiveStatisticsProxy2Test, GetStatsReportsFrameCounts) {
statistics_proxy_->OnCompleteFrame(false, 0, VideoContentType::UNSPECIFIED);
}
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(kKeyFrames, stats.frame_counts.key_frames);
EXPECT_EQ(kDeltaFrames, stats.frame_counts.delta_frames);
}
@ -1275,7 +1275,7 @@ INSTANTIATE_TEST_SUITE_P(_,
kFreezeDetectionCond2NotFreeze));
TEST_P(ReceiveStatisticsProxy2TestWithFreezeDuration, FreezeDetection) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(0u, stats.freeze_count);
webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);

28
video/receive_statistics_proxy_unittest.cc
View file

@ -52,8 +52,8 @@ class ReceiveStatisticsProxyTest : public ::testing::Test {
config_.rtp.remote_ssrc, &fake_clock_, &field_trials_));
}
VideoReceiveStream::Config GetTestConfig() {
VideoReceiveStream::Config config(nullptr);
VideoReceiveStreamInterface::Config GetTestConfig() {
VideoReceiveStreamInterface::Config config(nullptr);
config.rtp.local_ssrc = kLocalSsrc;
config.rtp.remote_ssrc = kRemoteSsrc;
return config;
@ -81,7 +81,7 @@ class ReceiveStatisticsProxyTest : public ::testing::Test {
test::ScopedKeyValueConfig field_trials_;
SimulatedClock fake_clock_;
const VideoReceiveStream::Config config_;
const VideoReceiveStreamInterface::Config config_;
std::unique_ptr<ReceiveStatisticsProxy> statistics_proxy_;
};
@ -313,7 +313,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportInterframeDelayInWindow) {
TEST_F(ReceiveStatisticsProxyTest, ReportsFreezeMetrics) {
const int64_t kFreezeDurationMs = 1000;
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(0u, stats.freeze_count);
EXPECT_FALSE(stats.total_freezes_duration_ms);
@ -334,7 +334,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportsFreezeMetrics) {
}
TEST_F(ReceiveStatisticsProxyTest, ReportsPauseMetrics) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.pause_count);
ASSERT_EQ(0u, stats.total_pauses_duration_ms);
@ -352,7 +352,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportsPauseMetrics) {
}
TEST_F(ReceiveStatisticsProxyTest, PauseBeforeFirstAndAfterLastFrameIgnored) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.pause_count);
ASSERT_EQ(0u, stats.total_pauses_duration_ms);
@ -375,7 +375,7 @@ TEST_F(ReceiveStatisticsProxyTest, PauseBeforeFirstAndAfterLastFrameIgnored) {
}
TEST_F(ReceiveStatisticsProxyTest, ReportsFramesDuration) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.total_frames_duration_ms);
webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@ -395,7 +395,7 @@ TEST_F(ReceiveStatisticsProxyTest, ReportsFramesDuration) {
}
TEST_F(ReceiveStatisticsProxyTest, ReportsSumSquaredFrameDurations) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
ASSERT_EQ(0u, stats.sum_squared_frame_durations);
webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);
@ -460,7 +460,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsOnCompleteFrame) {
const int kFrameSizeBytes = 1000;
statistics_proxy_->OnCompleteFrame(true, kFrameSizeBytes,
VideoContentType::UNSPECIFIED);
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(1, stats.network_frame_rate);
EXPECT_EQ(1, stats.frame_counts.key_frames);
EXPECT_EQ(0, stats.frame_counts.delta_frames);
@ -472,7 +472,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsOnDroppedFrame) {
statistics_proxy_->OnDroppedFrames(i);
dropped_frames += i;
}
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(dropped_frames, stats.frames_dropped);
}
@ -488,7 +488,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsDecodeTimingStats) {
statistics_proxy_->OnFrameBufferTimingsUpdated(
kMaxDecodeMs, kCurrentDelayMs, kTargetDelayMs, kJitterBufferMs,
kMinPlayoutDelayMs, kRenderDelayMs);
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(kMaxDecodeMs, stats.max_decode_ms);
EXPECT_EQ(kCurrentDelayMs, stats.current_delay_ms);
EXPECT_EQ(kTargetDelayMs, stats.target_delay_ms);
@ -506,7 +506,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsRtcpPacketTypeCounts) {
counter.pli_packets = kPliPackets;
counter.nack_packets = kNackPackets;
statistics_proxy_->RtcpPacketTypesCounterUpdated(kRemoteSsrc, counter);
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(kFirPackets, stats.rtcp_packet_type_counts.fir_packets);
EXPECT_EQ(kPliPackets, stats.rtcp_packet_type_counts.pli_packets);
EXPECT_EQ(kNackPackets, stats.rtcp_packet_type_counts.nack_packets);
@ -531,7 +531,7 @@ TEST_F(ReceiveStatisticsProxyTest, GetStatsReportsFrameCounts) {
statistics_proxy_->OnCompleteFrame(false, 0, VideoContentType::UNSPECIFIED);
}
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(kKeyFrames, stats.frame_counts.key_frames);
EXPECT_EQ(kDeltaFrames, stats.frame_counts.delta_frames);
}
@ -1150,7 +1150,7 @@ INSTANTIATE_TEST_SUITE_P(_,
kFreezeDetectionCond2NotFreeze));
TEST_P(ReceiveStatisticsProxyTestWithFreezeDuration, FreezeDetection) {
VideoReceiveStream::Stats stats = statistics_proxy_->GetStats();
VideoReceiveStreamInterface::Stats stats = statistics_proxy_->GetStats();
EXPECT_EQ(0u, stats.freeze_count);
webrtc::VideoFrame frame = CreateFrame(kWidth, kHeight);

4
video/rtp_video_stream_receiver.cc
View file

@ -203,7 +203,7 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
Transport* transport,
RtcpRttStats* rtt_stats,
PacketRouter* packet_router,
const VideoReceiveStream::Config* config,
const VideoReceiveStreamInterface::Config* config,
ReceiveStatistics* rtp_receive_statistics,
ReceiveStatisticsProxy* receive_stats_proxy,
ProcessThread* process_thread,
@ -234,7 +234,7 @@ RtpVideoStreamReceiver::RtpVideoStreamReceiver(
Transport* transport,
RtcpRttStats* rtt_stats,
PacketRouter* packet_router,
const VideoReceiveStream::Config* config,
const VideoReceiveStreamInterface::Config* config,
ReceiveStatistics* rtp_receive_statistics,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RtcpCnameCallback* rtcp_cname_callback,

11
video/rtp_video_stream_receiver.h
View file

@ -90,7 +90,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
// stream is registered as a candidate for sending REMB and transport
// feedback.
PacketRouter* packet_router,
const VideoReceiveStream::Config* config,
const VideoReceiveStreamInterface::Config* config,
ReceiveStatistics* rtp_receive_statistics,
ReceiveStatisticsProxy* receive_stats_proxy,
ProcessThread* process_thread,
@ -111,7 +111,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
// stream is registered as a candidate for sending REMB and transport
// feedback.
PacketRouter* packet_router,
const VideoReceiveStream::Config* config,
const VideoReceiveStreamInterface::Config* config,
ReceiveStatistics* rtp_receive_statistics,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RtcpCnameCallback* rtcp_cname_callback,
@ -201,7 +201,7 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
void SetDepacketizerToDecoderFrameTransformer(
rtc::scoped_refptr<FrameTransformerInterface> frame_transformer);
// Called by VideoReceiveStream when stats are updated.
// Called by VideoReceiveStreamInterface when stats are updated.
void UpdateRtt(int64_t max_rtt_ms);
absl::optional<int64_t> LastReceivedPacketMs() const;
@ -322,8 +322,9 @@ class RtpVideoStreamReceiver : public LossNotificationSender,
FieldTrialBasedConfig owned_field_trials_;
Clock* const clock_;
// Ownership of this object lies with VideoReceiveStream, which owns `this`.
const VideoReceiveStream::Config& config_;
// Ownership of this object lies with VideoReceiveStreamInterface, which owns
// `this`.
const VideoReceiveStreamInterface::Config& config_;
PacketRouter* const packet_router_;
ProcessThread* const process_thread_;

4
video/rtp_video_stream_receiver2.cc
View file

@ -105,7 +105,7 @@ std::unique_ptr<ModuleRtpRtcpImpl2> CreateRtpRtcpModule(
std::unique_ptr<NackRequester> MaybeConstructNackModule(
TaskQueueBase* current_queue,
NackPeriodicProcessor* nack_periodic_processor,
const VideoReceiveStream::Config& config,
const VideoReceiveStreamInterface::Config& config,
Clock* clock,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender,
@ -208,7 +208,7 @@ RtpVideoStreamReceiver2::RtpVideoStreamReceiver2(
Transport* transport,
RtcpRttStats* rtt_stats,
PacketRouter* packet_router,
const VideoReceiveStream::Config* config,
const VideoReceiveStreamInterface::Config* config,
ReceiveStatistics* rtp_receive_statistics,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RtcpCnameCallback* rtcp_cname_callback,

9
video/rtp_video_stream_receiver2.h
View file

@ -85,7 +85,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
// stream is registered as a candidate for sending REMB and transport
// feedback.
PacketRouter* packet_router,
const VideoReceiveStream::Config* config,
const VideoReceiveStreamInterface::Config* config,
ReceiveStatistics* rtp_receive_statistics,
RtcpPacketTypeCounterObserver* rtcp_packet_type_counter_observer,
RtcpCnameCallback* rtcp_cname_callback,
@ -181,7 +181,7 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
void SetRtpExtensions(const std::vector<RtpExtension>& extensions);
const RtpHeaderExtensionMap& GetRtpExtensions() const;
// Called by VideoReceiveStream when stats are updated.
// Called by VideoReceiveStreamInterface when stats are updated.
void UpdateRtt(int64_t max_rtt_ms);
// Called when the local_ssrc is changed to match with a sender.
@ -293,8 +293,9 @@ class RtpVideoStreamReceiver2 : public LossNotificationSender,
const FieldTrialsView& field_trials_;
Clock* const clock_;
// Ownership of this object lies with VideoReceiveStream, which owns `this`.
const VideoReceiveStream::Config& config_;
// Ownership of this object lies with VideoReceiveStreamInterface, which owns
// `this`.
const VideoReceiveStreamInterface::Config& config_;
PacketRouter* const packet_router_;
RemoteNtpTimeEstimator ntp_estimator_;

6
video/rtp_video_stream_receiver2_unittest.cc
View file

@ -215,8 +215,8 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test,
}
protected:
VideoReceiveStream::Config CreateConfig() {
VideoReceiveStream::Config config(nullptr);
VideoReceiveStreamInterface::Config CreateConfig() {
VideoReceiveStreamInterface::Config config(nullptr);
config.rtp.remote_ssrc = 1111;
config.rtp.local_ssrc = 2222;
config.rtp.red_payload_type = kRedPayloadType;
@ -229,7 +229,7 @@ class RtpVideoStreamReceiver2Test : public ::testing::Test,
TokenTaskQueue::CurrentTaskQueueSetter task_queue_setter_;
webrtc::test::ScopedKeyValueConfig field_trials_;
VideoReceiveStream::Config config_;
VideoReceiveStreamInterface::Config config_;
NackPeriodicProcessor nack_periodic_processor_;
MockNackSender mock_nack_sender_;
MockKeyFrameRequestSender mock_key_frame_request_sender_;

6
video/rtp_video_stream_receiver_unittest.cc
View file

@ -202,8 +202,8 @@ class RtpVideoStreamReceiverTest : public ::testing::Test {
}
protected:
static VideoReceiveStream::Config CreateConfig() {
VideoReceiveStream::Config config(nullptr);
static VideoReceiveStreamInterface::Config CreateConfig() {
VideoReceiveStreamInterface::Config config(nullptr);
config.rtp.remote_ssrc = 1111;
config.rtp.local_ssrc = 2222;
config.rtp.red_payload_type = kRedPayloadType;
@ -211,7 +211,7 @@ class RtpVideoStreamReceiverTest : public ::testing::Test {
}
webrtc::test::ScopedKeyValueConfig field_trials_;
VideoReceiveStream::Config config_;
VideoReceiveStreamInterface::Config config_;
MockNackSender mock_nack_sender_;
MockKeyFrameRequestSender mock_key_frame_request_sender_;
MockTransport mock_transport_;

5
video/video_analyzer.cc
View file

@ -188,7 +188,7 @@ void VideoAnalyzer::SetSendStream(VideoSendStream* stream) {
send_stream_ = stream;
}
void VideoAnalyzer::SetReceiveStream(VideoReceiveStream* stream) {
void VideoAnalyzer::SetReceiveStream(VideoReceiveStreamInterface* stream) {
MutexLock lock(&lock_);
RTC_DCHECK(!receive_stream_);
receive_stream_ = stream;
@ -490,7 +490,8 @@ void VideoAnalyzer::PollStats() {
last_fec_bytes_ = fec_bytes;
if (receive_stream_ != nullptr) {
VideoReceiveStream::Stats receive_stats = receive_stream_->GetStats();
VideoReceiveStreamInterface::Stats receive_stats =
receive_stream_->GetStats();
// `total_decode_time_ms` gives a good estimate of the mean decode time,
// `decode_ms` is used to keep track of the standard deviation.
if (receive_stats.frames_decoded > 0)

4
video/video_analyzer.h
View file

@ -61,7 +61,7 @@ class VideoAnalyzer : public PacketReceiver,
bool respect_sink_wants);
void SetCall(Call* call);
void SetSendStream(VideoSendStream* stream);
void SetReceiveStream(VideoReceiveStream* stream);
void SetReceiveStream(VideoReceiveStreamInterface* stream);
void SetAudioReceiveStream(AudioReceiveStream* recv_stream);
rtc::VideoSinkInterface<VideoFrame>* InputInterface();
@ -221,7 +221,7 @@ class VideoAnalyzer : public PacketReceiver,
Call* call_;
VideoSendStream* send_stream_;
VideoReceiveStream* receive_stream_;
VideoReceiveStreamInterface* receive_stream_;
AudioReceiveStream* audio_receive_stream_;
CapturedFrameForwarder captured_frame_forwarder_;
const std::string test_label_;

6
video/video_quality_test.cc
View file

@ -1011,7 +1011,7 @@ void VideoQualityTest::DestroyThumbnailStreams() {
receiver_call_->DestroyVideoSendStream(thumbnail_send_stream);
}
thumbnail_send_streams_.clear();
for (VideoReceiveStream* thumbnail_receive_stream :
for (VideoReceiveStreamInterface* thumbnail_receive_stream :
thumbnail_receive_streams_) {
sender_call_->DestroyVideoReceiveStream(thumbnail_receive_stream);
}
@ -1152,12 +1152,12 @@ void VideoQualityTest::StartAudioStreams() {
void VideoQualityTest::StartThumbnails() {
for (VideoSendStream* send_stream : thumbnail_send_streams_)
send_stream->Start();
for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
for (VideoReceiveStreamInterface* receive_stream : thumbnail_receive_streams_)
receive_stream->Start();
}
void VideoQualityTest::StopThumbnails() {
for (VideoReceiveStream* receive_stream : thumbnail_receive_streams_)
for (VideoReceiveStreamInterface* receive_stream : thumbnail_receive_streams_)
receive_stream->Stop();
for (VideoSendStream* send_stream : thumbnail_send_streams_)
send_stream->Stop();

6
video/video_quality_test.h
View file

@ -97,7 +97,7 @@ class VideoQualityTest : public test::CallTest,
bool use_real_adm);
void SetupAudio(Transport* transport);
void StartEncodedFrameLogs(VideoReceiveStream* stream);
void StartEncodedFrameLogs(VideoReceiveStreamInterface* stream);
virtual std::unique_ptr<test::LayerFilteringTransport> CreateSendTransport();
virtual std::unique_ptr<test::DirectTransport> CreateReceiveTransport();
@ -118,8 +118,8 @@ class VideoQualityTest : public test::CallTest,
std::vector<VideoSendStream::Config> thumbnail_send_configs_;
std::vector<VideoEncoderConfig> thumbnail_encoder_configs_;
std::vector<VideoSendStream*> thumbnail_send_streams_;
std::vector<VideoReceiveStream::Config> thumbnail_receive_configs_;
std::vector<VideoReceiveStream*> thumbnail_receive_streams_;
std::vector<VideoReceiveStreamInterface::Config> thumbnail_receive_configs_;
std::vector<VideoReceiveStreamInterface*> thumbnail_receive_streams_;
int receive_logs_;
int send_logs_;

9
video/video_receive_stream2.cc
View file

@ -184,8 +184,9 @@ constexpr TimeDelta kInactiveStreamThreshold = TimeDelta::Minutes(10);
} // namespace
TimeDelta DetermineMaxWaitForFrame(const VideoReceiveStream::Config& config,
bool is_keyframe) {
TimeDelta DetermineMaxWaitForFrame(
const VideoReceiveStreamInterface::Config& config,
bool is_keyframe) {
// A (arbitrary) conversion factor between the remotely signalled NACK buffer
// time (if not present defaults to 1000ms) and the maximum time we wait for a
// remote frame. Chosen to not change existing defaults when using not
@ -206,7 +207,7 @@ VideoReceiveStream2::VideoReceiveStream2(
Call* call,
int num_cpu_cores,
PacketRouter* packet_router,
VideoReceiveStream::Config config,
VideoReceiveStreamInterface::Config config,
CallStats* call_stats,
Clock* clock,
std::unique_ptr<VCMTiming> timing,
@ -532,7 +533,7 @@ void VideoReceiveStream2::CreateAndRegisterExternalDecoder(
decoder.payload_type);
}
VideoReceiveStream::Stats VideoReceiveStream2::GetStats() const {
VideoReceiveStreamInterface::Stats VideoReceiveStream2::GetStats() const {
RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
VideoReceiveStream2::Stats stats = stats_proxy_.GetStats();
stats.total_bitrate_bps = 0;

10
video/video_receive_stream2.h
View file

@ -79,7 +79,7 @@ struct VideoFrameMetaData {
};
class VideoReceiveStream2
: public webrtc::VideoReceiveStream,
: public webrtc::VideoReceiveStreamInterface,
public rtc::VideoSinkInterface<VideoFrame>,
public NackSender,
public RtpVideoStreamReceiver2::OnCompleteFrameCallback,
@ -95,7 +95,7 @@ class VideoReceiveStream2
Call* call,
int num_cpu_cores,
PacketRouter* packet_router,
VideoReceiveStream::Config config,
VideoReceiveStreamInterface::Config config,
CallStats* call_stats,
Clock* clock,
std::unique_ptr<VCMTiming> timing,
@ -135,7 +135,7 @@ class VideoReceiveStream2
// sender has been created, changed or removed.
void SetLocalSsrc(uint32_t local_ssrc);
// Implements webrtc::VideoReceiveStream.
// Implements webrtc::VideoReceiveStreamInterface.
void Start() override;
void Stop() override;
@ -143,7 +143,7 @@ class VideoReceiveStream2
RtpHeaderExtensionMap GetRtpExtensionMap() const override;
bool transport_cc() const override { return config_.rtp.transport_cc; }
webrtc::VideoReceiveStream::Stats GetStats() const override;
webrtc::VideoReceiveStreamInterface::Stats GetStats() const override;
// SetBaseMinimumPlayoutDelayMs and GetBaseMinimumPlayoutDelayMs are called
// from webrtc/api level and requested by user code. For e.g. blink/js layer
@ -225,7 +225,7 @@ class VideoReceiveStream2
TaskQueueFactory* const task_queue_factory_;
TransportAdapter transport_adapter_;
const VideoReceiveStream::Config config_;
const VideoReceiveStreamInterface::Config config_;
const int num_cpu_cores_;
Call* const call_;
Clock* const clock_;

25
video/video_receive_stream2_unittest.cc
View file

@ -226,12 +226,12 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
config_.rtp.remote_ssrc = 1111;
config_.rtp.local_ssrc = 2222;
config_.renderer = &fake_renderer_;
VideoReceiveStream::Decoder h264_decoder;
VideoReceiveStreamInterface::Decoder h264_decoder;
h264_decoder.payload_type = 99;
h264_decoder.video_format = SdpVideoFormat("H264");
h264_decoder.video_format.parameters.insert(
{"sprop-parameter-sets", "Z0IACpZTBYmI,aMljiA=="});
VideoReceiveStream::Decoder h265_decoder;
VideoReceiveStreamInterface::Decoder h265_decoder;
h265_decoder.payload_type = 100;
h265_decoder.video_format = SdpVideoFormat("H265");
@ -240,8 +240,9 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
RecreateReceiveStream();
}
void RecreateReceiveStream(absl::optional<VideoReceiveStream::RecordingState>
state = absl::nullopt) {
void RecreateReceiveStream(
absl::optional<VideoReceiveStreamInterface::RecordingState> state =
absl::nullopt) {
if (video_receive_stream_) {
video_receive_stream_->UnregisterFromTransport();
video_receive_stream_ = nullptr;
@ -266,7 +267,7 @@ class VideoReceiveStream2Test : public ::testing::TestWithParam<bool> {
test::RunLoop loop_;
NackPeriodicProcessor nack_periodic_processor_;
testing::NiceMock<MockVideoDecoderFactory> mock_h264_decoder_factory_;
VideoReceiveStream::Config config_;
VideoReceiveStreamInterface::Config config_;
internal::CallStats call_stats_;
testing::NiceMock<MockVideoDecoder> mock_decoder_;
FakeVideoRenderer fake_renderer_;
@ -600,7 +601,8 @@ TEST_P(VideoReceiveStream2Test, PassesFrameWhenEncodedFramesCallbackSet) {
EXPECT_CALL(mock_transport_, SendRtcp);
EXPECT_CALL(callback, Call);
video_receive_stream_->SetAndGetRecordingState(
VideoReceiveStream::RecordingState(callback.AsStdFunction()), true);
VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
true);
video_receive_stream_->OnCompleteFrame(
MakeFrame(VideoFrameType::kVideoFrameKey, 0));
EXPECT_TRUE(fake_renderer_.WaitForFrame(kDefaultTimeOut));
@ -613,11 +615,12 @@ TEST_P(VideoReceiveStream2Test, MovesEncodedFrameDispatchStateWhenReCreating) {
// Expect a key frame request over RTCP.
EXPECT_CALL(mock_transport_, SendRtcp).Times(1);
video_receive_stream_->SetAndGetRecordingState(
VideoReceiveStream::RecordingState(callback.AsStdFunction()), true);
VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
true);
video_receive_stream_->Stop();
VideoReceiveStream::RecordingState old_state =
VideoReceiveStreamInterface::RecordingState old_state =
video_receive_stream_->SetAndGetRecordingState(
VideoReceiveStream::RecordingState(), false);
VideoReceiveStreamInterface::RecordingState(), false);
RecreateReceiveStream(std::move(old_state));
video_receive_stream_->Stop();
}
@ -671,7 +674,7 @@ TEST_P(VideoReceiveStream2Test,
video_receive_stream_->Start();
testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
video_receive_stream_->SetAndGetRecordingState(
VideoReceiveStream::RecordingState(callback.AsStdFunction()),
VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
/*generate_key_frame=*/false);
InSequence s;
@ -694,7 +697,7 @@ TEST_P(VideoReceiveStream2Test,
video_receive_stream_->Start();
testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
video_receive_stream_->SetAndGetRecordingState(
VideoReceiveStream::RecordingState(callback.AsStdFunction()),
VideoReceiveStreamInterface::RecordingState(callback.AsStdFunction()),
/*generate_key_frame=*/false);
InSequence s;

106
video/video_send_stream_tests.cc
View file

@ -189,7 +189,7 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.c_name = kCName;
}
@ -233,7 +233,7 @@ TEST_F(VideoSendStreamTest, SupportsAbsoluteSendTime) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
@ -279,7 +279,7 @@ TEST_F(VideoSendStreamTest, SupportsTransmissionTimeOffset) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.extensions.clear();
@ -326,7 +326,7 @@ TEST_F(VideoSendStreamTest, SupportsTransportWideSequenceNumbers) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
}
@ -362,7 +362,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoRotation) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
@ -411,7 +411,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoContentType) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(RtpExtension(
@ -455,7 +455,7 @@ TEST_F(VideoSendStreamTest, SupportsVideoTimingFrames) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.extensions.clear();
send_config->rtp.extensions.push_back(
@ -606,7 +606,7 @@ class UlpfecObserver : public test::EndToEndTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
if (use_nack_) {
send_config->rtp.nack.rtp_history_ms =
@ -820,7 +820,7 @@ class FlexfecObserver : public test::EndToEndTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
if (use_nack_) {
send_config->rtp.nack.rtp_history_ms =
@ -1020,7 +1020,7 @@ void VideoSendStreamTest::TestNackRetransmission(
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
@ -1224,7 +1224,7 @@ void VideoSendStreamTest::TestPacketFragmentationSize(VideoFormat format,
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
transport_adapter_.reset(
new internal::TransportAdapter(send_config->send_transport));
@ -1357,7 +1357,7 @@ TEST_F(VideoSendStreamTest, NoPaddingWhenVideoIsMuted) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Make sure padding is sent if encoder is not producing media.
encoder_config->min_transmit_bitrate_bps = 50000;
@ -1436,7 +1436,7 @@ TEST_F(VideoSendStreamTest, PaddingIsPrimarilyRetransmissions) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Turn on RTX.
send_config->rtp.rtx.payload_type = kFakeVideoSendPayloadType;
@ -1525,9 +1525,9 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
return DROP_PACKET;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
stream_ = send_stream;
RtpRtcpInterface::Configuration config;
config.clock = Clock::GetRealTimeClock();
@ -1539,7 +1539,7 @@ TEST_F(VideoSendStreamTest, MinTransmitBitrateRespectsRemb) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
feedback_transport_.reset(
new internal::TransportAdapter(send_config->send_transport));
@ -1595,7 +1595,7 @@ TEST_F(VideoSendStreamTest, ChangingNetworkRoute) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
RTC_DCHECK_RUN_ON(&task_queue_thread_);
send_config->rtp.extensions.clear();
@ -1814,7 +1814,7 @@ TEST_F(VideoSendStreamTest, ChangingTransportOverhead) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.max_packet_size = kMaxRtpPacketSize;
}
@ -1886,7 +1886,7 @@ class MaxPaddingSetTest : public test::SendTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
RTC_DCHECK_RUN_ON(&task_queue_thread_);
RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
@ -2299,15 +2299,15 @@ TEST_F(VideoSendStreamTest, EncoderIsProperlyInitializedAndDestroyed) {
EXPECT_TRUE(IsReadyForEncode());
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
stream_ = send_stream;
}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
encoder_config_ = encoder_config->Copy();
@ -2367,7 +2367,7 @@ class VideoCodecConfigObserver : public test::SendTest,
private:
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = CodecTypeToPayloadString(video_codec_type_);
@ -2380,9 +2380,9 @@ class VideoCodecConfigObserver : public test::SendTest,
encoder_config_ = encoder_config->Copy();
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
stream_ = send_stream;
}
@ -2650,7 +2650,7 @@ TEST_F(VideoSendStreamTest, TranslatesTwoLayerScreencastToTargetBitrate) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
EXPECT_EQ(1u, encoder_config->number_of_streams);
@ -2792,7 +2792,7 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->encoder_settings.bitrate_allocator_factory = this;
@ -2809,9 +2809,9 @@ TEST_F(VideoSendStreamTest, ReconfigureBitratesSetsEncoderBitratesCorrectly) {
call_ = sender_call;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
@ -2930,7 +2930,7 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
EXPECT_EQ(kNumStreams, encoder_config->number_of_streams);
@ -2957,9 +2957,9 @@ TEST_F(VideoSendStreamTest, ReportsSentResolution) {
}
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
send_stream_ = send_stream;
}
@ -2982,7 +2982,7 @@ class Vp9HeaderObserver : public test::SendTest {
virtual void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) {}
virtual void InspectHeader(const RTPVideoHeaderVP9& vp9) = 0;
@ -2992,7 +2992,7 @@ class Vp9HeaderObserver : public test::SendTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = &encoder_factory_;
send_config->rtp.payload_name = "VP9";
@ -3390,7 +3390,7 @@ void VideoSendStreamTest::TestVp9NonFlexMode(
void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = kVideoCodecVP9;
int bitrate_bps = 0;
@ -3498,7 +3498,7 @@ TEST_F(VideoSendStreamTest, Vp9NonFlexModeSmallResolution) {
private:
void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = kVideoCodecVP9;
vp9_settings_.flexibleMode = false;
@ -3546,7 +3546,7 @@ TEST_F(VideoSendStreamTest, MAYBE_Vp9FlexModeRefCount) {
private:
void ModifyVideoConfigsHook(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->codec_type = kVideoCodecVP9;
encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
@ -3626,7 +3626,7 @@ TEST_F(VideoSendStreamTest, EncoderConfigMaxFramerateReportedToSource) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
encoder_config->simulcast_layers[0].max_framerate = kMaxFps;
}
@ -3674,7 +3674,7 @@ TEST_F(VideoSendStreamTest, RemoveOverheadFromBandwidth) {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->rtp.max_packet_size = 1200;
send_config->encoder_settings.encoder_factory = &encoder_factory_;
@ -3734,7 +3734,7 @@ class PacingFactorObserver : public test::SendTest {
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
// Check if send-side bwe extension is already present, and remove it if
// it is not desired.
@ -3766,9 +3766,9 @@ class PacingFactorObserver : public test::SendTest {
encoder_config->content_type = VideoEncoderConfig::ContentType::kScreen;
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
auto internal_send_peer = test::VideoSendStreamPeer(send_stream);
// Video streams created, check that pacing factor is correctly configured.
EXPECT_EQ(expected_pacing_factor_,
@ -3835,16 +3835,16 @@ class ContentSwitchTest : public test::SendTest {
RTC_DCHECK(stream_resetter_);
}
void OnVideoStreamsCreated(
VideoSendStream* send_stream,
const std::vector<VideoReceiveStream*>& receive_streams) override {
void OnVideoStreamsCreated(VideoSendStream* send_stream,
const std::vector<VideoReceiveStreamInterface*>&
receive_streams) override {
MutexLock lock(&mutex_);
send_stream_ = send_stream;
}
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
RTC_DCHECK_EQ(1, encoder_config->number_of_streams);
encoder_config->min_transmit_bitrate_bps = 0;
@ -4017,7 +4017,7 @@ void VideoSendStreamTest::TestTemporalLayers(
void ModifyVideoConfigs(
VideoSendStream::Config* send_config,
std::vector<VideoReceiveStream::Config>* receive_configs,
std::vector<VideoReceiveStreamInterface::Config>* receive_configs,
VideoEncoderConfig* encoder_config) override {
send_config->encoder_settings.encoder_factory = encoder_factory_;
send_config->rtp.payload_name = payload_name_;