Fixed time moving backwards in the AudioCodingModule.

webrtc/modules/audio_coding/acm2/audio_coding_module.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 454 matching lines @@
 AudioCodingModuleImpl::~AudioCodingModuleImpl() = default;
 
 int32_t AudioCodingModuleImpl::Encode(const InputData& input_data) {
   AudioEncoder::EncodedInfo encoded_info;
   uint8_t previous_pltype;
 
   // Check if there is an encoder before.
   if (!HaveValidEncoder("Process"))
     return -1;
 
+  if(!first_frame_) {
+    RTC_DCHECK_GT(input_data.input_timestamp, last_timestamp_)
+        << "Time should not move backwards";
+  }
+
   // Scale the timestamp to the codec's RTP timestamp rate.
   uint32_t rtp_timestamp =
       first_frame_ ? input_data.input_timestamp

[ossu, 2016/07/06 08:38:56]

Here is where the output timestamp gets adjusted if there's a mismatch between a
codec's sample rate and its RTP clockrate.

                    : last_rtp_timestamp_ +
                          rtc::CheckedDivExact(
                              input_data.input_timestamp - last_timestamp_,
                              static_cast<uint32_t>(rtc::CheckedDivExact(
                                  encoder_stack_->SampleRateHz(),
                                  encoder_stack_->RtpTimestampRateHz())));
   last_timestamp_ = input_data.input_timestamp;
   last_rtp_timestamp_ = rtp_timestamp;
   first_frame_ = false;
 
@@ skipping 257 matching lines @@
   // TODO(henrik.lundin): This condition should probably be
   //   in_frame.num_channels_ > encoder_stack_->NumChannels()
   const bool down_mix =
       in_frame.num_channels_ == 2 && encoder_stack_->NumChannels() == 1;
 
   if (!first_10ms_data_) {
     expected_in_ts_ = in_frame.timestamp_;
     expected_codec_ts_ = in_frame.timestamp_;
     first_10ms_data_ = true;
   } else if (in_frame.timestamp_ != expected_in_ts_) {
-    // TODO(turajs): Do we need a warning here.

[ossu, 2016/07/05 16:39:04]

Probably.

+    LOG(LS_WARNING) << "Unexpected input timestamp: " << in_frame.timestamp_
+                    << ", expected: " << expected_in_ts_;

[tlegrand-webrtc, 2016/07/06 08:25:44]

Will we only end up here once in the case the codec changes?

[ossu, 2016/07/06 08:38:56]

This shouldn't happen when the codec changes. In fact, I don't think we should
ever end up here. However, seeing as it's something we're not expecting, I think
we should log it. It could help track down other issues when we don't have
access to much other than logs.

Now, if this happens, we adjust for it and it should only log once, yes. Unless
something very strange is happening at the input (like maybe timestamps not
moving forward at all).

     expected_codec_ts_ +=
         (in_frame.timestamp_ - expected_in_ts_) *
         static_cast<uint32_t>(
             static_cast<double>(encoder_stack_->SampleRateHz()) /
             static_cast<double>(in_frame.sample_rate_hz_));
     expected_in_ts_ = in_frame.timestamp_;
   }
 
 
   if (!down_mix && !resample) {
     // No pre-processing is required.
+    if (expected_in_ts_ == expected_codec_ts_) {
+      // If we've never resampled, we can use the input frame as-is
+      *ptr_out = &in_frame;
+    } else {
+      // Otherwise we'll need to alter the timestamp. Since in_frame is const,
+      // we'll have to make a copy of it.
+      preprocess_frame_.CopyFrom(in_frame);
+      preprocess_frame_.timestamp_ = expected_codec_ts_;
+      *ptr_out = &preprocess_frame_;
+    }
+
     expected_in_ts_ += static_cast<uint32_t>(in_frame.samples_per_channel_);
     expected_codec_ts_ += static_cast<uint32_t>(in_frame.samples_per_channel_);
-    *ptr_out = &in_frame;
     return 0;
   }
 
   *ptr_out = &preprocess_frame_;
   preprocess_frame_.num_channels_ = in_frame.num_channels_;
   int16_t audio[WEBRTC_10MS_PCM_AUDIO];
   const int16_t* src_ptr_audio = in_frame.data_;
   int16_t* dest_ptr_audio = preprocess_frame_.data_;
   if (down_mix) {
     // If a resampling is required the output of a down-mix is written into a
@@ skipping 537 matching lines @@
 // Checks the validity of the parameters of the given codec
 bool AudioCodingModule::IsCodecValid(const CodecInst& codec) {
   bool valid = acm2::RentACodec::IsCodecValid(codec);
   if (!valid)
     WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceAudioCoding, -1,
                  "Invalid codec setting");
   return valid;
 }
 
 }  // namespace webrtc