Generalize UlpfecPacketGenerator into AugmentedPacketGenerator. (pt. 8)

webrtc/modules/rtp_rtcp/source/fec_test_helper.cc

Index: webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
diff --git a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
index 3799c7f0c2dfdf5bf161d4569035fb5e8785ec1e..c2d2f9acfb12be1606754fb72d306ab996fd8368 100644
--- a/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
+++ b/webrtc/modules/rtp_rtcp/source/fec_test_helper.cc
@@ -64,9 +64,8 @@ ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
     webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[8], ssrc_);
 
     // Generate random values for payload.
-    for (size_t j = 12; j < media_packet->length; ++j) {
+    for (size_t j = 12; j < media_packet->length; ++j)
       media_packet->data[j] = random_->Rand<uint8_t>();
-    }
     seq_num++;
     media_packets.push_back(std::move(media_packet));
   }
@@ -89,73 +88,91 @@ uint16_t MediaPacketGenerator::GetFecSeqNum() {
   return fec_seq_num_;
 }
 
-UlpfecPacketGenerator::UlpfecPacketGenerator()
-    : num_packets_(0), seq_num_(0), timestamp_(0) {}
+AugmentedPacketGenerator::AugmentedPacketGenerator(uint32_t ssrc)
+    : num_packets_(0), ssrc_(ssrc), seq_num_(0), timestamp_(0) {}
 
-void UlpfecPacketGenerator::NewFrame(int num_packets) {
+void AugmentedPacketGenerator::NewFrame(size_t num_packets) {
   num_packets_ = num_packets;
   timestamp_ += 3000;
 }
 
-uint16_t UlpfecPacketGenerator::NextSeqNum() {
+uint16_t AugmentedPacketGenerator::NextPacketSeqNum() {
   return ++seq_num_;
 }
 
-RawRtpPacket* UlpfecPacketGenerator::NextPacket(int offset, size_t length) {
-  RawRtpPacket* rtp_packet = new RawRtpPacket;
+std::unique_ptr<AugmentedPacket> AugmentedPacketGenerator::NextPacket(
+    size_t offset,
+    size_t length) {
+  std::unique_ptr<AugmentedPacket> packet(new AugmentedPacket());
+
   for (size_t i = 0; i < length; ++i)
-    rtp_packet->data[i + kRtpHeaderSize] = offset + i;
-  rtp_packet->length = length + kRtpHeaderSize;
-  memset(&rtp_packet->header, 0, sizeof(WebRtcRTPHeader));
-  rtp_packet->header.frameType = kVideoFrameDelta;
-  rtp_packet->header.header.headerLength = kRtpHeaderSize;
-  rtp_packet->header.header.markerBit = (num_packets_ == 1);
-  rtp_packet->header.header.sequenceNumber = seq_num_;
-  rtp_packet->header.header.timestamp = timestamp_;
-  rtp_packet->header.header.payloadType = kVp8PayloadType;
-  BuildRtpHeader(rtp_packet->data, &rtp_packet->header.header);
+    packet->data[i + kRtpHeaderSize] = offset + i;
+  packet->length = length + kRtpHeaderSize;
+  memset(&packet->header, 0, sizeof(WebRtcRTPHeader));
+  packet->header.frameType = kVideoFrameDelta;
+  packet->header.header.headerLength = kRtpHeaderSize;
+  packet->header.header.markerBit = (num_packets_ == 1);
+  packet->header.header.payloadType = kVp8PayloadType;
+  packet->header.header.sequenceNumber = seq_num_;
+  packet->header.header.timestamp = timestamp_;
+  packet->header.header.ssrc = ssrc_;
+  WriteRtpHeader(packet->header.header, packet->data);
   ++seq_num_;
   --num_packets_;
-  return rtp_packet;
+
+  return packet;
 }
 
-// Creates a new RtpPacket with the RED header added to the packet.
-RawRtpPacket* UlpfecPacketGenerator::BuildMediaRedPacket(
-    const RawRtpPacket* packet) {
-  const size_t kHeaderLength = packet->header.header.headerLength;
-  RawRtpPacket* red_packet = new RawRtpPacket;
-  red_packet->header = packet->header;
-  red_packet->length = packet->length + 1;  // 1 byte RED header.
+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);
+}
+
+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, red_packet->data[1] & 0x7f, kHeaderLength);
-  memcpy(red_packet->data + kHeaderLength + 1, packet->data + kHeaderLength,
-         packet->length - kHeaderLength);
+  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;
 }
 
-// Creates a new RtpPacket with FEC payload and RED header. Does this by
-// creating a new fake media RtpPacket, clears the marker bit and adds a RED
-// header. Finally replaces the payload with the content of |packet->data|.
-RawRtpPacket* UlpfecPacketGenerator::BuildFecRedPacket(
-    const ForwardErrorCorrection::Packet* packet) {
+std::unique_ptr<AugmentedPacket> UlpfecPacketGenerator::BuildUlpfecRedPacket(
+    const ForwardErrorCorrection::Packet& packet) {
   // Create a fake media packet to get a correct header. 1 byte RED header.
   ++num_packets_;
-  RawRtpPacket* red_packet = NextPacket(0, packet->length + 1);
+  std::unique_ptr<AugmentedPacket> red_packet =
+      NextPacket(0, packet.length + 1);
+
   red_packet->data[1] &= ~0x80;  // Clear marker bit.
   const size_t kHeaderLength = red_packet->header.header.headerLength;
-  SetRedHeader(red_packet, kFecPayloadType, kHeaderLength);
-  memcpy(red_packet->data + kHeaderLength + 1, packet->data, packet->length);
-  red_packet->length = kHeaderLength + 1 + packet->length;
+  SetRedHeader(kFecPayloadType, kHeaderLength, red_packet.get());
+  memcpy(red_packet->data + kHeaderLength + 1, packet.data, packet.length);
+  red_packet->length = kHeaderLength + 1 + packet.length;
+
   return red_packet;
 }
 
-void UlpfecPacketGenerator::SetRedHeader(
-    ForwardErrorCorrection::Packet* red_packet,
-    uint8_t payload_type,
-    size_t header_length) const {
-  // Replace pltype.
+void UlpfecPacketGenerator::SetRedHeader(uint8_t payload_type,
+                                         size_t header_length,
+                                         AugmentedPacket* red_packet) {
+  // Replace payload type.
   red_packet->data[1] &= 0x80;             // Reset.
   red_packet->data[1] += kRedPayloadType;  // Replace.
 
@@ -163,16 +180,6 @@ void UlpfecPacketGenerator::SetRedHeader(
   red_packet->data[header_length] = payload_type;
 }
 
-void UlpfecPacketGenerator::BuildRtpHeader(uint8_t* data,
-                                           const RTPHeader* header) {
-  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);
-}
-
 }  // namespace fec
 }  // namespace test
 }  // namespace webrtc