Removed RTPHeader from NetEq's Packet struct.

webrtc/modules/audio_coding/neteq/packet_buffer_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 35 matching lines @@
 void PacketGenerator::Reset(uint16_t seq_no, uint32_t ts, uint8_t pt,
                             int frame_size) {
   seq_no_ = seq_no;
   ts_ = ts;
   pt_ = pt;
   frame_size_ = frame_size;
 }
 
 Packet* PacketGenerator::NextPacket(int payload_size_bytes) {
   Packet* packet = new Packet;
-  packet->header.sequenceNumber = seq_no_;
-  packet->header.timestamp = ts_;
-  packet->header.payloadType = pt_;
-  packet->header.markerBit = false;
-  packet->header.ssrc = 0x12345678;
-  packet->header.numCSRCs = 0;
-  packet->header.paddingLength = 0;
+  packet->sequence_number = seq_no_;
+  packet->timestamp = ts_;
+  packet->payload_type = pt_;
   packet->payload.SetSize(payload_size_bytes);
   ++seq_no_;
   ts_ += frame_size_;
   return packet;
 }
 
 struct PacketsToInsert {
   uint16_t sequence_number;
   uint32_t timestamp;
   uint8_t payload_type;
@@ skipping 20 matching lines @@
 
   const int payload_len = 100;
   Packet* packet = gen.NextPacket(payload_len);
 
   EXPECT_EQ(0, buffer.InsertPacket(packet));
   uint32_t next_ts;
   EXPECT_EQ(PacketBuffer::kOK, buffer.NextTimestamp(&next_ts));
   EXPECT_EQ(4711u, next_ts);
   EXPECT_FALSE(buffer.Empty());
   EXPECT_EQ(1u, buffer.NumPacketsInBuffer());
-  const RTPHeader* hdr = buffer.NextRtpHeader();
-  EXPECT_EQ(&(packet->header), hdr);  // Compare pointer addresses.
+  const Packet* next_packet = buffer.PeekNextPacket();
+  EXPECT_EQ(packet, next_packet);  // Compare pointer addresses.
 
   // Do not explicitly flush buffer or delete packet to test that it is deleted
   // with the buffer. (Tested with Valgrind or similar tool.)
 }
 
 // Test to flush buffer.
 TEST(PacketBuffer, FlushBuffer) {
   TickTimer tick_timer;
   PacketBuffer buffer(10, &tick_timer);  // 10 packets.
   PacketGenerator gen(0, 0, 0, 10);
@@ skipping 30 matching lines @@
   uint32_t next_ts;
   EXPECT_EQ(PacketBuffer::kOK, buffer.NextTimestamp(&next_ts));
   EXPECT_EQ(0u, next_ts);  // Expect first inserted packet to be first in line.
 
   // Insert 11th packet; should flush the buffer and insert it after flushing.
   Packet* packet = gen.NextPacket(payload_len);
   EXPECT_EQ(PacketBuffer::kFlushed, buffer.InsertPacket(packet));
   EXPECT_EQ(1u, buffer.NumPacketsInBuffer());
   EXPECT_EQ(PacketBuffer::kOK, buffer.NextTimestamp(&next_ts));
   // Expect last inserted packet to be first in line.
-  EXPECT_EQ(packet->header.timestamp, next_ts);
+  EXPECT_EQ(packet->timestamp, next_ts);
 
   // Flush buffer to delete all packets.
   buffer.Flush();
 }
 
 // Test inserting a list of packets.
 TEST(PacketBuffer, InsertPacketList) {
   TickTimer tick_timer;
   PacketBuffer buffer(10, &tick_timer);  // 10 packets.
   PacketGenerator gen(0, 0, 0, 10);
@@ skipping 38 matching lines @@
   PacketList list;
   const int payload_len = 10;
 
   // Insert 10 small packets.
   for (int i = 0; i < 10; ++i) {
     Packet* packet = gen.NextPacket(payload_len);
     list.push_back(packet);
   }
   // Insert 11th packet of another payload type (not CNG).
   Packet* packet = gen.NextPacket(payload_len);
-  packet->header.payloadType = 1;
+  packet->payload_type = 1;
   list.push_back(packet);
 
 
   MockDecoderDatabase decoder_database;
   auto factory = CreateBuiltinAudioDecoderFactory();
   const DecoderDatabase::DecoderInfo info0(NetEqDecoder::kDecoderPCMu, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(0))
       .WillRepeatedly(Return(&info0));
   const DecoderDatabase::DecoderInfo info1(NetEqDecoder::kDecoderPCMa, factory);
   EXPECT_CALL(decoder_database, GetDecoderInfo(1))
@@ skipping 138 matching lines @@
                                                        decoder_database,
                                                        &current_pt,
                                                        &current_cng_pt));
   EXPECT_EQ(10u, buffer.NumPacketsInBuffer());
 
   // Extract them and make sure that come out in the right order.
   uint32_t current_ts = start_ts;
   for (int i = 0; i < 10; ++i) {
     Packet* packet = buffer.GetNextPacket(NULL);
     ASSERT_FALSE(packet == NULL);
-    EXPECT_EQ(current_ts, packet->header.timestamp);
+    EXPECT_EQ(current_ts, packet->timestamp);
     current_ts += ts_increment;
     delete packet;
   }
   EXPECT_TRUE(buffer.Empty());
 
   EXPECT_CALL(decoder_database, Die());  // Called when object is deleted.
 }
 
 // The test first inserts a packet with narrow-band CNG, then a packet with
 // wide-band speech. The expected behavior of the packet buffer is to detect a
@@ skipping 21 matching lines @@
   PacketGenerator gen(0, 0, kCngPt, 10);
   PacketList list;
   list.push_back(gen.NextPacket(kPayloadLen));
   rtc::Optional<uint8_t> current_pt;
   rtc::Optional<uint8_t> current_cng_pt;
   EXPECT_EQ(PacketBuffer::kOK,
             buffer.InsertPacketList(&list, decoder_database, &current_pt,
                                     &current_cng_pt));
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(1u, buffer.NumPacketsInBuffer());
-  ASSERT_TRUE(buffer.NextRtpHeader());
-  EXPECT_EQ(kCngPt, buffer.NextRtpHeader()->payloadType);
+  ASSERT_TRUE(buffer.PeekNextPacket());
+  EXPECT_EQ(kCngPt, buffer.PeekNextPacket()->payload_type);
   EXPECT_FALSE(current_pt);  // Current payload type not set.
   EXPECT_EQ(rtc::Optional<uint8_t>(kCngPt),
             current_cng_pt);  // CNG payload type set.
 
   // Insert second packet, which is wide-band speech.
   Packet* packet = gen.NextPacket(kPayloadLen);
-  packet->header.payloadType = kSpeechPt;
+  packet->payload_type = kSpeechPt;
   list.push_back(packet);
   // Expect the buffer to flush out the CNG packet, since it does not match the
   // new speech sample rate.
   EXPECT_EQ(PacketBuffer::kFlushed,
             buffer.InsertPacketList(&list, decoder_database, &current_pt,
                                     &current_cng_pt));
   EXPECT_TRUE(list.empty());
   EXPECT_EQ(1u, buffer.NumPacketsInBuffer());
-  ASSERT_TRUE(buffer.NextRtpHeader());
-  EXPECT_EQ(kSpeechPt, buffer.NextRtpHeader()->payloadType);
+  ASSERT_TRUE(buffer.PeekNextPacket());
+  EXPECT_EQ(kSpeechPt, buffer.PeekNextPacket()->payload_type);
 
   EXPECT_EQ(rtc::Optional<uint8_t>(kSpeechPt),
             current_pt);         // Current payload type set.
   EXPECT_FALSE(current_cng_pt);  // CNG payload type reset.
 
   buffer.Flush();                        // Clean up.
   EXPECT_CALL(decoder_database, Die());  // Called when object is deleted.
 }
 
 TEST(PacketBuffer, Failures) {
@@ skipping 10 matching lines @@
   packet = gen.NextPacket(payload_len);
   packet->payload.Clear();
   EXPECT_EQ(PacketBuffer::kInvalidPacket, buffer->InsertPacket(packet));
   // Packet is deleted by the PacketBuffer.
 
   // Buffer should still be empty. Test all empty-checks.
   uint32_t temp_ts;
   EXPECT_EQ(PacketBuffer::kBufferEmpty, buffer->NextTimestamp(&temp_ts));
   EXPECT_EQ(PacketBuffer::kBufferEmpty,
             buffer->NextHigherTimestamp(0, &temp_ts));
-  EXPECT_EQ(NULL, buffer->NextRtpHeader());
+  EXPECT_EQ(NULL, buffer->PeekNextPacket());
   EXPECT_EQ(NULL, buffer->GetNextPacket(NULL));
   EXPECT_EQ(PacketBuffer::kBufferEmpty, buffer->DiscardNextPacket());
   EXPECT_EQ(0, buffer->DiscardAllOldPackets(0));  // 0 packets discarded.
 
   // Insert one packet to make the buffer non-empty.
   packet = gen.NextPacket(payload_len);
   EXPECT_EQ(PacketBuffer::kOK, buffer->InsertPacket(packet));
   EXPECT_EQ(PacketBuffer::kInvalidPointer, buffer->NextTimestamp(NULL));
   EXPECT_EQ(PacketBuffer::kInvalidPointer,
             buffer->NextHigherTimestamp(0, NULL));
@@ skipping 34 matching lines @@
   std::unique_ptr<Packet> a(gen.NextPacket(10));  // SN = 0, TS = 0.
   std::unique_ptr<Packet> b(gen.NextPacket(10));  // SN = 1, TS = 10.
   EXPECT_FALSE(*a == *b);
   EXPECT_TRUE(*a != *b);
   EXPECT_TRUE(*a < *b);
   EXPECT_FALSE(*a > *b);
   EXPECT_TRUE(*a <= *b);
   EXPECT_FALSE(*a >= *b);
 
   // Testing wrap-around case; 'a' is earlier but has a larger timestamp value.
-  a->header.timestamp = 0xFFFFFFFF - 10;
+  a->timestamp = 0xFFFFFFFF - 10;
   EXPECT_FALSE(*a == *b);
   EXPECT_TRUE(*a != *b);
   EXPECT_TRUE(*a < *b);
   EXPECT_FALSE(*a > *b);
   EXPECT_TRUE(*a <= *b);
   EXPECT_FALSE(*a >= *b);
 
   // Test equal packets.
   EXPECT_TRUE(*a == *a);
   EXPECT_FALSE(*a != *a);
   EXPECT_FALSE(*a < *a);
   EXPECT_FALSE(*a > *a);
   EXPECT_TRUE(*a <= *a);
   EXPECT_TRUE(*a >= *a);
 
   // Test equal timestamps but different sequence numbers (0 and 1).
-  a->header.timestamp = b->header.timestamp;
+  a->timestamp = b->timestamp;
   EXPECT_FALSE(*a == *b);
   EXPECT_TRUE(*a != *b);
   EXPECT_TRUE(*a < *b);
   EXPECT_FALSE(*a > *b);
   EXPECT_TRUE(*a <= *b);
   EXPECT_FALSE(*a >= *b);
 
   // Test equal timestamps but different sequence numbers (32767 and 1).
-  a->header.sequenceNumber = 0xFFFF;
+  a->sequence_number = 0xFFFF;
   EXPECT_FALSE(*a == *b);
   EXPECT_TRUE(*a != *b);
   EXPECT_TRUE(*a < *b);
   EXPECT_FALSE(*a > *b);
   EXPECT_TRUE(*a <= *b);
   EXPECT_FALSE(*a >= *b);
 
   // Test equal timestamps and sequence numbers, but differing priorities.
-  a->header.sequenceNumber = b->header.sequenceNumber;
+  a->sequence_number = b->sequence_number;
   a->priority = {1, 0};
   b->priority = {0, 0};
   // a after b
   EXPECT_FALSE(*a == *b);
   EXPECT_TRUE(*a != *b);
   EXPECT_FALSE(*a < *b);
   EXPECT_TRUE(*a > *b);
   EXPECT_FALSE(*a <= *b);
   EXPECT_TRUE(*a >= *b);
 
   std::unique_ptr<Packet> c(gen.NextPacket(0));  // SN = 2, TS = 20.
   std::unique_ptr<Packet> d(gen.NextPacket(0));  // SN = 3, TS = 20.
-  c->header.timestamp = b->header.timestamp;
-  d->header.timestamp = b->header.timestamp;
-  c->header.sequenceNumber = b->header.sequenceNumber;
-  d->header.sequenceNumber = b->header.sequenceNumber;
+  c->timestamp = b->timestamp;
+  d->timestamp = b->timestamp;
+  c->sequence_number = b->sequence_number;
+  d->sequence_number = b->sequence_number;
   c->priority = {1, 1};
   d->priority = {0, 1};
   // c after d
   EXPECT_FALSE(*c == *d);
   EXPECT_TRUE(*c != *d);
   EXPECT_FALSE(*c < *d);
   EXPECT_TRUE(*c > *d);
   EXPECT_FALSE(*c <= *d);
   EXPECT_TRUE(*c >= *d);
 
@@ skipping 104 matching lines @@
 // Test the IsObsoleteTimestamp method with different limit timestamps.
 TEST(PacketBuffer, IsObsoleteTimestamp) {
   TestIsObsoleteTimestamp(0);
   TestIsObsoleteTimestamp(1);
   TestIsObsoleteTimestamp(0xFFFFFFFF);  // -1 in uint32_t.
   TestIsObsoleteTimestamp(0x80000000);  // 2^31.
   TestIsObsoleteTimestamp(0x80000001);  // 2^31 + 1.
   TestIsObsoleteTimestamp(0x7FFFFFFF);  // 2^31 - 1.
 }
 }  // namespace webrtc