1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
// 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_packetizer.h"
#include <chrono>
#include <memory>
#include "absl/types/optional.h"
#include "cast/streaming/frame_crypto.h"
#include "cast/streaming/rtp_defines.h"
#include "cast/streaming/rtp_packet_parser.h"
#include "cast/streaming/ssrc.h"
#include "gtest/gtest.h"
#include "util/chrono_helpers.h"
#include "util/crypto/random_bytes.h"
namespace openscreen {
namespace cast {
namespace {
constexpr RtpPayloadType kPayloadType = RtpPayloadType::kAudioOpus;
// Returns true if |needle| is fully within |haystack|.
bool IsSubspan(absl::Span<const uint8_t> needle,
absl::Span<const uint8_t> haystack) {
return (needle.data() >= haystack.data()) &&
((needle.data() + needle.size()) <=
(haystack.data() + haystack.size()));
}
class RtpPacketizerTest : public testing::Test {
public:
RtpPacketizerTest() = default;
~RtpPacketizerTest() = default;
RtpPacketizer* packetizer() { return &packetizer_; }
EncryptedFrame CreateFrame(FrameId frame_id,
bool is_key_frame,
milliseconds new_playout_delay,
int payload_size) const {
EncodedFrame frame;
frame.dependency = is_key_frame ? EncodedFrame::KEY_FRAME
: EncodedFrame::DEPENDS_ON_ANOTHER;
frame.frame_id = frame_id;
frame.referenced_frame_id = is_key_frame ? frame_id : (frame_id - 1);
frame.rtp_timestamp = RtpTimeTicks() + RtpTimeDelta::FromTicks(987);
frame.reference_time = Clock::now();
frame.new_playout_delay = new_playout_delay;
std::unique_ptr<uint8_t[]> buffer(new uint8_t[payload_size]);
for (int i = 0; i < payload_size; ++i) {
buffer[i] = static_cast<uint8_t>(i);
}
frame.data = absl::Span<uint8_t>(buffer.get(), payload_size);
return crypto_.Encrypt(frame);
}
// Generates one of the frame's packets, then parses it and checks for the
// expected values. Thus, this test assumes PacketParser is already working
// (i.e., all RtpPacketParser unit tests are passing).
void TestGeneratePacket(const EncryptedFrame& frame,
FramePacketId packet_id) {
SCOPED_TRACE(testing::Message() << "packet_id=" << packet_id);
const int frame_payload_size = frame.data.size();
constexpr int kExpectedRtpHeaderSize = 23;
const int packet_payload_size =
kMaxRtpPacketSizeForIpv4UdpOnEthernet - kExpectedRtpHeaderSize;
const int final_packet_payload_size =
frame_payload_size % packet_payload_size;
const int num_packets = 1 + frame_payload_size / packet_payload_size;
// Generate a RTP packet and parse it.
uint8_t scratch[kMaxRtpPacketSizeForIpv4UdpOnEthernet];
memset(scratch, 0, sizeof(scratch));
const auto packet = packetizer_.GeneratePacket(frame, packet_id, scratch);
ASSERT_TRUE(IsSubspan(packet, scratch));
const auto result = parser_.Parse(packet);
ASSERT_TRUE(result);
// Check that RTP header fields match expected values.
EXPECT_EQ(kPayloadType, result->payload_type);
EXPECT_EQ(frame.rtp_timestamp, result->rtp_timestamp);
EXPECT_EQ(frame.dependency == EncodedFrame::KEY_FRAME,
result->is_key_frame);
EXPECT_EQ(frame.frame_id, result->frame_id);
EXPECT_EQ(packet_id, result->packet_id);
EXPECT_EQ(static_cast<FramePacketId>(num_packets - 1),
result->max_packet_id);
EXPECT_EQ(frame.referenced_frame_id, result->referenced_frame_id);
// The sequence number field MUST be different for each packet, regardless
// of whether the exact same packet is being re-generated.
if (last_sequence_number_) {
EXPECT_EQ(static_cast<uint16_t>(*last_sequence_number_ + 1),
result->sequence_number);
}
last_sequence_number_ = result->sequence_number;
// If there is a playout delay change starting with this |frame|, it must
// only be mentioned in the first packet.
if (packet_id == FramePacketId{0}) {
EXPECT_EQ(frame.new_playout_delay, result->new_playout_delay);
} else {
EXPECT_EQ(milliseconds(0), result->new_playout_delay);
}
// Check that the RTP payload is correct for this packet.
ASSERT_TRUE(IsSubspan(result->payload, packet));
// Last packet is smaller, as its payload is just the remaining bytes.
const int expected_payload_size = (int{packet_id} == (num_packets - 1))
? final_packet_payload_size
: packet_payload_size;
EXPECT_EQ(expected_payload_size, static_cast<int>(result->payload.size()));
const absl::Span<const uint8_t> expected_bytes(
frame.data.data() + (packet_id * packet_payload_size),
expected_payload_size);
EXPECT_EQ(expected_bytes, result->payload);
}
private:
// The RtpPacketizer instance under test, plus some surrounding dependencies
// to generate its input and examine its output.
const Ssrc ssrc_{GenerateSsrc(true)};
const FrameCrypto crypto_{crypto::GenerateRandomBytes16(),
crypto::GenerateRandomBytes16()};
RtpPacketizer packetizer_{kPayloadType, ssrc_,
kMaxRtpPacketSizeForIpv4UdpOnEthernet};
RtpPacketParser parser_{ssrc_};
// absl::nullopt until the random starting sequence number, from the first
// packet generated by TestGeneratePacket(), is known.
absl::optional<uint16_t> last_sequence_number_;
};
// Tests that all packets are generated for one key frame, followed by 9 "delta"
// frames. The key frame is larger than the other frames, as is typical in a
// real-world usage scenario.
TEST_F(RtpPacketizerTest, GeneratesPacketsForSequenceOfFrames) {
for (int i = 0; i < 10; ++i) {
const bool is_key_frame = (i == 0);
const int frame_payload_size = is_key_frame ? 48269 : 10000;
const EncryptedFrame frame =
CreateFrame(FrameId::first() + i, is_key_frame, milliseconds(0),
frame_payload_size);
SCOPED_TRACE(testing::Message() << "frame_id=" << frame.frame_id);
const int num_packets = packetizer()->ComputeNumberOfPackets(frame);
ASSERT_EQ(is_key_frame ? 34 : 7, num_packets);
for (int j = 0; j < num_packets; ++j) {
TestGeneratePacket(frame, static_cast<FramePacketId>(j));
if (testing::Test::HasFailure()) {
return;
}
}
}
}
// Tests that all packets are generated for a key frame that includes a playout
// delay change. Only the first packet should mention the playout delay change.
TEST_F(RtpPacketizerTest, GeneratesPacketsForFrameWithLatencyChange) {
const int frame_payload_size = 38383;
const EncryptedFrame frame = CreateFrame(
FrameId::first() + 42, true, milliseconds(543), frame_payload_size);
const int num_packets = packetizer()->ComputeNumberOfPackets(frame);
ASSERT_EQ(27, num_packets);
for (int i = 0; i < num_packets; ++i) {
TestGeneratePacket(frame, static_cast<FramePacketId>(i));
if (testing::Test::HasFailure()) {
return;
}
}
}
// Tests that a single, valid RTP packet is generated for a frame with no data
// payload. Having no payload is valid with some codecs (e.g., complete audio
// silence can be represented by an empty payload).
TEST_F(RtpPacketizerTest, GeneratesOnePacketForFrameWithNoPayload) {
const int frame_payload_size = 0;
const EncryptedFrame frame = CreateFrame(FrameId::first() + 99, false,
milliseconds(0), frame_payload_size);
ASSERT_EQ(1, packetizer()->ComputeNumberOfPackets(frame));
TestGeneratePacket(frame, FramePacketId{0});
}
// Tests that re-generating the same packet for re-transmission works, including
// a different sequence counter value in the packet each time.
TEST_F(RtpPacketizerTest, GeneratesPacketForRetransmission) {
const int frame_payload_size = 16384;
const EncryptedFrame frame =
CreateFrame(FrameId::first(), true, milliseconds(0), frame_payload_size);
const int num_packets = packetizer()->ComputeNumberOfPackets(frame);
ASSERT_EQ(12, num_packets);
for (int i = 0; i < 10; ++i) {
// Keep generating the same packet. TestGeneratePacket() will check that a
// different sequence number is used each time.
TestGeneratePacket(frame, FramePacketId{3});
}
}
} // namespace
} // namespace cast
} // namespace openscreen
|
