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

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 39 matching lines @@
 // Flush the buffer. All packets in the buffer will be destroyed.
 void PacketBuffer::Flush() {
   DeleteAllPackets(&buffer_);
 }
 
 bool PacketBuffer::Empty() const {
   return buffer_.empty();
 }
 
 int PacketBuffer::InsertPacket(Packet* packet) {
-  if (!packet || !packet->payload) {
+  if (!packet || packet->payload.empty()) {
     if (packet) {
       delete packet;
     }
     LOG(LS_WARNING) << "InsertPacket invalid packet";
     return kInvalidPacket;
   }
 
   int return_val = kOK;
 
   packet->waiting_time = tick_timer_->GetNewStopwatch();
@@ skipping 10 matching lines @@
   // 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) {
-    delete [] packet->payload;
     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) {
-    delete [] (*it)->payload;
     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,
@@ skipping 73 matching lines @@
 }
 
 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.
-  assert(packet && packet->payload);
+  assert(packet && !packet->payload.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) {
     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.
   assert(buffer_.front());
-  assert(buffer_.front()->payload);
+  assert(!buffer_.front()->payload.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,
                              horizon_samples)) {
@@ skipping 18 matching lines @@
   size_t num_samples = 0;
   size_t last_duration = last_decoded_length;
   for (it = buffer_.begin(); it != buffer_.end(); ++it) {
     Packet* packet = (*it);
     AudioDecoder* decoder =
         decoder_database->GetDecoder(packet->header.payloadType);
     if (decoder && !packet->sync_packet) {
       if (!packet->primary) {
         continue;
       }
-      int duration =
-          decoder->PacketDuration(packet->payload, packet->payload_length);
+      int duration = decoder->PacketDuration(packet->payload.data(),
+                                             packet->payload.size());
       if (duration >= 0) {
         last_duration = duration;  // Save the most up-to-date (valid) duration.
       }
     }
     num_samples += last_duration;
   }
   return num_samples;
 }
 
 bool PacketBuffer::DeleteFirstPacket(PacketList* packet_list) {
   if (packet_list->empty()) {
     return false;
   }
   Packet* first_packet = packet_list->front();
-  delete [] first_packet->payload;
   delete first_packet;
   packet_list->pop_front();
   return true;
 }
 
 void PacketBuffer::DeleteAllPackets(PacketList* packet_list) {
   while (DeleteFirstPacket(packet_list)) {
     // 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