admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Combine VideoReceiveStream2TestWithFakeDecoder into the main test suite

Browse Source 
This is achieved by wrapping a fake decoder inside the mock decoder, in
a sort of spy pattern.

This is preperation for moving the FrameBufferProxy tests into the main
VideoReceiveStream2 suite.

Bug: webrtc:14003
Change-Id: I7b9691cc5a1a8a3fadfb7aa6981752b647d5c73f
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/260113
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Evan Shrubsole <eshr@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#36691}
This commit is contained in:
Evan Shrubsole 2022-04-26 16:01:44 +02:00 committed by WebRTC LUCI CQ
parent 1c18477070
commit 14ee8037b0
1 changed files with 34 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
video/video_receive_stream2_unittest.cc
View File

@ -68,6 +68,7 @@ using ::testing::SizeIs;
using ::testing::WithoutArgs;
constexpr int kDefaultTimeOutMs = 50;
constexpr int kDefaultNumCpuCores = 2;
} // namespace
@ -81,10 +82,25 @@ class VideoReceiveStream2Test : public ::testing::Test {
fake_call_.SetFieldTrial("WebRTC-FrameBuffer3/arm:FrameBuffer3/");
// By default, mock decoder factory is backed by VideoDecoderProxyFactory.
ON_CALL(mock_h264_decoder_factory_, CreateVideoDecoder(_))
ON_CALL(mock_h264_decoder_factory_, CreateVideoDecoder)
.WillByDefault(testing::Invoke(
&h264_decoder_factory_,
&test::VideoDecoderProxyFactory::CreateVideoDecoder));
// By default, mock decode will wrap the fake decoder.
ON_CALL(mock_h264_video_decoder_, Configure)
.WillByDefault(
testing::Invoke(&fake_decoder_, &test::FakeDecoder::Configure));
ON_CALL(mock_h264_video_decoder_, Decode)
.WillByDefault(
testing::Invoke(&fake_decoder_, &test::FakeDecoder::Decode));
ON_CALL(mock_h264_video_decoder_, RegisterDecodeCompleteCallback)
.WillByDefault(testing::Invoke(
&fake_decoder_,
&test::FakeDecoder::RegisterDecodeCompleteCallback));
ON_CALL(mock_h264_video_decoder_, Release)
.WillByDefault(
testing::Invoke(&fake_decoder_, &test::FakeDecoder::Release));
}
~VideoReceiveStream2Test() override {
if (video_receive_stream_)
@ -92,7 +108,6 @@ class VideoReceiveStream2Test : public ::testing::Test {
}
void SetUp() override {
constexpr int kDefaultNumCpuCores = 2;
config_.rtp.remote_ssrc = 1111;
config_.rtp.local_ssrc = 2222;
config_.renderer = &fake_renderer_;
@ -108,8 +123,16 @@ class VideoReceiveStream2Test : public ::testing::Test {
config_.decoders = {h265_decoder, h264_decoder};
clock_ = Clock::GetRealTimeClock();
timing_ = new VCMTiming(clock_, fake_call_.trials());
ReCreateReceiveStream(VideoReceiveStream::RecordingState());
}
void ReCreateReceiveStream(VideoReceiveStream::RecordingState state) {
if (video_receive_stream_) {
video_receive_stream_->UnregisterFromTransport();
video_receive_stream_ = nullptr;
}
timing_ = new VCMTiming(clock_, fake_call_.trials());
video_receive_stream_ =
std::make_unique<webrtc::internal::VideoReceiveStream2>(
task_queue_factory_.get(), &fake_call_, kDefaultNumCpuCores,
@ -117,6 +140,7 @@ class VideoReceiveStream2Test : public ::testing::Test {
absl::WrapUnique(timing_), &nack_periodic_processor_, nullptr);
video_receive_stream_->RegisterWithTransport(
&rtp_stream_receiver_controller_);
video_receive_stream_->SetAndGetRecordingState(std::move(state), false);
}
protected:
@ -138,6 +162,7 @@ class VideoReceiveStream2Test : public ::testing::Test {
private:
test::VideoDecoderProxyFactory h264_decoder_factory_;
test::FakeDecoder fake_decoder_;
};
TEST_F(VideoReceiveStream2Test, CreateFrameFromH264FmtpSpropAndIdr) {
@ -314,66 +339,7 @@ TEST_F(VideoReceiveStream2Test, LazyDecoderCreation) {
init_decode_event.Wait(kDefaultTimeOutMs);
}
class VideoReceiveStream2TestWithFakeDecoder : public ::testing::Test {
public:
VideoReceiveStream2TestWithFakeDecoder()
: fake_decoder_factory_(
[]() { return std::make_unique<test::FakeDecoder>(); }),
task_queue_factory_(CreateDefaultTaskQueueFactory()),
config_(&mock_transport_, &fake_decoder_factory_),
call_stats_(Clock::GetRealTimeClock(), loop_.task_queue()) {}
~VideoReceiveStream2TestWithFakeDecoder() override {
if (video_receive_stream_)
video_receive_stream_->UnregisterFromTransport();
}
void SetUp() override {
config_.rtp.remote_ssrc = 1111;
config_.rtp.local_ssrc = 2222;
config_.renderer = &fake_renderer_;
VideoReceiveStream::Decoder fake_decoder;
fake_decoder.payload_type = 99;
fake_decoder.video_format = SdpVideoFormat("VP8");
config_.decoders.push_back(fake_decoder);
clock_ = Clock::GetRealTimeClock();
ReCreateReceiveStream(VideoReceiveStream::RecordingState());
}
void ReCreateReceiveStream(VideoReceiveStream::RecordingState state) {
constexpr int kDefaultNumCpuCores = 2;
if (video_receive_stream_) {
video_receive_stream_->UnregisterFromTransport();
video_receive_stream_ = nullptr;
}
timing_ = new VCMTiming(clock_, fake_call_.trials());
video_receive_stream_ =
std::make_unique<webrtc::internal::VideoReceiveStream2>(
task_queue_factory_.get(), &fake_call_, kDefaultNumCpuCores,
&packet_router_, config_.Copy(), &call_stats_, clock_,
absl::WrapUnique(timing_), &nack_periodic_processor_, nullptr);
video_receive_stream_->RegisterWithTransport(
&rtp_stream_receiver_controller_);
video_receive_stream_->SetAndGetRecordingState(std::move(state), false);
}
protected:
test::RunLoop loop_;
test::FunctionVideoDecoderFactory fake_decoder_factory_;
const std::unique_ptr<TaskQueueFactory> task_queue_factory_;
NackPeriodicProcessor nack_periodic_processor_;
VideoReceiveStream::Config config_;
internal::CallStats call_stats_;
cricket::FakeVideoRenderer fake_renderer_;
MockTransport mock_transport_;
PacketRouter packet_router_;
RtpStreamReceiverController rtp_stream_receiver_controller_;
cricket::FakeCall fake_call_;
std::unique_ptr<webrtc::internal::VideoReceiveStream2> video_receive_stream_;
Clock* clock_;
VCMTiming* timing_;
};
TEST_F(VideoReceiveStream2TestWithFakeDecoder, PassesNtpTime) {
TEST_F(VideoReceiveStream2Test, PassesNtpTime) {
const Timestamp kNtpTimestamp = Timestamp::Millis(12345);
std::unique_ptr<test::FakeEncodedFrame> test_frame =
test::FakeFrameBuilder()
@ -389,7 +355,7 @@ TEST_F(VideoReceiveStream2TestWithFakeDecoder, PassesNtpTime) {
EXPECT_EQ(kNtpTimestamp.ms(), fake_renderer_.ntp_time_ms());
}
TEST_F(VideoReceiveStream2TestWithFakeDecoder, PassesRotation) {
TEST_F(VideoReceiveStream2Test, PassesRotation) {
const webrtc::VideoRotation kRotation = webrtc::kVideoRotation_180;
std::unique_ptr<test::FakeEncodedFrame> test_frame = test::FakeFrameBuilder()
.Id(0)
@ -405,7 +371,7 @@ TEST_F(VideoReceiveStream2TestWithFakeDecoder, PassesRotation) {
EXPECT_EQ(kRotation, fake_renderer_.rotation());
}
TEST_F(VideoReceiveStream2TestWithFakeDecoder, PassesPacketInfos) {
TEST_F(VideoReceiveStream2Test, PassesPacketInfos) {
RtpPacketInfos packet_infos = CreatePacketInfos(3);
auto test_frame = test::FakeFrameBuilder()
.Id(0)
@ -421,7 +387,7 @@ TEST_F(VideoReceiveStream2TestWithFakeDecoder, PassesPacketInfos) {
EXPECT_THAT(fake_renderer_.packet_infos(), ElementsAreArray(packet_infos));
}
TEST_F(VideoReceiveStream2TestWithFakeDecoder, RenderedFrameUpdatesGetSources) {
TEST_F(VideoReceiveStream2Test, RenderedFrameUpdatesGetSources) {
constexpr uint32_t kSsrc = 1111;
constexpr uint32_t kCsrc = 9001;
constexpr uint32_t kRtpTimestamp = 12345;
@ -516,8 +482,7 @@ std::unique_ptr<test::FakeEncodedFrame> MakeFrame(VideoFrameType frame_type,
return MakeFrameWithResolution(frame_type, picture_id, 320, 240);
}
TEST_F(VideoReceiveStream2TestWithFakeDecoder,
PassesFrameWhenEncodedFramesCallbackSet) {
TEST_F(VideoReceiveStream2Test, PassesFrameWhenEncodedFramesCallbackSet) {
testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
video_receive_stream_->Start();
// Expect a keyframe request to be generated
@ -531,8 +496,7 @@ TEST_F(VideoReceiveStream2TestWithFakeDecoder,
video_receive_stream_->Stop();
}
TEST_F(VideoReceiveStream2TestWithFakeDecoder,
MovesEncodedFrameDispatchStateWhenReCreating) {
TEST_F(VideoReceiveStream2Test, MovesEncodedFrameDispatchStateWhenReCreating) {
testing::MockFunction<void(const RecordableEncodedFrame&)> callback;
video_receive_stream_->Start();
// Expect a key frame request over RTCP.