Removing AudioMixerStatusReceiver and ParticipantStatistics

webrtc/modules/audio_conference_mixer/source/audio_conference_mixer_impl.cc

 /*
  *  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.
  */
 
@@ skipping 42 matching lines @@
 int MaxNumChannels(const AudioFrameList* list) {
   int max_num_channels = 1;
   for (AudioFrameList::const_iterator iter = list->begin();
        iter != list->end();
        ++iter) {
     max_num_channels = std::max(max_num_channels, (*iter)->num_channels_);
   }
   return max_num_channels;
 }
 
-void SetParticipantStatistics(ParticipantStatistics* stats,
-                              const AudioFrame& frame) {
-    stats->participant = frame.id_;
-    stats->level = 0;  // TODO(andrew): to what should this be set?
-}
-
 }  // namespace
 
 MixerParticipant::MixerParticipant()
     : _mixHistory(new MixHistory()) {
 }
 
 MixerParticipant::~MixerParticipant() {
     delete _mixHistory;
 }
 
@@ skipping 31 matching lines @@
 AudioConferenceMixer* AudioConferenceMixer::Create(int id) {
     AudioConferenceMixerImpl* mixer = new AudioConferenceMixerImpl(id);
     if(!mixer->Init()) {
         delete mixer;
         return NULL;
     }
     return mixer;
 }
 
 AudioConferenceMixerImpl::AudioConferenceMixerImpl(int id)
-    : _scratchParticipantsToMixAmount(0),
-      _scratchMixedParticipants(),
-      _scratchVadPositiveParticipantsAmount(0),
-      _scratchVadPositiveParticipants(),
-      _id(id),
+    : _id(id),
       _minimumMixingFreq(kLowestPossible),
       _mixReceiver(NULL),
-      _mixerStatusCallback(NULL),
-      _amountOf10MsBetweenCallbacks(1),
-      _amountOf10MsUntilNextCallback(0),
-      _mixerStatusCb(false),
       _outputFrequency(kDefaultFrequency),
       _sampleSize(0),
       _audioFramePool(NULL),
       _participantList(),
       _additionalParticipantList(),
       _numMixedParticipants(0),
       use_limiter_(true),
       _timeStamp(0),
       _timeScheduler(kProcessPeriodicityInMs),
-      _mixedAudioLevel(),
       _processCalls(0) {}
 
 bool AudioConferenceMixerImpl::Init() {
     _crit.reset(CriticalSectionWrapper::CreateCriticalSection());
     if (_crit.get() == NULL)
         return false;
 
     _cbCrit.reset(CriticalSectionWrapper::CreateCriticalSection());
     if(_cbCrit.get() == NULL)
         return false;
@@ skipping 117 matching lines @@
                 _processCalls--;
                 return -1;
             }
         }
 
         UpdateToMix(&mixList, &rampOutList, &mixedParticipantsMap,
                     remainingParticipantsAllowedToMix);
 
         GetAdditionalAudio(&additionalFramesList);
         UpdateMixedStatus(mixedParticipantsMap);
-        _scratchParticipantsToMixAmount = mixedParticipantsMap.size();
     }
 
     // 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;
     int retval = 0;
-    int32_t audioLevel = 0;
     {
         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 int num_mixed_channels = std::max(MaxNumChannels(&mixList),
             std::max(MaxNumChannels(&additionalFramesList),
                      MaxNumChannels(&rampOutList)));
@@ skipping 15 matching lines @@
 
         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.
             if(!LimitMixedAudio(*mixedAudio))
                 retval = -1;
         }
-
-        _mixedAudioLevel.ComputeLevel(mixedAudio->data_,_sampleSize);
-        audioLevel = _mixedAudioLevel.GetLevel();
-
-        if(_mixerStatusCb) {
-            _scratchVadPositiveParticipantsAmount = 0;
-            UpdateVADPositiveParticipants(&mixList);
-            if(_amountOf10MsUntilNextCallback-- == 0) {
-                _amountOf10MsUntilNextCallback = _amountOf10MsBetweenCallbacks;
-                timeForMixerCallback = true;
-            }
-        }
     }
 
     {
         CriticalSectionScoped cs(_cbCrit.get());
         if(_mixReceiver != NULL) {
             const AudioFrame** dummy = NULL;
             _mixReceiver->NewMixedAudio(
                 _id,
                 *mixedAudio,
                 dummy,
                 0);
         }
-
-        if((_mixerStatusCallback != NULL) &&
-            timeForMixerCallback) {
-            _mixerStatusCallback->MixedParticipants(
-                _id,
-                _scratchMixedParticipants,
-                static_cast<uint32_t>(_scratchParticipantsToMixAmount));
-
-            _mixerStatusCallback->VADPositiveParticipants(
-                _id,
-                _scratchVadPositiveParticipants,
-                _scratchVadPositiveParticipantsAmount);
-            _mixerStatusCallback->MixedAudioLevel(_id,audioLevel);
-        }
     }
 
     // Reclaim all outstanding memory.
     _audioFramePool->PushMemory(mixedAudio);
     ClearAudioFrameList(&mixList);
     ClearAudioFrameList(&rampOutList);
     ClearAudioFrameList(&additionalFramesList);
     {
         CriticalSectionScoped cs(_crit.get());
         _processCalls--;
@@ skipping 29 matching lines @@
 
     return 0;
 }
 
 AudioConferenceMixer::Frequency
 AudioConferenceMixerImpl::OutputFrequency() const {
     CriticalSectionScoped cs(_crit.get());
     return _outputFrequency;
 }
 
-int32_t AudioConferenceMixerImpl::RegisterMixerStatusCallback(
-    AudioMixerStatusReceiver& mixerStatusCallback,
-    const uint32_t amountOf10MsBetweenCallbacks) {
-    if(amountOf10MsBetweenCallbacks == 0) {
-        WEBRTC_TRACE(
-            kTraceWarning,
-            kTraceAudioMixerServer,
-            _id,
-            "amountOf10MsBetweenCallbacks(%d) needs to be larger than 0");
-        return -1;
-    }
-    {
-        CriticalSectionScoped cs(_cbCrit.get());
-        if(_mixerStatusCallback != NULL) {
-            WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
-                         "Mixer status callback already registered");
-            return -1;
-        }
-        _mixerStatusCallback = &mixerStatusCallback;
-    }
-    {
-        CriticalSectionScoped cs(_crit.get());
-        _amountOf10MsBetweenCallbacks  = amountOf10MsBetweenCallbacks;
-        _amountOf10MsUntilNextCallback = 0;
-        _mixerStatusCb                 = true;
-    }
-    return 0;
-}
-
-int32_t AudioConferenceMixerImpl::UnRegisterMixerStatusCallback() {
-    {
-        CriticalSectionScoped cs(_crit.get());
-        if(!_mixerStatusCb)
-        {
-            WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
-                         "Mixer status callback not registered");
-            return -1;
-        }
-        _mixerStatusCb = false;
-    }
-    {
-        CriticalSectionScoped cs(_cbCrit.get());
-        _mixerStatusCallback = NULL;
-    }
-    return 0;
-}
-
 int32_t AudioConferenceMixerImpl::SetMixabilityStatus(
     MixerParticipant& 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;
     {
@@ skipping 407 matching lines @@
 
 void AudioConferenceMixerImpl::UpdateVADPositiveParticipants(
     AudioFrameList* mixList) {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "UpdateVADPositiveParticipants(mixList)");
 
     for (AudioFrameList::iterator iter = mixList->begin();
          iter != mixList->end();
          ++iter) {
         CalculateEnergy(**iter);
-        if((*iter)->vad_activity_ == AudioFrame::kVadActive) {
-            _scratchVadPositiveParticipants[
-                _scratchVadPositiveParticipantsAmount].participant =
-                (*iter)->id_;
-            // TODO(andrew): to what should this be set?
-            _scratchVadPositiveParticipants[
-                _scratchVadPositiveParticipantsAmount].level = 0;
-            _scratchVadPositiveParticipantsAmount++;
-        }
     }
 }
 
 bool AudioConferenceMixerImpl::IsParticipantInList(
     MixerParticipant& participant,
     MixerParticipantList* participantList) const {
     WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                  "IsParticipantInList(participant,participantList)");
     for (MixerParticipantList::const_iterator iter = participantList->begin();
          iter != participantList->end();
@@ skipping 62 matching lines @@
                 kTraceAudioMixerServer,
                 _id,
                 "Trying to mix more than max amount of mixed participants:%d!",
                 kMaximumAmountOfMixedParticipants);
             // Assert and avoid crash
             assert(false);
             position = 0;
         }
         MixFrames(&mixedAudio, (*iter), use_limiter_);
 
-        SetParticipantStatistics(&_scratchMixedParticipants[position],
-                                 **iter);
-
         position++;
     }
 
     return 0;
 }
 
 // TODO(andrew): consolidate this function with MixFromList.
 int32_t AudioConferenceMixerImpl::MixAnonomouslyFromList(
     AudioFrame& mixedAudio,
     const AudioFrameList* audioFrameList) {
@@ skipping 32 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc