/*
 *  Copyright (c) 2011 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 "audio_conference_mixer_defines.h"
#include "audio_conference_mixer_impl.h"
#include "audio_frame_manipulator.h"
#include "critical_section_wrapper.h"
#include "map_wrapper.h"
#include "trace.h"

namespace webrtc {
MixerParticipant::MixerParticipant()
    : _mixHistory(new MixHistory())
{
}

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

WebRtc_Word32 MixerParticipant::IsMixed(bool& mixed) const
{
    return _mixHistory->IsMixed(mixed);
}

MixHistory::MixHistory()
    : _isMixed(0)
{
}

MixHistory::~MixHistory()
{
}

WebRtc_Word32 MixHistory::IsMixed(bool& mixed) const
{
    mixed = (_isMixed.Value() == 1);
    return 0;
}

WebRtc_Word32 MixHistory::SetIsMixed(const bool mixed)
{
    _isMixed = mixed ? 1 : 0;
    return 0;
}

void MixHistory::ResetMixedStatus()
{
    _isMixed  = 0;
}

AudioConferenceMixer* AudioConferenceMixer::CreateAudioConferenceMixer(
    const WebRtc_Word32 id)
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, id,
                 "CreateAudioConferenceMixer");
    return new AudioConferenceMixerImpl(id);
}

AudioConferenceMixerImpl::AudioConferenceMixerImpl(const WebRtc_Word32 id)
    : _scratchParticipantsToMixAmount(0),
      _scratchMixedParticipants(),
      _scratchVadPositiveParticipantsAmount(0),
      _scratchVadPositiveParticipants(),
      _crit(CriticalSectionWrapper::CreateCriticalSection()),
      _cbCrit(CriticalSectionWrapper::CreateCriticalSection()),
      _id(id),
      _minimumMixingFreq(kLowestPossible),
      _mixReceiver(NULL),
      _mixerStatusCallback(NULL),
      _amountOf10MsBetweenCallbacks(1),
      _amountOf10MsUntilNextCallback(0),
      _mixerStatusCb(false),
      _outputFrequency(kDefaultFrequency),
      _sampleSize((_outputFrequency*kProcessPeriodicityInMs)/1000),
      _participantList(),
      _amountOfMixableParticipants(0),
      _timeStamp(0),
      _timeScheduler(kProcessPeriodicityInMs),
      _mixedAudioLevel(),
      _processCalls(0)
{
    MemoryPool<AudioFrame>::CreateMemoryPool(_audioFramePool,
                                             DEFAULT_AUDIO_FRAME_POOLSIZE);
    WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id, "%s created",
                 __FUNCTION__);
}

AudioConferenceMixerImpl::~AudioConferenceMixerImpl()
{
    delete _crit;
    delete _cbCrit;

    MemoryPool<AudioFrame>::DeleteMemoryPool(_audioFramePool);
    assert(_audioFramePool==NULL);
    WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id, "%s deleted",
                 __FUNCTION__);
}

WebRtc_Word32 AudioConferenceMixerImpl::Version(
    WebRtc_Word8* version,
    WebRtc_UWord32& remainingBufferInBytes,
    WebRtc_UWord32& position) const
{
    WEBRTC_TRACE(
        kTraceModuleCall,
        kTraceAudioMixerServer,
        _id,
        "Version(version%s,remainingBufferLengthInBytes:%d,position:%d)",
        (version==NULL) ? ":NULL" : "",
        remainingBufferInBytes,position);
    return GetVersion(version,remainingBufferInBytes,position);
}

WebRtc_Word32 AudioConferenceMixerImpl::ChangeUniqueId(const WebRtc_Word32 id)
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "ChangeUniqueId(new id:%d)", id);
    _id = id;
    return 0;
}

WebRtc_Word32 AudioConferenceMixer::GetVersion(
    WebRtc_Word8* version,
    WebRtc_UWord32& remainingBufferInBytes,
    WebRtc_UWord32& position)
{
    WEBRTC_TRACE(
        kTraceModuleCall,
        kTraceAudioMixerServer,
        -1,
        "Version(version%s,remainingBufferLengthInBytes:%d,position:%d)",
        (version==NULL) ? "NULL" : "",
        remainingBufferInBytes,
        position);
    if(version == NULL)
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, -1,
                     "Invalid in argument to GetVersion()");
        return -1;
    }
    const char moduleVersion[] = VERSION_STRING;
    if(remainingBufferInBytes < sizeof(moduleVersion))
    {
        WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, -1,
                     "Too small buffer in GetVersion()");
        return -1;
    }
    strncpy(version, moduleVersion, sizeof(moduleVersion));  // null termination
    remainingBufferInBytes -= sizeof(moduleVersion);
    position += sizeof(moduleVersion);
    return 0;
}

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

WebRtc_Word32 AudioConferenceMixerImpl::Process()
{
    {
        CriticalSectionScoped cs(*_crit);
        assert(_processCalls == 0);
        _processCalls++;

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

    ListWrapper mixList;
    MapWrapper mixedParticipantsMap;
    {
        CriticalSectionScoped cs(*_cbCrit);

        WebRtc_Word32 lowFreq = GetLowestMixingFrequency();
        // SILK can run in 12 kHz and 24 kHz. These frequencies are not
        // supported so use closet higher frequency to not lose any information.
        // TODO (hellner): 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);
            _processCalls--;
            return 0;
        } 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;
            default:
                assert(false);

                CriticalSectionScoped cs(*_crit);
                _processCalls--;
                return -1;
            }
        }

        UpdateToMix(mixList,mixedParticipantsMap);
        UpdateMixedStatus(mixedParticipantsMap);
        _scratchParticipantsToMixAmount = mixedParticipantsMap.Size();
    }

    // Clear mixedParticipantsMap to avoid memory leak warning.
    // Please note that the mixedParticipantsMap doesn't own any dynamically
    // allocated memory.
    while(mixedParticipantsMap.Erase(mixedParticipantsMap.First()) == 0);

    // 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 -1;
    }

    bool timeForMixerCallback = false;
    WebRtc_Word32 audioLevel = 0;
    {
        const ListItem* firstItem = mixList.First();
        // Assume mono.
        WebRtc_UWord8 numberOfChannels = 1;
        if(firstItem != NULL)
        {
            // Use the same number of channels as the first frame to be mixed.
            numberOfChannels = static_cast<const AudioFrame*>(
                firstItem->GetItem())->_audioChannel;
        }
        // TODO (hellner): it might be better to decide the number of channels
        //                 with an API instead of dynamically.


        CriticalSectionScoped cs(*_crit);

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

        _timeStamp += _sampleSize;

        MixFromList(*mixedAudio,mixList);

        if(mixedAudio->_payloadDataLengthInSamples == 0)
        {
          // Nothing was mixed set the audio samples to silence.
          memset(mixedAudio->_payloadData, 0, _sampleSize);
          mixedAudio->_payloadDataLengthInSamples = _sampleSize;
        }

        _mixedAudioLevel.ComputeLevel(mixedAudio->_payloadData,_sampleSize);
        audioLevel = _mixedAudioLevel.GetLevel();

        if(_mixerStatusCb)
        {
            _scratchVadPositiveParticipantsAmount = 0;
            UpdateVADPositiveParticipants(mixList);
            if(_amountOf10MsUntilNextCallback-- == 0)
            {
                _amountOf10MsUntilNextCallback = _amountOf10MsBetweenCallbacks;
                timeForMixerCallback = true;
            }
        }
    }

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

        if((_mixerStatusCallback != NULL) &&
            timeForMixerCallback)
        {
            _mixerStatusCallback->MixedParticipants(
                _id,
                _scratchMixedParticipants,
                _scratchParticipantsToMixAmount);

            _mixerStatusCallback->VADPositiveParticipants(
                _id,
                _scratchVadPositiveParticipants,
                _scratchVadPositiveParticipantsAmount);
            _mixerStatusCallback->MixedAudioLevel(_id,audioLevel);
        }
    }

    // Reclaim all outstanding memory.
    _audioFramePool->PushMemory(mixedAudio);
    ClearAudioFrameList(mixList);
    {
        CriticalSectionScoped cs(*_crit);
        _processCalls--;
    }
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::RegisterMixedStreamCallback(
    AudioMixerOutputReceiver& mixReceiver)
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "RegisterMixedStreamCallback(mixReceiver)");
    CriticalSectionScoped cs(*_cbCrit);
    if(_mixReceiver != NULL)
    {
        return -1;
    }
    _mixReceiver = &mixReceiver;
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::UnRegisterMixedStreamCallback()
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "UnRegisterMixedStreamCallback()");
    CriticalSectionScoped cs(*_cbCrit);
    if(_mixReceiver == NULL)
    {
        return -1;
    }
    _mixReceiver = NULL;
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::SetOutputFrequency(
    const Frequency frequency)
{
    CriticalSectionScoped cs(*_crit);
    _outputFrequency = frequency;
    _sampleSize = (_outputFrequency*kProcessPeriodicityInMs) / 1000;
    return 0;
}

AudioConferenceMixer::Frequency
AudioConferenceMixerImpl::OutputFrequency() const
{
    CriticalSectionScoped cs(*_crit);
    return _outputFrequency;
}

WebRtc_Word32 AudioConferenceMixerImpl::RegisterMixerStatusCallback(
    AudioMixerStatusReceiver& mixerStatusCallback,
    const WebRtc_UWord32 amountOf10MsBetweenCallbacks)
{
    WEBRTC_TRACE(
        kTraceModuleCall,
        kTraceAudioMixerServer,
        _id,
        "RegisterMixerStatusCallback(mixerStatusCallback,%d)",
        amountOf10MsBetweenCallbacks);
    if(amountOf10MsBetweenCallbacks == 0)
    {
        WEBRTC_TRACE(
            kTraceWarning,
            kTraceAudioMixerServer,
            _id,
            "amountOf10MsBetweenCallbacks(%d) needs to be larger than 0");
        return -1;
    }
    {
        CriticalSectionScoped cs(*_cbCrit);
        if(_mixerStatusCallback != NULL)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                         "Mixer status callback already registered");
            return -1;
        }
        _mixerStatusCallback = &mixerStatusCallback;
    }
    {
        CriticalSectionScoped cs(*_crit);
        _amountOf10MsBetweenCallbacks  = amountOf10MsBetweenCallbacks;
        _amountOf10MsUntilNextCallback = 0;
        _mixerStatusCb                 = true;
    }
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::UnRegisterMixerStatusCallback()
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "UnRegisterMixerStatusCallback()");
    {
        CriticalSectionScoped cs(*_crit);
        if(!_mixerStatusCb)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                         "Mixer status callback not registered");
            return -1;
        }
        _mixerStatusCb = false;
    }
    {
        CriticalSectionScoped cs(*_cbCrit);
        _mixerStatusCallback = NULL;
    }
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::SetMixabilityStatus(
    MixerParticipant& participant,
    const bool mixable)
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "SetMixabilityStatus(participant,mixable:%s)",
                 mixable ? "true" : "false");
    WebRtc_UWord32 amountOfMixableParticipants;
    {
        CriticalSectionScoped cs(*_cbCrit);
        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)
        {
            if(_amountOfMixableParticipants >=
               kMaximumAmountOfMixedParticipants)
            {
                return -1;
            }
            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;
        }
        amountOfMixableParticipants = _participantList.GetSize();
    }
    // A MixerParticipant 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);
    _amountOfMixableParticipants = amountOfMixableParticipants;
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::MixabilityStatus(
    MixerParticipant& participant,
    bool& mixable)
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "MixabilityStatus(participant,mixable)");
    CriticalSectionScoped cs(*_cbCrit);
     mixable = IsParticipantInList(participant,_participantList);
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::AmountOfMixables(
    WebRtc_UWord32& amountOfMixableParticipants)
{
    WEBRTC_TRACE(kTraceModuleCall, kTraceAudioMixerServer, _id,
                 "AmountOfMixables(amountOfMixableParticipants)");
    CriticalSectionScoped cs(*_crit);
    amountOfMixableParticipants = _amountOfMixableParticipants;
    return 0;
}

WebRtc_Word32 AudioConferenceMixerImpl::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.
WebRtc_Word32 AudioConferenceMixerImpl::GetLowestMixingFrequency()
{
    WebRtc_Word32 highestFreq = 8000;
    ListItem* item = _participantList.First();
    while(item)
    {
        MixerParticipant* participant =
            static_cast<MixerParticipant*>(item->GetItem());
        const WebRtc_Word32 neededFrequency = participant->NeededFrequency(_id);
        if(neededFrequency > highestFreq)
        {
            highestFreq = neededFrequency;
        }
        item = _participantList.Next(item);
    }

    // Check if the user specified a lowest mixing frequency.
    if(_minimumMixingFreq != kLowestPossible)
    {
        if(_minimumMixingFreq > highestFreq)
        {
            return _minimumMixingFreq;
        }
    }
    return highestFreq;
}

void AudioConferenceMixerImpl::UpdateToMix(
    ListWrapper& mixList,
    MapWrapper& mixParticipantList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "UpdateToMix(mixList,mixParticipantList)");

    ListItem* item = _participantList.First();
    while(item)
    {
        MixerParticipant* participant = static_cast<MixerParticipant*>(
            item->GetItem());
        AudioFrame* audioFrame = NULL;
        if(_audioFramePool->PopMemory(audioFrame) == -1)
        {
            WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
                         "failed PopMemory() call");
            assert(false);
            return;
        }
        audioFrame->_frequencyInHz = _outputFrequency;

        if(participant->GetAudioFrame(_id,*audioFrame) != 0)
        {
            WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                         "failed to GetAudioFrame() from participant");
            _audioFramePool->PushMemory(audioFrame);
            item = _participantList.Next(item);
            continue;
        }
        assert(audioFrame->_vadActivity != AudioFrame::kVadUnknown);
        mixList.PushBack(static_cast<void*>(audioFrame));
        mixParticipantList.Insert(audioFrame->_id,static_cast<void*>(
            participant));
        assert(mixParticipantList.Size() <= kMaximumAmountOfMixedParticipants);
        item = _participantList.Next(item);
    }
}

void AudioConferenceMixerImpl::UpdateMixedStatus(
    MapWrapper& mixedParticipantsMap)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "UpdateMixedStatus(mixedParticipantsMap)");
    assert(mixedParticipantsMap.Size() <= kMaximumAmountOfMixedParticipants);

    // Loop through all non-VIP participants. If they are in the mix map they
    // were mixed.
    ListItem* participantItem = _participantList.First();
    while(participantItem != NULL)
    {
        bool isMixed = false;
        MixerParticipant* participant =
            static_cast<MixerParticipant*>(participantItem->GetItem());

        MapItem* mixedItem = mixedParticipantsMap.First();
        while(mixedItem)
        {
            if(participant == mixedItem->GetItem())
            {
                isMixed = true;
                break;
            }
            mixedItem = mixedParticipantsMap.Next(mixedItem);
        }
        participant->_mixHistory->SetIsMixed(isMixed);
        participantItem = _participantList.Next(participantItem);
    }
}

void AudioConferenceMixerImpl::ClearAudioFrameList(ListWrapper& audioFrameList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "ClearAudioFrameList(audioFrameList)");
    ListItem* item = audioFrameList.First();
    while(item)
    {
        AudioFrame* audioFrame = static_cast<AudioFrame*>(item->GetItem());
        _audioFramePool->PushMemory(audioFrame);
        audioFrameList.Erase(item);
        item = audioFrameList.First();
    }
}

void AudioConferenceMixerImpl::UpdateVADPositiveParticipants(
    ListWrapper& mixList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "UpdateVADPositiveParticipants(mixList)");

    ListItem* item = mixList.First();
    while(item != NULL)
    {
        AudioFrame* audioFrame = static_cast<AudioFrame*>(item->GetItem());
        CalculateEnergy(*audioFrame);
        if(audioFrame->_vadActivity == AudioFrame::kVadActive)
        {
            _scratchVadPositiveParticipants[
                _scratchVadPositiveParticipantsAmount].participant =
                audioFrame->_id;
            _scratchVadPositiveParticipants[
                _scratchVadPositiveParticipantsAmount].level =
                audioFrame->_volume;
            _scratchVadPositiveParticipantsAmount++;
        }
        item = mixList.Next(item);
    }
}

bool AudioConferenceMixerImpl::IsParticipantInList(
    MixerParticipant& participant,
    ListWrapper& participantList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "IsParticipantInList(participant,participantList)");
    ListItem* item = participantList.First();
    while(item != NULL)
    {
        MixerParticipant* rhsParticipant =
            static_cast<MixerParticipant*>(item->GetItem());
        if(&participant == rhsParticipant)
        {
            return true;
        }
        item = participantList.Next(item);
    }
    return false;
}

bool AudioConferenceMixerImpl::AddParticipantToList(
    MixerParticipant& participant,
    ListWrapper& participantList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "AddParticipantToList(participant, participantList)");
    if(participantList.PushBack(static_cast<void*>(&participant)) == -1)
    {
        return false;
    }
    // Make sure that the mixed status is correct for new MixerParticipant.
    participant._mixHistory->ResetMixedStatus();
    return true;
}

bool AudioConferenceMixerImpl::RemoveParticipantFromList(
    MixerParticipant& participant,
    ListWrapper& participantList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "RemoveParticipantFromList(participant, participantList)");
    ListItem* item = participantList.First();
    while(item)
    {
        if(item->GetItem() == &participant)
        {
            participantList.Erase(item);
            // Participant is no longer mixed, reset to default.
            participant._mixHistory->ResetMixedStatus();
            return true;
        }
        item = participantList.Next(item);
    }
    return false;
}

WebRtc_Word32 AudioConferenceMixerImpl::MixFromList(AudioFrame& mixedAudioFrame,
                                                    ListWrapper& audioFrameList)
{
    WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                 "MixFromList(mixedAudioFrame, audioFrameList)");
    WebRtc_UWord32 position = 0;
    ListItem* item = audioFrameList.First();
    while(item != NULL)
    {
        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;
        }
        AudioFrame* audioFrame = static_cast<AudioFrame*>(item->GetItem());

        // Divide the AudioFrame samples by 2 to avoid saturation.
        *audioFrame >>= 1;
        mixedAudioFrame += *audioFrame;

        _scratchMixedParticipants[position].participant = audioFrame->_id;
        _scratchMixedParticipants[position].level = audioFrame->_volume;

        position++;
        item = audioFrameList.Next(item);
    }
    return 0;
}
} // namespace webrtc