Removed RTPHeader from NetEq's Packet struct.

webrtc/modules/audio_coding/neteq/packet_buffer.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 82 matching lines @@
   // Get an iterator pointing to the place in the buffer where the new packet
   // should be inserted. The list is searched from the back, since the most
   // likely case is that the new packet should be near the end of the list.
   PacketList::reverse_iterator rit = std::find_if(
       buffer_.rbegin(), buffer_.rend(),
       NewTimestampIsLarger(packet));
 
   // The new packet is to be inserted to the right of |rit|. If it has the same
   // timestamp as |rit|, which has a higher priority, do not insert the new
   // packet to list.
-  if (rit != buffer_.rend() &&
-      packet->header.timestamp == (*rit)->header.timestamp) {
+  if (rit != buffer_.rend() && packet->timestamp == (*rit)->timestamp) {
     delete packet;
     return return_val;
   }
 
   // The new packet is to be inserted to the left of |it|. If it has the same
   // timestamp as |it|, which has a lower priority, replace |it| with the new
   // packet.
   PacketList::iterator it = rit.base();
-  if (it != buffer_.end() &&
-      packet->header.timestamp == (*it)->header.timestamp) {
+  if (it != buffer_.end() && packet->timestamp == (*it)->timestamp) {
     delete *it;
     it = buffer_.erase(it);
   }
   buffer_.insert(it, packet);  // Insert the packet at that position.
 
   return return_val;
 }
 
 int PacketBuffer::InsertPacketList(
     PacketList* packet_list,
     const DecoderDatabase& decoder_database,
     rtc::Optional<uint8_t>* current_rtp_payload_type,
     rtc::Optional<uint8_t>* current_cng_rtp_payload_type) {
   bool flushed = false;
   while (!packet_list->empty()) {
     Packet* packet = packet_list->front();
-    if (decoder_database.IsComfortNoise(packet->header.payloadType)) {
+    if (decoder_database.IsComfortNoise(packet->payload_type)) {
       if (*current_cng_rtp_payload_type &&
-          **current_cng_rtp_payload_type != packet->header.payloadType) {
+          **current_cng_rtp_payload_type != packet->payload_type) {
         // New CNG payload type implies new codec type.
         *current_rtp_payload_type = rtc::Optional<uint8_t>();
         Flush();
         flushed = true;
       }
       *current_cng_rtp_payload_type =
-          rtc::Optional<uint8_t>(packet->header.payloadType);
-    } else if (!decoder_database.IsDtmf(packet->header.payloadType)) {
+          rtc::Optional<uint8_t>(packet->payload_type);
+    } else if (!decoder_database.IsDtmf(packet->payload_type)) {
       // This must be speech.
       if ((*current_rtp_payload_type &&
-           **current_rtp_payload_type != packet->header.payloadType) ||
+           **current_rtp_payload_type != packet->payload_type) ||
           (*current_cng_rtp_payload_type &&
-           !EqualSampleRates(packet->header.payloadType,
+           !EqualSampleRates(packet->payload_type,
                              **current_cng_rtp_payload_type,
                              decoder_database))) {
         *current_cng_rtp_payload_type = rtc::Optional<uint8_t>();
         Flush();
         flushed = true;
       }
-      *current_rtp_payload_type =
-          rtc::Optional<uint8_t>(packet->header.payloadType);
+      *current_rtp_payload_type = rtc::Optional<uint8_t>(packet->payload_type);
     }
     int return_val = InsertPacket(packet);
     packet_list->pop_front();
     if (return_val == kFlushed) {
       // The buffer flushed, but this is not an error. We can still continue.
       flushed = true;
     } else if (return_val != kOK) {
       // An error occurred. Delete remaining packets in list and return.
       DeleteAllPackets(packet_list);
       return return_val;
     }
   }
   return flushed ? kFlushed : kOK;
 }
 
 int PacketBuffer::NextTimestamp(uint32_t* next_timestamp) const {
   if (Empty()) {
     return kBufferEmpty;
   }
   if (!next_timestamp) {
     return kInvalidPointer;
   }
-  *next_timestamp = buffer_.front()->header.timestamp;
+  *next_timestamp = buffer_.front()->timestamp;
   return kOK;
 }
 
 int PacketBuffer::NextHigherTimestamp(uint32_t timestamp,
                                       uint32_t* next_timestamp) const {
   if (Empty()) {
     return kBufferEmpty;
   }
   if (!next_timestamp) {
     return kInvalidPointer;
   }
   PacketList::const_iterator it;
   for (it = buffer_.begin(); it != buffer_.end(); ++it) {
-    if ((*it)->header.timestamp >= timestamp) {
+    if ((*it)->timestamp >= timestamp) {
       // Found a packet matching the search.
-      *next_timestamp = (*it)->header.timestamp;
+      *next_timestamp = (*it)->timestamp;
       return kOK;
     }
   }
   return kNotFound;
 }
 
-const RTPHeader* PacketBuffer::NextRtpHeader() const {
-  if (Empty()) {
-    return NULL;
-  }
-  return const_cast<const RTPHeader*>(&(buffer_.front()->header));
+const Packet* PacketBuffer::PeekNextPacket() const {
+  return buffer_.empty() ? nullptr : buffer_.front();
 }
 
 Packet* PacketBuffer::GetNextPacket(size_t* discard_count) {
   if (Empty()) {
     // Buffer is empty.
     return NULL;
   }
 
   Packet* packet = buffer_.front();
   // Assert that the packet sanity checks in InsertPacket method works.
   RTC_DCHECK(packet && !packet->empty());
   buffer_.pop_front();
 
   // Discard other packets with the same timestamp. These are duplicates or
   // redundant payloads that should not be used.
   size_t discards = 0;
 
-  while (!Empty() &&
-      buffer_.front()->header.timestamp == packet->header.timestamp) {
+  while (!Empty() && buffer_.front()->timestamp == packet->timestamp) {
     if (DiscardNextPacket() != kOK) {
       assert(false);  // Must be ok by design.
     }
     ++discards;
   }
   // The way of inserting packet should not cause any packet discarding here.
   // TODO(minyue): remove |discard_count|.
   assert(discards == 0);
   if (discard_count)
     *discard_count = discards;
 
   return packet;
 }
 
 int PacketBuffer::DiscardNextPacket() {
   if (Empty()) {
     return kBufferEmpty;
   }
   // Assert that the packet sanity checks in InsertPacket method works.
   RTC_DCHECK(buffer_.front());
   RTC_DCHECK(!buffer_.front()->empty());
   DeleteFirstPacket(&buffer_);
   return kOK;
 }
 
 int PacketBuffer::DiscardOldPackets(uint32_t timestamp_limit,
                                     uint32_t horizon_samples) {
-  while (!Empty() && timestamp_limit != buffer_.front()->header.timestamp &&
-         IsObsoleteTimestamp(buffer_.front()->header.timestamp,
-                             timestamp_limit,
+  while (!Empty() && timestamp_limit != buffer_.front()->timestamp &&
+         IsObsoleteTimestamp(buffer_.front()->timestamp, timestamp_limit,
                              horizon_samples)) {
     if (DiscardNextPacket() != kOK) {
       assert(false);  // Must be ok by design.
     }
   }
   return 0;
 }
 
 int PacketBuffer::DiscardAllOldPackets(uint32_t timestamp_limit) {
   return DiscardOldPackets(timestamp_limit, 0);
 }
 
 void PacketBuffer::DiscardPacketsWithPayloadType(uint8_t payload_type) {
   for (auto it = buffer_.begin(); it != buffer_.end(); /* */) {
     Packet* packet = *it;
-    if (packet->header.payloadType == payload_type) {
+    if (packet->payload_type == payload_type) {
       delete packet;
       it = buffer_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 size_t PacketBuffer::NumPacketsInBuffer() const {
   return buffer_.size();
@@ skipping 34 matching lines @@
     // Continue while the list is not empty.
   }
 }
 
 void PacketBuffer::BufferStat(int* num_packets, int* max_num_packets) const {
   *num_packets = static_cast<int>(buffer_.size());
   *max_num_packets = static_cast<int>(max_number_of_packets_);
 }
 
 }  // namespace webrtc