Fixed problems in neteq when RTP and decoder timestamps increment with

webrtc/modules/audio_coding/neteq/neteq_impl.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 576 matching lines @@
     Packet packet;
     packet.payload_type = rtp_header.header.payloadType;
     packet.sequence_number = rtp_header.header.sequenceNumber;
     packet.timestamp = rtp_header.header.timestamp;
     packet.payload.SetData(payload.data(), payload.size());
     // Waiting time will be set upon inserting the packet in the buffer.
     RTC_DCHECK(!packet.waiting_time);
     return packet;
   }());
 
-  bool update_sample_rate_and_channels = false;
+  bool update_sample_rate_and_channels = first_packet_ ||
+    (rtp_header.header.ssrc != ssrc_);
+
+  if (update_sample_rate_and_channels) {
+    // Reset timestamp scaling.
+    timestamp_scaler_->Reset();
+  }
+
+  if (!decoder_database_->IsRed(rtp_header.header.payloadType)) {

[ossu, 2017/03/14 16:57:14]

Hmm... I'm not sure this _should_ be necessary. I'll have a look at that
separately.

+    // Scale timestamp to internal domain (only for some codecs).
+    timestamp_scaler_->ToInternal(&packet_list);
+  }
+
+  // Store these for later use, since the first packet may very well disappear
+  // before we need these values.
+  uint32_t main_timestamp = packet_list.front().timestamp;
+  uint8_t main_payload_type = packet_list.front().payload_type;
+  uint16_t main_sequence_number = packet_list.front().sequence_number;
+
   // Reinitialize NetEq if it's needed (changed SSRC or first call).
-  if ((rtp_header.header.ssrc != ssrc_) || first_packet_) {
+  if (update_sample_rate_and_channels) {
     // Note: |first_packet_| will be cleared further down in this method, once
     // the packet has been successfully inserted into the packet buffer.
 
     rtcp_.Init(rtp_header.header.sequenceNumber);
 
     // Flush the packet buffer and DTMF buffer.
     packet_buffer_->Flush();
     dtmf_buffer_->Flush();
 
     // Store new SSRC.
     ssrc_ = rtp_header.header.ssrc;
 
     // Update audio buffer timestamp.
-    sync_buffer_->IncreaseEndTimestamp(rtp_header.header.timestamp -
-                                       timestamp_);
+    sync_buffer_->IncreaseEndTimestamp(main_timestamp - timestamp_);
 
     // Update codecs.
-    timestamp_ = rtp_header.header.timestamp;
-
-    // Reset timestamp scaling.
-    timestamp_scaler_->Reset();
-
-    // Trigger an update of sampling rate and the number of channels.
-    update_sample_rate_and_channels = true;
+    timestamp_ = main_timestamp;
   }
 
   // Update RTCP statistics, only for regular packets.
   rtcp_.Update(rtp_header.header, receive_timestamp);
 
   if (nack_enabled_) {
     RTC_DCHECK(nack_);
     if (update_sample_rate_and_channels) {
       nack_->Reset();
     }
@@ skipping 11 matching lines @@
     red_payload_splitter_->CheckRedPayloads(&packet_list, *decoder_database_);
   }
 
   // Check payload types.
   if (decoder_database_->CheckPayloadTypes(packet_list) ==
       DecoderDatabase::kDecoderNotFound) {
     return kUnknownRtpPayloadType;
   }
 
   RTC_DCHECK(!packet_list.empty());
-  // Store these for later use, since the first packet may very well disappear
-  // before we need these values.
-  const uint32_t main_timestamp = packet_list.front().timestamp;
-  const uint8_t main_payload_type = packet_list.front().payload_type;
-  const uint16_t main_sequence_number = packet_list.front().sequence_number;
 
-  // Scale timestamp to internal domain (only for some codecs).
-  timestamp_scaler_->ToInternal(&packet_list);
+  // Update main_timestamp, if new packets appear in the list
+  // after RED splitting.
+  if (decoder_database_->IsRed(rtp_header.header.payloadType)) {
+    timestamp_scaler_->ToInternal(&packet_list);
+    main_timestamp = packet_list.front().timestamp;
+    main_payload_type = packet_list.front().payload_type;
+    main_sequence_number = packet_list.front().sequence_number;
+  }
 
   // Process DTMF payloads. Cycle through the list of packets, and pick out any
   // DTMF payloads found.
   PacketList::iterator it = packet_list.begin();
   while (it != packet_list.end()) {
     const Packet& current_packet = (*it);
     RTC_DCHECK(!current_packet.payload.empty());
     if (decoder_database_->IsDtmf(current_packet.payload_type)) {
       DtmfEvent event;
       int ret = DtmfBuffer::ParseEvent(current_packet.timestamp,
@@ skipping 1455 matching lines @@
   }
 }
 
 void NetEqImpl::CreateDecisionLogic() {
   decision_logic_.reset(DecisionLogic::Create(
       fs_hz_, output_size_samples_, playout_mode_, decoder_database_.get(),
       *packet_buffer_.get(), delay_manager_.get(), buffer_level_filter_.get(),
       tick_timer_.get()));
 }
 }  // namespace webrtc