Removed the memory pool from the mixer.

webrtc/modules/audio_mixer/source/new_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 96 matching lines @@
     return NULL;
   }
   return mixer;
 }
 
 NewAudioConferenceMixerImpl::NewAudioConferenceMixerImpl(int id)
     : _id(id),
       _minimumMixingFreq(kLowestPossible),
       _outputFrequency(kDefaultFrequency),
       _sampleSize(0),
-      _audioFramePool(NULL),
       audio_source_list_(),
       additional_audio_source_list_(),
       num_mixed_audio_sources_(0),
       use_limiter_(true),
       _timeStamp(0) {
   thread_checker_.DetachFromThread();
-      }
+}
 
 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);
-  RTC_DCHECK_EQ(_audioFramePool, static_cast<MemoryPool<AudioFrame>*>(nullptr));
-}
-
 void NewAudioConferenceMixerImpl::Mix(AudioFrame* audio_frame_for_mixing) {
   size_t remainingAudioSourcesAllowedToMix = kMaximumAmountOfMixedAudioSources;
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   AudioFrameList mixList;
   AudioFrameList rampOutList;
   AudioFrameList additionalFramesList;
   std::map<int, MixerAudioSource*> mixedAudioSourcesMap;
   {
     CriticalSectionScoped cs(_cbCrit.get());
 
@@ skipping 269 matching lines @@
        audio_source != audio_source_list_.end(); ++audio_source) {
     // Stop keeping track of passive audioSources if there are already
     // enough audio sources available (they wont be mixed anyway).
     bool mustAddToPassiveList =
         (*maxAudioFrameCounter >
          (activeList.size() + passiveWasMixedList.size() +
           passiveWasNotMixedList.size()));
 
     bool wasMixed = false;
     wasMixed = (*audio_source)->_mixHistory->WasMixed();
-    AudioFrame* audioFrame = NULL;
-    if (_audioFramePool->PopMemory(audioFrame) == -1) {
-      WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
-                   "failed PopMemory() call");
-      RTC_NOTREACHED();
-      return;
-    }
-    audioFrame->sample_rate_hz_ = _outputFrequency;
 
-    auto ret = (*audio_source)->GetAudioFrameWithMuted(_id, audioFrame);
+    auto audio_frame_with_info =
+        (*audio_source)->GetAudioFrameWithMuted(_id, _outputFrequency);
+    auto ret = audio_frame_with_info.audio_frame_info;
+    AudioFrame* audio_frame = audio_frame_with_info.audio_frame;
     if (ret == MixerAudioSource::AudioFrameInfo::kError) {
-      WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
-                   "failed to GetAudioFrameWithMuted() from audio source");
-      _audioFramePool->PushMemory(audioFrame);
       continue;
     }
     const bool muted = (ret == MixerAudioSource::AudioFrameInfo::kMuted);
     if (audio_source_list_.size() != 1) {
       // TODO(wu): Issue 3390, add support for multiple audio sources case.
-      audioFrame->ntp_time_ms_ = -1;
+      audio_frame->ntp_time_ms_ = -1;
     }
 
     // TODO(aleloi): 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.
-    // RTC_DCHECK_NE(audioFrame->vad_activity_, AudioFrame::kVadUnknown);
-    if (audioFrame->vad_activity_ == AudioFrame::kVadUnknown) {
+    // RTC_DCHECK_NE(audio_frame->vad_activity_, AudioFrame::kVadUnknown);
+    if (audio_frame->vad_activity_ == AudioFrame::kVadUnknown) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                    "invalid VAD state from audio source");
     }
 
-    if (audioFrame->vad_activity_ == AudioFrame::kVadActive) {
+    if (audio_frame->vad_activity_ == AudioFrame::kVadActive) {
       if (!wasMixed && !muted) {
-        RampIn(*audioFrame);
+        RampIn(*audio_frame);
       }
 
       if (activeList.size() >= *maxAudioFrameCounter) {
         // There are already more active audio sources than should be
         // mixed. Only keep the ones with the highest energy.
         AudioFrameList::iterator replaceItem;
-        uint32_t lowestEnergy = muted ? 0 : CalculateEnergy(*audioFrame);
+        uint32_t lowestEnergy = muted ? 0 : CalculateEnergy(*audio_frame);
 
         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 =
               mixAudioSourceList->find(replaceFrame.frame->id_);
 
           // When a frame is pushed to |activeList| it is also pushed
           // to mixAudioSourceList with the frame's id. This means
           // that the Find call above should never fail.
           RTC_DCHECK(it != mixAudioSourceList->end());
           replaceWasMixed = it->second->_mixHistory->WasMixed();
 
           mixAudioSourceList->erase(replaceFrame.frame->id_);
           activeList.erase(replaceItem);
 
-          activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
-          (*mixAudioSourceList)[audioFrame->id_] = *audio_source;
+          activeList.push_front(FrameAndMuteInfo(audio_frame, muted));
+          (*mixAudioSourceList)[audio_frame->id_] = *audio_source;
           RTC_DCHECK_LE(mixAudioSourceList->size(),
                         static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
 
           if (replaceWasMixed) {
             if (!replaceFrame.muted) {
               RampOut(*replaceFrame.frame);
             }
             rampOutList->push_back(replaceFrame);
             RTC_DCHECK_LE(
                 rampOutList->size(),
                 static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
-          } else {
-            _audioFramePool->PushMemory(replaceFrame.frame);
           }
         } else {
           if (wasMixed) {
             if (!muted) {
-              RampOut(*audioFrame);
+              RampOut(*audio_frame);
             }
-            rampOutList->push_back(FrameAndMuteInfo(audioFrame, muted));
+            rampOutList->push_back(FrameAndMuteInfo(audio_frame, muted));
             RTC_DCHECK_LE(
                 rampOutList->size(),
                 static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
-          } else {
-            _audioFramePool->PushMemory(audioFrame);
           }
         }
       } else {
-        activeList.push_front(FrameAndMuteInfo(audioFrame, muted));
-        (*mixAudioSourceList)[audioFrame->id_] = *audio_source;
+        activeList.push_front(FrameAndMuteInfo(audio_frame, muted));
+        (*mixAudioSourceList)[audio_frame->id_] = *audio_source;
         RTC_DCHECK_LE(mixAudioSourceList->size(),
                       static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
       }
     } else {
       if (wasMixed) {
         AudioSourceWithFrame* part_struct =
-            new AudioSourceWithFrame(*audio_source, audioFrame, muted);
+            new AudioSourceWithFrame(*audio_source, audio_frame, muted);
         passiveWasMixedList.push_back(part_struct);
       } else if (mustAddToPassiveList) {
         if (!muted) {
-          RampIn(*audioFrame);
+          RampIn(*audio_frame);
         }
         AudioSourceWithFrame* part_struct =
-            new AudioSourceWithFrame(*audio_source, audioFrame, muted);
+            new AudioSourceWithFrame(*audio_source, audio_frame, muted);
         passiveWasNotMixedList.push_back(part_struct);
-      } else {
-        _audioFramePool->PushMemory(audioFrame);
       }
     }
   }
   RTC_DCHECK_LE(activeList.size(), *maxAudioFrameCounter);
   // At this point it is known which audio sources 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 audio sources mix passive ones. Starting with those that was mixed
   // last iteration.
   for (AudioSourceWithFrameList::const_iterator iter =
            passiveWasMixedList.begin();
        iter != passiveWasMixedList.end(); ++iter) {
     if (mixList->size() < *maxAudioFrameCounter + mixListStartSize) {
       mixList->push_back(
           FrameAndMuteInfo((*iter)->audio_frame, (*iter)->muted));
       (*mixAudioSourceList)[(*iter)->audio_frame->id_] = (*iter)->audio_source;
       RTC_DCHECK_LE(mixAudioSourceList->size(),
                     static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
-    } else {
-      _audioFramePool->PushMemory((*iter)->audio_frame);
     }
     delete *iter;
   }
   // And finally the ones that have not been mixed for a while.
   for (AudioSourceWithFrameList::const_iterator iter =
            passiveWasNotMixedList.begin();
        iter != passiveWasNotMixedList.end(); ++iter) {
     if (mixList->size() < *maxAudioFrameCounter + mixListStartSize) {
       mixList->push_back(
           FrameAndMuteInfo((*iter)->audio_frame, (*iter)->muted));
       (*mixAudioSourceList)[(*iter)->audio_frame->id_] = (*iter)->audio_source;
       RTC_DCHECK_LE(mixAudioSourceList->size(),
                     static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
-    } else {
-      _audioFramePool->PushMemory((*iter)->audio_frame);
     }
     delete *iter;
   }
   RTC_DCHECK_GE(*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 audio source being
-  // removed from additionalAudioSourceList_. If that happens it will
+  // removed from additionalAudioFramesList_. If that happens it will
   // invalidate any iterators. Create a copy of the audio sources list such
-  // that the list of audio sources can be traversed safely.
+  // that the list of participants can be traversed safely.
   MixerAudioSourceList additionalAudioSourceList;
   additionalAudioSourceList.insert(additionalAudioSourceList.begin(),
                                    additional_audio_source_list_.begin(),
                                    additional_audio_source_list_.end());
 
   for (MixerAudioSourceList::const_iterator audio_source =
            additionalAudioSourceList.begin();
        audio_source != additionalAudioSourceList.end(); ++audio_source) {
-    AudioFrame* audioFrame = NULL;
-    if (_audioFramePool->PopMemory(audioFrame) == -1) {
-      WEBRTC_TRACE(kTraceMemory, kTraceAudioMixerServer, _id,
-                   "failed PopMemory() call");
-      RTC_NOTREACHED();
-      return;
-    }
-    audioFrame->sample_rate_hz_ = _outputFrequency;
-    auto ret = (*audio_source)->GetAudioFrameWithMuted(_id, audioFrame);
+    auto audio_frame_with_info =
+        (*audio_source)->GetAudioFrameWithMuted(_id, _outputFrequency);
+    auto ret = audio_frame_with_info.audio_frame_info;
+    AudioFrame* audio_frame = audio_frame_with_info.audio_frame;
     if (ret == MixerAudioSource::AudioFrameInfo::kError) {
       WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                    "failed to GetAudioFrameWithMuted() from audio_source");
-      _audioFramePool->PushMemory(audioFrame);
       continue;
     }
-    if (audioFrame->samples_per_channel_ == 0) {
+    if (audio_frame->samples_per_channel_ == 0) {
       // Empty frame. Don't use it.
-      _audioFramePool->PushMemory(audioFrame);
       continue;
     }
     additionalFramesList->push_back(FrameAndMuteInfo(
-        audioFrame, ret == MixerAudioSource::AudioFrameInfo::kMuted));
+        audio_frame, ret == MixerAudioSource::AudioFrameInfo::kMuted));
   }
 }
 
 void NewAudioConferenceMixerImpl::UpdateMixedStatus(
     const std::map<int, MixerAudioSource*>& mixedAudioSourcesMap) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                "UpdateMixedStatus(mixedAudioSourcesMap)");
   RTC_DCHECK_LE(mixedAudioSourcesMap.size(),
                 static_cast<size_t>(kMaximumAmountOfMixedAudioSources));
 
@@ skipping 12 matching lines @@
       }
     }
     (*audio_source)->_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::IsAudioSourceInList(
     const MixerAudioSource& audio_source,
     const MixerAudioSourceList& audioSourceList) const {
   WEBRTC_TRACE(kTraceStream, kTraceAudioMixerServer, _id,
                "IsAudioSourceInList(audio_source,audioSourceList)");
   for (MixerAudioSourceList::const_iterator iter = audioSourceList.begin();
        iter != audioSourceList.end(); ++iter) {
@@ skipping 118 matching lines @@
 
   if (error != _limiter->kNoError) {
     WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                  "Error from AudioProcessing: %d", error);
     RTC_NOTREACHED();
     return false;
   }
   return true;
 }
 }  // namespace webrtc