Add FlexfecPacketGenerator. (pt. 9)

webrtc/modules/rtp_rtcp/source/fec_test_helper.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/fec_test_helper.h"
 
 #include <memory>
 #include <utility>
 
+#include "webrtc/base/checks.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/rtp_utility.h"
 
 namespace webrtc {
 namespace test {
 namespace fec {
 
 namespace {
 constexpr uint8_t kFecPayloadType = 96;
 constexpr uint8_t kRedPayloadType = 97;
 constexpr uint8_t kVp8PayloadType = 120;
+
+constexpr int kPacketTimestampIncrement = 3000;
 }  // namespace
 
 ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
     int num_media_packets,
     uint16_t start_seq_num) {
   RTC_DCHECK_GT(num_media_packets, 0);
   uint16_t seq_num = start_seq_num;
   int time_stamp = random_->Rand<int>();
 
   ForwardErrorCorrection::PacketList media_packets;
@@ skipping 49 matching lines @@
 
 uint16_t MediaPacketGenerator::GetFecSeqNum() {
   return fec_seq_num_;
 }
 
 AugmentedPacketGenerator::AugmentedPacketGenerator(uint32_t ssrc)
     : num_packets_(0), ssrc_(ssrc), seq_num_(0), timestamp_(0) {}
 
 void AugmentedPacketGenerator::NewFrame(size_t num_packets) {
   num_packets_ = num_packets;
-  timestamp_ += 3000;
+  timestamp_ += kPacketTimestampIncrement;
 }
 
 uint16_t AugmentedPacketGenerator::NextPacketSeqNum() {
   return ++seq_num_;
 }
 
 std::unique_ptr<AugmentedPacket> AugmentedPacketGenerator::NextPacket(
     size_t offset,
     size_t length) {
   std::unique_ptr<AugmentedPacket> packet(new AugmentedPacket());
@@ skipping 19 matching lines @@
 void AugmentedPacketGenerator::WriteRtpHeader(const RTPHeader& header,
                                               uint8_t* data) {
   data[0] = 0x80;  // Version 2.
   data[1] = header.payloadType;
   data[1] |= (header.markerBit ? kRtpMarkerBitMask : 0);
   ByteWriter<uint16_t>::WriteBigEndian(data + 2, header.sequenceNumber);
   ByteWriter<uint32_t>::WriteBigEndian(data + 4, header.timestamp);
   ByteWriter<uint32_t>::WriteBigEndian(data + 8, header.ssrc);
 }
 
+FlexfecPacketGenerator::FlexfecPacketGenerator(uint32_t media_ssrc,
+                                               uint32_t flexfec_ssrc)
+    : AugmentedPacketGenerator(media_ssrc),
+      flexfec_ssrc_(flexfec_ssrc),
+      flexfec_seq_num_(0),
+      flexfec_timestamp_(0) {}
+
+std::unique_ptr<AugmentedPacket> FlexfecPacketGenerator::BuildFlexfecPacket(
+    const ForwardErrorCorrection::Packet& packet) {
+  RTC_DCHECK_LE(packet.length,
+                static_cast<size_t>(IP_PACKET_SIZE - kRtpHeaderSize));
+
+  RTPHeader header;
+  header.sequenceNumber = flexfec_seq_num_;
+  ++flexfec_seq_num_;
+  header.timestamp = flexfec_timestamp_;
+  flexfec_timestamp_ += kPacketTimestampIncrement;
+  header.ssrc = flexfec_ssrc_;
+
+  std::unique_ptr<AugmentedPacket> packet_with_rtp_header(
+      new AugmentedPacket());
+  WriteRtpHeader(header, packet_with_rtp_header->data);
+  memcpy(packet_with_rtp_header->data + kRtpHeaderSize, packet.data,
+         packet.length);
+  packet_with_rtp_header->length = kRtpHeaderSize + packet.length;
+
+  return packet_with_rtp_header;
+}
+
 UlpfecPacketGenerator::UlpfecPacketGenerator(uint32_t ssrc)
     : AugmentedPacketGenerator(ssrc) {}
 
 std::unique_ptr<AugmentedPacket> UlpfecPacketGenerator::BuildMediaRedPacket(
     const AugmentedPacket& packet) {
   std::unique_ptr<AugmentedPacket> red_packet(new AugmentedPacket());
 
   const size_t kHeaderLength = packet.header.header.headerLength;
   red_packet->header = packet.header;
   red_packet->length = packet.length + 1;  // 1 byte RED header.
-  memset(red_packet->data, 0, red_packet->length);
   // Copy RTP header.
   memcpy(red_packet->data, packet.data, kHeaderLength);
   SetRedHeader(red_packet->data[1] & 0x7f, kHeaderLength, red_packet.get());
   memcpy(red_packet->data + kHeaderLength + 1, packet.data + kHeaderLength,
          packet.length - kHeaderLength);
 
   return red_packet;
 }
 
 std::unique_ptr<AugmentedPacket> UlpfecPacketGenerator::BuildUlpfecRedPacket(
@@ skipping 19 matching lines @@
   red_packet->data[1] &= 0x80;             // Reset.
   red_packet->data[1] += kRedPayloadType;  // Replace.
 
   // Add RED header, f-bit always 0.
   red_packet->data[header_length] = payload_type;
 }
 
 }  // namespace fec
 }  // namespace test
 }  // namespace webrtc