/*
 *  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.
 */

#include "webrtc/modules/audio_mixer/source/new_audio_conference_mixer_impl.h"

#include <algorithm>

#include "webrtc/modules/audio_conference_mixer/source/audio_frame_manipulator.h"
#include "webrtc/modules/audio_mixer/include/audio_mixer_defines.h"
#include "webrtc/modules/audio_processing/include/audio_processing.h"
#include "webrtc/modules/utility/include/audio_frame_operations.h"
#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
#include "webrtc/system_wrappers/include/trace.h"

namespace webrtc {
namespace {

struct ParticipantFrameStruct {
  ParticipantFrameStruct(MixerAudioSource* p, AudioFrame* a, bool m)
      : participant(p), audioFrame(a), muted(m) {}
  MixerAudioSource* participant;
  AudioFrame* audioFrame;
  bool muted;
};

typedef std::list<ParticipantFrameStruct*> ParticipantFrameStructList;

// Mix |frame| into |mixed_frame|, with saturation protection and upmixing.
// These effects are applied to |frame| itself prior to mixing. Assumes that
// |mixed_frame| always has at least as many channels as |frame|. Supports
// stereo at most.
//
// TODO(andrew): consider not modifying |frame| here.
void MixFrames(AudioFrame* mixed_frame, AudioFrame* frame, bool use_limiter) {
  assert(mixed_frame->num_channels_ >= frame->num_channels_);
  if (use_limiter) {
    // Divide by two to avoid saturation in the mixing.
    // This is only meaningful if the limiter will be used.
    *frame >>= 1;
  }
  if (mixed_frame->num_channels_ > frame->num_channels_) {
    // We only support mono-to-stereo.
    assert(mixed_frame->num_channels_ == 2 && frame->num_channels_ == 1);
    AudioFrameOperations::MonoToStereo(frame);
  }

  *mixed_frame += *frame;
}

// Return the max number of channels from a |list| composed of AudioFrames.
size_t MaxNumChannels(const AudioFrameList* list) {
  size_t max_num_channels = 1;
  for (AudioFrameList::const_iterator iter = list->begin(); iter != list->end();
       ++iter) {
    max_num_channels = std::max(max_num_channels, (*iter).frame->num_channels_);
  }
  return max_num_channels;
}

}  // namespace

MixerAudioSource::MixerAudioSource() : _mixHistory(new NewMixHistory()) {}

MixerAudioSource::~MixerAudioSource() {
  delete _mixHistory;
}

bool MixerAudioSource::IsMixed() const {
  return _mixHistory->IsMixed();
}

NewMixHistory::NewMixHistory() : _isMixed(0) {}

NewMixHistory::~NewMixHistory() {}

bool NewMixHistory::IsMixed() const {
  return _isMixed;
}

bool NewMixHistory::WasMixed() const {
  // Was mixed is the same as is mixed depending on perspective. This function
  // is for the perspective of NewAudioConferenceMixerImpl.
  return IsMixed();
}

int32_t NewMixHistory::SetIsMixed(const bool mixed) {
  _isMixed = mixed;
  return 0;
}

void NewMixHistory::ResetMixedStatus() {
  _isMixed = false;
}

NewAudioConferenceMixer* NewAudioConferenceMixer::Create(int id) {
  NewAudioConferenceMixerImpl* mixer = new NewAudioConferenceMixerImpl(id);
  if (!mixer->Init()) {
    delete mixer;
    return NULL;
  }
  return mixer;
}

NewAudioConferenceMixerImpl::NewAudioConferenceMixerImpl(int id)
    : _id(id),
      _minimumMixingFreq(kLowestPossible),
      _mixReceiver(NULL),
      _outputFrequency(kDefaultFrequency),
      _sampleSize(0),
      _audioFramePool(NULL),
      _participantList(),
      _additionalParticipantList(),
      _numMixedParticipants(0),
      use_limiter_(true),
      _timeStamp(0),
      _timeScheduler(kProcessPeriodicityInMs),
      _processCalls(0) {}

bool NewAudioConferenceMixerImpl::Init() {
  _crit.reset(CriticalSectionWrapper::CreateCriticalSection());
  if (_crit.get() == NULL)
    return false;

  _cbCrit.reset(CriticalSectionWrapper::CreateCriticalSection());
  if (_cbCrit.get() == NULL)
    return false;

  Config config;
  config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
  _limiter.reset(AudioProcessing::Create(config));
  if (!_limiter.get())
    return false;

  MemoryPool<AudioFrame>::CreateMemoryPool(_audioFramePool,
                                           DEFAULT_AUDIO_FRAME_POOLSIZE);
  if (_audioFramePool == NULL)
    return false;

  if (SetOutputFrequency(kDefaultFrequency) == -1)
    return false;

  if (_limiter->gain_control()->set_mode(GainControl::kFixedDigital) !=
      _limiter->kNoError)
    return false;

  // We smoothly limit the mixed frame to -7 dbFS. -6 would correspond to the
  // divide-by-2 but -7 is used instead to give a bit of headroom since the
  // AGC is not a hard limiter.
  if (_limiter->gain_control()->set_target_level_dbfs(7) != _limiter->kNoError)
    return false;

  if (_limiter->gain_control()->set_compression_gain_db(0) !=
      _limiter->kNoError)
    return false;

  if (_limiter->gain_control()->enable_limiter(true) != _limiter->kNoError)
    return false;

  if (_limiter->gain_control()->Enable(true) != _limiter->kNoError)
    return false;

  return true;
}

NewAudioConferenceMixerImpl::~NewAudioConferenceMixerImpl() {
  MemoryPool<AudioFrame>::DeleteMemoryPool(_audioFramePool);
  assert(_audioFramePool == NULL);
}

// Process should be called every kProcessPeriodicityInMs ms
int64_t NewAudioConferenceMixerImpl::TimeUntilNextProcess() {
  int64_t timeUntilNextProcess = 0;
  CriticalSectionScoped cs(_crit.get());
  if (_timeScheduler.TimeToNextUpdate(timeUntilNextProcess) != 0) {
    WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                 "failed in TimeToNextUpdate() call");
    // Sanity check
    assert(false);
    return -1;
  }
  return timeUntilNextProcess;
}

void NewAudioConferenceMixerImpl::Process() {
  size_t remainingParticipantsAllowedToMix = kMaximumAmountOfMixedParticipants;
  {
    CriticalSectionScoped cs(_crit.get());
    assert(_processCalls == 0);
    _processCalls++;

    // Let the scheduler know that we are running one iteration.
    _timeScheduler.UpdateScheduler();
  }

  AudioFrameList mixList;
  AudioFrameList rampOutList;
  AudioFrameList additionalFramesList;
  std::map<int, MixerAudioSource*> mixedParticipantsMap;
  {
    CriticalSectionScoped cs(_cbCrit.get());

    int32_t lowFreq = GetLowestMixingFrequency();
    // SILK can run in 12 kHz and 24 kHz. These frequencies are not
    // supported so use the closest higher frequency to not lose any
    // information.
    // TODO(henrike): this is probably more appropriate to do in
    //                GetLowestMixingFrequency().
    if (lowFreq == 12000) {
      lowFreq = 16000;
    } else if (lowFreq == 24000) {
      lowFreq = 32000;
    }
    if (lowFreq <= 0) {
      CriticalSectionScoped cs(_crit.get());
      _processCalls--;
      return;
    } else {
      switch (lowFreq) {
        case 8000:
          if (OutputFrequency() != kNbInHz) {
            SetOutputFrequency(kNbInHz);
          }
          break;
        case 16000:
          if (OutputFrequency() != kWbInHz) {
            SetOutputFrequency(kWbInHz);
          }
          break;
        case 32000:
          if (OutputFrequency() != kSwbInHz) {
            SetOutputFrequency(kSwbInHz);
          }
          break;
        case 48000:
          if (OutputFrequency() != kFbInHz) {
            SetOutputFrequency(kFbInHz);
          }
          break;
        default:
          assert(false);

          CriticalSectionScoped cs(_crit.get());
          _processCalls--;
          return;
      }
    }

    UpdateToMix(&mixList, &rampOutList, &mixedParticipantsMap,
                &remainingParticipantsAllowedToMix);

    GetAdditionalAudio(&additionalFramesList);
    UpdateMixedStatus(mixedParticipantsMap);
  }

  // Get an AudioFrame for mixing from the memory pool.
  AudioFrame* mixedAudio = NULL;
  if (_audioFramePool->PopMemory(mixedAudio) == -1) {
    WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                 "failed PopMemory() call");
    assert(false);
    return;
  }

  {
    CriticalSectionScoped cs(_crit.get());

    // TODO(henrike): it might be better to decide the number of channels
    //                with an API instead of dynamically.

    // Find the max channels over all mixing lists.
    const size_t num_mixed_channels =
        std::max(MaxNumChannels(&mixList),
                 std::max(MaxNumChannels(&additionalFramesList),
                          MaxNumChannels(&rampOutList)));

    mixedAudio->UpdateFrame(-1, _timeStamp, NULL, 0, _outputFrequency,
                            AudioFrame::kNormalSpeech, AudioFrame::kVadPassive,
                            num_mixed_channels);

    _timeStamp += static_cast<uint32_t>(_sampleSize);

    // We only use the limiter if it supports the output sample rate and
    // we're actually mixing multiple streams.
    use_limiter_ = _numMixedParticipants > 1 &&
                   _outputFrequency <= AudioProcessing::kMaxNativeSampleRateHz;

    MixFromList(mixedAudio, mixList);
    MixAnonomouslyFromList(mixedAudio, additionalFramesList);
    MixAnonomouslyFromList(mixedAudio, rampOutList);

    if (mixedAudio->samples_per_channel_ == 0) {
      // Nothing was mixed, set the audio samples to silence.
      mixedAudio->samples_per_channel_ = _sampleSize;
      mixedAudio->Mute();
    } else {
      // Only call the limiter if we have something to mix.
      LimitMixedAudio(mixedAudio);
    }
  }

  {
    CriticalSectionScoped cs(_cbCrit.get());
    if (_mixReceiver != NULL) {
      const AudioFrame** dummy = NULL;
      _mixReceiver->NewMixedAudio(_id, *mixedAudio, dummy, 0);
    }
  }

  // Reclaim all outstanding memory.
  _audioFramePool->PushMemory(mixedAudio);
  ClearAudioFrameList(&mixList);
  ClearAudioFrameList(&rampOutList);
  ClearAudioFrameList(&additionalFramesList);
  {
    CriticalSectionScoped cs(_crit.get());
    _processCalls--;
  }
  return;
}

int32_t NewAudioConferenceMixerImpl::RegisterMixedStreamCallback(
    OldAudioMixerOutputReceiver* mixReceiver) {
  CriticalSectionScoped cs(_cbCrit.get());
  if (_mixReceiver != NULL) {
    return -1;
  }
  _mixReceiver = mixReceiver;
  return 0;
}

int32_t NewAudioConferenceMixerImpl::UnRegisterMixedStreamCallback() {
  CriticalSectionScoped cs(_cbCrit.get());
  if (_mixReceiver == NULL) {
    return -1;
  }
  _mixReceiver = NULL;
  return 0;
}

int32_t NewAudioConferenceMixerImpl::SetOutputFrequency(
    const Frequency& frequency) {
  CriticalSectionScoped cs(_crit.get());

  _outputFrequency = frequency;
  _sampleSize =
      static_cast<size_t>((_outputFrequency * kProcessPeriodicityInMs) / 1000);

  return 0;
}

NewAudioConferenceMixer::Frequency
NewAudioConferenceMixerImpl::OutputFrequency() const {
  CriticalSectionScoped cs(_crit.get());
  return _outputFrequency;
}

int32_t NewAudioConferenceMixerImpl::SetMixabilityStatus(
    MixerAudioSource* participant,
    bool mixable) {
  if (!mixable) {
    // Anonymous participants are in a separate list. Make sure that the
    // participant is in the _participantList if it is being mixed.
    SetAnonymousMixabilityStatus(participant, false);
  }
  size_t numMixedParticipants;
  {
    CriticalSectionScoped cs(_cbCrit.get());
    const bool isMixed = IsParticipantInList(*participant, _participantList);
    // API must be called with a new state.
    if (!(mixable ^ isMixed)) {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                   "Mixable is aready %s", isMixed ? "ON" : "off");
      return -1;
    }
    bool success = false;
    if (mixable) {
      success = AddParticipantToList(participant, &_participantList);
    } else {
      success = RemoveParticipantFromList(participant, &_participantList);
    }
    if (!success) {
      WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                   "failed to %s participant", mixable ? "add" : "remove");
      assert(false);
      return -1;
    }

    size_t numMixedNonAnonymous = _participantList.size();
    if (numMixedNonAnonymous > kMaximumAmountOfMixedParticipants) {
      numMixedNonAnonymous = kMaximumAmountOfMixedParticipants;
    }
    numMixedParticipants =
        numMixedNonAnonymous + _additionalParticipantList.size();
  }
  // A MixerAudioSource was added or removed. Make sure the scratch
  // buffer is updated if necessary.
  // Note: The scratch buffer may only be updated in Process().
  CriticalSectionScoped cs(_crit.get());
  _numMixedParticipants = numMixedParticipants;
  return 0;
}

bool NewAudioConferenceMixerImpl::MixabilityStatus(
    const MixerAudioSource& participant) const {
  CriticalSectionScoped cs(_cbCrit.get());
  return IsParticipantInList(participant, _participantList);
}

int32_t NewAudioConferenceMixerImpl::SetAnonymousMixabilityStatus(
    MixerAudioSource* participant,
    bool anonymous) {
  CriticalSectionScoped cs(_cbCrit.get());
  if (IsParticipantInList(*participant, _additionalParticipantList)) {
    if (anonymous) {
      return 0;
    }
    if (!RemoveParticipantFromList(participant, &_additionalParticipantList)) {
      WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                   "unable to remove participant from anonymous list");
      assert(false);
      return -1;
    }
    return AddParticipantToList(participant, &_participantList) ? 0 : -1;
  }
  if (!anonymous) {
    return 0;
  }
  const bool mixable =
      RemoveParticipantFromList(participant, &_participantList);
  if (!mixable) {
    WEBRTC_TRACE(
        kTraceWarning, kTraceAudioMixerServer, _id,
        "participant must be registered before turning it into anonymous");
    // Setting anonymous status is only possible if MixerAudioSource is
    // already registered.
    return -1;
  }
  return AddParticipantToList(participant, &_additionalParticipantList) ? 0
                                                                        : -1;
}

bool NewAudioConferenceMixerImpl::AnonymousMixabilityStatus(
    const MixerAudioSource& participant) const {
  CriticalSectionScoped cs(_cbCrit.get());
  return IsParticipantInList(participant, _additionalParticipantList);
}

int32_t NewAudioConferenceMixerImpl::SetMinimumMixingFrequency(Frequency freq) {
  // Make sure that only allowed sampling frequencies are used. Use closest
  // higher sampling frequency to avoid losing information.
  if (static_cast<int>(freq) == 12000) {
    freq = kWbInHz;
  } else if (static_cast<int>(freq) == 24000) {
    freq = kSwbInHz;
  }

  if ((freq == kNbInHz) || (freq == kWbInHz) || (freq == kSwbInHz) ||
      (freq == kLowestPossible)) {
    _minimumMixingFreq = freq;
    return 0;
  } else {
    WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                 "SetMinimumMixingFrequency incorrect frequency: %i", freq);
    assert(false);
    return -1;
  }
}

// Check all AudioFrames that are to be mixed. The highest sampling frequency
// found is the lowest that can be used without losing information.
int32_t NewAudioConferenceMixerImpl::GetLowestMixingFrequency() const {
  const int participantListFrequency =
      GetLowestMixingFrequencyFromList(_participantList);
  const int anonymousListFrequency =
      GetLowestMixingFrequencyFromList(_additionalParticipantList);
  const int highestFreq = (participantListFrequency > anonymousListFrequency)
                              ? participantListFrequency
                              : anonymousListFrequency;
  // Check if the user specified a lowest mixing frequency.
  if (_minimumMixingFreq != kLowestPossible) {
    if (_minimumMixingFreq > highestFreq) {
      return _minimumMixingFreq;
    }
  }
  return highestFreq;
}

int32_t NewAudioConferenceMixerImpl::GetLowestMixingFrequencyFromList(
    const MixerAudioSourceList& mixList) const {
  int32_t highestFreq = 8000;
  for (MixerAudioSourceList::const_iterator iter = mixList.begin();
       iter != mixList.end(); ++iter) {
    const int32_t neededFrequency = (*iter)->NeededFrequency(_id);
    if (neededFrequency > highestFreq) {
      highestFreq = neededFrequency;
    }
  }
  return highestFreq;
}

void NewAudioConferenceMixerImpl::UpdateToMix(
    AudioFrameList* mixList,
    AudioFrameList* rampOutList,
    std::map<int, MixerAudioSource*>* mixParticipantList,
    size_t* maxAudioFrameCounter) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "UpdateToMix(mixList,rampOutList,mixParticipantList,%d)",
               *maxAudioFrameCounter);
  const size_t mixListStartSize = mixList->size();
  AudioFrameList activeList;
  // Struct needed by the passive lists to keep track of which AudioFrame
  // belongs to which MixerAudioSource.
  ParticipantFrameStructList passiveWasNotMixedList;
  ParticipantFrameStructList passiveWasMixedList;
  for (MixerAudioSourceList::const_iterator participant =
           _participantList.begin();
       participant != _participantList.end(); ++participant) {
    // Stop keeping track of passive participants if there are already
    // enough participants available (they wont be mixed anyway).
    bool mustAddToPassiveList =
        (*maxAudioFrameCounter >
         (activeList.size() + passiveWasMixedList.size() +
          passiveWasNotMixedList.size()));

    bool wasMixed = false;
    wasMixed = (*participant)->_mixHistory->WasMixed();
    AudioFrame* audioFrame = NULL;
    if (_audioFramePool->PopMemory(audioFrame) == -1) {
      WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                   "failed PopMemory() call");
      assert(false);
      return;
    }
    audioFrame->sample_rate_hz_ = _outputFrequency;

    auto ret = (*participant)->GetAudioFrameWithMuted(_id, audioFrame);
    if (ret == MixerAudioSource::AudioFrameInfo::kError) {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                   "failed to GetAudioFrameWithMuted() from participant");
      _audioFramePool->PushMemory(audioFrame);
      continue;
    }
    const bool muted = (ret == MixerAudioSource::AudioFrameInfo::kMuted);
    if (_participantList.size() != 1) {
      // TODO(wu): Issue 3390, add support for multiple participants case.
      audioFrame->ntp_time_ms_ = -1;
    }

    // TODO(henrike): this assert triggers in some test cases where SRTP is
    // used which prevents NetEQ from making a VAD. Temporarily disable this
    // assert until the problem is fixed on a higher level.
    // assert(audioFrame->vad_activity_ != AudioFrame::kVadUnknown);
    if (audioFrame->vad_activity_ == AudioFrame::kVadUnknown) {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                   "invalid VAD state from participant");
    }

    if (audioFrame->vad_activity_ == AudioFrame::kVadActive) {
      if (!wasMixed && !muted) {
        RampIn(*audioFrame);
      }

      if (activeList.size() >= *maxAudioFrameCounter) {
        // There are already more active participants than should be
        // mixed. Only keep the ones with the highest energy.
        AudioFrameList::iterator replaceItem;
        uint32_t lowestEnergy = muted ? 0 : CalculateEnergy(*audioFrame);

        bool found_replace_item = false;
        for (AudioFrameList::iterator iter = activeList.begin();
             iter != activeList.end(); ++iter) {
          const uint32_t energy = muted ? 0 : CalculateEnergy(*iter->frame);
          if (energy < lowestEnergy) {
            replaceItem = iter;
            lowestEnergy = energy;
            found_replace_item = true;
          }
        }
        if (found_replace_item) {
          RTC_DCHECK(!muted);  // Cannot replace with a muted frame.
          FrameAndMuteInfo replaceFrame = *replaceItem;

          bool replaceWasMixed = false;
          std::map<int, MixerAudioSource*>::const_iterator it =
              mixParticipantList->find(replaceFrame.frame->id_);

          // When a frame is pushed to |activeList| it is also pushed
          // to mixParticipantList with the frame's id. This means
          // that the Find call above should never fail.
          assert(it != mixParticipantList->end());
          replaceWasMixed = it->second->_mixHistory->WasMixed();

          mixParticipantList->erase(replaceFrame.frame->id_);
          activeList.erase(replaceItem);

          activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
          (*mixParticipantList)[audioFrame->id_] = *participant;
          assert(mixParticipantList->size() <=
                 kMaximumAmountOfMixedParticipants);

          if (replaceWasMixed) {
            if (!replaceFrame.muted) {
              RampOut(*replaceFrame.frame);
            }
            rampOutList->push_back(replaceFrame);
            assert(rampOutList->size() <= kMaximumAmountOfMixedParticipants);
          } else {
            _audioFramePool->PushMemory(replaceFrame.frame);
          }
        } else {
          if (wasMixed) {
            if (!muted) {
              RampOut(*audioFrame);
            }
            rampOutList->push_back(FrameAndMuteInfo(audioFrame, muted));
            assert(rampOutList->size() <= kMaximumAmountOfMixedParticipants);
          } else {
            _audioFramePool->PushMemory(audioFrame);
          }
        }
      } else {
        activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
        (*mixParticipantList)[audioFrame->id_] = *participant;
        assert(mixParticipantList->size() <= kMaximumAmountOfMixedParticipants);
      }
    } else {
      if (wasMixed) {
        ParticipantFrameStruct* part_struct =
            new ParticipantFrameStruct(*participant, audioFrame, muted);
        passiveWasMixedList.push_back(part_struct);
      } else if (mustAddToPassiveList) {
        if (!muted) {
          RampIn(*audioFrame);
        }
        ParticipantFrameStruct* part_struct =
            new ParticipantFrameStruct(*participant, audioFrame, muted);
        passiveWasNotMixedList.push_back(part_struct);
      } else {
        _audioFramePool->PushMemory(audioFrame);
      }
    }
  }
  assert(activeList.size() <= *maxAudioFrameCounter);
  // At this point it is known which participants should be mixed. Transfer
  // this information to this functions output parameters.
  for (AudioFrameList::const_iterator iter = activeList.begin();
       iter != activeList.end(); ++iter) {
    mixList->push_back(*iter);
  }
  activeList.clear();
  // Always mix a constant number of AudioFrames. If there aren't enough
  // active participants mix passive ones. Starting with those that was mixed
  // last iteration.
  for (ParticipantFrameStructList::const_iterator iter =
           passiveWasMixedList.begin();
       iter != passiveWasMixedList.end(); ++iter) {
    if (mixList->size() < *maxAudioFrameCounter + mixListStartSize) {
      mixList->push_back(FrameAndMuteInfo((*iter)->audioFrame, (*iter)->muted));
      (*mixParticipantList)[(*iter)->audioFrame->id_] = (*iter)->participant;
      assert(mixParticipantList->size() <= kMaximumAmountOfMixedParticipants);
    } else {
      _audioFramePool->PushMemory((*iter)->audioFrame);
    }
    delete *iter;
  }
  // And finally the ones that have not been mixed for a while.
  for (ParticipantFrameStructList::const_iterator iter =
           passiveWasNotMixedList.begin();
       iter != passiveWasNotMixedList.end(); ++iter) {
    if (mixList->size() < *maxAudioFrameCounter + mixListStartSize) {
      mixList->push_back(FrameAndMuteInfo((*iter)->audioFrame, (*iter)->muted));
      (*mixParticipantList)[(*iter)->audioFrame->id_] = (*iter)->participant;
      assert(mixParticipantList->size() <= kMaximumAmountOfMixedParticipants);
    } else {
      _audioFramePool->PushMemory((*iter)->audioFrame);
    }
    delete *iter;
  }
  assert(*maxAudioFrameCounter + mixListStartSize >= mixList->size());
  *maxAudioFrameCounter += mixListStartSize - mixList->size();
}

void NewAudioConferenceMixerImpl::GetAdditionalAudio(
    AudioFrameList* additionalFramesList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "GetAdditionalAudio(additionalFramesList)");
  // The GetAudioFrameWithMuted() callback may result in the participant being
  // removed from additionalParticipantList_. If that happens it will
  // invalidate any iterators. Create a copy of the participants list such
  // that the list of participants can be traversed safely.
  MixerAudioSourceList additionalParticipantList;
  additionalParticipantList.insert(additionalParticipantList.begin(),
                                   _additionalParticipantList.begin(),
                                   _additionalParticipantList.end());

  for (MixerAudioSourceList::const_iterator participant =
           additionalParticipantList.begin();
       participant != additionalParticipantList.end(); ++participant) {
    AudioFrame* audioFrame = NULL;
    if (_audioFramePool->PopMemory(audioFrame) == -1) {
      WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                   "failed PopMemory() call");
      assert(false);
      return;
    }
    audioFrame->sample_rate_hz_ = _outputFrequency;
    auto ret = (*participant)->GetAudioFrameWithMuted(_id, audioFrame);
    if (ret == MixerAudioSource::AudioFrameInfo::kError) {
      WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                   "failed to GetAudioFrameWithMuted() from participant");
      _audioFramePool->PushMemory(audioFrame);
      continue;
    }
    if (audioFrame->samples_per_channel_ == 0) {
      // Empty frame. Don't use it.
      _audioFramePool->PushMemory(audioFrame);
      continue;
    }
    additionalFramesList->push_back(FrameAndMuteInfo(
        audioFrame, ret == MixerAudioSource::AudioFrameInfo::kMuted));
  }
}

void NewAudioConferenceMixerImpl::UpdateMixedStatus(
    const std::map<int, MixerAudioSource*>& mixedParticipantsMap) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "UpdateMixedStatus(mixedParticipantsMap)");
  assert(mixedParticipantsMap.size() <= kMaximumAmountOfMixedParticipants);

  // Loop through all participants. If they are in the mix map they
  // were mixed.
  for (MixerAudioSourceList::const_iterator participant =
           _participantList.begin();
       participant != _participantList.end(); ++participant) {
    bool isMixed = false;
    for (std::map<int, MixerAudioSource*>::const_iterator it =
             mixedParticipantsMap.begin();
         it != mixedParticipantsMap.end(); ++it) {
      if (it->second == *participant) {
        isMixed = true;
        break;
      }
    }
    (*participant)->_mixHistory->SetIsMixed(isMixed);
  }
}

void NewAudioConferenceMixerImpl::ClearAudioFrameList(
    AudioFrameList* audioFrameList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "ClearAudioFrameList(audioFrameList)");
  for (AudioFrameList::iterator iter = audioFrameList->begin();
       iter != audioFrameList->end(); ++iter) {
    _audioFramePool->PushMemory(iter->frame);
  }
  audioFrameList->clear();
}

bool NewAudioConferenceMixerImpl::IsParticipantInList(
    const MixerAudioSource& participant,
    const MixerAudioSourceList& participantList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "IsParticipantInList(participant,participantList)");
  for (MixerAudioSourceList::const_iterator iter = participantList.begin();
       iter != participantList.end(); ++iter) {
    if (&participant == *iter) {
      return true;
    }
  }
  return false;
}

bool NewAudioConferenceMixerImpl::AddParticipantToList(
    MixerAudioSource* participant,
    MixerAudioSourceList* participantList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "AddParticipantToList(participant, participantList)");
  participantList->push_back(participant);
  // Make sure that the mixed status is correct for new MixerAudioSource.
  participant->_mixHistory->ResetMixedStatus();
  return true;
}

bool NewAudioConferenceMixerImpl::RemoveParticipantFromList(
    MixerAudioSource* participant,
    MixerAudioSourceList* participantList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "RemoveParticipantFromList(participant, participantList)");
  for (MixerAudioSourceList::iterator iter = participantList->begin();
       iter != participantList->end(); ++iter) {
    if (*iter == participant) {
      participantList->erase(iter);
      // Participant is no longer mixed, reset to default.
      participant->_mixHistory->ResetMixedStatus();
      return true;
    }
  }
  return false;
}

int32_t NewAudioConferenceMixerImpl::MixFromList(
    AudioFrame* mixedAudio,
    const AudioFrameList& audioFrameList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "MixFromList(mixedAudio, audioFrameList)");
  if (audioFrameList.empty())
    return 0;

  uint32_t position = 0;

  if (_numMixedParticipants == 1) {
    mixedAudio->timestamp_ = audioFrameList.front().frame->timestamp_;
    mixedAudio->elapsed_time_ms_ =
        audioFrameList.front().frame->elapsed_time_ms_;
  } else {
    // TODO(wu): Issue 3390.
    // Audio frame timestamp is only supported in one channel case.
    mixedAudio->timestamp_ = 0;
    mixedAudio->elapsed_time_ms_ = -1;
  }

  for (AudioFrameList::const_iterator iter = audioFrameList.begin();
       iter != audioFrameList.end(); ++iter) {
    if (position >= kMaximumAmountOfMixedParticipants) {
      WEBRTC_TRACE(
          kTraceMemory, kTraceAudioMixerServer, _id,
          "Trying to mix more than max amount of mixed participants:%d!",
          kMaximumAmountOfMixedParticipants);
      // Assert and avoid crash
      assert(false);
      position = 0;
    }
    if (!iter->muted) {
      MixFrames(mixedAudio, iter->frame, use_limiter_);
    }

    position++;
  }

  return 0;
}

// TODO(andrew): consolidate this function with MixFromList.
int32_t NewAudioConferenceMixerImpl::MixAnonomouslyFromList(
    AudioFrame* mixedAudio,
    const AudioFrameList& audioFrameList) const {
  WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
               "MixAnonomouslyFromList(mixedAudio, audioFrameList)");

  if (audioFrameList.empty())
    return 0;

  for (AudioFrameList::const_iterator iter = audioFrameList.begin();
       iter != audioFrameList.end(); ++iter) {
    if (!iter->muted) {
      MixFrames(mixedAudio, iter->frame, use_limiter_);
    }
  }
  return 0;
}

bool NewAudioConferenceMixerImpl::LimitMixedAudio(
    AudioFrame* mixedAudio) const {
  if (!use_limiter_) {
    return true;
  }

  // Smoothly limit the mixed frame.
  const int error = _limiter->ProcessStream(mixedAudio);

  // And now we can safely restore the level. This procedure results in
  // some loss of resolution, deemed acceptable.
  //
  // It's possible to apply the gain in the AGC (with a target level of 0 dbFS
  // and compression gain of 6 dB). However, in the transition frame when this
  // is enabled (moving from one to two participants) it has the potential to
  // create discontinuities in the mixed frame.
  //
  // Instead we double the frame (with addition since left-shifting a
  // negative value is undefined).
  *mixedAudio += *mixedAudio;

  if (error != _limiter->kNoError) {
    WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                 "Error from AudioProcessing: %d", error);
    assert(false);
    return false;
  }
  return true;
}
}  // namespace webrtc