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 71 matching lines @@
 
 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::NextSeqNum() {
   return ++seq_num_;
 }
 
-RawRtpPacket* UlpfecPacketGenerator::NextPacket(int offset, size_t length) {
-  RawRtpPacket* rtp_packet = new RawRtpPacket;
-  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);
+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) {

[philipel, 2016/09/22 11:29:30]

remove {}

[brandtr, 2016/09/22 14:21:38]

Do I have to? :(

[philipel, 2016/09/23 11:52:14]

Yes, also remove from for loop at line 67 :)

+    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