NetEq: Changed Packet::payload to be an rtc::Buffer

webrtc/modules/audio_coding/neteq/payload_splitter_unittest.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 64 matching lines @@
 // |num_payloads|). Each redundant payload is |timestamp_offset| samples
 // "behind" the the previous payload.
 Packet* CreateRedPayload(size_t num_payloads,
                          uint8_t* payload_types,
                          int timestamp_offset,
                          bool embed_opus_fec = false) {
   Packet* packet = new Packet;
   packet->header.payloadType = kRedPayloadType;
   packet->header.timestamp = kBaseTimestamp;
   packet->header.sequenceNumber = kSequenceNumber;
-  packet->payload_length = (kPayloadLength + 1) +
-      (num_payloads - 1) * (kPayloadLength + kRedHeaderLength);
-  uint8_t* payload = new uint8_t[packet->payload_length];
-  uint8_t* payload_ptr = payload;
+  packet->payload.SetSize((kPayloadLength + 1) +
+                          (num_payloads - 1) *
+                              (kPayloadLength + kRedHeaderLength));
+  uint8_t* payload_ptr = packet->payload.data();
   for (size_t i = 0; i < num_payloads; ++i) {
     // Write the RED headers.
     if (i == num_payloads - 1) {
       // Special case for last payload.
       *payload_ptr = payload_types[i] & 0x7F;  // F = 0;
       ++payload_ptr;
       break;
     }
     *payload_ptr = payload_types[i] & 0x7F;
     // Not the last block; set F = 1.
@@ skipping 11 matching lines @@
   for (size_t i = 0; i < num_payloads; ++i) {
     // Write |i| to all bytes in each payload.
     if (embed_opus_fec) {
       CreateOpusFecPayload(payload_ptr, kPayloadLength,
                            static_cast<uint8_t>(i));
     } else {
       memset(payload_ptr, static_cast<int>(i), kPayloadLength);
     }
     payload_ptr += kPayloadLength;
   }
-  packet->payload = payload;
   return packet;
 }
 
 // Create a packet with all payload bytes set to |payload_value|.
 Packet* CreatePacket(uint8_t payload_type, size_t payload_length,
                      uint8_t payload_value, bool opus_fec = false) {
   Packet* packet = new Packet;
   packet->header.payloadType = payload_type;
   packet->header.timestamp = kBaseTimestamp;
   packet->header.sequenceNumber = kSequenceNumber;
-  packet->payload_length = payload_length;
-  uint8_t* payload = new uint8_t[packet->payload_length];
-  packet->payload = payload;
+  packet->payload.SetSize(payload_length);
   if (opus_fec) {
-    CreateOpusFecPayload(packet->payload, packet->payload_length,
+    CreateOpusFecPayload(packet->payload.data(), packet->payload.size(),
                          payload_value);
   } else {
-    memset(payload, payload_value, payload_length);
+    memset(packet->payload.data(), payload_value, packet->payload.size());

[hlundin-webrtc, 2016/09/01 14:08:04]

I was thinking you could use std::fill, to avoid the pitfall with the element
sizes. But that makes the line just as long as the current one. I for one
wouldn't mind an rtc::BufferT::fill(T value) method... :)

   }
   return packet;
 }
 
 // Checks that |packet| has the attributes given in the remaining parameters.
 void VerifyPacket(const Packet* packet,
                   size_t payload_length,
                   uint8_t payload_type,
                   uint16_t sequence_number,
                   uint32_t timestamp,
                   uint8_t payload_value,
                   bool primary = true) {
-  EXPECT_EQ(payload_length, packet->payload_length);
+  EXPECT_EQ(payload_length, packet->payload.size());
   EXPECT_EQ(payload_type, packet->header.payloadType);
   EXPECT_EQ(sequence_number, packet->header.sequenceNumber);
   EXPECT_EQ(timestamp, packet->header.timestamp);
   EXPECT_EQ(primary, packet->primary);
-  ASSERT_FALSE(packet->payload == NULL);
-  for (size_t i = 0; i < packet->payload_length; ++i) {
+  ASSERT_FALSE(packet->payload.empty());
+  for (size_t i = 0; i < packet->payload.size(); ++i) {
     EXPECT_EQ(payload_value, packet->payload[i]);
   }
 }
 
 // Start of test definitions.
 
 TEST(PayloadSplitter, CreateAndDestroy) {
   PayloadSplitter* splitter = new PayloadSplitter;
   delete splitter;
 }
 
 // Packet A is split into A1 and A2.
 TEST(RedPayloadSplitter, OnePacketTwoPayloads) {
   uint8_t payload_types[] = {0, 0};
   const int kTimestampOffset = 160;
   Packet* packet = CreateRedPayload(2, payload_types, kTimestampOffset);
   PacketList packet_list;
   packet_list.push_back(packet);
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kOK, splitter.SplitRed(&packet_list));
   ASSERT_EQ(2u, packet_list.size());
   // Check first packet. The first in list should always be the primary payload.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[1], kSequenceNumber,
                kBaseTimestamp, 1, true);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check second packet.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
                kBaseTimestamp - kTimestampOffset, 0, false);
-  delete [] packet->payload;
   delete packet;
 }
 
 // Packets A and B are not split at all. Only the RED header in each packet is
 // removed.
 TEST(RedPayloadSplitter, TwoPacketsOnePayload) {
   uint8_t payload_types[] = {0};
   const int kTimestampOffset = 160;
   // Create first packet, with a single RED payload.
   Packet* packet = CreateRedPayload(1, payload_types, kTimestampOffset);
   PacketList packet_list;
   packet_list.push_back(packet);
   // Create second packet, with a single RED payload.
   packet = CreateRedPayload(1, payload_types, kTimestampOffset);
   // Manually change timestamp and sequence number of second packet.
   packet->header.timestamp += kTimestampOffset;
   packet->header.sequenceNumber++;
   packet_list.push_back(packet);
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kOK, splitter.SplitRed(&packet_list));
   ASSERT_EQ(2u, packet_list.size());
   // Check first packet.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
                kBaseTimestamp, 0, true);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check second packet.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber + 1,
                kBaseTimestamp + kTimestampOffset, 0, true);
-  delete [] packet->payload;
   delete packet;
 }
 
 // Packets A and B are split into packets A1, A2, A3, B1, B2, B3, with
 // attributes as follows:
 //
 //                  A1*   A2    A3    B1*   B2    B3
 // Payload type     0     1     2     0     1     2
 // Timestamp        b     b-o   b-2o  b+o   b     b-o
 // Sequence number  0     0     0     1     1     1
@@ skipping 12 matching lines @@
   packet->header.timestamp += kTimestampOffset;
   packet->header.sequenceNumber++;
   packet_list.push_back(packet);
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kOK, splitter.SplitRed(&packet_list));
   ASSERT_EQ(6u, packet_list.size());
   // Check first packet, A1.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[2], kSequenceNumber,
                kBaseTimestamp, 2, true);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check second packet, A2.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[1], kSequenceNumber,
                kBaseTimestamp - kTimestampOffset, 1, false);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check third packet, A3.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
                kBaseTimestamp - 2 * kTimestampOffset, 0, false);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check fourth packet, B1.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[2], kSequenceNumber + 1,
                kBaseTimestamp + kTimestampOffset, 2, true);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check fifth packet, B2.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[1], kSequenceNumber + 1,
                kBaseTimestamp, 1, false);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
   // Check sixth packet, B3.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber + 1,
                kBaseTimestamp - kTimestampOffset, 0, false);
-  delete [] packet->payload;
   delete packet;
 }
 
 // Creates a list with 4 packets with these payload types:
 // 0 = CNGnb
 // 1 = PCMu
 // 2 = DTMF (AVT)
 // 3 = iLBC
 // We expect the method CheckRedPayloads to discard the iLBC packet, since it
 // is a non-CNG, non-DTMF payload of another type than the first speech payload
@@ skipping 18 matching lines @@
 
   PayloadSplitter splitter;
   splitter.CheckRedPayloads(&packet_list, decoder_database);
 
   ASSERT_EQ(3u, packet_list.size());  // Should have dropped the last packet.
   // Verify packets. The loop verifies that payload types 0, 1, and 2 are in the
   // list.
   for (int i = 0; i <= 2; ++i) {
     Packet* packet = packet_list.front();
     VerifyPacket(packet, 10, i, kSequenceNumber, kBaseTimestamp, 0, true);
-    delete [] packet->payload;
     delete packet;
     packet_list.pop_front();
   }
   EXPECT_TRUE(packet_list.empty());
 }
 
 // Packet A is split into A1, A2 and A3. But the length parameter is off, so
 // the last payloads should be discarded.
 TEST(RedPayloadSplitter, WrongPayloadLength) {
   uint8_t payload_types[] = {0, 0, 0};
   const int kTimestampOffset = 160;
   Packet* packet = CreateRedPayload(3, payload_types, kTimestampOffset);
   // Manually tamper with the payload length of the packet.
   // This is one byte too short for the second payload (out of three).
   // We expect only the first payload to be returned.
-  packet->payload_length -= kPayloadLength + 1;
+  packet->payload.SetSize(packet->payload.size() - (kPayloadLength + 1));
   PacketList packet_list;
   packet_list.push_back(packet);
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kRedLengthMismatch,
             splitter.SplitRed(&packet_list));
   ASSERT_EQ(1u, packet_list.size());
   // Check first packet.
   packet = packet_list.front();
   VerifyPacket(packet, kPayloadLength, payload_types[0], kSequenceNumber,
                kBaseTimestamp - 2 * kTimestampOffset, 0, false);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 }
 
 // Test that iSAC, iSAC-swb, RED, DTMF, CNG, and "Arbitrary" payloads do not
 // get split.
 TEST(AudioPayloadSplitter, NonSplittable) {
   // Set up packets with different RTP payload types. The actual values do not
   // matter, since we are mocking the decoder database anyway.
   PacketList packet_list;
@@ skipping 35 matching lines @@
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(6u, packet_list.size());
 
   // Check that all payloads are intact.
   uint8_t payload_type = 0;
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
     VerifyPacket((*it), kPayloadLength, payload_type, kSequenceNumber,
                  kBaseTimestamp, 10 * payload_type);
     ++payload_type;
-    delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 // Test unknown payload type.
 TEST(AudioPayloadSplitter, UnknownPayloadType) {
@@ skipping 10 matching lines @@
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kUnknownPayloadType,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
 
   // Delete the packets and payloads to avoid having the test leak memory.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
-    delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 class SplitBySamplesTest : public ::testing::TestWithParam<NetEqDecoder> {
  protected:
@@ skipping 99 matching lines @@
   EXPECT_EQ(expected_num_packets, packet_list.size());
 
   PacketList::iterator it = packet_list.begin();
   int i = 0;
   while (it != packet_list.end()) {
     size_t length_bytes = expected_size_ms[i] * bytes_per_ms_;
     uint32_t expected_timestamp = kBaseTimestamp +
         expected_timestamp_offset_ms[i] * samples_per_ms_;
     VerifyPacket((*it), length_bytes, kPayloadType, kSequenceNumber,
                  expected_timestamp, expected_payload_value[i]);
-    delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
     ++i;
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 INSTANTIATE_TEST_CASE_P(
@@ skipping 28 matching lines @@
 };
 
 // Test splitting sample-based payloads.
 TEST_P(SplitIlbcTest, NumFrames) {
   PacketList packet_list;
   static const uint8_t kPayloadType = 17;  // Just a random number.
   const int frame_length_samples = frame_length_ms_ * 8;
   size_t payload_length_bytes = frame_length_bytes_ * num_frames_;
   Packet* packet = CreatePacket(kPayloadType, payload_length_bytes, 0);
   // Fill payload with increasing integers {0, 1, 2, ...}.
-  for (size_t i = 0; i < packet->payload_length; ++i) {
+  for (size_t i = 0; i < packet->payload.size(); ++i) {
     packet->payload[i] = static_cast<uint8_t>(i);
   }
   packet_list.push_back(packet);
 
   MockDecoderDatabase decoder_database;
   // Tell the mock decoder database to return DecoderInfo structs with different
   // codec types.
   // Use scoped pointers to avoid having to delete them later.
   std::unique_ptr<DecoderDatabase::DecoderInfo> info(
       new DecoderDatabase::DecoderInfo(NetEqDecoder::kDecoderILBC, ""));
   EXPECT_CALL(decoder_database, GetDecoderInfo(kPayloadType))
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(0, splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(num_frames_, packet_list.size());
 
   PacketList::iterator it = packet_list.begin();
   int frame_num = 0;
   uint8_t payload_value = 0;
   while (it != packet_list.end()) {
     Packet* packet = (*it);
     EXPECT_EQ(kBaseTimestamp + frame_length_samples * frame_num,
               packet->header.timestamp);
-    EXPECT_EQ(frame_length_bytes_, packet->payload_length);
+    EXPECT_EQ(frame_length_bytes_, packet->payload.size());
     EXPECT_EQ(kPayloadType, packet->header.payloadType);
     EXPECT_EQ(kSequenceNumber, packet->header.sequenceNumber);
     EXPECT_EQ(true, packet->primary);
-    ASSERT_FALSE(packet->payload == NULL);
-    for (size_t i = 0; i < packet->payload_length; ++i) {
+    ASSERT_FALSE(packet->payload.empty());
+    for (size_t i = 0; i < packet->payload.size(); ++i) {
       EXPECT_EQ(payload_value, packet->payload[i]);
       ++payload_value;
     }
-    delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
     ++frame_num;
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 // Test 1 through 5 frames of 20 and 30 ms size.
@@ skipping 30 matching lines @@
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kTooLargePayload,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
   // Delete the packets and payloads to avoid having the test leak memory.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
-    delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 // Payload not an integer number of frames.
 TEST(IlbcPayloadSplitter, UnevenPayload) {
@@ skipping 10 matching lines @@
       .WillRepeatedly(Return(info.get()));
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kFrameSplitError,
             splitter.SplitAudio(&packet_list, decoder_database));
   EXPECT_EQ(1u, packet_list.size());
 
   // Delete the packets and payloads to avoid having the test leak memory.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
-    delete [] (*it)->payload;
     delete (*it);
     it = packet_list.erase(it);
   }
 
   // The destructor is called when decoder_database goes out of scope.
   EXPECT_CALL(decoder_database, Die());
 }
 
 TEST(FecPayloadSplitter, MixedPayload) {
   PacketList packet_list;
@@ skipping 13 matching lines @@
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kOK,
             splitter.SplitFec(&packet_list, &decoder_database));
   EXPECT_EQ(4u, packet_list.size());
 
   // Check first packet.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
   EXPECT_EQ(kBaseTimestamp - 20 * 48, packet->header.timestamp);
-  EXPECT_EQ(10U, packet->payload_length);
+  EXPECT_EQ(10U, packet->payload.size());
   EXPECT_FALSE(packet->primary);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 
   // Check second packet.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
   EXPECT_EQ(kBaseTimestamp, packet->header.timestamp);
-  EXPECT_EQ(10U, packet->payload_length);
+  EXPECT_EQ(10U, packet->payload.size());
   EXPECT_TRUE(packet->primary);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 
   // Check third packet.
   packet = packet_list.front();
   VerifyPacket(packet, 10, 0, kSequenceNumber, kBaseTimestamp, 0, true);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 
   // Check fourth packet.
   packet = packet_list.front();
   VerifyPacket(packet, 10, 1, kSequenceNumber, kBaseTimestamp, 0, true);
-  delete [] packet->payload;
   delete packet;
 }
 
 TEST(FecPayloadSplitter, EmbedFecInRed) {
   PacketList packet_list;
   DecoderDatabase decoder_database(CreateBuiltinAudioDecoderFactory());
 
   const int kTimestampOffset = 20 * 48;  // 20 ms * 48 kHz.
   uint8_t payload_types[] = {0, 0};
   decoder_database.RegisterPayload(0, NetEqDecoder::kDecoderOpus, "opus");
   Packet* packet = CreateRedPayload(2, payload_types, kTimestampOffset, true);
   packet_list.push_back(packet);
 
   PayloadSplitter splitter;
   EXPECT_EQ(PayloadSplitter::kOK,
             splitter.SplitRed(&packet_list));
   EXPECT_EQ(PayloadSplitter::kOK,
             splitter.SplitFec(&packet_list, &decoder_database));
 
   EXPECT_EQ(4u, packet_list.size());
 
   // Check first packet. FEC packet copied from primary payload in RED.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
   EXPECT_EQ(kBaseTimestamp - kTimestampOffset, packet->header.timestamp);
-  EXPECT_EQ(kPayloadLength, packet->payload_length);
+  EXPECT_EQ(kPayloadLength, packet->payload.size());
   EXPECT_FALSE(packet->primary);
   EXPECT_EQ(packet->payload[3], 1);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 
   // Check second packet. Normal packet copied from primary payload in RED.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
   EXPECT_EQ(kBaseTimestamp, packet->header.timestamp);
-  EXPECT_EQ(kPayloadLength, packet->payload_length);
+  EXPECT_EQ(kPayloadLength, packet->payload.size());
   EXPECT_TRUE(packet->primary);
   EXPECT_EQ(packet->payload[3], 1);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 
   // Check third packet. FEC packet copied from secondary payload in RED.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
   EXPECT_EQ(kBaseTimestamp - 2 * kTimestampOffset, packet->header.timestamp);
-  EXPECT_EQ(kPayloadLength, packet->payload_length);
+  EXPECT_EQ(kPayloadLength, packet->payload.size());
   EXPECT_FALSE(packet->primary);
   EXPECT_EQ(packet->payload[3], 0);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 
   // Check fourth packet. Normal packet copied from primary payload in RED.
   packet = packet_list.front();
   EXPECT_EQ(0, packet->header.payloadType);
   EXPECT_EQ(kBaseTimestamp - kTimestampOffset, packet->header.timestamp);
-  EXPECT_EQ(kPayloadLength, packet->payload_length);
+  EXPECT_EQ(kPayloadLength, packet->payload.size());
   EXPECT_TRUE(packet->primary);
   EXPECT_EQ(packet->payload[3], 0);
-  delete [] packet->payload;
   delete packet;
   packet_list.pop_front();
 }
 
 }  // namespace webrtc