Reland of Conversational speech tool, simualtor + unit tests

webrtc/modules/audio_processing/test/conversational_speech/multiend_call.cc

 /*
  *  Copyright (c) 2017 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.
  */
 
 #include "webrtc/modules/audio_processing/test/conversational_speech/multiend_call.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/pathutils.h"
 
 namespace webrtc {
 namespace test {
 namespace conversational_speech {
 
 MultiEndCall::MultiEndCall(
     rtc::ArrayView<const Turn> timing, const std::string& audiotracks_path,
     std::unique_ptr<WavReaderAbstractFactory> wavreader_abstract_factory)
         : timing_(timing), audiotracks_path_(audiotracks_path),
-          wavreader_abstract_factory_(std::move(wavreader_abstract_factory)) {
+          wavreader_abstract_factory_(std::move(wavreader_abstract_factory)),
+          valid_(false) {
   FindSpeakerNames();
-  CreateAudioTrackReaders();
-  valid_ = CheckTiming();
+  if (CreateAudioTrackReaders())
+    valid_ = CheckTiming();
 }
 
 MultiEndCall::~MultiEndCall() = default;
 
-const std::set<std::string>& MultiEndCall::speaker_names() const {
-  return speaker_names_;
-}
-
-const std::map<std::string, std::unique_ptr<WavReaderInterface>>&
-    MultiEndCall::audiotrack_readers() const {
-  return audiotrack_readers_;
-}
-
-bool MultiEndCall::valid() const {
-  return valid_;
-}
-
-size_t MultiEndCall::total_duration_samples() const {
-  return total_duration_samples_;
-}
-
-const std::vector<MultiEndCall::SpeakingTurn>& MultiEndCall::speaking_turns()
-    const {
-  return speaking_turns_;
-}
-
 void MultiEndCall::FindSpeakerNames() {
   RTC_DCHECK(speaker_names_.empty());
   for (const Turn& turn : timing_) {
     speaker_names_.emplace(turn.speaker_name);
   }
 }
 
-void MultiEndCall::CreateAudioTrackReaders() {
+bool MultiEndCall::CreateAudioTrackReaders() {
   RTC_DCHECK(audiotrack_readers_.empty());
+  sample_rate_hz_ = 0;  // Sample rate will be set when reading the first track.
   for (const Turn& turn : timing_) {
     auto it = audiotrack_readers_.find(turn.audiotrack_file_name);
     if (it != audiotrack_readers_.end())
       continue;
 
     // Instance Pathname to retrieve the full path to the audiotrack file.
     const rtc::Pathname audiotrack_file_path(
         audiotracks_path_, turn.audiotrack_file_name);
 
     // Map the audiotrack file name to a new instance of WavReaderInterface.
     std::unique_ptr<WavReaderInterface> wavreader =
         wavreader_abstract_factory_->Create(audiotrack_file_path.pathname());
+
+    if (sample_rate_hz_ == 0) {
+      sample_rate_hz_ = wavreader->SampleRate();
+    } else if (sample_rate_hz_ != wavreader->SampleRate()) {
+      LOG(LS_ERROR) << "All the audio tracks should have the same sample rate.";
+      return false;
+    }
+
+    if (wavreader->NumChannels() != 1) {
+      LOG(LS_ERROR) << "Only mono audio tracks supported.";
+      return false;
+    }
+
     audiotrack_readers_.emplace(
         turn.audiotrack_file_name, std::move(wavreader));
   }
+
+  return true;
 }
 
 bool MultiEndCall::CheckTiming() {
   struct Interval {
     size_t begin;
     size_t end;
   };
   size_t number_of_turns = timing_.size();
   auto millisecond_to_samples = [](int ms, int sr) -> int {
     // Truncation may happen if the sampling rate is not an integer multiple
@@ skipping 95 matching lines @@
       return false;
     }
   }
 
   return true;
 }
 
 }  // namespace conversational_speech
 }  // namespace test
 }  // namespace webrtc