Generalize FEC header formatting. (pt. 4)

webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
 
 #include <assert.h>
 #include <string.h>
 
+#include <algorithm>
+
+#include "webrtc/base/checks.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_private_tables_bursty.h"
 #include "webrtc/modules/rtp_rtcp/source/fec_private_tables_random.h"
 
 namespace {
 using webrtc::fec_private_tables::kPacketMaskBurstyTbl;
 using webrtc::fec_private_tables::kPacketMaskRandomTbl;
 
 // Allow for different modes of protection for packets in UEP case.
 enum ProtectionMode {
   kModeNoOverlap,
@@ skipping 170 matching lines @@
                                int num_mask_bytes,
                                ProtectionMode mode,
                                uint8_t* packet_mask,
                                const PacketMaskTable& mask_table) {
   if (mode == kModeNoOverlap) {
     // sub_mask21
 
     const int l_bit =
         (num_media_packets - num_fec_for_imp_packets) > 16 ? 1 : 0;
 
-    const int res_mask_bytes =
-        (l_bit == 1) ? kMaskSizeLBitSet : kMaskSizeLBitClear;
+    const int res_mask_bytes = (l_bit == 1) ? kUlpfecPacketMaskSizeLBitSet
+                                            : kUlpfecPacketMaskSizeLBitClear;
 
     const uint8_t* packet_mask_sub_21 =
         mask_table.fec_packet_mask_table()[num_media_packets -
                                            num_fec_for_imp_packets -
                                            1][num_fec_remaining - 1];
 
     ShiftFitSubMask(num_mask_bytes, res_mask_bytes, num_fec_for_imp_packets,
                     (num_fec_for_imp_packets + num_fec_remaining),
                     packet_mask_sub_21, packet_mask);
 
@@ skipping 19 matching lines @@
   }
 }
 
 // Protection for important (first partition) packets
 void ImportantPacketProtection(int num_fec_for_imp_packets,
                                int num_imp_packets,
                                int num_mask_bytes,
                                uint8_t* packet_mask,
                                const PacketMaskTable& mask_table) {
   const int l_bit = num_imp_packets > 16 ? 1 : 0;
-  const int num_imp_mask_bytes =
-      (l_bit == 1) ? kMaskSizeLBitSet : kMaskSizeLBitClear;
+  const int num_imp_mask_bytes = (l_bit == 1) ? kUlpfecPacketMaskSizeLBitSet
+                                              : kUlpfecPacketMaskSizeLBitClear;
 
   // Get sub_mask1 from table
   const uint8_t* packet_mask_sub_1 =
       mask_table.fec_packet_mask_table()[num_imp_packets -
                                          1][num_fec_for_imp_packets - 1];
 
   FitSubMask(num_mask_bytes, num_imp_mask_bytes, num_fec_for_imp_packets,
              packet_mask_sub_1, packet_mask);
 }
 
@@ skipping 108 matching lines @@
                          int num_fec_packets,
                          int num_imp_packets,
                          bool use_unequal_protection,
                          const PacketMaskTable& mask_table,
                          uint8_t* packet_mask) {
   assert(num_media_packets > 0);
   assert(num_fec_packets <= num_media_packets && num_fec_packets > 0);
   assert(num_imp_packets <= num_media_packets && num_imp_packets >= 0);
 
   int l_bit = num_media_packets > 16 ? 1 : 0;
-  const int num_mask_bytes =
-      (l_bit == 1) ? kMaskSizeLBitSet : kMaskSizeLBitClear;
+  const int num_mask_bytes = (l_bit == 1) ? kUlpfecPacketMaskSizeLBitSet
+                                          : kUlpfecPacketMaskSizeLBitClear;
 
   // Equal-protection for these cases.
   if (!use_unequal_protection || num_imp_packets == 0) {
     // Retrieve corresponding mask table directly:for equal-protection case.
     // Mask = (k,n-k), with protection factor = (n-k)/k,
     // where k = num_media_packets, n=total#packets, (n-k)=num_fec_packets.
     memcpy(packet_mask,
            mask_table.fec_packet_mask_table()[num_media_packets -
                                               1][num_fec_packets - 1],
            num_fec_packets * num_mask_bytes);
   } else {  // UEP case
     UnequalProtectionMask(num_media_packets, num_fec_packets, num_imp_packets,
                           num_mask_bytes, packet_mask, mask_table);
   }  // End of UEP modification
 }  // End of GetPacketMasks
 
+size_t PacketMaskSize(size_t seq_num_spread) {
+  RTC_DCHECK_LE(seq_num_spread, 8 * kUlpfecPacketMaskSizeLBitSet);
+  if (seq_num_spread > 8 * kUlpfecPacketMaskSizeLBitClear) {
+    return kUlpfecPacketMaskSizeLBitSet;
+  } else {
+    return kUlpfecPacketMaskSizeLBitClear;
+  }
+}
+
+void InsertZeroColumns(int num_zeros,
+                       uint8_t* new_mask,
+                       int new_mask_bytes,
+                       int num_fec_packets,
+                       int new_bit_index) {
+  for (uint16_t row = 0; row < num_fec_packets; ++row) {
+    const int new_byte_index = row * new_mask_bytes + new_bit_index / 8;
+    const int max_shifts = (7 - (new_bit_index % 8));
+    new_mask[new_byte_index] <<= std::min(num_zeros, max_shifts);
+  }
+}
+
+void CopyColumn(uint8_t* new_mask,
+                int new_mask_bytes,
+                uint8_t* old_mask,
+                int old_mask_bytes,
+                int num_fec_packets,
+                int new_bit_index,
+                int old_bit_index) {
+  // Copy column from the old mask to the beginning of the new mask and shift it
+  // out from the old mask.
+  for (uint16_t row = 0; row < num_fec_packets; ++row) {
+    int new_byte_index = row * new_mask_bytes + new_bit_index / 8;
+    int old_byte_index = row * old_mask_bytes + old_bit_index / 8;
+    new_mask[new_byte_index] |= ((old_mask[old_byte_index] & 0x80) >> 7);
+    if (new_bit_index % 8 != 7) {
+      new_mask[new_byte_index] <<= 1;
+    }
+    old_mask[old_byte_index] <<= 1;
+  }
+}
+
 }  // namespace internal
 }  // namespace webrtc