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/flexfec_header_reader_writer.h" |
| 12 |
| 13 #include <string.h> |
| 14 |
| 15 #include <utility> |
| 16 |
| 17 #include "webrtc/base/checks.h" |
| 18 #include "webrtc/base/logging.h" |
| 19 #include "webrtc/modules/rtp_rtcp/source/byte_io.h" |
| 20 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h" |
| 21 |
| 22 namespace webrtc { |
| 23 |
| 24 namespace { |
| 25 |
| 26 // Maximum number of media packets that can be protected in one batch. |
| 27 constexpr size_t kMaxMediaPackets = 48; // Since we are reusing ULPFEC masks. |
| 28 |
| 29 // Maximum number of FEC packets stored inside ForwardErrorCorrection. |
| 30 constexpr size_t kMaxFecPackets = kMaxMediaPackets; |
| 31 |
| 32 // Size (in bytes) of packet masks, given number of K bits set. |
| 33 constexpr size_t kFlexfecPacketMaskSizes[] = {2, 6, 14}; |
| 34 |
| 35 // Size (in bytes) of part of header which is not packet mask specific. |
| 36 constexpr size_t kBaseHeaderSize = 12; |
| 37 |
| 38 // Size (in bytes) of part of header which is stream specific. |
| 39 constexpr size_t kStreamSpecificHeaderSize = 6; |
| 40 |
| 41 // Size (in bytes) of header, given the single stream packet mask size, i.e. |
| 42 // the number of K-bits set. |
| 43 constexpr size_t kHeaderSizes[] = { |
| 44 kBaseHeaderSize + kStreamSpecificHeaderSize + kFlexfecPacketMaskSizes[0], |
| 45 kBaseHeaderSize + kStreamSpecificHeaderSize + kFlexfecPacketMaskSizes[1], |
| 46 kBaseHeaderSize + kStreamSpecificHeaderSize + kFlexfecPacketMaskSizes[2]}; |
| 47 |
| 48 // We currently only support single-stream protection. |
| 49 // TODO(brandtr): Update this when we support multistream protection. |
| 50 constexpr uint8_t kSsrcCount = 1; |
| 51 |
| 52 // There are three reserved bytes that MUST be set to zero in the header. |
| 53 constexpr uint32_t kReservedBits = 0; |
| 54 |
| 55 // TODO(brandtr): Update this when we support multistream protection. |
| 56 constexpr size_t kPacketMaskOffset = |
| 57 kBaseHeaderSize + kStreamSpecificHeaderSize; |
| 58 |
| 59 // Here we count the K-bits as belonging to the packet mask. |
| 60 // This can be used in conjunction with FlexfecHeaderWriter::MinPacketMaskSize, |
| 61 // which calculates a bound on the needed packet mask size including K-bits, |
| 62 // given a packet mask without K-bits. |
| 63 size_t FlexfecHeaderSize(size_t packet_mask_size) { |
| 64 RTC_DCHECK_LE(packet_mask_size, kFlexfecPacketMaskSizes[2]); |
| 65 if (packet_mask_size <= kFlexfecPacketMaskSizes[0]) { |
| 66 return kHeaderSizes[0]; |
| 67 } else if (packet_mask_size <= kFlexfecPacketMaskSizes[1]) { |
| 68 return kHeaderSizes[1]; |
| 69 } |
| 70 return kHeaderSizes[2]; |
| 71 } |
| 72 |
| 73 } // namespace |
| 74 |
| 75 FlexfecHeaderReader::FlexfecHeaderReader() |
| 76 : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {} |
| 77 |
| 78 FlexfecHeaderReader::~FlexfecHeaderReader() = default; |
| 79 |
| 80 // TODO(brandtr): Update this function when we support flexible masks, |
| 81 // retransmissions, and/or several protected SSRCs. |
| 82 bool FlexfecHeaderReader::ReadFecHeader( |
| 83 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { |
| 84 if (fec_packet->pkt->length <= kBaseHeaderSize + kStreamSpecificHeaderSize) { |
| 85 LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; |
| 86 return false; |
| 87 } |
| 88 bool f_bit = (fec_packet->pkt->data[0] & 0x80) != 0; |
| 89 if (f_bit) { |
| 90 LOG(LS_INFO) << "FlexFEC packet with inflexible generator matrix. We do " |
| 91 "not yet support this, thus discarding packet."; |
| 92 return false; |
| 93 } |
| 94 bool r_bit = (fec_packet->pkt->data[0] & 0x40) != 0; |
| 95 if (r_bit) { |
| 96 LOG(LS_INFO) << "FlexFEC packet with retransmission bit set. We do not yet " |
| 97 "support this, thus discarding the packet."; |
| 98 return false; |
| 99 } |
| 100 uint8_t ssrc_count = |
| 101 ByteReader<uint8_t>::ReadBigEndian(&fec_packet->pkt->data[8]); |
| 102 if (ssrc_count != 1) { |
| 103 LOG(LS_INFO) << "FlexFEC packet protecting multiple media SSRCs. We do not " |
| 104 "yet support this, thus discarding packet."; |
| 105 return false; |
| 106 } |
| 107 uint32_t protected_ssrc = |
| 108 ByteReader<uint32_t>::ReadBigEndian(&fec_packet->pkt->data[12]); |
| 109 uint16_t seq_num_base = |
| 110 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[16]); |
| 111 |
| 112 // Parse the FlexFEC packet mask and remove the interleaved K-bits. |
| 113 // (See FEC header schematic in flexfec_header_reader_writer.h.) |
| 114 // We store the packed packet mask in-band, which "destroys" the standards |
| 115 // compliance of the header. That is fine though, since the code that |
| 116 // reads from the header (from this point and onwards) is aware of this. |
| 117 // TODO(brandtr): When the FEC packet classes have been refactored, store |
| 118 // the packed packet masks out-of-band, thus leaving the FlexFEC header as is. |
| 119 // |
| 120 // We treat the mask parts as unsigned integers with host order endianness |
| 121 // in order to simplify the bit shifting between bytes. |
| 122 if (fec_packet->pkt->length < kHeaderSizes[0]) { |
| 123 LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; |
| 124 return false; |
| 125 } |
| 126 uint8_t* const packet_mask = fec_packet->pkt->data + kPacketMaskOffset; |
| 127 bool k_bit0 = (packet_mask[0] & 0x80) != 0; |
| 128 uint16_t mask_part0 = ByteReader<uint16_t>::ReadBigEndian(&packet_mask[0]); |
| 129 // Shift away K-bit 0, implicitly clearing the last bit. |
| 130 mask_part0 <<= 1; |
| 131 ByteWriter<uint16_t>::WriteBigEndian(&packet_mask[0], mask_part0); |
| 132 size_t packet_mask_size; |
| 133 if (k_bit0) { |
| 134 // The first K-bit is set, and the packet mask is thus only 2 bytes long. |
| 135 // We have now read the entire FEC header, and the rest of the packet |
| 136 // is payload. |
| 137 packet_mask_size = kFlexfecPacketMaskSizes[0]; |
| 138 } else { |
| 139 if (fec_packet->pkt->length < kHeaderSizes[1]) { |
| 140 return false; |
| 141 } |
| 142 bool k_bit1 = (packet_mask[2] & 0x80) != 0; |
| 143 // We have already shifted the first two bytes of the packet mask one step |
| 144 // to the left, thus removing K-bit 0. We will now shift the next four bytes |
| 145 // of the packet mask two steps to the left. (One step for the removed |
| 146 // K-bit 0, and one step for the to be removed K-bit 1). |
| 147 uint8_t bit15 = (packet_mask[2] >> 6) & 0x01; |
| 148 packet_mask[1] |= bit15; |
| 149 uint32_t mask_part1 = ByteReader<uint32_t>::ReadBigEndian(&packet_mask[2]); |
| 150 // Shift away K-bit 1 and bit 15, implicitly clearing the last two bits. |
| 151 mask_part1 <<= 2; |
| 152 ByteWriter<uint32_t>::WriteBigEndian(&packet_mask[2], mask_part1); |
| 153 if (k_bit1) { |
| 154 // The first K-bit is clear, but the second K-bit is set. The packet |
| 155 // mask is thus 6 bytes long. We have now read the entire FEC header, |
| 156 // and the rest of the packet is payload. |
| 157 packet_mask_size = kFlexfecPacketMaskSizes[1]; |
| 158 } else { |
| 159 if (fec_packet->pkt->length < kHeaderSizes[2]) { |
| 160 LOG(LS_WARNING) << "Discarding truncated FlexFEC packet."; |
| 161 return false; |
| 162 } |
| 163 bool k_bit2 = (packet_mask[6] & 0x80) != 0; |
| 164 if (k_bit2) { |
| 165 // The first and second K-bits are clear, but the third K-bit is set. |
| 166 // The packet mask is thus 14 bytes long. We have now read the entire |
| 167 // FEC header, and the rest of the packet is payload. |
| 168 packet_mask_size = kFlexfecPacketMaskSizes[2]; |
| 169 } else { |
| 170 LOG(LS_WARNING) << "Discarding FlexFEC packet with malformed header."; |
| 171 return false; |
| 172 } |
| 173 // At this point, K-bits 0 and 1 have been removed, and the front-most |
| 174 // part of the FlexFEC packet mask has been packed accordingly. We will |
| 175 // now shift the remaning part of the packet mask three steps to the left. |
| 176 // This corresponds to the (in total) three K-bits, which have been |
| 177 // removed. |
| 178 uint8_t tail_bits = (packet_mask[6] >> 5) & 0x03; |
| 179 packet_mask[5] |= tail_bits; |
| 180 uint64_t mask_part2 = |
| 181 ByteReader<uint64_t>::ReadBigEndian(&packet_mask[6]); |
| 182 // Shift away K-bit 2, bit 46, and bit 47, implicitly clearing the last |
| 183 // three bits. |
| 184 mask_part2 <<= 3; |
| 185 ByteWriter<uint64_t>::WriteBigEndian(&packet_mask[6], mask_part2); |
| 186 } |
| 187 } |
| 188 |
| 189 // Store "ULPFECized" packet mask info. |
| 190 fec_packet->fec_header_size = FlexfecHeaderSize(packet_mask_size); |
| 191 fec_packet->protected_ssrc = protected_ssrc; |
| 192 fec_packet->seq_num_base = seq_num_base; |
| 193 fec_packet->packet_mask_offset = kPacketMaskOffset; |
| 194 fec_packet->packet_mask_size = packet_mask_size; |
| 195 |
| 196 // In FlexFEC, all media packets are protected in their entirety. |
| 197 fec_packet->protection_length = |
| 198 fec_packet->pkt->length - fec_packet->fec_header_size; |
| 199 |
| 200 return true; |
| 201 } |
| 202 |
| 203 FlexfecHeaderWriter::FlexfecHeaderWriter() |
| 204 : FecHeaderWriter(kMaxMediaPackets, kMaxFecPackets, kHeaderSizes[2]) {} |
| 205 |
| 206 FlexfecHeaderWriter::~FlexfecHeaderWriter() = default; |
| 207 |
| 208 size_t FlexfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask, |
| 209 size_t packet_mask_size) const { |
| 210 if (packet_mask_size == kUlpfecPacketMaskSizeLBitClear && |
| 211 (packet_mask[1] & 0x01) == 0) { |
| 212 // Packet mask is 16 bits long, with bit 15 clear. |
| 213 // It can be used as is. |
| 214 return kFlexfecPacketMaskSizes[0]; |
| 215 } else if (packet_mask_size == kUlpfecPacketMaskSizeLBitClear) { |
| 216 // Packet mask is 16 bits long, with bit 15 set. |
| 217 // We must expand the packet mask with zeros in the FlexFEC header. |
| 218 return kFlexfecPacketMaskSizes[1]; |
| 219 } else if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet && |
| 220 (packet_mask[5] & 0x03) == 0) { |
| 221 // Packet mask is 48 bits long, with bits 46 and 47 clear. |
| 222 // It can be used as is. |
| 223 return kFlexfecPacketMaskSizes[1]; |
| 224 } else if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) { |
| 225 // Packet mask is 48 bits long, with at least one of bits 46 and 47 set. |
| 226 // We must expand it with zeros. |
| 227 return kFlexfecPacketMaskSizes[2]; |
| 228 } |
| 229 RTC_NOTREACHED() << "Incorrect packet mask size: " << packet_mask_size << "."; |
| 230 return kFlexfecPacketMaskSizes[2]; |
| 231 } |
| 232 |
| 233 size_t FlexfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const { |
| 234 return FlexfecHeaderSize(packet_mask_size); |
| 235 } |
| 236 |
| 237 // This function adapts the precomputed ULPFEC packet masks to the |
| 238 // FlexFEC header standard. Note that the header size is computed by |
| 239 // FecHeaderSize(), so in this function we can be sure that we are |
| 240 // writing in space that is intended for the header. |
| 241 // |
| 242 // TODO(brandtr): Update this function when we support offset-based masks, |
| 243 // retransmissions, and protecting multiple SSRCs. |
| 244 void FlexfecHeaderWriter::FinalizeFecHeader( |
| 245 uint32_t media_ssrc, |
| 246 uint16_t seq_num_base, |
| 247 const uint8_t* packet_mask, |
| 248 size_t packet_mask_size, |
| 249 ForwardErrorCorrection::Packet* fec_packet) const { |
| 250 fec_packet->data[0] &= 0x7f; // Clear F bit. |
| 251 fec_packet->data[0] &= 0xbf; // Clear R bit. |
| 252 ByteWriter<uint8_t>::WriteBigEndian(&fec_packet->data[8], kSsrcCount); |
| 253 ByteWriter<uint32_t, 3>::WriteBigEndian(&fec_packet->data[9], kReservedBits); |
| 254 ByteWriter<uint32_t>::WriteBigEndian(&fec_packet->data[12], media_ssrc); |
| 255 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[16], seq_num_base); |
| 256 // Adapt ULPFEC packet mask to FlexFEC header. |
| 257 // |
| 258 // We treat the mask parts as unsigned integers with host order endianness |
| 259 // in order to simplify the bit shifting between bytes. |
| 260 uint8_t* const written_packet_mask = fec_packet->data + kPacketMaskOffset; |
| 261 if (packet_mask_size == kUlpfecPacketMaskSizeLBitSet) { |
| 262 // The packet mask is 48 bits long. |
| 263 uint16_t tmp_mask_part0 = |
| 264 ByteReader<uint16_t>::ReadBigEndian(&packet_mask[0]); |
| 265 uint32_t tmp_mask_part1 = |
| 266 ByteReader<uint32_t>::ReadBigEndian(&packet_mask[2]); |
| 267 |
| 268 tmp_mask_part0 >>= 1; // Shift, thus clearing K-bit 0. |
| 269 ByteWriter<uint16_t>::WriteBigEndian(&written_packet_mask[0], |
| 270 tmp_mask_part0); |
| 271 tmp_mask_part1 >>= 2; // Shift, thus clearing K-bit 1 and bit 15. |
| 272 ByteWriter<uint32_t>::WriteBigEndian(&written_packet_mask[2], |
| 273 tmp_mask_part1); |
| 274 bool bit15 = (packet_mask[1] & 0x01) != 0; |
| 275 if (bit15) |
| 276 written_packet_mask[2] |= 0x40; // Set bit 15. |
| 277 bool bit46 = (packet_mask[5] & 0x02) != 0; |
| 278 bool bit47 = (packet_mask[5] & 0x01) != 0; |
| 279 if (!bit46 && !bit47) { |
| 280 written_packet_mask[2] |= 0x80; // Set K-bit 1. |
| 281 } else { |
| 282 memset(&written_packet_mask[6], 0, 8); // Clear all trailing bits. |
| 283 written_packet_mask[6] |= 0x80; // Set K-bit 2. |
| 284 if (bit46) |
| 285 written_packet_mask[6] |= 0x40; // Set bit 46. |
| 286 if (bit47) |
| 287 written_packet_mask[6] |= 0x20; // Set bit 47. |
| 288 } |
| 289 } else if (packet_mask_size == kUlpfecPacketMaskSizeLBitClear) { |
| 290 // The packet mask is 16 bits long. |
| 291 uint16_t tmp_mask_part0 = |
| 292 ByteReader<uint16_t>::ReadBigEndian(&packet_mask[0]); |
| 293 |
| 294 tmp_mask_part0 >>= 1; // Shift, thus clearing K-bit 0. |
| 295 ByteWriter<uint16_t>::WriteBigEndian(&written_packet_mask[0], |
| 296 tmp_mask_part0); |
| 297 bool bit15 = (packet_mask[1] & 0x01) != 0; |
| 298 if (!bit15) { |
| 299 written_packet_mask[0] |= 0x80; // Set K-bit 0. |
| 300 } else { |
| 301 memset(&written_packet_mask[2], 0U, 4); // Clear all trailing bits. |
| 302 written_packet_mask[2] |= 0x80; // Set K-bit 1. |
| 303 written_packet_mask[2] |= 0x40; // Set bit 15. |
| 304 } |
| 305 } else { |
| 306 RTC_NOTREACHED() << "Incorrect packet mask size: " << packet_mask_size |
| 307 << "."; |
| 308 } |
| 309 } |
| 310 |
| 311 } // namespace webrtc |
OLD | NEW |