Generalize UlpfecPacketGenerator into AugmentedPacketGenerator. (pt. 8)

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.
  */
 
@@ skipping 46 matching lines @@
     // Only push one (fake) frame to the FEC.
     media_packet->data[1] &= 0x7f;
 
     webrtc::ByteWriter<uint16_t>::WriteBigEndian(&media_packet->data[2],
                                                  seq_num);
     webrtc::ByteWriter<uint32_t>::WriteBigEndian(&media_packet->data[4],
                                                  time_stamp);
     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));
   }
   // Last packet, set marker bit.
   ForwardErrorCorrection::Packet* media_packet = media_packets.back().get();
   RTC_DCHECK(media_packet);
   media_packet->data[1] |= 0x80;
 
   fec_seq_num_ = seq_num;
 
   return media_packets;
 }
 
 ForwardErrorCorrection::PacketList MediaPacketGenerator::ConstructMediaPackets(
     int num_media_packets) {
   return ConstructMediaPackets(num_media_packets, random_->Rand<uint16_t>());
 }
 
 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.
 
   // Add RED header, f-bit always 0.
   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