WIP: Adding a centralized NetEq Clock

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.
  */
 
 // This is the implementation of the PacketBuffer class. It is mostly based on
 // an STL list. The list is kept sorted at all times so that the next packet to
 // decode is at the beginning of the list.
 
 #include "webrtc/modules/audio_coding/neteq/packet_buffer.h"
 
 #include <algorithm>  // find_if()
 
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/audio_coding/codecs/audio_decoder.h"
 #include "webrtc/modules/audio_coding/neteq/decoder_database.h"
+#include "webrtc/modules/audio_coding/neteq/tick_timer.h"
 
 namespace webrtc {
 
 // Predicate used when inserting packets in the buffer list.
 // Operator() returns true when |packet| goes before |new_packet|.
 class NewTimestampIsLarger {
  public:
   explicit NewTimestampIsLarger(const Packet* new_packet)
       : new_packet_(new_packet) {
   }
   bool operator()(Packet* packet) {
     return (*new_packet_ >= *packet);
   }
 
  private:
   const Packet* new_packet_;
 };
 
-PacketBuffer::PacketBuffer(size_t max_number_of_packets)
-    : max_number_of_packets_(max_number_of_packets) {}
+PacketBuffer::PacketBuffer(size_t max_number_of_packets,
+                           const TickTimer& tick_timer)
+    : max_number_of_packets_(max_number_of_packets), tick_timer_(tick_timer) {}
 
 // Destructor. All packets in the buffer will be destroyed.
 PacketBuffer::~PacketBuffer() {
   Flush();
 }
 
 // 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) {
       delete packet;
     }
     LOG(LS_WARNING) << "InsertPacket invalid packet";
     return kInvalidPacket;
   }
 
   int return_val = kOK;
 
+  packet->waiting_time = tick_timer_.GetNewStopwatch();
+
   if (buffer_.size() >= max_number_of_packets_) {
     // Buffer is full. Flush it.
     Flush();
     LOG(LS_WARNING) << "Packet buffer flushed";
     return_val = kFlushed;
   }
 
   // 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.
@@ skipping 183 matching lines @@
           decoder->PacketDuration(packet->payload, packet->payload_length);
       if (duration >= 0) {
         last_duration = duration;  // Save the most up-to-date (valid) duration.
       }
     }
     num_samples += last_duration;
   }
   return num_samples;
 }
 
-void PacketBuffer::IncrementWaitingTimes(int inc) {
-  PacketList::iterator it;
-  for (it = buffer_.begin(); it != buffer_.end(); ++it) {
-    (*it)->waiting_time += inc;
-  }
-}
-
 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