Removals and renamings in the new audio mixer.

webrtc/modules/audio_mixer/test/audio_mixer_unittest.cc

 /*
  *  Copyright (c) 2016 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 <memory>
 #include <utility>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "webrtc/modules/audio_mixer/audio_mixer_defines.h"
-#include "webrtc/modules/audio_mixer/new_audio_conference_mixer.h"
+#include "webrtc/modules/audio_mixer/audio_mixer.h"
 
 using testing::_;
 using testing::Exactly;
 using testing::Invoke;
 using testing::Return;
 
 namespace webrtc {
 
 namespace {
 
@@ skipping 51 matching lines @@
 // Creates participants from |frames| and |frame_info| and adds them
 // to the mixer. Compares mixed status with |expected_status|
 void MixAndCompare(
     const std::vector<AudioFrame>& frames,
     const std::vector<MixerAudioSource::AudioFrameInfo>& frame_info,
     const std::vector<bool>& expected_status) {
   size_t num_audio_sources = frames.size();
   RTC_DCHECK(frames.size() == frame_info.size() &&
              frame_info.size() == expected_status.size());
 
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
   std::vector<MockMixerAudioSource> participants(num_audio_sources);
 
   for (size_t i = 0; i < num_audio_sources; i++) {
     participants[i].fake_frame()->CopyFrom(frames[i]);
     participants[i].set_fake_info(frame_info[i]);
   }
 
   for (size_t i = 0; i < num_audio_sources; i++) {
     EXPECT_EQ(0, mixer->SetMixabilityStatus(&participants[i], true));
     EXPECT_CALL(participants[i],
                 GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
   }
 
   mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
 
   for (size_t i = 0; i < num_audio_sources; i++) {
     EXPECT_EQ(participants[i].IsMixed(), expected_status[i])
         << "Mixed status of AudioSource #" << i << " wrong.";
   }
 }
 
 TEST(AudioMixer, AnonymousAndNamed) {
   // Should not matter even if partipants are more than
   // kMaximumAmountOfMixedAudioSources.
-  constexpr int kNamed =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
-  constexpr int kAnonymous =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+  constexpr int kNamed = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
+  constexpr int kAnonymous = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
 
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource named[kNamed];
   MockMixerAudioSource anonymous[kAnonymous];
 
   for (int i = 0; i < kNamed; ++i) {
     EXPECT_EQ(0, mixer->SetMixabilityStatus(&named[i], true));
     EXPECT_TRUE(mixer->MixabilityStatus(named[i]));
   }
 
   for (int i = 0; i < kAnonymous; ++i) {
@@ skipping 25 matching lines @@
   }
 
   // SetMixabilityStatus(anonymous, false) will remove anonymous from both
   // anonymous and named groups.
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&anonymous[kAnonymous - 1], false));
   EXPECT_FALSE(mixer->AnonymousMixabilityStatus(anonymous[kAnonymous - 1]));
   EXPECT_FALSE(mixer->MixabilityStatus(anonymous[kAnonymous - 1]));
 }
 
 TEST(AudioMixer, LargestEnergyVadActiveMixed) {
-  const int kAudioSources =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 3;
+  const int kAudioSources = AudioMixer::kMaximumAmountOfMixedAudioSources + 3;
 
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource participants[kAudioSources];
 
   for (int i = 0; i < kAudioSources; ++i) {
     ResetFrame(participants[i].fake_frame());
 
     // We set the 80-th sample value since the first 80 samples may be
     // modified by a ramped-in window.
     participants[i].fake_frame()->data_[80] = i;
 
     EXPECT_EQ(0, mixer->SetMixabilityStatus(&participants[i], true));
     EXPECT_CALL(participants[i], GetAudioFrameWithMuted(_, _))
         .Times(Exactly(1));
   }
 
   // Last participant gives audio frame with passive VAD, although it has the
   // largest energy.
   participants[kAudioSources - 1].fake_frame()->vad_activity_ =
       AudioFrame::kVadPassive;
 
   AudioFrame audio_frame;
   mixer->Mix(kDefaultSampleRateHz,
              1,  // number of channels
              &audio_frame);
 
   for (int i = 0; i < kAudioSources; ++i) {
     bool is_mixed = participants[i].IsMixed();
     if (i == kAudioSources - 1 ||
-        i < kAudioSources - 1 -
-                NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources) {
+        i < kAudioSources - 1 - AudioMixer::kMaximumAmountOfMixedAudioSources) {
       EXPECT_FALSE(is_mixed) << "Mixing status of AudioSource #" << i
                              << " wrong.";
     } else {
       EXPECT_TRUE(is_mixed) << "Mixing status of AudioSource #" << i
                             << " wrong.";
     }
   }
 }
 
 TEST(AudioMixer, ParticipantSampleRate) {
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource participant;
   ResetFrame(participant.fake_frame());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (auto frequency : {8000, 16000, 32000, 48000}) {
     EXPECT_CALL(participant, GetAudioFrameWithMuted(_, frequency))
         .Times(Exactly(1));
     mixer->Mix(frequency, 1, &frame_for_mixing);
     EXPECT_EQ(frequency, frame_for_mixing.sample_rate_hz_);
   }
 }
 
 TEST(AudioMixer, ParticipantNumberOfChannels) {
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource participant;
   ResetFrame(participant.fake_frame());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (size_t number_of_channels : {1, 2}) {
     EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
     mixer->Mix(kDefaultSampleRateHz, number_of_channels, &frame_for_mixing);
     EXPECT_EQ(number_of_channels, frame_for_mixing.num_channels_);
   }
 }
 
 // Test that the volume is reported as zero when the mixer input
 // comprises only zero values.
 TEST(AudioMixer, LevelIsZeroWhenMixingZeroes) {
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource participant;
   ResetFrame(participant.fake_frame());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (size_t i = 0; i < 11; i++) {
     EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
     mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
   }
 
   EXPECT_EQ(static_cast<uint32_t>(0), mixer->GetOutputAudioLevel());
   EXPECT_EQ(static_cast<uint32_t>(0), mixer->GetOutputAudioLevelFullRange());
 }
 
 // Test that the reported volume is maximal as full when the mixer
 // input comprises frames with maximal values.
 TEST(AudioMixer, LevelIsMaximalWhenMixingMaximalValues) {
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource participant;
   ResetFrame(participant.fake_frame());
 
   // Fill participant frame data with maximal sound.
   std::fill(participant.fake_frame()->data_,
             participant.fake_frame()->data_ + kDefaultSampleRateHz / 100,
             std::numeric_limits<int16_t>::max());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant, true));
   for (size_t i = 0; i < 11; i++) {
     EXPECT_CALL(participant, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
     mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
   }
 
   // 9 is the highest possible audio level
   EXPECT_EQ(static_cast<uint32_t>(9), mixer->GetOutputAudioLevel());
 
   // 0x7fff = 32767 is the highest full range audio level.
   EXPECT_EQ(static_cast<uint32_t>(std::numeric_limits<int16_t>::max()),
             mixer->GetOutputAudioLevelFullRange());
 }
 
 // Test that the reported volume is maximal as full when the mixer
 // input comprises frames with maximal values.
 TEST(AudioMixer, VolumeTwoParticipants) {
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
 
   MockMixerAudioSource participant1, participant2;
   ResetFrame(participant1.fake_frame());
   ResetFrame(participant2.fake_frame());
 
   // Fill participant1 frame data with maximal sound.
   std::fill(participant1.fake_frame()->data_,
             participant1.fake_frame()->data_ + kDefaultSampleRateHz / 100, 0);
   std::fill(participant2.fake_frame()->data_,
             participant2.fake_frame()->data_ + kDefaultSampleRateHz / 100,
             std::numeric_limits<int16_t>::max());
 
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant1, true));
   EXPECT_EQ(0, mixer->SetMixabilityStatus(&participant2, true));
   for (size_t i = 0; i < 11; i++) {
     EXPECT_CALL(participant1, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
     EXPECT_CALL(participant2, GetAudioFrameWithMuted(_, kDefaultSampleRateHz))
         .Times(Exactly(1));
     mixer->Mix(kDefaultSampleRateHz, 1, &frame_for_mixing);
   }
 }
 
 // Maximal amount of participants are mixed one iteration, then
 // another participant with higher energy is added.
 TEST(AudioMixer, RampedOutSourcesShouldNotBeMarkedMixed) {
-  const int kAudioSources =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+  const int kAudioSources = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
 
-  std::unique_ptr<NewAudioConferenceMixer> mixer(
-      NewAudioConferenceMixer::Create(kId));
+  std::unique_ptr<AudioMixer> mixer(AudioMixer::Create(kId));
   MockMixerAudioSource participants[kAudioSources];
 
   for (size_t i = 0; i < kAudioSources; i++) {
     ResetFrame(participants[i].fake_frame());
     participants[i].fake_frame()->data_[0] = 100 * i;
   }
 
   for (size_t i = 0; i < kAudioSources - 1; i++) {
     EXPECT_EQ(0, mixer->SetMixabilityStatus(&participants[i], true));
     EXPECT_CALL(participants[i],
@@ skipping 23 matching lines @@
   EXPECT_FALSE(participants[0].IsMixed())
       << "Mixed status of AudioSource #0 wrong.";
 
   for (size_t i = 1; i < kAudioSources; i++) {
     EXPECT_EQ(participants[i].IsMixed(), true)
         << "Mixed status of AudioSource #" << i << " wrong.";
   }
 }
 
 TEST(AudioMixer, MutedShouldMixAfterUnmuted) {
-  const int kAudioSources =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+  const int kAudioSources = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
 
   std::vector<AudioFrame> frames(kAudioSources);
   for (auto& frame : frames) {
     ResetFrame(&frame);
   }
 
   std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
       kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
   frame_info[0] = MixerAudioSource::AudioFrameInfo::kMuted;
   std::vector<bool> expected_status(kAudioSources, true);
   expected_status[0] = false;
 
   MixAndCompare(frames, frame_info, expected_status);
 }
 
 TEST(AudioMixer, PassiveShouldMixAfterNormal) {
-  const int kAudioSources =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+  const int kAudioSources = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
 
   std::vector<AudioFrame> frames(kAudioSources);
   for (auto& frame : frames) {
     ResetFrame(&frame);
   }
 
   std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
       kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
   frames[0].vad_activity_ = AudioFrame::kVadPassive;
   std::vector<bool> expected_status(kAudioSources, true);
   expected_status[0] = false;
 
   MixAndCompare(frames, frame_info, expected_status);
 }
 
 TEST(AudioMixer, ActiveShouldMixBeforeLoud) {
-  const int kAudioSources =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+  const int kAudioSources = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
 
   std::vector<AudioFrame> frames(kAudioSources);
   for (auto& frame : frames) {
     ResetFrame(&frame);
   }
 
   std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
       kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
   frames[0].vad_activity_ = AudioFrame::kVadPassive;
   std::fill(frames[0].data_, frames[0].data_ + kDefaultSampleRateHz / 100,
             std::numeric_limits<int16_t>::max());
   std::vector<bool> expected_status(kAudioSources, true);
   expected_status[0] = false;
 
   MixAndCompare(frames, frame_info, expected_status);
 }
 
 TEST(AudioMixer, UnmutedShouldMixBeforeLoud) {
-  const int kAudioSources =
-      NewAudioConferenceMixer::kMaximumAmountOfMixedAudioSources + 1;
+  const int kAudioSources = AudioMixer::kMaximumAmountOfMixedAudioSources + 1;
 
   std::vector<AudioFrame> frames(kAudioSources);
   for (auto& frame : frames) {
     ResetFrame(&frame);
   }
 
   std::vector<MixerAudioSource::AudioFrameInfo> frame_info(
       kAudioSources, MixerAudioSource::AudioFrameInfo::kNormal);
   frame_info[0] = MixerAudioSource::AudioFrameInfo::kMuted;
   std::fill(frames[0].data_, frames[0].data_ + kDefaultSampleRateHz / 100,
             std::numeric_limits<int16_t>::max());
   std::vector<bool> expected_status(kAudioSources, true);
   expected_status[0] = false;
 
   MixAndCompare(frames, frame_info, expected_status);
 }
 }  // namespace webrtc