blob: ad00e6449f0c4d28f99efc2227cba905d8e528d6 [file] [log] [blame]
/*
* Copyright (c) 2023 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/source/rtp_sender_video_frame_transformer_delegate.h"
#include <utility>
#include "api/test/mock_transformable_video_frame.h"
#include "rtc_base/event.h"
#include "test/gmock.h"
#include "test/gtest.h"
#include "test/mock_frame_transformer.h"
#include "test/time_controller/simulated_time_controller.h"
namespace webrtc {
namespace {
using ::testing::_;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::SaveArg;
using ::testing::WithoutArgs;
class MockRTPVideoFrameSenderInterface : public RTPVideoFrameSenderInterface {
public:
MOCK_METHOD(bool,
SendVideo,
(int payload_type,
absl::optional<VideoCodecType> codec_type,
uint32_t rtp_timestamp,
Timestamp capture_time,
rtc::ArrayView<const uint8_t> payload,
size_t encoder_output_size,
RTPVideoHeader video_header,
TimeDelta expected_retransmission_time,
std::vector<uint32_t> csrcs),
(override));
MOCK_METHOD(void,
SetVideoStructureAfterTransformation,
(const FrameDependencyStructure* video_structure),
(override));
MOCK_METHOD(void,
SetVideoLayersAllocationAfterTransformation,
(VideoLayersAllocation allocation),
(override));
};
class RtpSenderVideoFrameTransformerDelegateTest : public ::testing::Test {
protected:
RtpSenderVideoFrameTransformerDelegateTest()
: frame_transformer_(rtc::make_ref_counted<MockFrameTransformer>()),
time_controller_(Timestamp::Seconds(0)) {}
~RtpSenderVideoFrameTransformerDelegateTest() override = default;
std::unique_ptr<TransformableFrameInterface> GetTransformableFrame(
rtc::scoped_refptr<RTPSenderVideoFrameTransformerDelegate> delegate,
bool key_frame = false) {
EncodedImage encoded_image;
encoded_image.SetEncodedData(EncodedImageBuffer::Create(1));
encoded_image._frameType = key_frame ? VideoFrameType::kVideoFrameKey
: VideoFrameType::kVideoFrameDelta;
std::unique_ptr<TransformableFrameInterface> frame = nullptr;
EXPECT_CALL(*frame_transformer_, Transform)
.WillOnce([&](std::unique_ptr<TransformableFrameInterface>
frame_to_transform) {
frame = std::move(frame_to_transform);
});
RTPVideoHeader rtp_header;
VideoFrameMetadata metadata;
metadata.SetCodec(VideoCodecType::kVideoCodecVP8);
metadata.SetRTPVideoHeaderCodecSpecifics(RTPVideoHeaderVP8());
delegate->TransformFrame(
/*payload_type=*/1, VideoCodecType::kVideoCodecVP8, /*rtp_timestamp=*/2,
encoded_image, RTPVideoHeader::FromMetadata(metadata),
/*expected_retransmission_time=*/TimeDelta::PlusInfinity());
return frame;
}
MockRTPVideoFrameSenderInterface test_sender_;
rtc::scoped_refptr<MockFrameTransformer> frame_transformer_;
GlobalSimulatedTimeController time_controller_;
};
TEST_F(RtpSenderVideoFrameTransformerDelegateTest,
RegisterTransformedFrameCallbackSinkOnInit) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
EXPECT_CALL(*frame_transformer_,
RegisterTransformedFrameSinkCallback(_, 1111));
delegate->Init();
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest,
UnregisterTransformedFrameSinkCallbackOnReset) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
EXPECT_CALL(*frame_transformer_,
UnregisterTransformedFrameSinkCallback(1111));
delegate->Reset();
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest,
TransformFrameCallsTransform) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
EncodedImage encoded_image;
EXPECT_CALL(*frame_transformer_, Transform);
delegate->TransformFrame(
/*payload_type=*/1, VideoCodecType::kVideoCodecVP8, /*rtp_timestamp=*/2,
encoded_image, RTPVideoHeader(),
/*expected_retransmission_time=*/TimeDelta::PlusInfinity());
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest,
OnTransformedFrameCallsSenderSendVideo) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
rtc::scoped_refptr<TransformedFrameCallback> callback;
EXPECT_CALL(*frame_transformer_, RegisterTransformedFrameSinkCallback)
.WillOnce(SaveArg<0>(&callback));
delegate->Init();
ASSERT_TRUE(callback);
std::unique_ptr<TransformableFrameInterface> frame =
GetTransformableFrame(delegate);
ASSERT_TRUE(frame);
EXPECT_STRCASEEQ("video/VP8", frame->GetMimeType().c_str());
rtc::Event event;
EXPECT_CALL(test_sender_, SendVideo).WillOnce(WithoutArgs([&] {
event.Set();
return true;
}));
callback->OnTransformedFrame(std::move(frame));
event.Wait(TimeDelta::Seconds(1));
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest, CloneSenderVideoFrame) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
std::unique_ptr<TransformableFrameInterface> frame =
GetTransformableFrame(delegate);
ASSERT_TRUE(frame);
auto& video_frame = static_cast<TransformableVideoFrameInterface&>(*frame);
std::unique_ptr<TransformableVideoFrameInterface> clone =
CloneSenderVideoFrame(&video_frame);
EXPECT_EQ(clone->IsKeyFrame(), video_frame.IsKeyFrame());
EXPECT_EQ(clone->GetPayloadType(), video_frame.GetPayloadType());
EXPECT_EQ(clone->GetMimeType(), video_frame.GetMimeType());
EXPECT_EQ(clone->GetSsrc(), video_frame.GetSsrc());
EXPECT_EQ(clone->GetTimestamp(), video_frame.GetTimestamp());
EXPECT_EQ(clone->Metadata(), video_frame.Metadata());
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest, CloneKeyFrame) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
std::unique_ptr<TransformableFrameInterface> frame =
GetTransformableFrame(delegate, /*key_frame=*/true);
ASSERT_TRUE(frame);
auto& video_frame = static_cast<TransformableVideoFrameInterface&>(*frame);
std::unique_ptr<TransformableVideoFrameInterface> clone =
CloneSenderVideoFrame(&video_frame);
EXPECT_EQ(clone->IsKeyFrame(), video_frame.IsKeyFrame());
EXPECT_EQ(clone->GetPayloadType(), video_frame.GetPayloadType());
EXPECT_EQ(clone->GetMimeType(), video_frame.GetMimeType());
EXPECT_EQ(clone->GetSsrc(), video_frame.GetSsrc());
EXPECT_EQ(clone->GetTimestamp(), video_frame.GetTimestamp());
EXPECT_EQ(clone->Metadata(), video_frame.Metadata());
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest, MetadataAfterSetMetadata) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
std::unique_ptr<TransformableFrameInterface> frame =
GetTransformableFrame(delegate);
ASSERT_TRUE(frame);
auto& video_frame = static_cast<TransformableVideoFrameInterface&>(*frame);
VideoFrameMetadata metadata;
metadata.SetFrameType(VideoFrameType::kVideoFrameKey);
metadata.SetFrameId(654);
metadata.SetSsrc(2222);
metadata.SetCsrcs({1, 2, 3});
video_frame.SetMetadata(metadata);
VideoFrameMetadata actual_metadata = video_frame.Metadata();
// TODO(bugs.webrtc.org/14708): Just EXPECT_EQ the whole Metadata once the
// equality operator lands.
EXPECT_EQ(metadata.GetFrameType(), actual_metadata.GetFrameType());
EXPECT_EQ(metadata.GetFrameId(), actual_metadata.GetFrameId());
EXPECT_EQ(metadata.GetSsrc(), actual_metadata.GetSsrc());
EXPECT_EQ(metadata.GetCsrcs(), actual_metadata.GetCsrcs());
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest,
ReceiverFrameConvertedToSenderFrame) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
const uint8_t payload_type = 1;
const uint32_t timestamp = 2;
const std::vector<uint32_t> frame_csrcs = {123, 456, 789};
auto mock_receiver_frame =
std::make_unique<NiceMock<MockTransformableVideoFrame>>();
ON_CALL(*mock_receiver_frame, GetDirection)
.WillByDefault(Return(TransformableFrameInterface::Direction::kReceiver));
VideoFrameMetadata metadata;
metadata.SetCodec(kVideoCodecVP8);
metadata.SetRTPVideoHeaderCodecSpecifics(RTPVideoHeaderVP8());
metadata.SetCsrcs(frame_csrcs);
ON_CALL(*mock_receiver_frame, Metadata).WillByDefault(Return(metadata));
rtc::ArrayView<const uint8_t> buffer =
(rtc::ArrayView<const uint8_t>)*EncodedImageBuffer::Create(1);
ON_CALL(*mock_receiver_frame, GetData).WillByDefault(Return(buffer));
ON_CALL(*mock_receiver_frame, GetPayloadType)
.WillByDefault(Return(payload_type));
ON_CALL(*mock_receiver_frame, GetTimestamp).WillByDefault(Return(timestamp));
rtc::scoped_refptr<TransformedFrameCallback> callback;
EXPECT_CALL(*frame_transformer_, RegisterTransformedFrameSinkCallback)
.WillOnce(SaveArg<0>(&callback));
delegate->Init();
ASSERT_TRUE(callback);
rtc::Event event;
EXPECT_CALL(
test_sender_,
SendVideo(payload_type, absl::make_optional(kVideoCodecVP8), timestamp,
/*capture_time=*/Timestamp::MinusInfinity(), buffer, _, _,
/*expected_retransmission_time=*/TimeDelta::PlusInfinity(),
frame_csrcs))
.WillOnce(WithoutArgs([&] {
event.Set();
return true;
}));
callback->OnTransformedFrame(std::move(mock_receiver_frame));
event.Wait(TimeDelta::Seconds(1));
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest, SettingRTPTimestamp) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
std::unique_ptr<TransformableFrameInterface> frame =
GetTransformableFrame(delegate);
ASSERT_TRUE(frame);
auto& video_frame = static_cast<TransformableVideoFrameInterface&>(*frame);
uint32_t rtp_timestamp = 12345;
ASSERT_FALSE(video_frame.GetTimestamp() == rtp_timestamp);
video_frame.SetRTPTimestamp(rtp_timestamp);
EXPECT_EQ(video_frame.GetTimestamp(), rtp_timestamp);
}
TEST_F(RtpSenderVideoFrameTransformerDelegateTest,
ShortCircuitingSkipsTransform) {
auto delegate = rtc::make_ref_counted<RTPSenderVideoFrameTransformerDelegate>(
&test_sender_, frame_transformer_,
/*ssrc=*/1111, time_controller_.CreateTaskQueueFactory().get());
EXPECT_CALL(*frame_transformer_,
RegisterTransformedFrameSinkCallback(_, 1111));
delegate->Init();
delegate->StartShortCircuiting();
// Will not call the actual transformer.
EXPECT_CALL(*frame_transformer_, Transform).Times(0);
// Will pass the frame straight to the reciever.
EXPECT_CALL(test_sender_, SendVideo);
EncodedImage encoded_image;
encoded_image.SetEncodedData(EncodedImageBuffer::Create(1));
delegate->TransformFrame(
/*payload_type=*/1, VideoCodecType::kVideoCodecVP8, /*rtp_timestamp=*/2,
encoded_image, RTPVideoHeader(),
/*expected_retransmission_time=*/TimeDelta::PlusInfinity());
}
} // namespace
} // namespace webrtc