Replace ASSERT with DCHECK in WebAudio

third_party/WebKit/Source/modules/webaudio/RealtimeAnalyser.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 42 matching lines @@
     , m_smoothingTimeConstant(DefaultSmoothingTimeConstant)
     , m_minDecibels(DefaultMinDecibels)
     , m_maxDecibels(DefaultMaxDecibels)
     , m_lastAnalysisTime(-1)
 {
     m_analysisFrame = wrapUnique(new FFTFrame(DefaultFFTSize));
 }
 
 bool RealtimeAnalyser::setFftSize(size_t size)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     // Only allow powers of two.
     unsigned log2size = static_cast<unsigned>(log2(size));
     bool isPOT(1UL << log2size == size);
 
     if (!isPOT || size > MaxFFTSize || size < MinFFTSize)
         return false;
 
     if (m_fftSize != size) {
         m_analysisFrame = wrapUnique(new FFTFrame(size));
         // m_magnitudeBuffer has size = fftSize / 2 because it contains floats reduced from complex values in m_analysisFrame.
         m_magnitudeBuffer.allocate(size / 2);
         m_fftSize = size;
     }
 
     return true;
 }
 
 void RealtimeAnalyser::writeInput(AudioBus* bus, size_t framesToProcess)
 {
     bool isBusGood = bus && bus->numberOfChannels() > 0 && bus->channel(0)->length() >= framesToProcess;
-    ASSERT(isBusGood);
+    DCHECK(isBusGood);
     if (!isBusGood)
         return;
 
     // FIXME : allow to work with non-FFTSize divisible chunking
     bool isDestinationGood = m_writeIndex < m_inputBuffer.size() && m_writeIndex + framesToProcess <= m_inputBuffer.size();
-    ASSERT(isDestinationGood);
+    DCHECK(isDestinationGood);
     if (!isDestinationGood)
         return;
 
     // Perform real-time analysis
     float* dest = m_inputBuffer.data() + m_writeIndex;
 
     // Clear the bus and downmix the input according to the down mixing rules.  Then save the result
     // in the m_inputBuffer at the appropriate place.
     m_downMixBus->zero();
     m_downMixBus->sumFrom(*bus);
     memcpy(dest, m_downMixBus->channel(0)->data(), framesToProcess * sizeof(*dest));
 
     m_writeIndex += framesToProcess;
     if (m_writeIndex >= InputBufferSize)
         m_writeIndex = 0;
 }
 
 namespace {
 
 void applyWindow(float* p, size_t n)
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     // Blackman window
     double alpha = 0.16;
     double a0 = 0.5 * (1 - alpha);
     double a1 = 0.5;
     double a2 = 0.5 * alpha;
 
     for (unsigned i = 0; i < n; ++i) {
         double x = static_cast<double>(i) / static_cast<double>(n);
         double window = a0 - a1 * cos(twoPiDouble * x) + a2 * cos(twoPiDouble * 2.0 * x);
         p[i] *= float(window);
     }
 }
 
 } // namespace
 
 void RealtimeAnalyser::doFFTAnalysis()
 {
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     // Unroll the input buffer into a temporary buffer, where we'll apply an analysis window followed by an FFT.
     size_t fftSize = this->fftSize();
 
     AudioFloatArray temporaryBuffer(fftSize);
     float* inputBuffer = m_inputBuffer.data();
     float* tempP = temporaryBuffer.data();
 
     // Take the previous fftSize values from the input buffer and copy into the temporary buffer.
     unsigned writeIndex = m_writeIndex;
@@ skipping 46 matching lines @@
         for (unsigned i = 0; i < len; ++i) {
             float linearValue = source[i];
             double dbMag = AudioUtilities::linearToDecibels(linearValue);
             destination[i] = float(dbMag);
         }
     }
 }
 
 void RealtimeAnalyser::getFloatFrequencyData(DOMFloat32Array* destinationArray, double currentTime)
 {
-    ASSERT(isMainThread());
-    ASSERT(destinationArray);
+    DCHECK(isMainThread());
+    DCHECK(destinationArray);
 
     if (currentTime <= m_lastAnalysisTime) {
         convertFloatToDb(destinationArray);
         return;
     }
 
     // Time has advanced since the last call; update the FFT data.
     m_lastAnalysisTime = currentTime;
     doFFTAnalysis();
 
@@ skipping 25 matching lines @@
             if (scaledValue > UCHAR_MAX)
                 scaledValue = UCHAR_MAX;
 
             destination[i] = static_cast<unsigned char>(scaledValue);
         }
     }
 }
 
 void RealtimeAnalyser::getByteFrequencyData(DOMUint8Array* destinationArray, double currentTime)
 {
-    ASSERT(isMainThread());
-    ASSERT(destinationArray);
+    DCHECK(isMainThread());
+    DCHECK(destinationArray);
 
     if (currentTime <= m_lastAnalysisTime) {
         // FIXME: Is it worth caching the data so we don't have to do the conversion every time?
         // Perhaps not, since we expect many calls in the same rendering quantum.
         convertToByteData(destinationArray);
         return;
     }
 
     // Time has advanced since the last call; update the FFT data.
     m_lastAnalysisTime = currentTime;
     doFFTAnalysis();
 
     convertToByteData(destinationArray);
 }
 
 void RealtimeAnalyser::getFloatTimeDomainData(DOMFloat32Array* destinationArray)
 {
-    ASSERT(isMainThread());
-    ASSERT(destinationArray);
+    DCHECK(isMainThread());
+    DCHECK(destinationArray);
 
     unsigned fftSize = this->fftSize();
     size_t len = std::min(fftSize, destinationArray->length());
     if (len > 0) {
         bool isInputBufferGood = m_inputBuffer.size() == InputBufferSize && m_inputBuffer.size() > fftSize;
-        ASSERT(isInputBufferGood);
+        DCHECK(isInputBufferGood);
         if (!isInputBufferGood)
             return;
 
         float* inputBuffer = m_inputBuffer.data();
         float* destination = destinationArray->data();
 
         unsigned writeIndex = m_writeIndex;
 
         for (unsigned i = 0; i < len; ++i) {
             // Buffer access is protected due to modulo operation.
             float value = inputBuffer[(i + writeIndex - fftSize + InputBufferSize) % InputBufferSize];
 
             destination[i] = value;
         }
     }
 }
 
 void RealtimeAnalyser::getByteTimeDomainData(DOMUint8Array* destinationArray)
 {
-    ASSERT(isMainThread());
-    ASSERT(destinationArray);
+    DCHECK(isMainThread());
+    DCHECK(destinationArray);
 
     unsigned fftSize = this->fftSize();
     size_t len = std::min(fftSize, destinationArray->length());
     if (len > 0) {
         bool isInputBufferGood = m_inputBuffer.size() == InputBufferSize && m_inputBuffer.size() > fftSize;
-        ASSERT(isInputBufferGood);
+        DCHECK(isInputBufferGood);
         if (!isInputBufferGood)
             return;
 
         float* inputBuffer = m_inputBuffer.data();
         unsigned char* destination = destinationArray->data();
 
         unsigned writeIndex = m_writeIndex;
 
         for (unsigned i = 0; i < len; ++i) {
             // Buffer access is protected due to modulo operation.
             float value = inputBuffer[(i + writeIndex - fftSize + InputBufferSize) % InputBufferSize];
 
             // Scale from nominal -1 -> +1 to unsigned byte.
             double scaledValue = 128 * (value + 1);
 
             // Clip to valid range.
             if (scaledValue < 0)
                 scaledValue = 0;
             if (scaledValue > UCHAR_MAX)
                 scaledValue = UCHAR_MAX;
 
             destination[i] = static_cast<unsigned char>(scaledValue);
         }
     }
 }
 
 } // namespace blink