Use clampTo instead of chaining std::max(std::min(...))

third_party/WebKit/Source/platform/audio/Biquad.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 19 matching lines @@
 
 #if ENABLE(WEB_AUDIO)
 
 #include "platform/audio/Biquad.h"
 
 #include "platform/audio/AudioUtilities.h"
 #include "platform/audio/DenormalDisabler.h"
 #include "wtf/MathExtras.h"
 
 #include <algorithm>
+#include <complex>

[Raymond Toy, 2015/12/17 19:45:55]

Why is <complex> needed now?

[Daniel Bratell, 2015/12/17 22:58:19]

It should always have been there but luckily someone else included it so it
worked anyway. While trying to clean up <algorithm> I also picked up other
includes that were missing and corrected that.

 #include <stdio.h>
 
 #if OS(MACOSX)
 #include <Accelerate/Accelerate.h>
 #endif
 
 namespace blink {
 
 #if OS(MACOSX)
 const int kBufferSize = 1024;
@@ skipping 218 matching lines @@
     ippsIIRGetStateSize64f_BiQuad_32f(1, &bufferSize);
     ippsZero_8u(m_ippInternalBuffer, bufferSize);
 
 #endif
     m_x1 = m_x2 = m_y1 = m_y2 = 0;
 }
 
 void Biquad::setLowpassParams(int index, double cutoff, double resonance)
 {
     // Limit cutoff to 0 to 1.
-    cutoff = std::max(0.0, std::min(cutoff, 1.0));
+    cutoff = clampTo(cutoff, 0.0, 1.0);
 
     if (cutoff == 1) {
         // When cutoff is 1, the z-transform is 1.
         setNormalizedCoefficients(index,
             1, 0, 0,
             1, 0, 0);
     } else if (cutoff > 0) {
         // Compute biquad coefficients for lowpass filter
         resonance = std::max(0.0, resonance); // can't go negative
         double g = pow(10.0, 0.05 * resonance);
@@ skipping 17 matching lines @@
         // coefficients up correctly.
         setNormalizedCoefficients(index,
             0, 0, 0,
             1, 0, 0);
     }
 }
 
 void Biquad::setHighpassParams(int index, double cutoff, double resonance)
 {
     // Limit cutoff to 0 to 1.
-    cutoff = std::max(0.0, std::min(cutoff, 1.0));
+    cutoff = clampTo(cutoff, 0.0, 1.0);
 
     if (cutoff == 1) {
         // The z-transform is 0.
         setNormalizedCoefficients(index,
             0, 0, 0,
             1, 0, 0);
     } else if (cutoff > 0) {
         // Compute biquad coefficients for highpass filter
         resonance = std::max(0.0, resonance); // can't go negative
         double g = pow(10.0, 0.05 * resonance);
@@ skipping 43 matching lines @@
     taps[5] = m_a2[0];
     m_biquadState = 0;
 
     ippsIIRInit64f_BiQuad_32f(&m_biquadState, taps, 1, 0, m_ippInternalBuffer);
 #endif // USE(WEBAUDIO_IPP)
 }
 
 void Biquad::setLowShelfParams(int index, double frequency, double dbGain)
 {
     // Clip frequencies to between 0 and 1, inclusive.
-    frequency = std::max(0.0, std::min(frequency, 1.0));
+    frequency = clampTo(frequency, 0.0, 1.0);
 
     double A = pow(10.0, dbGain / 40);
 
     if (frequency == 1) {
         // The z-transform is a constant gain.
         setNormalizedCoefficients(index,
             A * A, 0, 0,
             1, 0, 0);
     } else if (frequency > 0) {
         double w0 = piDouble * frequency;
@@ skipping 16 matching lines @@
         // When frequency is 0, the z-transform is 1.
         setNormalizedCoefficients(index,
             1, 0, 0,
             1, 0, 0);
     }
 }
 
 void Biquad::setHighShelfParams(int index, double frequency, double dbGain)
 {
     // Clip frequencies to between 0 and 1, inclusive.
-    frequency = std::max(0.0, std::min(frequency, 1.0));
+    frequency = clampTo(frequency, 0.0, 1.0);
 
     double A = pow(10.0, dbGain / 40);
 
     if (frequency == 1) {
         // The z-transform is 1.
         setNormalizedCoefficients(index,
             1, 0, 0,
             1, 0, 0);
     } else if (frequency > 0) {
         double w0 = piDouble * frequency;
@@ skipping 18 matching lines @@
         // When frequency = 0, the filter is just a gain, A^2.
         setNormalizedCoefficients(index,
             A * A, 0, 0,
             1, 0, 0);
     }
 }
 
 void Biquad::setPeakingParams(int index, double frequency, double Q, double dbGain)
 {
     // Clip frequencies to between 0 and 1, inclusive.
-    frequency = std::max(0.0, std::min(frequency, 1.0));
+    frequency = clampTo(frequency, 0.0, 1.0);
 
     // Don't let Q go negative, which causes an unstable filter.
     Q = std::max(0.0, Q);
 
     double A = pow(10.0, dbGain / 40);
 
     if (frequency > 0 && frequency < 1) {
         if (Q > 0) {
             double w0 = piDouble * frequency;
             double alpha = sin(w0) / (2 * Q);
@@ skipping 21 matching lines @@
         // When frequency is 0 or 1, the z-transform is 1.
         setNormalizedCoefficients(index,
             1, 0, 0,
             1, 0, 0);
     }
 }
 
 void Biquad::setAllpassParams(int index, double frequency, double Q)
 {
     // Clip frequencies to between 0 and 1, inclusive.
-    frequency = std::max(0.0, std::min(frequency, 1.0));
+    frequency = clampTo(frequency, 0.0, 1.0);
 
     // Don't let Q go negative, which causes an unstable filter.
     Q = std::max(0.0, Q);
 
     if (frequency > 0 && frequency < 1) {
         if (Q > 0) {
             double w0 = piDouble * frequency;
             double alpha = sin(w0) / (2 * Q);
             double k = cos(w0);
 
@@ skipping 19 matching lines @@
         // When frequency is 0 or 1, the z-transform is 1.
         setNormalizedCoefficients(index,
             1, 0, 0,
             1, 0, 0);
     }
 }
 
 void Biquad::setNotchParams(int index, double frequency, double Q)
 {
     // Clip frequencies to between 0 and 1, inclusive.
-    frequency = std::max(0.0, std::min(frequency, 1.0));
+    frequency = clampTo(frequency, 0.0, 1.0);
 
     // Don't let Q go negative, which causes an unstable filter.
     Q = std::max(0.0, Q);
 
     if (frequency > 0 && frequency < 1) {
         if (Q > 0) {
             double w0 = piDouble * frequency;
             double alpha = sin(w0) / (2 * Q);
             double k = cos(w0);
 
@@ skipping 103 matching lines @@
             std::complex<double>(1, 0) + (a1 + a2 * z) * z;
         std::complex<double> response = numerator / denominator;
         magResponse[k] = static_cast<float>(abs(response));
         phaseResponse[k] = static_cast<float>(atan2(imag(response), real(response)));
     }
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)