OLD | NEW |
---|---|
(Empty) | |
1 /* | |
2 * Copyright (c) 2016 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 "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h" | |
12 | |
13 #include <utility> | |
14 | |
15 #include "webrtc/base/checks.h" | |
16 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" | |
17 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" | |
18 | |
19 namespace webrtc { | |
20 | |
21 namespace { | |
22 | |
23 // Maximum number of media packets that can be protected in one batch. | |
24 constexpr size_t kMaxMediaPackets = 48; | |
25 | |
26 // Maximum number of FEC packets stored inside ForwardErrorCorrection. | |
27 constexpr size_t kMaxFecPackets = kMaxMediaPackets; | |
28 | |
29 // FEC Level 0 header size in bytes. | |
30 constexpr size_t kFecLevel0HeaderSize = 10; | |
31 | |
32 // FEC Level 1 (ULP) header size in bytes (L bit is set). | |
33 constexpr size_t kFecLevel1HeaderSizeLBitSet = 2 + kUlpfecPacketMaskSizeLBitSet; | |
34 | |
35 // FEC Level 1 (ULP) header size in bytes (L bit is cleared). | |
36 constexpr size_t kFecLevel1HeaderSizeLBitClear = | |
37 2 + kUlpfecPacketMaskSizeLBitClear; | |
38 | |
39 size_t UlpfecHeaderSize(size_t packet_mask_size) { | |
40 RTC_DCHECK_LE(packet_mask_size, kUlpfecPacketMaskSizeLBitSet); | |
41 if (packet_mask_size <= kUlpfecPacketMaskSizeLBitClear) { | |
42 return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitClear; | |
43 } else { | |
44 return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet; | |
45 } | |
46 } | |
47 | |
48 } // namespace | |
49 | |
50 UlpfecHeaderReader::UlpfecHeaderReader() | |
51 : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {} | |
52 | |
53 UlpfecHeaderReader::~UlpfecHeaderReader() = default; | |
54 | |
55 bool UlpfecHeaderReader::ReadFecHeader( | |
56 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { | |
57 bool l_bit = (fec_packet->pkt->data[0] & 0x40) != 0u; | |
58 size_t packet_mask_size = | |
59 l_bit ? kUlpfecPacketMaskSizeLBitSet : kUlpfecPacketMaskSizeLBitClear; | |
60 fec_packet->fec_header_size = UlpfecHeaderSize(packet_mask_size); | |
61 uint16_t seq_num_base = | |
62 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[2]); | |
63 const size_t kPacketMaskOffset = kFecLevel0HeaderSize + 2; | |
64 fec_packet->packet_mask_infos[fec_packet->ssrc] = | |
danilchap
2016/08/30 12:29:01
should protected_ssrc be used as the key here?
(su
brandtr
2016/08/30 14:14:24
Yep, that's a bit cleaner.
| |
65 ForwardErrorCorrection::ReceivedFecPacket::StreamPacketMaskInfo{ | |
66 seq_num_base, kPacketMaskOffset, packet_mask_size}; | |
67 fec_packet->protection_length = | |
68 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[10]); | |
69 fec_packet->protected_ssrc = fec_packet->ssrc; // Due to RED. | |
70 | |
71 // Store length recovery field in temporary location in header. | |
72 // This makes the header "compatible" with the corresponding | |
73 // FlexFEC location of the length recovery field, thus simplifying | |
74 // the XORing operations. | |
75 memcpy(&fec_packet->pkt->data[2], &fec_packet->pkt->data[8], 2); | |
76 | |
77 return true; | |
78 } | |
79 | |
80 UlpfecHeaderWriter::UlpfecHeaderWriter() | |
81 : FecHeaderWriter(kMaxMediaPackets, | |
82 kMaxFecPackets, | |
83 kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet) {} | |
84 | |
85 UlpfecHeaderWriter::~UlpfecHeaderWriter() = default; | |
86 | |
87 // TODO(brandtr): Consider updating this implementation (which actually | |
88 // returns a bound on the sequence number spread), if logic is added to | |
89 // UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end | |
90 // in a string of zeroes. (Similar to how it is done in the FlexFEC case.) | |
91 size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask, | |
92 size_t packet_mask_size) const { | |
93 return packet_mask_size; | |
94 } | |
95 | |
96 size_t UlpfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const { | |
97 return UlpfecHeaderSize(packet_mask_size); | |
98 } | |
99 | |
100 void UlpfecHeaderWriter::FinalizeFecHeader( | |
101 uint16_t seq_num_base, | |
102 const uint8_t* packet_mask, | |
103 size_t packet_mask_size, | |
104 ForwardErrorCorrection::Packet* fec_packet) const { | |
105 // Set E bit to zero. | |
106 fec_packet->data[0] &= 0x7f; | |
107 // Set L bit based on packet mask size. (Note that the packet mask | |
108 // can only take on two discrete values.) | |
109 bool l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet); | |
110 if (l_bit) { | |
111 fec_packet->data[0] |= 0x40; // Set the L bit. | |
112 } else { | |
113 RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear); | |
114 fec_packet->data[0] &= 0xbf; // Clear the L bit. | |
115 } | |
116 // Copy length recovery field from temporary location. | |
117 memcpy(&fec_packet->data[8], &fec_packet->data[2], 2); | |
118 // Write sequence number base. | |
119 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[2], seq_num_base); | |
120 // Protection length is set to entire packet. (This is not | |
121 // required in general.) | |
122 const size_t fec_header_size = FecHeaderSize(packet_mask_size); | |
123 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[10], | |
124 fec_packet->length - fec_header_size); | |
125 // Copy the packet mask. | |
126 memcpy(&fec_packet->data[12], packet_mask, packet_mask_size); | |
127 } | |
128 | |
129 } // namespace webrtc | |
OLD | NEW |