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->protected_ssrc = fec_packet->ssrc; // Due to RED. |
| 65 fec_packet->packet_mask_infos[fec_packet->protected_ssrc] = |
| 66 ForwardErrorCorrection::ReceivedFecPacket::StreamPacketMaskInfo{ |
| 67 seq_num_base, kPacketMaskOffset, packet_mask_size}; |
| 68 fec_packet->protection_length = |
| 69 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[10]); |
| 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 |