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 constexpr size_t kPacketMaskOffset = kFecLevel0HeaderSize + 2; |
| 40 |
| 41 size_t UlpfecHeaderSize(size_t packet_mask_size) { |
| 42 RTC_DCHECK_LE(packet_mask_size, kUlpfecPacketMaskSizeLBitSet); |
| 43 if (packet_mask_size <= kUlpfecPacketMaskSizeLBitClear) { |
| 44 return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitClear; |
| 45 } else { |
| 46 return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet; |
| 47 } |
| 48 } |
| 49 |
| 50 } // namespace |
| 51 |
| 52 UlpfecHeaderReader::UlpfecHeaderReader() |
| 53 : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {} |
| 54 |
| 55 UlpfecHeaderReader::~UlpfecHeaderReader() = default; |
| 56 |
| 57 bool UlpfecHeaderReader::ReadFecHeader( |
| 58 ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const { |
| 59 bool l_bit = (fec_packet->pkt->data[0] & 0x40) != 0u; |
| 60 size_t packet_mask_size = |
| 61 l_bit ? kUlpfecPacketMaskSizeLBitSet : kUlpfecPacketMaskSizeLBitClear; |
| 62 fec_packet->fec_header_size = UlpfecHeaderSize(packet_mask_size); |
| 63 uint16_t seq_num_base = |
| 64 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[2]); |
| 65 fec_packet->protected_ssrc = fec_packet->ssrc; // Due to RED. |
| 66 fec_packet->seq_num_base = seq_num_base; |
| 67 fec_packet->packet_mask_offset = kPacketMaskOffset; |
| 68 fec_packet->packet_mask_size = packet_mask_size; |
| 69 fec_packet->protection_length = |
| 70 ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[10]); |
| 71 |
| 72 // Store length recovery field in temporary location in header. |
| 73 // This makes the header "compatible" with the corresponding |
| 74 // FlexFEC location of the length recovery field, thus simplifying |
| 75 // the XORing operations. |
| 76 memcpy(&fec_packet->pkt->data[2], &fec_packet->pkt->data[8], 2); |
| 77 |
| 78 return true; |
| 79 } |
| 80 |
| 81 UlpfecHeaderWriter::UlpfecHeaderWriter() |
| 82 : FecHeaderWriter(kMaxMediaPackets, |
| 83 kMaxFecPackets, |
| 84 kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet) {} |
| 85 |
| 86 UlpfecHeaderWriter::~UlpfecHeaderWriter() = default; |
| 87 |
| 88 // TODO(brandtr): Consider updating this implementation (which actually |
| 89 // returns a bound on the sequence number spread), if logic is added to |
| 90 // UlpfecHeaderWriter::FinalizeFecHeader to truncate packet masks which end |
| 91 // in a string of zeroes. (Similar to how it is done in the FlexFEC case.) |
| 92 size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask, |
| 93 size_t packet_mask_size) const { |
| 94 return packet_mask_size; |
| 95 } |
| 96 |
| 97 size_t UlpfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const { |
| 98 return UlpfecHeaderSize(packet_mask_size); |
| 99 } |
| 100 |
| 101 void UlpfecHeaderWriter::FinalizeFecHeader( |
| 102 uint16_t seq_num_base, |
| 103 const uint8_t* packet_mask, |
| 104 size_t packet_mask_size, |
| 105 ForwardErrorCorrection::Packet* fec_packet) const { |
| 106 // Set E bit to zero. |
| 107 fec_packet->data[0] &= 0x7f; |
| 108 // Set L bit based on packet mask size. (Note that the packet mask |
| 109 // can only take on two discrete values.) |
| 110 bool l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet); |
| 111 if (l_bit) { |
| 112 fec_packet->data[0] |= 0x40; // Set the L bit. |
| 113 } else { |
| 114 RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear); |
| 115 fec_packet->data[0] &= 0xbf; // Clear the L bit. |
| 116 } |
| 117 // Copy length recovery field from temporary location. |
| 118 memcpy(&fec_packet->data[8], &fec_packet->data[2], 2); |
| 119 // Write sequence number base. |
| 120 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[2], seq_num_base); |
| 121 // Protection length is set to entire packet. (This is not |
| 122 // required in general.) |
| 123 const size_t fec_header_size = FecHeaderSize(packet_mask_size); |
| 124 ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[10], |
| 125 fec_packet->length - fec_header_size); |
| 126 // Copy the packet mask. |
| 127 memcpy(&fec_packet->data[12], packet_mask, packet_mask_size); |
| 128 } |
| 129 |
| 130 } // namespace webrtc |
OLD | NEW |