Line data    Source code

       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           0 : size_t UlpfecHeaderSize(size_t packet_mask_size) {
      42           0 :   RTC_DCHECK_LE(packet_mask_size, kUlpfecPacketMaskSizeLBitSet);
      43           0 :   if (packet_mask_size <= kUlpfecPacketMaskSizeLBitClear) {
      44           0 :     return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitClear;
      45             :   } else {
      46           0 :     return kFecLevel0HeaderSize + kFecLevel1HeaderSizeLBitSet;
      47             :   }
      48             : }
      49             : 
      50             : }  // namespace
      51             : 
      52           0 : UlpfecHeaderReader::UlpfecHeaderReader()
      53           0 :     : FecHeaderReader(kMaxMediaPackets, kMaxFecPackets) {}
      54             : 
      55             : UlpfecHeaderReader::~UlpfecHeaderReader() = default;
      56             : 
      57           0 : bool UlpfecHeaderReader::ReadFecHeader(
      58             :     ForwardErrorCorrection::ReceivedFecPacket* fec_packet) const {
      59           0 :   bool l_bit = (fec_packet->pkt->data[0] & 0x40) != 0u;
      60             :   size_t packet_mask_size =
      61           0 :       l_bit ? kUlpfecPacketMaskSizeLBitSet : kUlpfecPacketMaskSizeLBitClear;
      62           0 :   fec_packet->fec_header_size = UlpfecHeaderSize(packet_mask_size);
      63             :   uint16_t seq_num_base =
      64           0 :       ByteReader<uint16_t>::ReadBigEndian(&fec_packet->pkt->data[2]);
      65           0 :   fec_packet->protected_ssrc = fec_packet->ssrc;  // Due to RED.
      66           0 :   fec_packet->seq_num_base = seq_num_base;
      67           0 :   fec_packet->packet_mask_offset = kPacketMaskOffset;
      68           0 :   fec_packet->packet_mask_size = packet_mask_size;
      69           0 :   fec_packet->protection_length =
      70           0 :       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           0 :   memcpy(&fec_packet->pkt->data[2], &fec_packet->pkt->data[8], 2);
      77             : 
      78           0 :   return true;
      79             : }
      80             : 
      81           0 : UlpfecHeaderWriter::UlpfecHeaderWriter()
      82             :     : FecHeaderWriter(kMaxMediaPackets,
      83             :                       kMaxFecPackets,
      84           0 :                       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           0 : size_t UlpfecHeaderWriter::MinPacketMaskSize(const uint8_t* packet_mask,
      93             :                                              size_t packet_mask_size) const {
      94           0 :   return packet_mask_size;
      95             : }
      96             : 
      97           0 : size_t UlpfecHeaderWriter::FecHeaderSize(size_t packet_mask_size) const {
      98           0 :   return UlpfecHeaderSize(packet_mask_size);
      99             : }
     100             : 
     101           0 : void UlpfecHeaderWriter::FinalizeFecHeader(
     102             :     uint32_t /* media_ssrc */,
     103             :     uint16_t seq_num_base,
     104             :     const uint8_t* packet_mask,
     105             :     size_t packet_mask_size,
     106             :     ForwardErrorCorrection::Packet* fec_packet) const {
     107             :   // Set E bit to zero.
     108           0 :   fec_packet->data[0] &= 0x7f;
     109             :   // Set L bit based on packet mask size. (Note that the packet mask
     110             :   // can only take on two discrete values.)
     111           0 :   bool l_bit = (packet_mask_size == kUlpfecPacketMaskSizeLBitSet);
     112           0 :   if (l_bit) {
     113           0 :     fec_packet->data[0] |= 0x40;  // Set the L bit.
     114             :   } else {
     115           0 :     RTC_DCHECK_EQ(packet_mask_size, kUlpfecPacketMaskSizeLBitClear);
     116           0 :     fec_packet->data[0] &= 0xbf;  // Clear the L bit.
     117             :   }
     118             :   // Copy length recovery field from temporary location.
     119           0 :   memcpy(&fec_packet->data[8], &fec_packet->data[2], 2);
     120             :   // Write sequence number base.
     121           0 :   ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[2], seq_num_base);
     122             :   // Protection length is set to entire packet. (This is not
     123             :   // required in general.)
     124           0 :   const size_t fec_header_size = FecHeaderSize(packet_mask_size);
     125           0 :   ByteWriter<uint16_t>::WriteBigEndian(&fec_packet->data[10],
     126           0 :                                        fec_packet->length - fec_header_size);
     127             :   // Copy the packet mask.
     128           0 :   memcpy(&fec_packet->data[12], packet_mask, packet_mask_size);
     129           0 : }
     130             : 
     131             : }  // namespace webrtc