Added a ParsePayload method to AudioDecoder.

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 50 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.empty()) {
+  if (!packet || packet->empty()) {
     if (packet) {
       delete packet;
     }
     LOG(LS_WARNING) << "InsertPacket invalid packet";
     return kInvalidPacket;
   }
 
   int return_val = kOK;
 
   packet->waiting_time = tick_timer_->GetNewStopwatch();
@@ skipping 120 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.empty());
+  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) {
     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.empty());
+  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,
                              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);
 }
 
 size_t PacketBuffer::NumPacketsInBuffer() const {
   return buffer_.size();
 }
 
-size_t PacketBuffer::NumSamplesInBuffer(DecoderDatabase* decoder_database,
-                                        size_t last_decoded_length) const {
-  PacketList::const_iterator it;
+size_t PacketBuffer::NumSamplesInBuffer(size_t last_decoded_length) const {
   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) {
+  for (Packet* packet : buffer_) {
+    if (packet->frame) {
       if (!packet->primary) {
         continue;
       }
-      int duration = decoder->PacketDuration(packet->payload.data(),
-                                             packet->payload.size());
-      if (duration >= 0) {
+      size_t duration = packet->frame->Duration();
+      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()) {
@@ skipping 10 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