NetEq: Flush and reset if the speech and cng sample rates mismatch

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 {
-
+namespace {
 // 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_;
 };
 
+// Returns true if either payload types is empty; or if both payload types are

[minyue-webrtc, 2016/09/01 09:35:32]

"Returns true if either payload types is empty" can be moved out of the function
to match the function name better.

and can avoid  "rtc::Optional<uint8_t>(packet->header.payloadType)" as the first
argument for the use of this function

[hlundin-webrtc, 2016/09/01 10:31:10]

Done.

+// known to the decoder database, and have the same sample rate.
+bool EqualSampleRates(rtc::Optional<uint8_t> pt1,
+                      rtc::Optional<uint8_t> pt2,
+                      const DecoderDatabase& decoder_database) {
+  if (!pt1 || !pt2)
+    return true;
+  auto di1 = decoder_database.GetDecoderInfo(*pt1);
+  auto di2 = decoder_database.GetDecoderInfo(*pt2);
+  return di1 && di2 && di1->SampleRateHz() == di2->SampleRateHz();
+}
+}  // namespace
+
 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.
@@ skipping 68 matching lines @@
           **current_cng_rtp_payload_type != packet->header.payloadType) {
         // 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)) {
       // This must be speech.
-      if (*current_rtp_payload_type &&
-          **current_rtp_payload_type != packet->header.payloadType) {
+      if ((*current_rtp_payload_type &&
+           **current_rtp_payload_type != packet->header.payloadType) ||
+          !EqualSampleRates(rtc::Optional<uint8_t>(packet->header.payloadType),
+                            *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);
     }
     int return_val = InsertPacket(packet);
     packet_list->pop_front();
     if (return_val == kFlushed) {
@@ skipping 147 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