1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 #include "modules/rtp_rtcp/source/fec_test_helper.h"
12
13 #include <memory>
14 #include <utility>
15
16 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
17 #include "modules/rtp_rtcp/source/byte_io.h"
18 #include "modules/rtp_rtcp/source/rtp_packet.h"
19 #include "rtc_base/checks.h"
20
21 namespace webrtc {
22 namespace test {
23 namespace fec {
24
25 namespace {
26
27 constexpr uint8_t kRtpMarkerBitMask = 0x80;
28
29 constexpr uint8_t kFecPayloadType = 96;
30 constexpr uint8_t kRedPayloadType = 97;
31 constexpr uint8_t kVp8PayloadType = 120;
32
33 constexpr int kPacketTimestampIncrement = 3000;
34 } // namespace
35
MediaPacketGenerator(uint32_t min_packet_size,uint32_t max_packet_size,uint32_t ssrc,Random * random)36 MediaPacketGenerator::MediaPacketGenerator(uint32_t min_packet_size,
37 uint32_t max_packet_size,
38 uint32_t ssrc,
39 Random* random)
40 : min_packet_size_(min_packet_size),
41 max_packet_size_(max_packet_size),
42 ssrc_(ssrc),
43 random_(random) {}
44
45 MediaPacketGenerator::~MediaPacketGenerator() = default;
46
ConstructMediaPackets(int num_media_packets,uint16_t start_seq_num)47 ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
48 int num_media_packets,
49 uint16_t start_seq_num) {
50 RTC_DCHECK_GT(num_media_packets, 0);
51 uint16_t seq_num = start_seq_num;
52 int time_stamp = random_->Rand<int>();
53
54 ForwardErrorCorrection::PacketList media_packets;
55
56 for (int i = 0; i < num_media_packets; ++i) {
57 std::unique_ptr<ForwardErrorCorrection::Packet> media_packet(
58 new ForwardErrorCorrection::Packet());
59 media_packet->data.SetSize(
60 random_->Rand(min_packet_size_, max_packet_size_));
61
62 uint8_t* data = media_packet->data.MutableData();
63 // Generate random values for the first 2 bytes
64 data[0] = random_->Rand<uint8_t>();
65 data[1] = random_->Rand<uint8_t>();
66
67 // The first two bits are assumed to be 10 by the FEC encoder.
68 // In fact the FEC decoder will set the two first bits to 10 regardless of
69 // what they actually were. Set the first two bits to 10 so that a memcmp
70 // can be performed for the whole restored packet.
71 data[0] |= 0x80;
72 data[0] &= 0xbf;
73
74 // FEC is applied to a whole frame.
75 // A frame is signaled by multiple packets without the marker bit set
76 // followed by the last packet of the frame for which the marker bit is set.
77 // Only push one (fake) frame to the FEC.
78 data[1] &= 0x7f;
79
80 webrtc::ByteWriter<uint16_t>::WriteBigEndian(&data[2], seq_num);
81 webrtc::ByteWriter<uint32_t>::WriteBigEndian(&data[4], time_stamp);
82 webrtc::ByteWriter<uint32_t>::WriteBigEndian(&data[8], ssrc_);
83
84 // Generate random values for payload.
85 for (size_t j = 12; j < media_packet->data.size(); ++j)
86 data[j] = random_->Rand<uint8_t>();
87 seq_num++;
88 media_packets.push_back(std::move(media_packet));
89 }
90 // Last packet, set marker bit.
91 ForwardErrorCorrection::Packet* media_packet = media_packets.back().get();
92 RTC_DCHECK(media_packet);
93 media_packet->data.MutableData()[1] |= 0x80;
94
95 next_seq_num_ = seq_num;
96
97 return media_packets;
98 }
99
ConstructMediaPackets(int num_media_packets)100 ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
101 int num_media_packets) {
102 return ConstructMediaPackets(num_media_packets, random_->Rand<uint16_t>());
103 }
104
GetNextSeqNum()105 uint16_t MediaPacketGenerator::GetNextSeqNum() {
106 return next_seq_num_;
107 }
108
AugmentedPacketGenerator(uint32_t ssrc)109 AugmentedPacketGenerator::AugmentedPacketGenerator(uint32_t ssrc)
110 : num_packets_(0), ssrc_(ssrc), seq_num_(0), timestamp_(0) {}
111
NewFrame(size_t num_packets)112 void AugmentedPacketGenerator::NewFrame(size_t num_packets) {
113 num_packets_ = num_packets;
114 timestamp_ += kPacketTimestampIncrement;
115 }
116
NextPacketSeqNum()117 uint16_t AugmentedPacketGenerator::NextPacketSeqNum() {
118 return ++seq_num_;
119 }
120
NextPacket(size_t offset,size_t length)121 std::unique_ptr<AugmentedPacket> AugmentedPacketGenerator::NextPacket(
122 size_t offset,
123 size_t length) {
124 std::unique_ptr<AugmentedPacket> packet(new AugmentedPacket());
125
126 packet->data.SetSize(length + kRtpHeaderSize);
127 uint8_t* data = packet->data.MutableData();
128 for (size_t i = 0; i < length; ++i)
129 data[i + kRtpHeaderSize] = offset + i;
130 packet->data.SetSize(length + kRtpHeaderSize);
131 packet->header.headerLength = kRtpHeaderSize;
132 packet->header.markerBit = (num_packets_ == 1);
133 packet->header.payloadType = kVp8PayloadType;
134 packet->header.sequenceNumber = seq_num_;
135 packet->header.timestamp = timestamp_;
136 packet->header.ssrc = ssrc_;
137 WriteRtpHeader(packet->header, data);
138 ++seq_num_;
139 --num_packets_;
140
141 return packet;
142 }
143
WriteRtpHeader(const RTPHeader & header,uint8_t * data)144 void AugmentedPacketGenerator::WriteRtpHeader(const RTPHeader& header,
145 uint8_t* data) {
146 data[0] = 0x80; // Version 2.
147 data[1] = header.payloadType;
148 data[1] |= (header.markerBit ? kRtpMarkerBitMask : 0);
149 ByteWriter<uint16_t>::WriteBigEndian(data + 2, header.sequenceNumber);
150 ByteWriter<uint32_t>::WriteBigEndian(data + 4, header.timestamp);
151 ByteWriter<uint32_t>::WriteBigEndian(data + 8, header.ssrc);
152 }
153
FlexfecPacketGenerator(uint32_t media_ssrc,uint32_t flexfec_ssrc)154 FlexfecPacketGenerator::FlexfecPacketGenerator(uint32_t media_ssrc,
155 uint32_t flexfec_ssrc)
156 : AugmentedPacketGenerator(media_ssrc),
157 flexfec_ssrc_(flexfec_ssrc),
158 flexfec_seq_num_(0),
159 flexfec_timestamp_(0) {}
160
BuildFlexfecPacket(const ForwardErrorCorrection::Packet & packet)161 std::unique_ptr<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
162 const ForwardErrorCorrection::Packet& packet) {
163 RTC_DCHECK_LE(packet.data.size(),
164 static_cast<size_t>(IP_PACKET_SIZE - kRtpHeaderSize));
165
166 RTPHeader header;
167 header.sequenceNumber = flexfec_seq_num_;
168 ++flexfec_seq_num_;
169 header.timestamp = flexfec_timestamp_;
170 flexfec_timestamp_ += kPacketTimestampIncrement;
171 header.ssrc = flexfec_ssrc_;
172
173 std::unique_ptr<AugmentedPacket> packet_with_rtp_header(
174 new AugmentedPacket());
175 packet_with_rtp_header->data.SetSize(kRtpHeaderSize + packet.data.size());
176 WriteRtpHeader(header, packet_with_rtp_header->data.MutableData());
177 memcpy(packet_with_rtp_header->data.MutableData() + kRtpHeaderSize,
178 packet.data.cdata(), packet.data.size());
179
180 return packet_with_rtp_header;
181 }
182
UlpfecPacketGenerator(uint32_t ssrc)183 UlpfecPacketGenerator::UlpfecPacketGenerator(uint32_t ssrc)
184 : AugmentedPacketGenerator(ssrc) {}
185
BuildMediaRedPacket(const AugmentedPacket & packet,bool is_recovered)186 RtpPacketReceived UlpfecPacketGenerator::BuildMediaRedPacket(
187 const AugmentedPacket& packet,
188 bool is_recovered) {
189 // Create a temporary buffer used to wrap the media packet in RED.
190 rtc::CopyOnWriteBuffer red_buffer;
191 const size_t kHeaderLength = packet.header.headerLength;
192 // Append header.
193 red_buffer.SetData(packet.data.data(), kHeaderLength);
194 // Find payload type and add it as RED header.
195 uint8_t media_payload_type = red_buffer[1] & 0x7F;
196 red_buffer.AppendData({media_payload_type});
197 // Append rest of payload/padding.
198 red_buffer.AppendData(
199 packet.data.Slice(kHeaderLength, packet.data.size() - kHeaderLength));
200
201 RtpPacketReceived red_packet;
202 RTC_CHECK(red_packet.Parse(std::move(red_buffer)));
203 red_packet.SetPayloadType(kRedPayloadType);
204 red_packet.set_recovered(is_recovered);
205
206 return red_packet;
207 }
208
BuildUlpfecRedPacket(const ForwardErrorCorrection::Packet & packet)209 RtpPacketReceived UlpfecPacketGenerator::BuildUlpfecRedPacket(
210 const ForwardErrorCorrection::Packet& packet) {
211 // Create a fake media packet to get a correct header. 1 byte RED header.
212 ++num_packets_;
213 std::unique_ptr<AugmentedPacket> fake_packet =
214 NextPacket(0, packet.data.size() + 1);
215
216 RtpPacketReceived red_packet;
217 red_packet.Parse(fake_packet->data);
218 red_packet.SetMarker(false);
219 uint8_t* rtp_payload = red_packet.AllocatePayload(packet.data.size() + 1);
220 rtp_payload[0] = kFecPayloadType;
221 red_packet.SetPayloadType(kRedPayloadType);
222 memcpy(rtp_payload + 1, packet.data.cdata(), packet.data.size());
223 red_packet.set_recovered(false);
224
225 return red_packet;
226 }
227
228 } // namespace fec
229 } // namespace test
230 } // namespace webrtc
231