remove WTF::Complex

Source/platform/audio/FFTFrame.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
@@ skipping 16 matching lines @@
  */
 
 #include "config.h"
 
 #if ENABLE(WEB_AUDIO)
 
 #include "platform/audio/FFTFrame.h"
 
 #include "platform/audio/VectorMath.h"
 #include "platform/Logging.h"
-#include "wtf/Complex.h"
 #include "wtf/MathExtras.h"
 #include "wtf/OwnPtr.h"
 
+#include <complex>
+
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 void FFTFrame::doPaddedFFT(const float* data, size_t dataSize)
 {
     // Zero-pad the impulse response
     AudioFloatArray paddedResponse(fftSize()); // zero-initialized
@@ skipping 42 matching lines @@
     double phaseAccum = 0.0;
     double lastPhase1 = 0.0;
     double lastPhase2 = 0.0;
 
     realP[0] = static_cast<float>(s1base * realP1[0] + s2base * realP2[0]);
     imagP[0] = static_cast<float>(s1base * imagP1[0] + s2base * imagP2[0]);
 
     int n = m_FFTSize / 2;
 
     for (int i = 1; i < n; ++i) {
-        Complex c1(realP1[i], imagP1[i]);
-        Complex c2(realP2[i], imagP2[i]);
+        std::complex<double> c1(realP1[i], imagP1[i]);
+        std::complex<double> c2(realP2[i], imagP2[i]);
 
         double mag1 = abs(c1);
         double mag2 = abs(c2);
 
         // Interpolate magnitudes in decibels
         double mag1db = 20.0 * log10(mag1);
         double mag2db = 20.0 * log10(mag2);
 
         double s1 = s1base;
         double s2 = s2base;
@@ skipping 45 matching lines @@
             deltaPhaseBlend = s1 * deltaPhase1 + s2 * deltaPhase2;
 
         phaseAccum += deltaPhaseBlend;
 
         // Unwrap
         if (phaseAccum > piDouble)
             phaseAccum -= twoPiDouble;
         if (phaseAccum < -piDouble)
             phaseAccum += twoPiDouble;
 
-        Complex c = complexFromMagnitudePhase(mag, phaseAccum);
+        std::complex<double> c = std::polar(mag, phaseAccum);
 
         realP[i] = static_cast<float>(c.real());
         imagP[i] = static_cast<float>(c.imag());
     }
 }
 
 double FFTFrame::extractAverageGroupDelay()
 {
     float* realP = realData();
     float* imagP = imagData();
 
     double aveSum = 0.0;
     double weightSum = 0.0;
     double lastPhase = 0.0;
 
     int halfSize = fftSize() / 2;
 
     const double kSamplePhaseDelay = (twoPiDouble) / double(fftSize());
 
     // Calculate weighted average group delay
     for (int i = 0; i < halfSize; i++) {
-        Complex c(realP[i], imagP[i]);
+        std::complex<double> c(realP[i], imagP[i]);
         double mag = abs(c);
         double phase = arg(c);
 
         double deltaPhase = phase - lastPhase;
         lastPhase = phase;
 
         // Unwrap
         if (deltaPhase < -piDouble)
             deltaPhase += twoPiDouble;
         if (deltaPhase > piDouble)
@@ skipping 26 matching lines @@
 
     float* realP = realData();
     float* imagP = imagData();
 
     const double kSamplePhaseDelay = (twoPiDouble) / double(fftSize());
 
     double phaseAdj = -sampleFrameDelay * kSamplePhaseDelay;
 
     // Add constant group delay
     for (int i = 1; i < halfSize; i++) {
-        Complex c(realP[i], imagP[i]);
+        std::complex<double> c(realP[i], imagP[i]);
         double mag = abs(c);
         double phase = arg(c);
 
         phase += i * phaseAdj;
 
-        Complex c2 = complexFromMagnitudePhase(mag, phase);
+        std::complex<double> c2 = std::polar(mag, phase);
 
         realP[i] = static_cast<float>(c2.real());
         imagP[i] = static_cast<float>(c2.imag());
     }
 }
 
 void FFTFrame::multiply(const FFTFrame& frame)
 {
     FFTFrame& frame1 = *this;
     FFTFrame& frame2 = const_cast<FFTFrame&>(frame);
@@ skipping 10 matching lines @@
     VectorMath::zvmul(realP1, imagP1, realP2, imagP2, realP1, imagP1, halfSize);
 
     // Multiply the packed DC/nyquist component
     realP1[0] = real0 * realP2[0];
     imagP1[0] = imag0 * imagP2[0];
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)