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;
@@ skipping 102 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_ += 3000;

[philipel, 2016/09/21 11:15:27]

constexpr int kMagicConstantWithSomeDescriptiveName = 3000;

[brandtr, 2016/09/21 11:59:21]

Done.

+  header.ssrc = flexfec_ssrc_;
+
+  std::unique_ptr<AugmentedPacket> packet_with_rtp_header(
+      new AugmentedPacket());
+  memset(packet_with_rtp_header->data, 0, IP_PACKET_SIZE);

[philipel, 2016/09/21 11:15:27]

Do you really need to zero this memory?

[brandtr, 2016/09/21 11:59:21]

No, this was overly cautious of me.

Parts of the FEC code depends on the tail memory being zero (I will try to get
rid of that assumption, later on), but the FlexfecReceiver that will be tested
using this helper class should not depend on that.

+  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);

[brandtr, 2016/09/21 11:59:21]

This memset is also unnecessary, since the entire zeroed out memory is
overwritten right below.

   // 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