From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- .../libwebrtc/call/rtx_receive_stream_unittest.cc | 271 +++++++++++++++++++++ 1 file changed, 271 insertions(+) create mode 100644 third_party/libwebrtc/call/rtx_receive_stream_unittest.cc (limited to 'third_party/libwebrtc/call/rtx_receive_stream_unittest.cc') diff --git a/third_party/libwebrtc/call/rtx_receive_stream_unittest.cc b/third_party/libwebrtc/call/rtx_receive_stream_unittest.cc new file mode 100644 index 0000000000..b06990820f --- /dev/null +++ b/third_party/libwebrtc/call/rtx_receive_stream_unittest.cc @@ -0,0 +1,271 @@ +/* + * Copyright (c) 2017 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 "call/rtx_receive_stream.h" + +#include "call/test/mock_rtp_packet_sink_interface.h" +#include "modules/rtp_rtcp/include/rtp_header_extension_map.h" +#include "modules/rtp_rtcp/source/rtp_header_extensions.h" +#include "modules/rtp_rtcp/source/rtp_packet_received.h" +#include "test/gmock.h" +#include "test/gtest.h" + +namespace webrtc { + +namespace { + +using ::testing::_; +using ::testing::Property; +using ::testing::StrictMock; + +constexpr int kMediaPayloadType = 100; +constexpr int kRtxPayloadType = 98; +constexpr int kUnknownPayloadType = 90; +constexpr uint32_t kMediaSSRC = 0x3333333; +constexpr uint16_t kMediaSeqno = 0x5657; + +constexpr uint8_t kRtxPacket[] = { + 0x80, // Version 2. + 98, // Payload type. + 0x12, + 0x34, // Seqno. + 0x11, + 0x11, + 0x11, + 0x11, // Timestamp. + 0x22, + 0x22, + 0x22, + 0x22, // SSRC. + // RTX header. + 0x56, + 0x57, // Orig seqno. + // Payload. + 0xee, +}; + +constexpr uint8_t kRtxPacketWithPadding[] = { + 0xa0, // Version 2, P set + 98, // Payload type. + 0x12, + 0x34, // Seqno. + 0x11, + 0x11, + 0x11, + 0x11, // Timestamp. + 0x22, + 0x22, + 0x22, + 0x22, // SSRC. + // RTX header. + 0x56, + 0x57, // Orig seqno. + // Padding + 0x1, +}; + +constexpr uint8_t kRtxPacketWithCVO[] = { + 0x90, // Version 2, X set. + 98, // Payload type. + 0x12, + 0x34, // Seqno. + 0x11, + 0x11, + 0x11, + 0x11, // Timestamp. + 0x22, + 0x22, + 0x22, + 0x22, // SSRC. + 0xbe, + 0xde, + 0x00, + 0x01, // Extension header. + 0x30, + 0x01, + 0x00, + 0x00, // 90 degree rotation. + // RTX header. + 0x56, + 0x57, // Orig seqno. + // Payload. + 0xee, +}; + +std::map PayloadTypeMapping() { + const std::map m = {{kRtxPayloadType, kMediaPayloadType}}; + return m; +} + +template +rtc::ArrayView Truncate(rtc::ArrayView a, size_t drop) { + return a.subview(0, a.size() - drop); +} + +} // namespace + +TEST(RtxReceiveStreamTest, RestoresPacketPayload) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpPacketReceived rtx_packet; + EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView(kRtxPacket))); + + EXPECT_CALL(media_sink, OnRtpPacket) + .WillOnce([](const RtpPacketReceived& packet) { + EXPECT_EQ(packet.SequenceNumber(), kMediaSeqno); + EXPECT_EQ(packet.Ssrc(), kMediaSSRC); + EXPECT_EQ(packet.PayloadType(), kMediaPayloadType); + EXPECT_THAT(packet.payload(), ::testing::ElementsAre(0xee)); + }); + + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, SetsRecoveredFlag) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpPacketReceived rtx_packet; + EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView(kRtxPacket))); + EXPECT_FALSE(rtx_packet.recovered()); + EXPECT_CALL(media_sink, OnRtpPacket) + .WillOnce([](const RtpPacketReceived& packet) { + EXPECT_TRUE(packet.recovered()); + }); + + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, IgnoresUnknownPayloadType) { + StrictMock media_sink; + const std::map payload_type_mapping = { + {kUnknownPayloadType, kMediaPayloadType}}; + + RtxReceiveStream rtx_sink(&media_sink, payload_type_mapping, kMediaSSRC); + RtpPacketReceived rtx_packet; + EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView(kRtxPacket))); + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, IgnoresTruncatedPacket) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpPacketReceived rtx_packet; + EXPECT_TRUE( + rtx_packet.Parse(Truncate(rtc::ArrayView(kRtxPacket), 2))); + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, CopiesRtpHeaderExtensions) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpHeaderExtensionMap extension_map; + extension_map.RegisterByType(3, kRtpExtensionVideoRotation); + RtpPacketReceived rtx_packet(&extension_map); + EXPECT_TRUE( + rtx_packet.Parse(rtc::ArrayView(kRtxPacketWithCVO))); + + VideoRotation rotation = kVideoRotation_0; + EXPECT_TRUE(rtx_packet.GetExtension(&rotation)); + EXPECT_EQ(kVideoRotation_90, rotation); + + EXPECT_CALL(media_sink, OnRtpPacket) + .WillOnce([](const RtpPacketReceived& packet) { + EXPECT_EQ(packet.SequenceNumber(), kMediaSeqno); + EXPECT_EQ(packet.Ssrc(), kMediaSSRC); + EXPECT_EQ(packet.PayloadType(), kMediaPayloadType); + EXPECT_THAT(packet.payload(), ::testing::ElementsAre(0xee)); + VideoRotation rotation = kVideoRotation_0; + EXPECT_TRUE(packet.GetExtension(&rotation)); + EXPECT_EQ(rotation, kVideoRotation_90); + }); + + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, PropagatesArrivalTime) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpPacketReceived rtx_packet(nullptr); + EXPECT_TRUE(rtx_packet.Parse(rtc::ArrayView(kRtxPacket))); + rtx_packet.set_arrival_time(Timestamp::Millis(123)); + EXPECT_CALL(media_sink, OnRtpPacket(Property(&RtpPacketReceived::arrival_time, + Timestamp::Millis(123)))); + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, SupportsLargePacket) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpPacketReceived rtx_packet; + constexpr int kRtxPacketSize = 2000; + constexpr int kRtxPayloadOffset = 14; + uint8_t large_rtx_packet[kRtxPacketSize]; + memcpy(large_rtx_packet, kRtxPacket, sizeof(kRtxPacket)); + rtc::ArrayView payload(large_rtx_packet + kRtxPayloadOffset, + kRtxPacketSize - kRtxPayloadOffset); + + // Fill payload. + for (size_t i = 0; i < payload.size(); i++) { + payload[i] = i; + } + EXPECT_TRUE( + rtx_packet.Parse(rtc::ArrayView(large_rtx_packet))); + + EXPECT_CALL(media_sink, OnRtpPacket) + .WillOnce([&](const RtpPacketReceived& packet) { + EXPECT_EQ(packet.SequenceNumber(), kMediaSeqno); + EXPECT_EQ(packet.Ssrc(), kMediaSSRC); + EXPECT_EQ(packet.PayloadType(), kMediaPayloadType); + EXPECT_THAT(packet.payload(), ::testing::ElementsAreArray(payload)); + }); + + rtx_sink.OnRtpPacket(rtx_packet); +} + +TEST(RtxReceiveStreamTest, SupportsLargePacketWithPadding) { + StrictMock media_sink; + RtxReceiveStream rtx_sink(&media_sink, PayloadTypeMapping(), kMediaSSRC); + RtpPacketReceived rtx_packet; + constexpr int kRtxPacketSize = 2000; + constexpr int kRtxPayloadOffset = 14; + constexpr int kRtxPaddingSize = 50; + uint8_t large_rtx_packet[kRtxPacketSize]; + memcpy(large_rtx_packet, kRtxPacketWithPadding, + sizeof(kRtxPacketWithPadding)); + rtc::ArrayView payload( + large_rtx_packet + kRtxPayloadOffset, + kRtxPacketSize - kRtxPayloadOffset - kRtxPaddingSize); + rtc::ArrayView padding( + large_rtx_packet + kRtxPacketSize - kRtxPaddingSize, kRtxPaddingSize); + + // Fill payload. + for (size_t i = 0; i < payload.size(); i++) { + payload[i] = i; + } + // Fill padding. Only value of last padding byte matters. + for (size_t i = 0; i < padding.size(); i++) { + padding[i] = kRtxPaddingSize; + } + + EXPECT_TRUE( + rtx_packet.Parse(rtc::ArrayView(large_rtx_packet))); + + EXPECT_CALL(media_sink, OnRtpPacket) + .WillOnce([&](const RtpPacketReceived& packet) { + EXPECT_EQ(packet.SequenceNumber(), kMediaSeqno); + EXPECT_EQ(packet.Ssrc(), kMediaSSRC); + EXPECT_EQ(packet.PayloadType(), kMediaPayloadType); + EXPECT_THAT(packet.payload(), ::testing::ElementsAreArray(payload)); + }); + + rtx_sink.OnRtpPacket(rtx_packet); +} + +} // namespace webrtc -- cgit v1.2.3