Replace NULL with nullptr in all C++ files.

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 89 matching lines @@
 }
 
 void MixHistory::ResetMixedStatus() {
     _isMixed = false;
 }
 
 AudioConferenceMixer* AudioConferenceMixer::Create(int id) {
     AudioConferenceMixerImpl* mixer = new AudioConferenceMixerImpl(id);
     if(!mixer->Init()) {
         delete mixer;
-        return NULL;
+        return nullptr;
     }
     return mixer;
 }
 
 AudioConferenceMixerImpl::AudioConferenceMixerImpl(int id)
     : _id(id),
       _minimumMixingFreq(kLowestPossible),
-      _mixReceiver(NULL),
+      _mixReceiver(nullptr),
       _outputFrequency(kDefaultFrequency),
       _sampleSize(0),
-      _audioFramePool(NULL),
+      _audioFramePool(nullptr),
       _participantList(),
       _additionalParticipantList(),
       _numMixedParticipants(0),
       use_limiter_(true),
       _timeStamp(0),
       _timeScheduler(kProcessPeriodicityInMs),
       _processCalls(0) {}
 
 bool AudioConferenceMixerImpl::Init() {
     _crit.reset(CriticalSectionWrapper::CreateCriticalSection());
-    if (_crit.get() == NULL)
-        return false;
+    if (_crit.get() == nullptr)
+      return false;
 
     _cbCrit.reset(CriticalSectionWrapper::CreateCriticalSection());
-    if(_cbCrit.get() == NULL)
-        return false;
+    if (_cbCrit.get() == nullptr)
+      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 (_audioFramePool == nullptr)
+      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;
 }
 
 AudioConferenceMixerImpl::~AudioConferenceMixerImpl() {
     MemoryPool<AudioFrame>::DeleteMemoryPool(_audioFramePool);
-    assert(_audioFramePool == NULL);
+    assert(_audioFramePool == nullptr);
 }
 
 // Process should be called every kProcessPeriodicityInMs ms
 int64_t AudioConferenceMixerImpl::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
@@ skipping 69 matching lines @@
         }
 
         UpdateToMix(&mixList, &rampOutList, &mixedParticipantsMap,
                     &remainingParticipantsAllowedToMix);
 
         GetAdditionalAudio(&additionalFramesList);
         UpdateMixedStatus(mixedParticipantsMap);
     }
 
     // Get an AudioFrame for mixing from the memory pool.
-    AudioFrame* mixedAudio = NULL;
+    AudioFrame* mixedAudio = nullptr;
     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,
+        mixedAudio->UpdateFrame(-1, _timeStamp, nullptr, 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;
             AudioFrameOperations::Mute(mixedAudio);
         } 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);
+        if (_mixReceiver != nullptr) {
+          const AudioFrame** dummy = nullptr;
+          _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 AudioConferenceMixerImpl::RegisterMixedStreamCallback(
     AudioMixerOutputReceiver* mixReceiver) {
     CriticalSectionScoped cs(_cbCrit.get());
-    if(_mixReceiver != NULL) {
-        return -1;
+    if (_mixReceiver != nullptr) {
+      return -1;
     }
     _mixReceiver = mixReceiver;
     return 0;
 }
 
 int32_t AudioConferenceMixerImpl::UnRegisterMixedStreamCallback() {
     CriticalSectionScoped cs(_cbCrit.get());
-    if(_mixReceiver == NULL) {
-        return -1;
+    if (_mixReceiver == nullptr) {
+      return -1;
     }
-    _mixReceiver = NULL;
+    _mixReceiver = nullptr;
     return 0;
 }
 
 int32_t AudioConferenceMixerImpl::SetOutputFrequency(
     const Frequency& frequency) {
     CriticalSectionScoped cs(_crit.get());
 
     _outputFrequency = frequency;
     _sampleSize =
         static_cast<size_t>((_outputFrequency*kProcessPeriodicityInMs) / 1000);
@@ skipping 176 matching lines @@
          ++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;
+        AudioFrame* audioFrame = nullptr;
         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 == MixerParticipant::AudioFrameInfo::kError) {
@@ skipping 167 matching lines @@
     // that the list of participants can be traversed safely.
     MixerParticipantList additionalParticipantList;
     additionalParticipantList.insert(additionalParticipantList.begin(),
                                      _additionalParticipantList.begin(),
                                      _additionalParticipantList.end());
 
     for (MixerParticipantList::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* audioFrame = nullptr;
+      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 == MixerParticipant::AudioFrameInfo::kError) {
             WEBRTC_TRACE(kTraceWarning, kTraceAudioMixerServer, _id,
                          "failed to GetAudioFrameWithMuted() from participant");
             _audioFramePool->PushMemory(audioFrame);
             continue;
         }
         if(audioFrame->samples_per_channel_ == 0) {
@@ skipping 173 matching lines @@
 
     if(error != _limiter->kNoError) {
         WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, _id,
                      "Error from AudioProcessing: %d", error);
         assert(false);
         return false;
     }
     return true;
 }
 }  // namespace webrtc