Add FlexFEC header formatters. (pt. 5)

webrtc/modules/rtp_rtcp/source/forward_error_correction.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.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/flexfec_header_reader_writer.h"
+#include "webrtc/modules/rtp_rtcp/source/forward_error_correction_internal.h"
 #include "webrtc/modules/rtp_rtcp/source/ulpfec_header_reader_writer.h"
 
 namespace webrtc {
 
 namespace {
 // Transport header size in bytes. Assume UDP/IPv4 as a reasonable minimum.
 constexpr size_t kTransportOverhead = 28;
 }  // namespace
 
 ForwardErrorCorrection::Packet::Packet() : length(0), data(), ref_count_(0) {}
@@ skipping 44 matching lines @@
 
 ForwardErrorCorrection::~ForwardErrorCorrection() = default;
 
 std::unique_ptr<ForwardErrorCorrection> ForwardErrorCorrection::CreateUlpfec() {
   std::unique_ptr<FecHeaderReader> fec_header_reader(new UlpfecHeaderReader());
   std::unique_ptr<FecHeaderWriter> fec_header_writer(new UlpfecHeaderWriter());
   return std::unique_ptr<ForwardErrorCorrection>(new ForwardErrorCorrection(
       std::move(fec_header_reader), std::move(fec_header_writer)));
 }
 
+std::unique_ptr<ForwardErrorCorrection>
+ForwardErrorCorrection::CreateFlexfec() {
+  std::unique_ptr<FecHeaderReader> fec_header_reader(new FlexfecHeaderReader());
+  std::unique_ptr<FecHeaderWriter> fec_header_writer(new FlexfecHeaderWriter());
+  return std::unique_ptr<ForwardErrorCorrection>(new ForwardErrorCorrection(
+      std::move(fec_header_reader), std::move(fec_header_writer)));
+}
+
 int ForwardErrorCorrection::EncodeFec(const PacketList& media_packets,
                                       uint8_t protection_factor,
                                       int num_important_packets,
                                       bool use_unequal_protection,
                                       FecMaskType fec_mask_type,
                                       std::list<Packet*>* fec_packets) {
   const size_t num_media_packets = media_packets.size();
 
   // Sanity check arguments.
   RTC_DCHECK_GT(num_media_packets, 0u);
@@ skipping 48 matching lines @@
   int num_mask_bits = InsertZerosInPacketMasks(media_packets, num_fec_packets);
   if (num_mask_bits < 0) {
     return -1;
   }
   packet_mask_size_ = internal::PacketMaskSize(num_mask_bits);
 
   // Write FEC packets to |generated_fec_packets_|.
   GenerateFecPayloads(media_packets, num_fec_packets);
   // TODO(brandtr): Generalize this when multistream protection support is
   // added.
+  const uint32_t ssrc = ParseSsrc(media_packets.front().get()->data);
   const uint16_t seq_num_base =
       ParseSequenceNumber(media_packets.front().get()->data);
-  FinalizeFecHeaders(num_fec_packets, seq_num_base);
+  FinalizeFecHeaders(num_fec_packets, ssrc, seq_num_base);
 
   return 0;
 }
 
 int ForwardErrorCorrection::NumFecPackets(int num_media_packets,
                                           int protection_factor) {
   // Result in Q0 with an unsigned round.
   int num_fec_packets = (num_media_packets * protection_factor + (1 << 7)) >> 8;
   // Generate at least one FEC packet if we need protection.
   if (protection_factor > 0 && num_fec_packets == 0) {
@@ skipping 130 matching lines @@
       tmp_packet_masks_[new_byte_index] <<= (7 - (new_bit_index % 8));
     }
   }
   // Replace the old mask with the new.
   memcpy(packet_masks_, tmp_packet_masks_,
          num_fec_packets * tmp_packet_mask_size);
   return new_bit_index;
 }
 
 void ForwardErrorCorrection::FinalizeFecHeaders(size_t num_fec_packets,
+                                                uint32_t ssrc,
                                                 uint16_t seq_num_base) {
   for (size_t i = 0; i < num_fec_packets; ++i) {
     fec_header_writer_->FinalizeFecHeader(
-        seq_num_base, &packet_masks_[i * packet_mask_size_], packet_mask_size_,
-        &generated_fec_packets_[i]);
+        ssrc, seq_num_base, &packet_masks_[i * packet_mask_size_],
+        packet_mask_size_, &generated_fec_packets_[i]);
   }
 }
 
 void ForwardErrorCorrection::ResetState(
     RecoveredPacketList* recovered_packets) {
   // Free the memory for any existing recovered packets, if the caller hasn't.
   recovered_packets->clear();
   received_fec_packets_.clear();
 }
 
@@ skipping 402 matching lines @@
 
 size_t FecHeaderWriter::MaxFecPackets() const {
   return max_fec_packets_;
 }
 
 size_t FecHeaderWriter::MaxPacketOverhead() const {
   return max_packet_overhead_;
 }
 
 }  // namespace webrtc