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

#ifndef WEBRTC_MODULES_AUDIO_MIXER_SOURCE_NEW_AUDIO_CONFERENCE_MIXER_IMPL_H_
#define WEBRTC_MODULES_AUDIO_MIXER_SOURCE_NEW_AUDIO_CONFERENCE_MIXER_IMPL_H_

#include <list>
#include <map>
#include <memory>

#include "webrtc/engine_configurations.h"
#include "webrtc/modules/audio_mixer/include/new_audio_conference_mixer.h"
#include "webrtc/modules/audio_conference_mixer/source/memory_pool.h"
#include "webrtc/modules/audio_conference_mixer/source/time_scheduler.h"
#include "webrtc/modules/include/module_common_types.h"

namespace webrtc {
class AudioProcessing;
class CriticalSectionWrapper;

struct FrameAndMuteInfo {
  FrameAndMuteInfo(AudioFrame* f, bool m) : frame(f), muted(m) {}
  AudioFrame* frame;
  bool muted;
};

typedef std::list<FrameAndMuteInfo> AudioFrameList;
typedef std::list<MixerAudioSource*> MixerAudioSourceList;

// Cheshire cat implementation of MixerAudioSource's non virtual functions.
class NewMixHistory {
 public:
  NewMixHistory();
  ~NewMixHistory();

  // Returns true if the participant is being mixed.
  bool IsMixed() const;

  // Returns true if the participant was mixed previous mix
  // iteration.
  bool WasMixed() const;

  // Updates the mixed status.
  int32_t SetIsMixed(bool mixed);

  void ResetMixedStatus();

 private:
  bool _isMixed;
};

class NewAudioConferenceMixerImpl : public NewAudioConferenceMixer {
 public:
  // AudioProcessing only accepts 10 ms frames.
  enum { kProcessPeriodicityInMs = 10 };

  explicit NewAudioConferenceMixerImpl(int id);
  ~NewAudioConferenceMixerImpl();

  // Must be called after ctor.
  bool Init();

  // Module functions
  int64_t TimeUntilNextProcess() override;
  void Process() override;

  // NewAudioConferenceMixer functions
  int32_t RegisterMixedStreamCallback(
      OldAudioMixerOutputReceiver* mixReceiver) override;
  int32_t UnRegisterMixedStreamCallback() override;
  int32_t SetMixabilityStatus(MixerAudioSource* participant,
                              bool mixable) override;
  bool MixabilityStatus(const MixerAudioSource& participant) const override;
  int32_t SetMinimumMixingFrequency(Frequency freq) override;
  int32_t SetAnonymousMixabilityStatus(MixerAudioSource* participant,
                                       bool mixable) override;
  bool AnonymousMixabilityStatus(
      const MixerAudioSource& participant) const override;

 private:
  enum { DEFAULT_AUDIO_FRAME_POOLSIZE = 50 };

  // Set/get mix frequency
  int32_t SetOutputFrequency(const Frequency& frequency);
  Frequency OutputFrequency() const;

  // Fills mixList with the AudioFrames pointers that should be used when
  // mixing.
  // maxAudioFrameCounter both input and output specifies how many more
  // AudioFrames that are allowed to be mixed.
  // rampOutList contain AudioFrames corresponding to an audio stream that
  // used to be mixed but shouldn't be mixed any longer. These AudioFrames
  // should be ramped out over this AudioFrame to avoid audio discontinuities.
  void UpdateToMix(AudioFrameList* mixList,
                   AudioFrameList* rampOutList,
                   std::map<int, MixerAudioSource*>* mixParticipantList,
                   size_t* maxAudioFrameCounter) const;

  // Return the lowest mixing frequency that can be used without having to
  // downsample any audio.
  int32_t GetLowestMixingFrequency() const;
  int32_t GetLowestMixingFrequencyFromList(
      const MixerAudioSourceList& mixList) const;

  // Return the AudioFrames that should be mixed anonymously.
  void GetAdditionalAudio(AudioFrameList* additionalFramesList) const;

  // Update the NewMixHistory of all MixerAudioSources. mixedParticipantsList
  // should contain a map of MixerAudioSources that have been mixed.
  void UpdateMixedStatus(
      const std::map<int, MixerAudioSource*>& mixedParticipantsList) const;

  // Clears audioFrameList and reclaims all memory associated with it.
  void ClearAudioFrameList(AudioFrameList* audioFrameList) const;

  // This function returns true if it finds the MixerAudioSource in the
  // specified list of MixerAudioSources.
  bool IsParticipantInList(const MixerAudioSource& participant,
                           const MixerAudioSourceList& participantList) const;

  // Add/remove the MixerAudioSource to the specified
  // MixerAudioSource list.
  bool AddParticipantToList(MixerAudioSource* participant,
                            MixerAudioSourceList* participantList) const;
  bool RemoveParticipantFromList(MixerAudioSource* removeParticipant,
                                 MixerAudioSourceList* participantList) const;

  // Mix the AudioFrames stored in audioFrameList into mixedAudio.
  int32_t MixFromList(AudioFrame* mixedAudio,
                      const AudioFrameList& audioFrameList) const;

  // Mix the AudioFrames stored in audioFrameList into mixedAudio. No
  // record will be kept of this mix (e.g. the corresponding MixerAudioSources
  // will not be marked as IsMixed()
  int32_t MixAnonomouslyFromList(AudioFrame* mixedAudio,
                                 const AudioFrameList& audioFrameList) const;

  bool LimitMixedAudio(AudioFrame* mixedAudio) const;

  std::unique_ptr<CriticalSectionWrapper> _crit;
  std::unique_ptr<CriticalSectionWrapper> _cbCrit;

  int32_t _id;

  Frequency _minimumMixingFreq;

  // Mix result callback
  OldAudioMixerOutputReceiver* _mixReceiver;

  // The current sample frequency and sample size when mixing.
  Frequency _outputFrequency;
  size_t _sampleSize;

  // Memory pool to avoid allocating/deallocating AudioFrames
  MemoryPool<AudioFrame>* _audioFramePool;

  // List of all participants. Note all lists are disjunct
  MixerAudioSourceList _participantList;  // May be mixed.
  // Always mixed, anonomously.
  MixerAudioSourceList _additionalParticipantList;

  size_t _numMixedParticipants;
  // Determines if we will use a limiter for clipping protection during
  // mixing.
  bool use_limiter_;

  uint32_t _timeStamp;

  // Metronome class.
  TimeScheduler _timeScheduler;

  // Counter keeping track of concurrent calls to process.
  // Note: should never be higher than 1 or lower than 0.
  int16_t _processCalls;

  // Used for inhibiting saturation in mixing.
  std::unique_ptr<AudioProcessing> _limiter;
};
}  // namespace webrtc

#endif  // WEBRTC_MODULES_AUDIO_MIXER_SOURCE_NEW_AUDIO_CONFERENCE_MIXER_IMPL_H_