blob: 40a615e93cebea12ccadb5065f0c90f9ca3d6319 [file] [log] [blame]
/*
* 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/rtp_demuxer.h"
#include <cstddef>
#include <cstdint>
#include <memory>
#include <set>
#include <string>
#include "absl/strings/string_view.h"
#include "call/test/mock_rtp_packet_sink_interface.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/checks.h"
#include "rtc_base/numerics/safe_conversions.h"
#include "test/gmock.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
using ::testing::_;
using ::testing::AtLeast;
using ::testing::InSequence;
using ::testing::NiceMock;
class RtpDemuxerTest : public ::testing::Test {
protected:
~RtpDemuxerTest() {
for (auto* sink : sinks_to_tear_down_) {
demuxer_.RemoveSink(sink);
}
}
// These are convenience methods for calling demuxer.AddSink with different
// parameters and will ensure that the sink is automatically removed when the
// test case finishes.
bool AddSink(const RtpDemuxerCriteria& criteria,
RtpPacketSinkInterface* sink) {
bool added = demuxer_.AddSink(criteria, sink);
if (added) {
sinks_to_tear_down_.insert(sink);
}
return added;
}
bool AddSinkOnlySsrc(uint32_t ssrc, RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria;
criteria.ssrcs().insert(ssrc);
return AddSink(criteria, sink);
}
bool AddSinkOnlyRsid(absl::string_view rsid, RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(absl::string_view(), rsid);
return AddSink(criteria, sink);
}
bool AddSinkOnlyMid(absl::string_view mid, RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(mid);
return AddSink(criteria, sink);
}
bool AddSinkBothMidRsid(absl::string_view mid,
absl::string_view rsid,
RtpPacketSinkInterface* sink) {
RtpDemuxerCriteria criteria(mid, rsid);
return AddSink(criteria, sink);
}
bool RemoveSink(RtpPacketSinkInterface* sink) {
sinks_to_tear_down_.erase(sink);
return demuxer_.RemoveSink(sink);
}
// The CreatePacket* methods are helpers for creating new RTP packets with
// various attributes set. Tests should use the helper that provides the
// minimum information needed to exercise the behavior under test. Tests also
// should not rely on any behavior which is not clearly described in the
// helper name/arguments. Any additional settings that are not covered by the
// helper should be set manually on the packet once it has been returned.
// For example, most tests in this file do not care about the RTP sequence
// number, but to ensure that the returned packets are valid the helpers will
// auto-increment the sequence number starting with 1. Tests that rely on
// specific sequence number behavior should call SetSequenceNumber manually on
// the returned packet.
// Intended for use only by other CreatePacket* helpers.
std::unique_ptr<RtpPacketReceived> CreatePacket(
uint32_t ssrc,
RtpPacketReceived::ExtensionManager* extension_manager) {
auto packet = std::make_unique<RtpPacketReceived>(extension_manager);
packet->SetSsrc(ssrc);
packet->SetSequenceNumber(next_sequence_number_++);
return packet;
}
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrc(uint32_t ssrc) {
return CreatePacket(ssrc, nullptr);
}
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcMid(
uint32_t ssrc,
absl::string_view mid) {
RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpMid>(11);
auto packet = CreatePacket(ssrc, &extension_manager);
packet->SetExtension<RtpMid>(mid);
return packet;
}
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRsid(
uint32_t ssrc,
absl::string_view rsid) {
RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpStreamId>(6);
auto packet = CreatePacket(ssrc, &extension_manager);
packet->SetExtension<RtpStreamId>(rsid);
return packet;
}
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRrid(
uint32_t ssrc,
absl::string_view rrid) {
RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RepairedRtpStreamId>(7);
auto packet = CreatePacket(ssrc, &extension_manager);
packet->SetExtension<RepairedRtpStreamId>(rrid);
return packet;
}
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcMidRsid(
uint32_t ssrc,
absl::string_view mid,
absl::string_view rsid) {
RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpMid>(11);
extension_manager.Register<RtpStreamId>(6);
auto packet = CreatePacket(ssrc, &extension_manager);
packet->SetExtension<RtpMid>(mid);
packet->SetExtension<RtpStreamId>(rsid);
return packet;
}
std::unique_ptr<RtpPacketReceived> CreatePacketWithSsrcRsidRrid(
uint32_t ssrc,
absl::string_view rsid,
absl::string_view rrid) {
RtpPacketReceived::ExtensionManager extension_manager;
extension_manager.Register<RtpStreamId>(6);
extension_manager.Register<RepairedRtpStreamId>(7);
auto packet = CreatePacket(ssrc, &extension_manager);
packet->SetExtension<RtpStreamId>(rsid);
packet->SetExtension<RepairedRtpStreamId>(rrid);
return packet;
}
RtpDemuxer demuxer_;
std::set<RtpPacketSinkInterface*> sinks_to_tear_down_;
uint16_t next_sequence_number_ = 1;
};
class RtpDemuxerDeathTest : public RtpDemuxerTest {};
MATCHER_P(SamePacketAs, other, "") {
return arg.Ssrc() == other.Ssrc() &&
arg.SequenceNumber() == other.SequenceNumber();
}
TEST_F(RtpDemuxerTest, CanAddSinkBySsrc) {
MockRtpPacketSink sink;
constexpr uint32_t ssrc = 1;
EXPECT_TRUE(AddSinkOnlySsrc(ssrc, &sink));
}
TEST_F(RtpDemuxerTest, AllowAddSinkWithOverlappingPayloadTypesIfDifferentMid) {
const std::string mid1 = "v";
const std::string mid2 = "a";
constexpr uint8_t pt1 = 30;
constexpr uint8_t pt2 = 31;
constexpr uint8_t pt3 = 32;
RtpDemuxerCriteria pt1_pt2(mid1);
pt1_pt2.payload_types() = {pt1, pt2};
MockRtpPacketSink sink1;
AddSink(pt1_pt2, &sink1);
RtpDemuxerCriteria pt1_pt3(mid2);
pt1_pt3.payload_types() = {pt1, pt3};
MockRtpPacketSink sink2;
EXPECT_TRUE(AddSink(pt1_pt3, &sink2));
}
TEST_F(RtpDemuxerTest, RejectAddSinkForSameMidOnly) {
const std::string mid = "mid";
MockRtpPacketSink sink;
AddSinkOnlyMid(mid, &sink);
EXPECT_FALSE(AddSinkOnlyMid(mid, &sink));
}
TEST_F(RtpDemuxerTest, RejectAddSinkForSameMidRsid) {
const std::string mid = "v";
const std::string rsid = "1";
MockRtpPacketSink sink1;
AddSinkBothMidRsid(mid, rsid, &sink1);
MockRtpPacketSink sink2;
EXPECT_FALSE(AddSinkBothMidRsid(mid, rsid, &sink2));
}
TEST_F(RtpDemuxerTest, RejectAddSinkForConflictingMidAndMidRsid) {
const std::string mid = "v";
const std::string rsid = "1";
MockRtpPacketSink mid_sink;
AddSinkOnlyMid(mid, &mid_sink);
// This sink would never get any packets routed to it because the above sink
// would receive them all.
MockRtpPacketSink mid_rsid_sink;
EXPECT_FALSE(AddSinkBothMidRsid(mid, rsid, &mid_rsid_sink));
}
TEST_F(RtpDemuxerTest, RejectAddSinkForConflictingMidRsidAndMid) {
const std::string mid = "v";
const std::string rsid = "";
MockRtpPacketSink mid_rsid_sink;
AddSinkBothMidRsid(mid, rsid, &mid_rsid_sink);
// This sink would shadow the above sink.
MockRtpPacketSink mid_sink;
EXPECT_FALSE(AddSinkOnlyMid(mid, &mid_sink));
}
TEST_F(RtpDemuxerTest, AddSinkFailsIfCalledForTwoSinksWithSameSsrc) {
MockRtpPacketSink sink_a;
MockRtpPacketSink sink_b;
constexpr uint32_t ssrc = 1;
ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sink_a));
EXPECT_FALSE(AddSinkOnlySsrc(ssrc, &sink_b));
}
TEST_F(RtpDemuxerTest, AddSinkFailsIfCalledTwiceEvenIfSameSinkWithSameSsrc) {
MockRtpPacketSink sink;
constexpr uint32_t ssrc = 1;
ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sink));
EXPECT_FALSE(AddSinkOnlySsrc(ssrc, &sink));
}
// TODO(steveanton): Currently fails because payload type validation is not
// complete in AddSink (see note in rtp_demuxer.cc).
TEST_F(RtpDemuxerTest, DISABLED_RejectAddSinkForSamePayloadTypes) {
constexpr uint8_t pt1 = 30;
constexpr uint8_t pt2 = 31;
RtpDemuxerCriteria pt1_pt2;
pt1_pt2.payload_types() = {pt1, pt2};
MockRtpPacketSink sink1;
AddSink(pt1_pt2, &sink1);
RtpDemuxerCriteria pt2_pt1;
pt2_pt1.payload_types() = {pt2, pt1};
MockRtpPacketSink sink2;
EXPECT_FALSE(AddSink(pt2_pt1, &sink2));
}
// Routing Tests
TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkBySsrc) {
constexpr uint32_t ssrcs[] = {101, 202, 303};
MockRtpPacketSink sinks[arraysize(ssrcs)];
for (size_t i = 0; i < arraysize(ssrcs); i++) {
AddSinkOnlySsrc(ssrcs[i], &sinks[i]);
}
for (size_t i = 0; i < arraysize(ssrcs); i++) {
auto packet = CreatePacketWithSsrc(ssrcs[i]);
EXPECT_CALL(sinks[i], OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByRsid) {
const std::string rsids[] = {"a", "b", "c"};
MockRtpPacketSink sinks[arraysize(rsids)];
for (size_t i = 0; i < arraysize(rsids); i++) {
AddSinkOnlyRsid(rsids[i], &sinks[i]);
}
for (size_t i = 0; i < arraysize(rsids); i++) {
auto packet =
CreatePacketWithSsrcRsid(rtc::checked_cast<uint32_t>(i), rsids[i]);
EXPECT_CALL(sinks[i], OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByMid) {
const std::string mids[] = {"a", "v", "s"};
MockRtpPacketSink sinks[arraysize(mids)];
for (size_t i = 0; i < arraysize(mids); i++) {
AddSinkOnlyMid(mids[i], &sinks[i]);
}
for (size_t i = 0; i < arraysize(mids); i++) {
auto packet =
CreatePacketWithSsrcMid(rtc::checked_cast<uint32_t>(i), mids[i]);
EXPECT_CALL(sinks[i], OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByMidAndRsid) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
MockRtpPacketSink sink;
AddSinkBothMidRsid(mid, rsid, &sink);
auto packet = CreatePacketWithSsrcMidRsid(ssrc, mid, rsid);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByRepairedRsid) {
const std::string rrid = "1";
constexpr uint32_t ssrc = 10;
MockRtpPacketSink sink;
AddSinkOnlyRsid(rrid, &sink);
auto packet_with_rrid = CreatePacketWithSsrcRrid(ssrc, rrid);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_rrid))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_rrid));
}
TEST_F(RtpDemuxerTest, OnRtpPacketCalledOnCorrectSinkByPayloadType) {
constexpr uint32_t ssrc = 10;
constexpr uint8_t payload_type = 30;
MockRtpPacketSink sink;
RtpDemuxerCriteria criteria;
criteria.payload_types() = {payload_type};
AddSink(criteria, &sink);
auto packet = CreatePacketWithSsrc(ssrc);
packet->SetPayloadType(payload_type);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, PacketsDeliveredInRightOrder) {
constexpr uint32_t ssrc = 101;
MockRtpPacketSink sink;
AddSinkOnlySsrc(ssrc, &sink);
std::unique_ptr<RtpPacketReceived> packets[5];
for (size_t i = 0; i < arraysize(packets); i++) {
packets[i] = CreatePacketWithSsrc(ssrc);
packets[i]->SetSequenceNumber(rtc::checked_cast<uint16_t>(i));
}
InSequence sequence;
for (const auto& packet : packets) {
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
}
for (const auto& packet : packets) {
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
TEST_F(RtpDemuxerTest, SinkMappedToMultipleSsrcs) {
constexpr uint32_t ssrcs[] = {404, 505, 606};
MockRtpPacketSink sink;
for (uint32_t ssrc : ssrcs) {
AddSinkOnlySsrc(ssrc, &sink);
}
// The sink which is associated with multiple SSRCs gets the callback
// triggered for each of those SSRCs.
for (uint32_t ssrc : ssrcs) {
auto packet = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
TEST_F(RtpDemuxerTest, NoCallbackOnSsrcSinkRemovedBeforeFirstPacket) {
constexpr uint32_t ssrc = 404;
MockRtpPacketSink sink;
AddSinkOnlySsrc(ssrc, &sink);
ASSERT_TRUE(RemoveSink(&sink));
// The removed sink does not get callbacks.
auto packet = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called.
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, NoCallbackOnSsrcSinkRemovedAfterFirstPacket) {
constexpr uint32_t ssrc = 404;
NiceMock<MockRtpPacketSink> sink;
AddSinkOnlySsrc(ssrc, &sink);
InSequence sequence;
for (size_t i = 0; i < 10; i++) {
ASSERT_TRUE(demuxer_.OnRtpPacket(*CreatePacketWithSsrc(ssrc)));
}
ASSERT_TRUE(RemoveSink(&sink));
// The removed sink does not get callbacks.
auto packet = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called.
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
// An SSRC may only be mapped to a single sink. However, since configuration
// of this associations might come from the network, we need to fail gracefully.
TEST_F(RtpDemuxerTest, OnlyOneSinkPerSsrcGetsOnRtpPacketTriggered) {
MockRtpPacketSink sinks[3];
constexpr uint32_t ssrc = 404;
ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sinks[0]));
ASSERT_FALSE(AddSinkOnlySsrc(ssrc, &sinks[1]));
ASSERT_FALSE(AddSinkOnlySsrc(ssrc, &sinks[2]));
// The first sink associated with the SSRC remains active; other sinks
// were not really added, and so do not get OnRtpPacket() called.
auto packet = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sinks[0], OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_CALL(sinks[1], OnRtpPacket(_)).Times(0);
EXPECT_CALL(sinks[2], OnRtpPacket(_)).Times(0);
ASSERT_TRUE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, NoRepeatedCallbackOnRepeatedAddSinkForSameSink) {
constexpr uint32_t ssrc = 111;
MockRtpPacketSink sink;
ASSERT_TRUE(AddSinkOnlySsrc(ssrc, &sink));
ASSERT_FALSE(AddSinkOnlySsrc(ssrc, &sink));
auto packet = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, RemoveSinkReturnsFalseForNeverAddedSink) {
MockRtpPacketSink sink;
EXPECT_FALSE(RemoveSink(&sink));
}
TEST_F(RtpDemuxerTest, RemoveSinkReturnsTrueForPreviouslyAddedSsrcSink) {
constexpr uint32_t ssrc = 101;
MockRtpPacketSink sink;
AddSinkOnlySsrc(ssrc, &sink);
EXPECT_TRUE(RemoveSink(&sink));
}
TEST_F(RtpDemuxerTest,
RemoveSinkReturnsTrueForUnresolvedPreviouslyAddedRsidSink) {
const std::string rsid = "a";
MockRtpPacketSink sink;
AddSinkOnlyRsid(rsid, &sink);
EXPECT_TRUE(RemoveSink(&sink));
}
TEST_F(RtpDemuxerTest,
RemoveSinkReturnsTrueForResolvedPreviouslyAddedRsidSink) {
const std::string rsid = "a";
constexpr uint32_t ssrc = 101;
NiceMock<MockRtpPacketSink> sink;
AddSinkOnlyRsid(rsid, &sink);
ASSERT_TRUE(demuxer_.OnRtpPacket(*CreatePacketWithSsrcRsid(ssrc, rsid)));
EXPECT_TRUE(RemoveSink(&sink));
}
TEST_F(RtpDemuxerTest, RsidLearnedAndLaterPacketsDeliveredWithOnlySsrc) {
MockRtpPacketSink sink;
const std::string rsid = "a";
AddSinkOnlyRsid(rsid, &sink);
// Create a sequence of RTP packets, where only the first one actually
// mentions the RSID.
std::unique_ptr<RtpPacketReceived> packets[5];
constexpr uint32_t rsid_ssrc = 111;
packets[0] = CreatePacketWithSsrcRsid(rsid_ssrc, rsid);
for (size_t i = 1; i < arraysize(packets); i++) {
packets[i] = CreatePacketWithSsrc(rsid_ssrc);
}
// The first packet associates the RSID with the SSRC, thereby allowing the
// demuxer to correctly demux all of the packets.
InSequence sequence;
for (const auto& packet : packets) {
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
}
for (const auto& packet : packets) {
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
TEST_F(RtpDemuxerTest, NoCallbackOnRsidSinkRemovedBeforeFirstPacket) {
MockRtpPacketSink sink;
const std::string rsid = "a";
AddSinkOnlyRsid(rsid, &sink);
// Sink removed - it won't get triggers even if packets with its RSID arrive.
ASSERT_TRUE(RemoveSink(&sink));
constexpr uint32_t ssrc = 111;
auto packet = CreatePacketWithSsrcRsid(ssrc, rsid);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called.
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, NoCallbackOnRsidSinkRemovedAfterFirstPacket) {
NiceMock<MockRtpPacketSink> sink;
const std::string rsid = "a";
AddSinkOnlyRsid(rsid, &sink);
InSequence sequence;
constexpr uint32_t ssrc = 111;
for (size_t i = 0; i < 10; i++) {
auto packet = CreatePacketWithSsrcRsid(ssrc, rsid);
ASSERT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// Sink removed - it won't get triggers even if packets with its RSID arrive.
ASSERT_TRUE(RemoveSink(&sink));
auto packet = CreatePacketWithSsrcRsid(ssrc, rsid);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0); // Not called.
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, NoCallbackOnMidSinkRemovedBeforeFirstPacket) {
const std::string mid = "v";
constexpr uint32_t ssrc = 10;
MockRtpPacketSink sink;
AddSinkOnlyMid(mid, &sink);
RemoveSink(&sink);
auto packet = CreatePacketWithSsrcMid(ssrc, mid);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, NoCallbackOnMidSinkRemovedAfterFirstPacket) {
const std::string mid = "v";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink;
AddSinkOnlyMid(mid, &sink);
auto p1 = CreatePacketWithSsrcMid(ssrc, mid);
demuxer_.OnRtpPacket(*p1);
RemoveSink(&sink);
auto p2 = CreatePacketWithSsrcMid(ssrc, mid);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*p2));
}
TEST_F(RtpDemuxerTest, NoCallbackOnMidRsidSinkRemovedAfterFirstPacket) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink;
AddSinkBothMidRsid(mid, rsid, &sink);
auto p1 = CreatePacketWithSsrcMidRsid(ssrc, mid, rsid);
demuxer_.OnRtpPacket(*p1);
RemoveSink(&sink);
auto p2 = CreatePacketWithSsrcMidRsid(ssrc, mid, rsid);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*p2));
}
// The RSID to SSRC mapping should be one-to-one. If we end up receiving
// two (or more) packets with the same SSRC, but different RSIDs, we guarantee
// delivery to one of them but not both.
TEST_F(RtpDemuxerTest, FirstSsrcAssociatedWithAnRsidIsNotForgotten) {
// Each sink has a distinct RSID.
MockRtpPacketSink sink_a;
const std::string rsid_a = "a";
AddSinkOnlyRsid(rsid_a, &sink_a);
MockRtpPacketSink sink_b;
const std::string rsid_b = "b";
AddSinkOnlyRsid(rsid_b, &sink_b);
InSequence sequence; // Verify that the order of delivery is unchanged.
constexpr uint32_t shared_ssrc = 100;
// First a packet with `rsid_a` is received, and `sink_a` is associated with
// its SSRC.
auto packet_a = CreatePacketWithSsrcRsid(shared_ssrc, rsid_a);
EXPECT_CALL(sink_a, OnRtpPacket(SamePacketAs(*packet_a))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_a));
// Second, a packet with `rsid_b` is received. We guarantee that `sink_b`
// receives it.
auto packet_b = CreatePacketWithSsrcRsid(shared_ssrc, rsid_b);
EXPECT_CALL(sink_a, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink_b, OnRtpPacket(SamePacketAs(*packet_b))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_b));
// Known edge-case; adding a new RSID association makes us re-examine all
// SSRCs. `sink_b` may or may not be associated with the SSRC now; we make
// no promises on that. However, since the RSID is specified and it cannot be
// found the packet should be dropped.
MockRtpPacketSink sink_c;
const std::string rsid_c = "c";
constexpr uint32_t some_other_ssrc = shared_ssrc + 1;
AddSinkOnlySsrc(some_other_ssrc, &sink_c);
auto packet_c = CreatePacketWithSsrcMid(shared_ssrc, rsid_c);
EXPECT_CALL(sink_a, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink_b, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink_c, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet_c));
}
TEST_F(RtpDemuxerTest, MultipleRsidsOnSameSink) {
MockRtpPacketSink sink;
const std::string rsids[] = {"a", "b", "c"};
for (const std::string& rsid : rsids) {
AddSinkOnlyRsid(rsid, &sink);
}
InSequence sequence;
for (size_t i = 0; i < arraysize(rsids); i++) {
// Assign different SSRCs and sequence numbers to all packets.
const uint32_t ssrc = 1000 + static_cast<uint32_t>(i);
const uint16_t sequence_number = 50 + static_cast<uint16_t>(i);
auto packet = CreatePacketWithSsrcRsid(ssrc, rsids[i]);
packet->SetSequenceNumber(sequence_number);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
}
// RSIDs are given higher priority than SSRC because we believe senders are less
// likely to mislabel packets with RSID than mislabel them with SSRCs.
TEST_F(RtpDemuxerTest, SinkWithBothRsidAndSsrcAssociations) {
MockRtpPacketSink sink;
constexpr uint32_t standalone_ssrc = 10101;
constexpr uint32_t rsid_ssrc = 20202;
const std::string rsid = "1";
AddSinkOnlySsrc(standalone_ssrc, &sink);
AddSinkOnlyRsid(rsid, &sink);
InSequence sequence;
auto ssrc_packet = CreatePacketWithSsrc(standalone_ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*ssrc_packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*ssrc_packet));
auto rsid_packet = CreatePacketWithSsrcRsid(rsid_ssrc, rsid);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*rsid_packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*rsid_packet));
}
// Packets are always guaranteed to be routed to only one sink.
TEST_F(RtpDemuxerTest, AssociatingByRsidAndBySsrcCannotTriggerDoubleCall) {
constexpr uint32_t ssrc = 10101;
const std::string rsid = "a";
MockRtpPacketSink sink;
AddSinkOnlySsrc(ssrc, &sink);
AddSinkOnlyRsid(rsid, &sink);
auto packet = CreatePacketWithSsrcRsid(ssrc, rsid);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// If one sink is associated with SSRC x, and another sink with RSID y, then if
// we receive a packet with both SSRC x and RSID y, route that to only the sink
// for RSID y since we believe RSID tags to be more trustworthy than signaled
// SSRCs.
TEST_F(RtpDemuxerTest,
PacketFittingBothRsidSinkAndSsrcSinkGivenOnlyToRsidSink) {
constexpr uint32_t ssrc = 111;
MockRtpPacketSink ssrc_sink;
AddSinkOnlySsrc(ssrc, &ssrc_sink);
const std::string rsid = "a";
MockRtpPacketSink rsid_sink;
AddSinkOnlyRsid(rsid, &rsid_sink);
auto packet = CreatePacketWithSsrcRsid(ssrc, rsid);
EXPECT_CALL(ssrc_sink, OnRtpPacket(_)).Times(0);
EXPECT_CALL(rsid_sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// We're not expecting RSIDs to be resolved to SSRCs which were previously
// mapped to sinks, and make no guarantees except for graceful handling.
TEST_F(RtpDemuxerTest,
GracefullyHandleRsidBeingMappedToPrevouslyAssociatedSsrc) {
constexpr uint32_t ssrc = 111;
NiceMock<MockRtpPacketSink> ssrc_sink;
AddSinkOnlySsrc(ssrc, &ssrc_sink);
const std::string rsid = "a";
NiceMock<MockRtpPacketSink> rsid_sink;
AddSinkOnlyRsid(rsid, &rsid_sink);
// The SSRC was mapped to an SSRC sink, but was even active (packets flowed
// over it).
auto packet = CreatePacketWithSsrcRsid(ssrc, rsid);
demuxer_.OnRtpPacket(*packet);
// If the SSRC sink is ever removed, the RSID sink *might* receive indications
// of packets, and observers *might* be informed. Only graceful handling
// is guaranteed.
RemoveSink(&ssrc_sink);
EXPECT_CALL(rsid_sink, OnRtpPacket(SamePacketAs(*packet))).Times(AtLeast(0));
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// Tests that when one MID sink is configured, packets that include the MID
// extension will get routed to that sink and any packets that use the same
// SSRC as one of those packets later will also get routed to the sink, even
// if a new SSRC is introduced for the same MID.
TEST_F(RtpDemuxerTest, RoutedByMidWhenSsrcAdded) {
const std::string mid = "v";
NiceMock<MockRtpPacketSink> sink;
AddSinkOnlyMid(mid, &sink);
constexpr uint32_t ssrc1 = 10;
constexpr uint32_t ssrc2 = 11;
auto packet_ssrc1_mid = CreatePacketWithSsrcMid(ssrc1, mid);
demuxer_.OnRtpPacket(*packet_ssrc1_mid);
auto packet_ssrc2_mid = CreatePacketWithSsrcMid(ssrc2, mid);
demuxer_.OnRtpPacket(*packet_ssrc2_mid);
auto packet_ssrc1_only = CreatePacketWithSsrc(ssrc1);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_ssrc1_only))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_ssrc1_only));
auto packet_ssrc2_only = CreatePacketWithSsrc(ssrc2);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_ssrc2_only))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_ssrc2_only));
}
TEST_F(RtpDemuxerTest, DontLearnMidSsrcBindingBeforeSinkAdded) {
const std::string mid = "v";
constexpr uint32_t ssrc = 10;
auto packet_ssrc_mid = CreatePacketWithSsrcMid(ssrc, mid);
ASSERT_FALSE(demuxer_.OnRtpPacket(*packet_ssrc_mid));
MockRtpPacketSink sink;
AddSinkOnlyMid(mid, &sink);
auto packet_ssrc_only = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet_ssrc_only));
}
TEST_F(RtpDemuxerTest, DontForgetMidSsrcBindingWhenSinkRemoved) {
const std::string mid = "v";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink1;
AddSinkOnlyMid(mid, &sink1);
auto packet_with_mid = CreatePacketWithSsrcMid(ssrc, mid);
demuxer_.OnRtpPacket(*packet_with_mid);
RemoveSink(&sink1);
MockRtpPacketSink sink2;
AddSinkOnlyMid(mid, &sink2);
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink2, OnRtpPacket(SamePacketAs(*packet_with_ssrc)));
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
// If a sink is added with only a MID, then any packet with that MID no matter
// the RSID should be routed to that sink.
TEST_F(RtpDemuxerTest, RoutedByMidWithAnyRsid) {
const std::string mid = "v";
const std::string rsid1 = "1";
const std::string rsid2 = "2";
constexpr uint32_t ssrc1 = 10;
constexpr uint32_t ssrc2 = 11;
MockRtpPacketSink sink;
AddSinkOnlyMid(mid, &sink);
InSequence sequence;
auto packet_ssrc1_rsid1 = CreatePacketWithSsrcMidRsid(ssrc1, mid, rsid1);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_ssrc1_rsid1))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_ssrc1_rsid1));
auto packet_ssrc2_rsid2 = CreatePacketWithSsrcMidRsid(ssrc2, mid, rsid2);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_ssrc2_rsid2))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_ssrc2_rsid2));
}
// These two tests verify that for a sink added with a MID, RSID pair, if the
// MID and RSID are learned in separate packets (e.g., because the header
// extensions are sent separately), then a later packet with just SSRC will get
// routed to that sink.
// The first test checks that the functionality works when MID is learned first.
// The second test checks that the functionality works when RSID is learned
// first.
TEST_F(RtpDemuxerTest, LearnMidThenRsidSeparatelyAndRouteBySsrc) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink;
AddSinkBothMidRsid(mid, rsid, &sink);
auto packet_with_mid = CreatePacketWithSsrcMid(ssrc, mid);
ASSERT_FALSE(demuxer_.OnRtpPacket(*packet_with_mid));
auto packet_with_rsid = CreatePacketWithSsrcRsid(ssrc, rsid);
ASSERT_TRUE(demuxer_.OnRtpPacket(*packet_with_rsid));
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_ssrc))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
TEST_F(RtpDemuxerTest, LearnRsidThenMidSeparatelyAndRouteBySsrc) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink;
AddSinkBothMidRsid(mid, rsid, &sink);
auto packet_with_rsid = CreatePacketWithSsrcRsid(ssrc, rsid);
ASSERT_FALSE(demuxer_.OnRtpPacket(*packet_with_rsid));
auto packet_with_mid = CreatePacketWithSsrcMid(ssrc, mid);
ASSERT_TRUE(demuxer_.OnRtpPacket(*packet_with_mid));
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_ssrc))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
TEST_F(RtpDemuxerTest, DontLearnMidRsidBindingBeforeSinkAdded) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
auto packet_with_both = CreatePacketWithSsrcMidRsid(ssrc, mid, rsid);
ASSERT_FALSE(demuxer_.OnRtpPacket(*packet_with_both));
MockRtpPacketSink sink;
AddSinkBothMidRsid(mid, rsid, &sink);
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
TEST_F(RtpDemuxerTest, DontForgetMidRsidBindingWhenSinkRemoved) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink1;
AddSinkBothMidRsid(mid, rsid, &sink1);
auto packet_with_both = CreatePacketWithSsrcMidRsid(ssrc, mid, rsid);
demuxer_.OnRtpPacket(*packet_with_both);
RemoveSink(&sink1);
MockRtpPacketSink sink2;
AddSinkBothMidRsid(mid, rsid, &sink2);
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink2, OnRtpPacket(SamePacketAs(*packet_with_ssrc)));
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
TEST_F(RtpDemuxerTest, LearnMidRsidBindingAfterSinkAdded) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
NiceMock<MockRtpPacketSink> sink;
AddSinkBothMidRsid(mid, rsid, &sink);
auto packet_with_both = CreatePacketWithSsrcMidRsid(ssrc, mid, rsid);
demuxer_.OnRtpPacket(*packet_with_both);
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_ssrc)));
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
TEST_F(RtpDemuxerTest, DropByPayloadTypeIfNoSink) {
constexpr uint8_t payload_type = 30;
constexpr uint32_t ssrc = 10;
auto packet = CreatePacketWithSsrc(ssrc);
packet->SetPayloadType(payload_type);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
// For legacy applications, it's possible for us to demux if the payload type is
// unique. But if multiple sinks are registered with different MIDs and the same
// payload types, then we cannot route a packet with just payload type because
// it is ambiguous which sink it should be sent to.
TEST_F(RtpDemuxerTest, DropByPayloadTypeIfAddedInMultipleSinks) {
const std::string mid1 = "v";
const std::string mid2 = "a";
constexpr uint8_t payload_type = 30;
constexpr uint32_t ssrc = 10;
RtpDemuxerCriteria mid1_pt(mid1);
mid1_pt.payload_types() = {payload_type};
MockRtpPacketSink sink1;
AddSink(mid1_pt, &sink1);
RtpDemuxerCriteria mid2_pt(mid2);
mid2_pt.payload_types() = {payload_type};
MockRtpPacketSink sink2;
AddSink(mid2_pt, &sink2);
auto packet = CreatePacketWithSsrc(ssrc);
packet->SetPayloadType(payload_type);
EXPECT_CALL(sink1, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink2, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
// If two sinks are added with different MIDs but the same payload types, then
// we cannot demux on the payload type only unless one of the sinks is removed.
TEST_F(RtpDemuxerTest, RoutedByPayloadTypeIfAmbiguousSinkRemoved) {
const std::string mid1 = "v";
const std::string mid2 = "a";
constexpr uint8_t payload_type = 30;
constexpr uint32_t ssrc = 10;
RtpDemuxerCriteria mid1_pt(mid1);
mid1_pt.payload_types().insert(payload_type);
MockRtpPacketSink sink1;
AddSink(mid1_pt, &sink1);
RtpDemuxerCriteria mid2_pt(mid2);
mid2_pt.payload_types().insert(payload_type);
MockRtpPacketSink sink2;
AddSink(mid2_pt, &sink2);
RemoveSink(&sink1);
auto packet = CreatePacketWithSsrc(ssrc);
packet->SetPayloadType(payload_type);
EXPECT_CALL(sink1, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink2, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, RoutedByPayloadTypeLatchesSsrc) {
constexpr uint8_t payload_type = 30;
constexpr uint32_t ssrc = 10;
RtpDemuxerCriteria pt;
pt.payload_types().insert(payload_type);
NiceMock<MockRtpPacketSink> sink;
AddSink(pt, &sink);
auto packet_with_pt = CreatePacketWithSsrc(ssrc);
packet_with_pt->SetPayloadType(payload_type);
ASSERT_TRUE(demuxer_.OnRtpPacket(*packet_with_pt));
auto packet_with_ssrc = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_ssrc))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_ssrc));
}
// RSIDs are scoped within MID, so if two sinks are registered with the same
// RSIDs but different MIDs, then packets containing both extensions should be
// routed to the correct one.
TEST_F(RtpDemuxerTest, PacketWithSameRsidDifferentMidRoutedToProperSink) {
const std::string mid1 = "mid1";
const std::string mid2 = "mid2";
const std::string rsid = "rsid";
constexpr uint32_t ssrc1 = 10;
constexpr uint32_t ssrc2 = 11;
NiceMock<MockRtpPacketSink> mid1_sink;
AddSinkBothMidRsid(mid1, rsid, &mid1_sink);
MockRtpPacketSink mid2_sink;
AddSinkBothMidRsid(mid2, rsid, &mid2_sink);
auto packet_mid1 = CreatePacketWithSsrcMidRsid(ssrc1, mid1, rsid);
ASSERT_TRUE(demuxer_.OnRtpPacket(*packet_mid1));
auto packet_mid2 = CreatePacketWithSsrcMidRsid(ssrc2, mid2, rsid);
EXPECT_CALL(mid2_sink, OnRtpPacket(SamePacketAs(*packet_mid2))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_mid2));
}
// If a sink is first bound to a given SSRC by signaling but later a new sink is
// bound to a given MID by a later signaling, then when a packet arrives with
// both the SSRC and MID, then the signaled MID sink should take precedence.
TEST_F(RtpDemuxerTest, SignaledMidShouldOverwriteSignaledSsrc) {
constexpr uint32_t ssrc = 11;
const std::string mid = "mid";
MockRtpPacketSink ssrc_sink;
AddSinkOnlySsrc(ssrc, &ssrc_sink);
MockRtpPacketSink mid_sink;
AddSinkOnlyMid(mid, &mid_sink);
auto p = CreatePacketWithSsrcMid(ssrc, mid);
EXPECT_CALL(ssrc_sink, OnRtpPacket(_)).Times(0);
EXPECT_CALL(mid_sink, OnRtpPacket(SamePacketAs(*p))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*p));
}
// Extends the previous test to also ensure that later packets that do not
// specify MID are still routed to the MID sink rather than the overwritten SSRC
// sink.
TEST_F(RtpDemuxerTest, SignaledMidShouldOverwriteSignalledSsrcPersistent) {
constexpr uint32_t ssrc = 11;
const std::string mid = "mid";
MockRtpPacketSink ssrc_sink;
AddSinkOnlySsrc(ssrc, &ssrc_sink);
NiceMock<MockRtpPacketSink> mid_sink;
AddSinkOnlyMid(mid, &mid_sink);
EXPECT_CALL(ssrc_sink, OnRtpPacket(_)).Times(0);
auto packet_with_mid = CreatePacketWithSsrcMid(ssrc, mid);
demuxer_.OnRtpPacket(*packet_with_mid);
auto packet_without_mid = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(mid_sink, OnRtpPacket(SamePacketAs(*packet_without_mid)))
.Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_without_mid));
}
TEST_F(RtpDemuxerTest, RouteByPayloadTypeMultipleMatch) {
constexpr uint32_t ssrc = 10;
constexpr uint8_t pt1 = 30;
constexpr uint8_t pt2 = 31;
MockRtpPacketSink sink;
RtpDemuxerCriteria criteria;
criteria.payload_types() = {pt1, pt2};
AddSink(criteria, &sink);
auto packet_with_pt1 = CreatePacketWithSsrc(ssrc);
packet_with_pt1->SetPayloadType(pt1);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_pt1)));
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_pt1));
auto packet_with_pt2 = CreatePacketWithSsrc(ssrc);
packet_with_pt2->SetPayloadType(pt2);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet_with_pt2)));
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_with_pt2));
}
TEST_F(RtpDemuxerTest, DontDemuxOnMidAloneIfAddedWithRsid) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
MockRtpPacketSink sink;
AddSinkBothMidRsid(mid, rsid, &sink);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
auto packet = CreatePacketWithSsrcMid(ssrc, mid);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
TEST_F(RtpDemuxerTest, DemuxBySsrcEvenWithMidAndRsid) {
const std::string mid = "v";
const std::string rsid = "1";
constexpr uint32_t ssrc = 10;
RtpDemuxerCriteria criteria(mid, rsid);
criteria.ssrcs().insert(ssrc);
MockRtpPacketSink sink;
AddSink(criteria, &sink);
auto packet = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// In slight deviation from the BUNDLE spec, if we match a sink according to
// SSRC, then we do not verify payload type against the criteria and defer to
// the sink to check that it is correct.
TEST_F(RtpDemuxerTest, DoNotCheckPayloadTypeIfMatchedByOtherCriteria) {
constexpr uint32_t ssrc = 10;
constexpr uint8_t payload_type = 30;
constexpr uint8_t different_payload_type = payload_type + 1;
RtpDemuxerCriteria criteria;
criteria.ssrcs().insert(ssrc);
criteria.payload_types().insert(payload_type);
MockRtpPacketSink sink;
AddSink(criteria, &sink);
auto packet = CreatePacketWithSsrc(ssrc);
packet->SetPayloadType(different_payload_type);
EXPECT_CALL(sink, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// If a repair packet includes an RSID it should be ignored and the packet
// should be routed by its RRID.
TEST_F(RtpDemuxerTest, PacketWithRsidAndRridRoutedByRrid) {
const std::string rsid = "1";
const std::string rrid = "1r";
constexpr uint32_t ssrc = 10;
MockRtpPacketSink sink_rsid;
AddSinkOnlyRsid(rsid, &sink_rsid);
MockRtpPacketSink sink_rrid;
AddSinkOnlyRsid(rrid, &sink_rrid);
auto packet = CreatePacketWithSsrcRsidRrid(ssrc, rsid, rrid);
EXPECT_CALL(sink_rsid, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink_rrid, OnRtpPacket(SamePacketAs(*packet))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet));
}
// Same test as above but checks that the latched SSRC routes to the RRID sink.
TEST_F(RtpDemuxerTest, PacketWithRsidAndRridLatchesSsrcToRrid) {
const std::string rsid = "1";
const std::string rrid = "1r";
constexpr uint32_t ssrc = 10;
MockRtpPacketSink sink_rsid;
AddSinkOnlyRsid(rsid, &sink_rsid);
NiceMock<MockRtpPacketSink> sink_rrid;
AddSinkOnlyRsid(rrid, &sink_rrid);
auto packet_rsid_rrid = CreatePacketWithSsrcRsidRrid(ssrc, rsid, rrid);
demuxer_.OnRtpPacket(*packet_rsid_rrid);
auto packet_ssrc_only = CreatePacketWithSsrc(ssrc);
EXPECT_CALL(sink_rsid, OnRtpPacket(_)).Times(0);
EXPECT_CALL(sink_rrid, OnRtpPacket(SamePacketAs(*packet_ssrc_only))).Times(1);
EXPECT_TRUE(demuxer_.OnRtpPacket(*packet_ssrc_only));
}
// Tests that a packet which includes MID and RSID is dropped and not routed by
// SSRC if the MID and RSID do not match an added sink.
TEST_F(RtpDemuxerTest, PacketWithMidAndUnknownRsidIsNotRoutedBySsrc) {
constexpr uint32_t ssrc = 10;
const std::string mid = "v";
const std::string rsid = "1";
const std::string wrong_rsid = "2";
RtpDemuxerCriteria criteria(mid, rsid);
criteria.ssrcs().insert(ssrc);
MockRtpPacketSink sink;
AddSink(criteria, &sink);
auto packet = CreatePacketWithSsrcMidRsid(ssrc, mid, wrong_rsid);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
// Tests that a packet which includes MID and RSID is dropped and not routed by
// payload type if the MID and RSID do not match an added sink.
TEST_F(RtpDemuxerTest, PacketWithMidAndUnknownRsidIsNotRoutedByPayloadType) {
constexpr uint32_t ssrc = 10;
const std::string mid = "v";
const std::string rsid = "1";
const std::string wrong_rsid = "2";
constexpr uint8_t payload_type = 30;
RtpDemuxerCriteria criteria(mid, rsid);
criteria.payload_types().insert(payload_type);
MockRtpPacketSink sink;
AddSink(criteria, &sink);
auto packet = CreatePacketWithSsrcMidRsid(ssrc, mid, wrong_rsid);
packet->SetPayloadType(payload_type);
EXPECT_CALL(sink, OnRtpPacket(_)).Times(0);
EXPECT_FALSE(demuxer_.OnRtpPacket(*packet));
}
#if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
TEST_F(RtpDemuxerDeathTest, MidMustNotExceedMaximumLength) {
MockRtpPacketSink sink1;
std::string mid1(BaseRtpStringExtension::kMaxValueSizeBytes + 1, 'a');
EXPECT_DEATH(AddSinkOnlyMid(mid1, &sink1), "");
}
TEST_F(RtpDemuxerDeathTest, CriteriaMustBeNonEmpty) {
MockRtpPacketSink sink;
RtpDemuxerCriteria criteria;
EXPECT_DEATH(AddSink(criteria, &sink), "");
}
TEST_F(RtpDemuxerDeathTest, RsidMustBeAlphaNumeric) {
MockRtpPacketSink sink;
EXPECT_DEATH(AddSinkOnlyRsid("a_3", &sink), "");
}
TEST_F(RtpDemuxerDeathTest, MidMustBeToken) {
MockRtpPacketSink sink;
EXPECT_DEATH(AddSinkOnlyMid("a(3)", &sink), "");
}
TEST_F(RtpDemuxerDeathTest, RsidMustNotExceedMaximumLength) {
MockRtpPacketSink sink;
std::string rsid(BaseRtpStringExtension::kMaxValueSizeBytes + 1, 'a');
EXPECT_DEATH(AddSinkOnlyRsid(rsid, &sink), "");
}
#endif
} // namespace
} // namespace webrtc