cast/streaming/rtp_packet_parser_unittest.cc - platform/external/openscreen - Git at Google

 // Copyright 2019 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "cast/streaming/rtp_packet_parser.h"

 #include "cast/streaming/rtp_defines.h"
 #include "gtest/gtest.h"
 #include "util/big_endian.h"

 namespace openscreen {
 namespace cast {
 namespace {

 // Tests that a simple packet for a key frame can be parsed.
 TEST(RtpPacketParserTest, ParsesPacketForKeyFrame) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xbe, 0xef,  // Sequence number.
     9, 8, 7, 6,  // RTP timestamp.
     1, 2, 3, 4,  // SSRC.
     0b10000000,  // Is key frame, no extensions.
     5,  // Frame ID.
     0xa, 0xb,  // Packet ID.
     0xa, 0xc,  // Max packet ID.
     0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8,  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x01020304;

   RtpPacketParser parser(kSenderSsrc);
   const auto result = parser.Parse(kInput);
   ASSERT_TRUE(result);
   EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
   EXPECT_EQ(UINT16_C(0xbeef), result->sequence_number);
   EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x09080706),
             result->rtp_timestamp);
   EXPECT_TRUE(result->is_key_frame);
   EXPECT_EQ(FrameId::first() + 5, result->frame_id);
   EXPECT_EQ(FramePacketId{0x0a0b}, result->packet_id);
   EXPECT_EQ(FramePacketId{0x0a0c}, result->max_packet_id);
   EXPECT_EQ(FrameId::first() + 5, result->referenced_frame_id);
   EXPECT_EQ(0, result->new_playout_delay.count());
   const absl::Span<const uint8_t> expected_payload(kInput + 18, 8);
   ASSERT_EQ(expected_payload, result->payload);
   EXPECT_TRUE(expected_payload == result->payload);
 }

 // Tests that a packet which includes a "referenced frame ID" can be parsed.
 TEST(RtpPacketParserTest, ParsesPacketForNonKeyFrameWithReferenceFrameId) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xde, 0xad,  // Sequence number.
     2, 4, 6, 8,  // RTP timestamp.
     0, 0, 1, 1,  // SSRC.
     0b01000000,  // Not a key frame, but has ref frame ID; no extensions.
     42,  // Frame ID.
     0x0, 0xb,  // Packet ID.
     0x0, 0xc,  // Max packet ID.
     39,  // Reference Frame ID.
     1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x00000101;

   RtpPacketParser parser(kSenderSsrc);
   const auto result = parser.Parse(kInput);
   ASSERT_TRUE(result);
   EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
   EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
   EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
             result->rtp_timestamp);
   EXPECT_FALSE(result->is_key_frame);
   EXPECT_EQ(FrameId::first() + 42, result->frame_id);
   EXPECT_EQ(FramePacketId{0x000b}, result->packet_id);
   EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
   EXPECT_EQ(FrameId::first() + 39, result->referenced_frame_id);
   EXPECT_EQ(0, result->new_playout_delay.count());
   const absl::Span<const uint8_t> expected_payload(kInput + 19, 15);
   ASSERT_EQ(expected_payload, result->payload);
   EXPECT_TRUE(expected_payload == result->payload);
 }

 // Tests that a packet which lacks a "referenced frame ID" field can be parsed,
 // but the parser will provide the implied referenced_frame_id value in the
 // result.
 TEST(RtpPacketParserTest, ParsesPacketForNonKeyFrameWithoutReferenceFrameId) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xde, 0xad,  // Sequence number.
     2, 4, 6, 8,  // RTP timestamp.
     0, 0, 1, 1,  // SSRC.
     0b00000000,  // Not a key frame, no ref frame ID; no extensions.
     42,  // Frame ID.
     0x0, 0xb,  // Packet ID.
     0x0, 0xc,  // Max packet ID.
     1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x00000101;

   RtpPacketParser parser(kSenderSsrc);
   const auto result = parser.Parse(kInput);
   ASSERT_TRUE(result);
   EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
   EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
   EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
             result->rtp_timestamp);
   EXPECT_FALSE(result->is_key_frame);
   EXPECT_EQ(FrameId::first() + 42, result->frame_id);
   EXPECT_EQ(FramePacketId{0x000b}, result->packet_id);
   EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
   EXPECT_EQ(FrameId::first() + 41, result->referenced_frame_id);
   EXPECT_EQ(0, result->new_playout_delay.count());
   const absl::Span<const uint8_t> expected_payload(kInput + 18, 15);
   ASSERT_EQ(expected_payload, result->payload);
   EXPECT_TRUE(expected_payload == result->payload);
 }

 // Tests that a packet indicating a new playout delay can be parsed.
 TEST(RtpPacketParserTest, ParsesPacketWithAdaptiveLatencyExtension) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xde, 0xad,  // Sequence number.
     2, 4, 6, 8,  // RTP timestamp.
     0, 0, 1, 1,  // SSRC.
     0b11000001,  // Is key frame, has ref frame ID; has one extension.
     64,  // Frame ID.
     0x0, 0x0,  // Packet ID.
     0x0, 0xc,  // Max packet ID.
     64,  // Reference Frame ID.
     4, 2, 1, 14,  // Cast Adaptive Latency Extension data.
     1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x00000101;

   RtpPacketParser parser(kSenderSsrc);
   const auto result = parser.Parse(kInput);
   ASSERT_TRUE(result);
   EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
   EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
   EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
             result->rtp_timestamp);
   EXPECT_TRUE(result->is_key_frame);
   EXPECT_EQ(FrameId::first() + 64, result->frame_id);
   EXPECT_EQ(FramePacketId{0x0000}, result->packet_id);
   EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
   EXPECT_EQ(FrameId::first() + 64, result->referenced_frame_id);
   EXPECT_EQ(270, result->new_playout_delay.count());
   const absl::Span<const uint8_t> expected_payload(kInput + 23, 15);
   ASSERT_EQ(expected_payload, result->payload);
   EXPECT_TRUE(expected_payload == result->payload);
 }

 // Tests that the parser can handle multiple Cast Header Extensions in a RTP
 // packet, and ignores all but the one (Adaptive Latency) that it understands.
 TEST(RtpPacketParserTest, ParsesPacketWithMultipleExtensions) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xde, 0xad,  // Sequence number.
     2, 4, 6, 8,  // RTP timestamp.
     0, 0, 1, 1,  // SSRC.
     0b11000011,  // Is key frame, has ref frame ID; has 3 extensions.
     64,  // Frame ID.
     0x0, 0xb,  // Packet ID.
     0x0, 0xc,  // Max packet ID.
     64,  // Reference Frame ID.
     8, 2, 0, 0,  // Unknown extension with 2 bytes of data.
     4, 2, 1, 14,  // Cast Adaptive Latency Extension data.
     16, 5, 0, 0, 0, 0, 0,  // Unknown extension with 5 bytes of data.
     1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x00000101;

   RtpPacketParser parser(kSenderSsrc);
   const auto result = parser.Parse(kInput);
   ASSERT_TRUE(result);
   EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
   EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
   EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
             result->rtp_timestamp);
   EXPECT_TRUE(result->is_key_frame);
   EXPECT_EQ(FrameId::first() + 64, result->frame_id);
   EXPECT_EQ(FramePacketId{0x000b}, result->packet_id);
   EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
   EXPECT_EQ(FrameId::first() + 64, result->referenced_frame_id);
   EXPECT_EQ(270, result->new_playout_delay.count());
   const absl::Span<const uint8_t> expected_payload(kInput + 34, 15);
   ASSERT_EQ(expected_payload, result->payload);
   EXPECT_TRUE(expected_payload == result->payload);
 }

 // Tests that the parser ignores packets from an unknown source.
 TEST(RtpPacketParserTest, IgnoresPacketWithWrongSsrc) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xbe, 0xef,  // Sequence number.
     9, 8, 7, 6,  // RTP timestamp.
     4, 3, 2, 1,  // SSRC.
     0b10000000,  // Is key frame, no extensions.
     5,  // Frame ID.
     0xa, 0xb,  // Packet ID.
     0xa, 0xc,  // Max packet ID.
     0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8,  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x01020304;

   RtpPacketParser parser(kSenderSsrc);
   const auto result = parser.Parse(kInput);
   ASSERT_FALSE(result);
 }

 // Tests that unexpected truncations in the RTP packets does not crash the
 // parser, and that it correctly errors-out.
 TEST(RtpPacketParserTest, RejectsTruncatedPackets) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xde, 0xad,  // Sequence number.
     2, 4, 6, 8,  // RTP timestamp.
     0, 0, 1, 1,  // SSRC.
     0b11000011,  // Is key frame, has ref frame ID; has 3 extensions.
     64,  // Frame ID.
     0x0, 0xb,  // Packet ID.
     0x0, 0xc,  // Max packet ID.
     64,  // Reference Frame ID.
     8, 2, 0, 0,  // Unknown extension with 2 bytes of data.
     4, 2, 1, 14,  // Cast Adaptive Latency Extension data.
     16, 5, 0, 0, 0, 0, 0,  // Unknown extension with 5 bytes of data.
     1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x00000101;

   RtpPacketParser parser(kSenderSsrc);
   ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 1)));
   ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 18)));
   ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 22)));
   ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 33)));

   // When truncated to 34 bytes, the parser should see it as a packet with zero
   // payload bytes.
   const auto result_without_payload =
       parser.Parse(absl::Span<const uint8_t>(kInput, 34));
   ASSERT_TRUE(result_without_payload);
   EXPECT_TRUE(result_without_payload->payload.empty());

   // And, of course, with the entire kInput available, the parser should see it
   // as a packet with 15 bytes of payload.
   const auto result_with_payload =
       parser.Parse(absl::Span<const uint8_t>(kInput, sizeof(kInput)));
   ASSERT_TRUE(result_with_payload);
   EXPECT_EQ(size_t{15}, result_with_payload->payload.size());
 }

 // Tests that the parser rejects invalid packet ID values.
 TEST(RtpPacketParserTest, RejectsPacketWithBadFramePacketIds) {
   // clang-format off
   const uint8_t kInput[] = {
     0b10000000,  // Version/Padding byte.
     96,  // Payload type byte.
     0xbe, 0xef,  // Sequence number.
     9, 8, 7, 6,  // RTP timestamp.
     1, 2, 3, 4,  // SSRC.
     0b10000000,  // Is key frame, no extensions.
     5,  // Frame ID.
     0xa, 0xb,  // Packet ID (which is GREATER than the max packet ID).
     0x0, 0x1,  // Max packet ID.
     0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8,  // Payload.
   };
   // clang-format on
   const Ssrc kSenderSsrc = 0x01020304;

   // The parser should reject the packet because its packet ID field is greater
   // than the max packet ID.
   RtpPacketParser parser(kSenderSsrc);
   ASSERT_FALSE(parser.Parse(kInput));

   // Now, modify the packet such that its "max packet ID" field is set to the
   // special "all packets lost" value. This makes the "packet ID" field valid,
   // because it is less than the "max packet ID", but the "max packet ID" value
   // itself is invalid.
   uint8_t input_with_bad_max_packet_id[sizeof(kInput)];
   memcpy(input_with_bad_max_packet_id, kInput, sizeof(kInput));
   WriteBigEndian<uint16_t>(kAllPacketsLost, &input_with_bad_max_packet_id[16]);
   const uint16_t packet_id =
       ReadBigEndian<uint16_t>(&input_with_bad_max_packet_id[14]);
   ASSERT_LE(packet_id, kAllPacketsLost);
   ASSERT_FALSE(parser.Parse(input_with_bad_max_packet_id));
 }

 }  // namespace
 }  // namespace cast
 }  // namespace openscreen
	// Copyright 2019 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "cast/streaming/rtp_packet_parser.h"

	#include "cast/streaming/rtp_defines.h"
	#include "gtest/gtest.h"
	#include "util/big_endian.h"

	namespace openscreen {
	namespace cast {
	namespace {

	// Tests that a simple packet for a key frame can be parsed.
	TEST(RtpPacketParserTest, ParsesPacketForKeyFrame) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xbe, 0xef, // Sequence number.
	9, 8, 7, 6, // RTP timestamp.
	1, 2, 3, 4, // SSRC.
	0b10000000, // Is key frame, no extensions.
	5, // Frame ID.
	0xa, 0xb, // Packet ID.
	0xa, 0xc, // Max packet ID.
	0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x01020304;

	RtpPacketParser parser(kSenderSsrc);
	const auto result = parser.Parse(kInput);
	ASSERT_TRUE(result);
	EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
	EXPECT_EQ(UINT16_C(0xbeef), result->sequence_number);
	EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x09080706),
	result->rtp_timestamp);
	EXPECT_TRUE(result->is_key_frame);
	EXPECT_EQ(FrameId::first() + 5, result->frame_id);
	EXPECT_EQ(FramePacketId{0x0a0b}, result->packet_id);
	EXPECT_EQ(FramePacketId{0x0a0c}, result->max_packet_id);
	EXPECT_EQ(FrameId::first() + 5, result->referenced_frame_id);
	EXPECT_EQ(0, result->new_playout_delay.count());
	const absl::Span<const uint8_t> expected_payload(kInput + 18, 8);
	ASSERT_EQ(expected_payload, result->payload);
	EXPECT_TRUE(expected_payload == result->payload);
	}

	// Tests that a packet which includes a "referenced frame ID" can be parsed.
	TEST(RtpPacketParserTest, ParsesPacketForNonKeyFrameWithReferenceFrameId) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xde, 0xad, // Sequence number.
	2, 4, 6, 8, // RTP timestamp.
	0, 0, 1, 1, // SSRC.
	0b01000000, // Not a key frame, but has ref frame ID; no extensions.
	42, // Frame ID.
	0x0, 0xb, // Packet ID.
	0x0, 0xc, // Max packet ID.
	39, // Reference Frame ID.
	1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x00000101;

	RtpPacketParser parser(kSenderSsrc);
	const auto result = parser.Parse(kInput);
	ASSERT_TRUE(result);
	EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
	EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
	EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
	result->rtp_timestamp);
	EXPECT_FALSE(result->is_key_frame);
	EXPECT_EQ(FrameId::first() + 42, result->frame_id);
	EXPECT_EQ(FramePacketId{0x000b}, result->packet_id);
	EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
	EXPECT_EQ(FrameId::first() + 39, result->referenced_frame_id);
	EXPECT_EQ(0, result->new_playout_delay.count());
	const absl::Span<const uint8_t> expected_payload(kInput + 19, 15);
	ASSERT_EQ(expected_payload, result->payload);
	EXPECT_TRUE(expected_payload == result->payload);
	}

	// Tests that a packet which lacks a "referenced frame ID" field can be parsed,
	// but the parser will provide the implied referenced_frame_id value in the
	// result.
	TEST(RtpPacketParserTest, ParsesPacketForNonKeyFrameWithoutReferenceFrameId) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xde, 0xad, // Sequence number.
	2, 4, 6, 8, // RTP timestamp.
	0, 0, 1, 1, // SSRC.
	0b00000000, // Not a key frame, no ref frame ID; no extensions.
	42, // Frame ID.
	0x0, 0xb, // Packet ID.
	0x0, 0xc, // Max packet ID.
	1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x00000101;

	RtpPacketParser parser(kSenderSsrc);
	const auto result = parser.Parse(kInput);
	ASSERT_TRUE(result);
	EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
	EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
	EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
	result->rtp_timestamp);
	EXPECT_FALSE(result->is_key_frame);
	EXPECT_EQ(FrameId::first() + 42, result->frame_id);
	EXPECT_EQ(FramePacketId{0x000b}, result->packet_id);
	EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
	EXPECT_EQ(FrameId::first() + 41, result->referenced_frame_id);
	EXPECT_EQ(0, result->new_playout_delay.count());
	const absl::Span<const uint8_t> expected_payload(kInput + 18, 15);
	ASSERT_EQ(expected_payload, result->payload);
	EXPECT_TRUE(expected_payload == result->payload);
	}

	// Tests that a packet indicating a new playout delay can be parsed.
	TEST(RtpPacketParserTest, ParsesPacketWithAdaptiveLatencyExtension) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xde, 0xad, // Sequence number.
	2, 4, 6, 8, // RTP timestamp.
	0, 0, 1, 1, // SSRC.
	0b11000001, // Is key frame, has ref frame ID; has one extension.
	64, // Frame ID.
	0x0, 0x0, // Packet ID.
	0x0, 0xc, // Max packet ID.
	64, // Reference Frame ID.
	4, 2, 1, 14, // Cast Adaptive Latency Extension data.
	1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x00000101;

	RtpPacketParser parser(kSenderSsrc);
	const auto result = parser.Parse(kInput);
	ASSERT_TRUE(result);
	EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
	EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
	EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
	result->rtp_timestamp);
	EXPECT_TRUE(result->is_key_frame);
	EXPECT_EQ(FrameId::first() + 64, result->frame_id);
	EXPECT_EQ(FramePacketId{0x0000}, result->packet_id);
	EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
	EXPECT_EQ(FrameId::first() + 64, result->referenced_frame_id);
	EXPECT_EQ(270, result->new_playout_delay.count());
	const absl::Span<const uint8_t> expected_payload(kInput + 23, 15);
	ASSERT_EQ(expected_payload, result->payload);
	EXPECT_TRUE(expected_payload == result->payload);
	}

	// Tests that the parser can handle multiple Cast Header Extensions in a RTP
	// packet, and ignores all but the one (Adaptive Latency) that it understands.
	TEST(RtpPacketParserTest, ParsesPacketWithMultipleExtensions) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xde, 0xad, // Sequence number.
	2, 4, 6, 8, // RTP timestamp.
	0, 0, 1, 1, // SSRC.
	0b11000011, // Is key frame, has ref frame ID; has 3 extensions.
	64, // Frame ID.
	0x0, 0xb, // Packet ID.
	0x0, 0xc, // Max packet ID.
	64, // Reference Frame ID.
	8, 2, 0, 0, // Unknown extension with 2 bytes of data.
	4, 2, 1, 14, // Cast Adaptive Latency Extension data.
	16, 5, 0, 0, 0, 0, 0, // Unknown extension with 5 bytes of data.
	1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x00000101;

	RtpPacketParser parser(kSenderSsrc);
	const auto result = parser.Parse(kInput);
	ASSERT_TRUE(result);
	EXPECT_EQ(RtpPayloadType::kAudioOpus, result->payload_type);
	EXPECT_EQ(UINT16_C(0xdead), result->sequence_number);
	EXPECT_EQ(RtpTimeTicks() + RtpTimeDelta::FromTicks(0x02040608),
	result->rtp_timestamp);
	EXPECT_TRUE(result->is_key_frame);
	EXPECT_EQ(FrameId::first() + 64, result->frame_id);
	EXPECT_EQ(FramePacketId{0x000b}, result->packet_id);
	EXPECT_EQ(FramePacketId{0x000c}, result->max_packet_id);
	EXPECT_EQ(FrameId::first() + 64, result->referenced_frame_id);
	EXPECT_EQ(270, result->new_playout_delay.count());
	const absl::Span<const uint8_t> expected_payload(kInput + 34, 15);
	ASSERT_EQ(expected_payload, result->payload);
	EXPECT_TRUE(expected_payload == result->payload);
	}

	// Tests that the parser ignores packets from an unknown source.
	TEST(RtpPacketParserTest, IgnoresPacketWithWrongSsrc) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xbe, 0xef, // Sequence number.
	9, 8, 7, 6, // RTP timestamp.
	4, 3, 2, 1, // SSRC.
	0b10000000, // Is key frame, no extensions.
	5, // Frame ID.
	0xa, 0xb, // Packet ID.
	0xa, 0xc, // Max packet ID.
	0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x01020304;

	RtpPacketParser parser(kSenderSsrc);
	const auto result = parser.Parse(kInput);
	ASSERT_FALSE(result);
	}

	// Tests that unexpected truncations in the RTP packets does not crash the
	// parser, and that it correctly errors-out.
	TEST(RtpPacketParserTest, RejectsTruncatedPackets) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xde, 0xad, // Sequence number.
	2, 4, 6, 8, // RTP timestamp.
	0, 0, 1, 1, // SSRC.
	0b11000011, // Is key frame, has ref frame ID; has 3 extensions.
	64, // Frame ID.
	0x0, 0xb, // Packet ID.
	0x0, 0xc, // Max packet ID.
	64, // Reference Frame ID.
	8, 2, 0, 0, // Unknown extension with 2 bytes of data.
	4, 2, 1, 14, // Cast Adaptive Latency Extension data.
	16, 5, 0, 0, 0, 0, 0, // Unknown extension with 5 bytes of data.
	1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x00000101;

	RtpPacketParser parser(kSenderSsrc);
	ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 1)));
	ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 18)));
	ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 22)));
	ASSERT_FALSE(parser.Parse(absl::Span<const uint8_t>(kInput, 33)));

	// When truncated to 34 bytes, the parser should see it as a packet with zero
	// payload bytes.
	const auto result_without_payload =
	parser.Parse(absl::Span<const uint8_t>(kInput, 34));
	ASSERT_TRUE(result_without_payload);
	EXPECT_TRUE(result_without_payload->payload.empty());

	// And, of course, with the entire kInput available, the parser should see it
	// as a packet with 15 bytes of payload.
	const auto result_with_payload =
	parser.Parse(absl::Span<const uint8_t>(kInput, sizeof(kInput)));
	ASSERT_TRUE(result_with_payload);
	EXPECT_EQ(size_t{15}, result_with_payload->payload.size());
	}

	// Tests that the parser rejects invalid packet ID values.
	TEST(RtpPacketParserTest, RejectsPacketWithBadFramePacketIds) {
	// clang-format off
	const uint8_t kInput[] = {
	0b10000000, // Version/Padding byte.
	96, // Payload type byte.
	0xbe, 0xef, // Sequence number.
	9, 8, 7, 6, // RTP timestamp.
	1, 2, 3, 4, // SSRC.
	0b10000000, // Is key frame, no extensions.
	5, // Frame ID.
	0xa, 0xb, // Packet ID (which is GREATER than the max packet ID).
	0x0, 0x1, // Max packet ID.
	0xf, 0xe, 0xd, 0xc, 0xb, 0xa, 0x9, 0x8, // Payload.
	};
	// clang-format on
	const Ssrc kSenderSsrc = 0x01020304;

	// The parser should reject the packet because its packet ID field is greater
	// than the max packet ID.
	RtpPacketParser parser(kSenderSsrc);
	ASSERT_FALSE(parser.Parse(kInput));

	// Now, modify the packet such that its "max packet ID" field is set to the
	// special "all packets lost" value. This makes the "packet ID" field valid,
	// because it is less than the "max packet ID", but the "max packet ID" value
	// itself is invalid.
	uint8_t input_with_bad_max_packet_id[sizeof(kInput)];
	memcpy(input_with_bad_max_packet_id, kInput, sizeof(kInput));
	WriteBigEndian<uint16_t>(kAllPacketsLost, &input_with_bad_max_packet_id[16]);
	const uint16_t packet_id =
	ReadBigEndian<uint16_t>(&input_with_bad_max_packet_id[14]);
	ASSERT_LE(packet_id, kAllPacketsLost);
	ASSERT_FALSE(parser.Parse(input_with_bad_max_packet_id));
	}

	} // namespace
	} // namespace cast
	} // namespace openscreen