Moves channel-dependent audio input processing to separate encoder task queue

webrtc/modules/audio_device/audio_device_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 304 matching lines @@
       only_silence_recorded_ = false;
     }
   }
   // Update recording stats which is used as base for periodic logging of the
   // audio input state.
   UpdateRecStats(max_abs, samples_per_channel);
   return 0;
 }
 
 int32_t AudioDeviceBuffer::DeliverRecordedData() {
+  int64_t start_time = rtc::TimeMicros();
   RTC_DCHECK_RUN_ON(&recording_thread_checker_);
   if (!audio_transport_cb_) {
     LOG(LS_WARNING) << "Invalid audio transport";
     return 0;
   }
   const size_t frames = rec_buffer_.size() / rec_channels_;
   const size_t bytes_per_frame = rec_channels_ * sizeof(int16_t);
   uint32_t new_mic_level(0);
   uint32_t total_delay_ms = play_delay_ms_ + rec_delay_ms_;
   int32_t res = audio_transport_cb_->RecordedDataIsAvailable(
       rec_buffer_.data(), frames, bytes_per_frame, rec_channels_,
       rec_sample_rate_, total_delay_ms, clock_drift_, current_mic_level_,
       typing_status_, new_mic_level);
   if (res != -1) {
     new_mic_level_ = new_mic_level;
   } else {
     LOG(LS_ERROR) << "RecordedDataIsAvailable() failed";
   }
+  int64_t diff_time = rtc::TimeMicros() - start_time;
+  acc_diff_times_ += diff_time;
+  num_diff_times_++;
+  if (diff_time > max_diff_time_) {
+    max_diff_time_ = diff_time;
+    LOG(INFO) << "max_diff_time: " << max_diff_time_;
+  }
+
   return 0;
 }
 
 int32_t AudioDeviceBuffer::RequestPlayoutData(size_t samples_per_channel) {
   RTC_DCHECK_RUN_ON(&playout_thread_checker_);
   // The consumer can change the requested size on the fly and we therefore
   // resize the buffer accordingly. Also takes place at the first call to this
   // method.
   const size_t total_samples = play_channels_ * samples_per_channel;
   if (play_buffer_.size() != total_samples) {
@@ skipping 105 matching lines @@
     rate = diff_samples / (static_cast<float>(time_since_last) / 1000.0);
     LOG(INFO) << "[PLAY: " << time_since_last << "msec, "
               << play_sample_rate_ / 1000 << "kHz] callbacks: "
               << stats.play_callbacks - last_stats_.play_callbacks << ", "
               << "samples: " << diff_samples << ", "
               << "rate: " << static_cast<int>(rate + 0.5) << ", "
               << "level: " << stats.max_play_level;
     last_stats_ = stats;
   }
 
+  double avg_diff_time = (double)acc_diff_times_ / num_diff_times_;
+  LOG(INFO) << "avg_diff_time: " << avg_diff_time;

[the sun, 2017/03/23 12:45:55]

log max here as well, to avoid it in audio cb

[henrika_webrtc, 2017/03/23 14:02:17]

Done.

+
   int64_t time_to_wait_ms = next_callback_time - rtc::TimeMillis();
   RTC_DCHECK_GT(time_to_wait_ms, 0) << "Invalid timer interval";
 
   // Keep posting new (delayed) tasks until state is changed to kLogStop.
   task_queue_.PostDelayedTask(rtc::Bind(&AudioDeviceBuffer::LogStats, this,
                                         AudioDeviceBuffer::LOG_ACTIVE),
                               time_to_wait_ms);
 }
 
 void AudioDeviceBuffer::ResetRecStats() {
@@ skipping 26 matching lines @@
   RTC_DCHECK_RUN_ON(&playout_thread_checker_);
   rtc::CritScope cs(&lock_);
   ++stats_.play_callbacks;
   stats_.play_samples += samples_per_channel;
   if (max_abs > stats_.max_play_level) {
     stats_.max_play_level = max_abs;
   }
 }
 
 }  // namespace webrtc