/*
 * 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
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 */

#include "platform/audio/VectorMath.h"
#include "wtf/Assertions.h"
#include "wtf/CPU.h"
#include "wtf/MathExtras.h"
#include <stdint.h>

#if OS(MACOSX)
#include <Accelerate/Accelerate.h>
#endif

#if CPU(X86) || CPU(X86_64)
#include <emmintrin.h>
#endif

#if HAVE(ARM_NEON_INTRINSICS)
#include <arm_neon.h>
#endif

#include <math.h>
#include <algorithm>

namespace blink {

namespace VectorMath {

#if OS(MACOSX)
// On the Mac we use the highly optimized versions in Accelerate.framework
// In 32-bit mode (__ppc__ or __i386__) <Accelerate/Accelerate.h> includes
// <vecLib/vDSP_translate.h> which defines macros of the same name as
// our namespaced function names, so we must handle this case differently. Other
// architectures (64bit, ARM, etc.) do not include this header file.

void vsmul(const float* sourceP,
           int sourceStride,
           const float* scale,
           float* destP,
           int destStride,
           size_t framesToProcess) {
#if CPU(X86)
  ::vsmul(sourceP, sourceStride, scale, destP, destStride, framesToProcess);
#else
  vDSP_vsmul(sourceP, sourceStride, scale, destP, destStride, framesToProcess);
#endif
}

void vadd(const float* source1P,
          int sourceStride1,
          const float* source2P,
          int sourceStride2,
          float* destP,
          int destStride,
          size_t framesToProcess) {
#if CPU(X86)
  ::vadd(source1P, sourceStride1, source2P, sourceStride2, destP, destStride,
         framesToProcess);
#else
  vDSP_vadd(source1P, sourceStride1, source2P, sourceStride2, destP, destStride,
            framesToProcess);
#endif
}

void vmul(const float* source1P,
          int sourceStride1,
          const float* source2P,
          int sourceStride2,
          float* destP,
          int destStride,
          size_t framesToProcess) {
#if CPU(X86)
  ::vmul(source1P, sourceStride1, source2P, sourceStride2, destP, destStride,
         framesToProcess);
#else
  vDSP_vmul(source1P, sourceStride1, source2P, sourceStride2, destP, destStride,
            framesToProcess);
#endif
}

void zvmul(const float* real1P,
           const float* imag1P,
           const float* real2P,
           const float* imag2P,
           float* realDestP,
           float* imagDestP,
           size_t framesToProcess) {
  DSPSplitComplex sc1;
  DSPSplitComplex sc2;
  DSPSplitComplex dest;
  sc1.realp = const_cast<float*>(real1P);
  sc1.imagp = const_cast<float*>(imag1P);
  sc2.realp = const_cast<float*>(real2P);
  sc2.imagp = const_cast<float*>(imag2P);
  dest.realp = realDestP;
  dest.imagp = imagDestP;
#if CPU(X86)
  ::zvmul(&sc1, 1, &sc2, 1, &dest, 1, framesToProcess, 1);
#else
  vDSP_zvmul(&sc1, 1, &sc2, 1, &dest, 1, framesToProcess, 1);
#endif
}

void vsma(const float* sourceP,
          int sourceStride,
          const float* scale,
          float* destP,
          int destStride,
          size_t framesToProcess) {
  vDSP_vsma(sourceP, sourceStride, scale, destP, destStride, destP, destStride,
            framesToProcess);
}

void vmaxmgv(const float* sourceP,
             int sourceStride,
             float* maxP,
             size_t framesToProcess) {
  vDSP_maxmgv(sourceP, sourceStride, maxP, framesToProcess);
}

void vsvesq(const float* sourceP,
            int sourceStride,
            float* sumP,
            size_t framesToProcess) {
  vDSP_svesq(const_cast<float*>(sourceP), sourceStride, sumP, framesToProcess);
}

void vclip(const float* sourceP,
           int sourceStride,
           const float* lowThresholdP,
           const float* highThresholdP,
           float* destP,
           int destStride,
           size_t framesToProcess) {
  vDSP_vclip(const_cast<float*>(sourceP), sourceStride,
             const_cast<float*>(lowThresholdP),
             const_cast<float*>(highThresholdP), destP, destStride,
             framesToProcess);
}
#else

void vsma(const float* sourceP,
          int sourceStride,
          const float* scale,
          float* destP,
          int destStride,
          size_t framesToProcess) {
  int n = framesToProcess;

#if CPU(X86) || CPU(X86_64)
  if ((sourceStride == 1) && (destStride == 1)) {
    float k = *scale;

    // If the sourceP address is not 16-byte aligned, the first several frames
    // (at most three) should be processed separately.
    while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
      *destP += k * *sourceP;
      sourceP++;
      destP++;
      n--;
    }

    // Now the sourceP is aligned, use SSE.
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;

    __m128 pSource;
    __m128 dest;
    __m128 temp;
    __m128 mScale = _mm_set_ps1(k);

    bool destAligned = !(reinterpret_cast<uintptr_t>(destP) & 0x0F);

#define SSE2_MULT_ADD(loadInstr, storeInstr) \
  while (destP < endP) {                     \
    pSource = _mm_load_ps(sourceP);          \
    temp = _mm_mul_ps(pSource, mScale);      \
    dest = _mm_##loadInstr##_ps(destP);      \
    dest = _mm_add_ps(dest, temp);           \
    _mm_##storeInstr##_ps(destP, dest);      \
    sourceP += 4;                            \
    destP += 4;                              \
  }

    if (destAligned)
      SSE2_MULT_ADD(load, store)
    else
      SSE2_MULT_ADD(loadu, storeu)

    n = tailFrames;
  }
#elif HAVE(ARM_NEON_INTRINSICS)
  if ((sourceStride == 1) && (destStride == 1)) {
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;

    float32x4_t k = vdupq_n_f32(*scale);
    while (destP < endP) {
      float32x4_t source = vld1q_f32(sourceP);
      float32x4_t dest = vld1q_f32(destP);

      dest = vmlaq_f32(dest, source, k);
      vst1q_f32(destP, dest);

      sourceP += 4;
      destP += 4;
    }
    n = tailFrames;
  }
#endif
  while (n) {
    *destP += *sourceP * *scale;
    sourceP += sourceStride;
    destP += destStride;
    n--;
  }
}

void vsmul(const float* sourceP,
           int sourceStride,
           const float* scale,
           float* destP,
           int destStride,
           size_t framesToProcess) {
  int n = framesToProcess;

#if CPU(X86) || CPU(X86_64)
  if ((sourceStride == 1) && (destStride == 1)) {
    float k = *scale;

    // If the sourceP address is not 16-byte aligned, the first several frames
    // (at most three) should be processed separately.
    while ((reinterpret_cast<size_t>(sourceP) & 0x0F) && n) {
      *destP = k * *sourceP;
      sourceP++;
      destP++;
      n--;
    }

    // Now the sourceP address is aligned and start to apply SSE.
    int group = n / 4;
    __m128 mScale = _mm_set_ps1(k);
    __m128* pSource;
    __m128* pDest;
    __m128 dest;

    if (reinterpret_cast<size_t>(destP) & 0x0F) {
      while (group--) {
        pSource = reinterpret_cast<__m128*>(const_cast<float*>(sourceP));
        dest = _mm_mul_ps(*pSource, mScale);
        _mm_storeu_ps(destP, dest);

        sourceP += 4;
        destP += 4;
      }
    } else {
      while (group--) {
        pSource = reinterpret_cast<__m128*>(const_cast<float*>(sourceP));
        pDest = reinterpret_cast<__m128*>(destP);
        *pDest = _mm_mul_ps(*pSource, mScale);

        sourceP += 4;
        destP += 4;
      }
    }

    // Non-SSE handling for remaining frames which is less than 4.
    n %= 4;
    while (n) {
      *destP = k * *sourceP;
      sourceP++;
      destP++;
      n--;
    }
  } else {  // If strides are not 1, rollback to normal algorithm.
#elif HAVE(ARM_NEON_INTRINSICS)
  if ((sourceStride == 1) && (destStride == 1)) {
    float k = *scale;
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;

    while (destP < endP) {
      float32x4_t source = vld1q_f32(sourceP);
      vst1q_f32(destP, vmulq_n_f32(source, k));

      sourceP += 4;
      destP += 4;
    }
    n = tailFrames;
  }
#endif
    float k = *scale;
    while (n--) {
      *destP = k * *sourceP;
      sourceP += sourceStride;
      destP += destStride;
    }
#if CPU(X86) || CPU(X86_64)
  }
#endif
}

void vadd(const float* source1P,
          int sourceStride1,
          const float* source2P,
          int sourceStride2,
          float* destP,
          int destStride,
          size_t framesToProcess) {
  int n = framesToProcess;

#if CPU(X86) || CPU(X86_64)
  if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
    // If the sourceP address is not 16-byte aligned, the first several frames
    // (at most three) should be processed separately.
    while ((reinterpret_cast<size_t>(source1P) & 0x0F) && n) {
      *destP = *source1P + *source2P;
      source1P++;
      source2P++;
      destP++;
      n--;
    }

    // Now the source1P address is aligned and start to apply SSE.
    int group = n / 4;
    __m128* pSource1;
    __m128* pSource2;
    __m128* pDest;
    __m128 source2;
    __m128 dest;

    bool source2Aligned = !(reinterpret_cast<size_t>(source2P) & 0x0F);
    bool destAligned = !(reinterpret_cast<size_t>(destP) & 0x0F);

    if (source2Aligned && destAligned) {  // all aligned
      while (group--) {
        pSource1 = reinterpret_cast<__m128*>(const_cast<float*>(source1P));
        pSource2 = reinterpret_cast<__m128*>(const_cast<float*>(source2P));
        pDest = reinterpret_cast<__m128*>(destP);
        *pDest = _mm_add_ps(*pSource1, *pSource2);

        source1P += 4;
        source2P += 4;
        destP += 4;
      }

    } else if (source2Aligned &&
               !destAligned) {  // source2 aligned but dest not aligned
      while (group--) {
        pSource1 = reinterpret_cast<__m128*>(const_cast<float*>(source1P));
        pSource2 = reinterpret_cast<__m128*>(const_cast<float*>(source2P));
        dest = _mm_add_ps(*pSource1, *pSource2);
        _mm_storeu_ps(destP, dest);

        source1P += 4;
        source2P += 4;
        destP += 4;
      }

    } else if (!source2Aligned &&
               destAligned) {  // source2 not aligned but dest aligned
      while (group--) {
        pSource1 = reinterpret_cast<__m128*>(const_cast<float*>(source1P));
        source2 = _mm_loadu_ps(source2P);
        pDest = reinterpret_cast<__m128*>(destP);
        *pDest = _mm_add_ps(*pSource1, source2);

        source1P += 4;
        source2P += 4;
        destP += 4;
      }
    } else if (!source2Aligned &&
               !destAligned) {  // both source2 and dest not aligned
      while (group--) {
        pSource1 = reinterpret_cast<__m128*>(const_cast<float*>(source1P));
        source2 = _mm_loadu_ps(source2P);
        dest = _mm_add_ps(*pSource1, source2);
        _mm_storeu_ps(destP, dest);

        source1P += 4;
        source2P += 4;
        destP += 4;
      }
    }

    // Non-SSE handling for remaining frames which is less than 4.
    n %= 4;
    while (n) {
      *destP = *source1P + *source2P;
      source1P++;
      source2P++;
      destP++;
      n--;
    }
  } else {  // if strides are not 1, rollback to normal algorithm
#elif HAVE(ARM_NEON_INTRINSICS)
  if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;

    while (destP < endP) {
      float32x4_t source1 = vld1q_f32(source1P);
      float32x4_t source2 = vld1q_f32(source2P);
      vst1q_f32(destP, vaddq_f32(source1, source2));

      source1P += 4;
      source2P += 4;
      destP += 4;
    }
    n = tailFrames;
  }
#endif
    while (n--) {
      *destP = *source1P + *source2P;
      source1P += sourceStride1;
      source2P += sourceStride2;
      destP += destStride;
    }
#if CPU(X86) || CPU(X86_64)
  }
#endif
}

void vmul(const float* source1P,
          int sourceStride1,
          const float* source2P,
          int sourceStride2,
          float* destP,
          int destStride,
          size_t framesToProcess) {
  int n = framesToProcess;

#if CPU(X86) || CPU(X86_64)
  if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
    // If the source1P address is not 16-byte aligned, the first several frames
    // (at most three) should be processed separately.
    while ((reinterpret_cast<uintptr_t>(source1P) & 0x0F) && n) {
      *destP = *source1P * *source2P;
      source1P++;
      source2P++;
      destP++;
      n--;
    }

    // Now the source1P address aligned and start to apply SSE.
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;
    __m128 pSource1;
    __m128 pSource2;
    __m128 dest;

    bool source2Aligned = !(reinterpret_cast<uintptr_t>(source2P) & 0x0F);
    bool destAligned = !(reinterpret_cast<uintptr_t>(destP) & 0x0F);

#define SSE2_MULT(loadInstr, storeInstr)       \
  while (destP < endP) {                       \
    pSource1 = _mm_load_ps(source1P);          \
    pSource2 = _mm_##loadInstr##_ps(source2P); \
    dest = _mm_mul_ps(pSource1, pSource2);     \
    _mm_##storeInstr##_ps(destP, dest);        \
    source1P += 4;                             \
    source2P += 4;                             \
    destP += 4;                                \
  }

    if (source2Aligned && destAligned)  // Both aligned.
      SSE2_MULT(load, store)
    else if (source2Aligned &&
             !destAligned)  // Source2 is aligned but dest not.
      SSE2_MULT(load, storeu)
    else if (!source2Aligned &&
             destAligned)  // Dest is aligned but source2 not.
      SSE2_MULT(loadu, store)
    else  // Neither aligned.
      SSE2_MULT(loadu, storeu)

    n = tailFrames;
  }
#elif HAVE(ARM_NEON_INTRINSICS)
  if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;

    while (destP < endP) {
      float32x4_t source1 = vld1q_f32(source1P);
      float32x4_t source2 = vld1q_f32(source2P);
      vst1q_f32(destP, vmulq_f32(source1, source2));

      source1P += 4;
      source2P += 4;
      destP += 4;
    }
    n = tailFrames;
  }
#endif
  while (n) {
    *destP = *source1P * *source2P;
    source1P += sourceStride1;
    source2P += sourceStride2;
    destP += destStride;
    n--;
  }
}

void zvmul(const float* real1P,
           const float* imag1P,
           const float* real2P,
           const float* imag2P,
           float* realDestP,
           float* imagDestP,
           size_t framesToProcess) {
  unsigned i = 0;
#if CPU(X86) || CPU(X86_64)
  // Only use the SSE optimization in the very common case that all addresses
  // are 16-byte aligned.  Otherwise, fall through to the scalar code below.
  if (!(reinterpret_cast<uintptr_t>(real1P) & 0x0F) &&
      !(reinterpret_cast<uintptr_t>(imag1P) & 0x0F) &&
      !(reinterpret_cast<uintptr_t>(real2P) & 0x0F) &&
      !(reinterpret_cast<uintptr_t>(imag2P) & 0x0F) &&
      !(reinterpret_cast<uintptr_t>(realDestP) & 0x0F) &&
      !(reinterpret_cast<uintptr_t>(imagDestP) & 0x0F)) {
    unsigned endSize = framesToProcess - framesToProcess % 4;
    while (i < endSize) {
      __m128 real1 = _mm_load_ps(real1P + i);
      __m128 real2 = _mm_load_ps(real2P + i);
      __m128 imag1 = _mm_load_ps(imag1P + i);
      __m128 imag2 = _mm_load_ps(imag2P + i);
      __m128 real = _mm_mul_ps(real1, real2);
      real = _mm_sub_ps(real, _mm_mul_ps(imag1, imag2));
      __m128 imag = _mm_mul_ps(real1, imag2);
      imag = _mm_add_ps(imag, _mm_mul_ps(imag1, real2));
      _mm_store_ps(realDestP + i, real);
      _mm_store_ps(imagDestP + i, imag);
      i += 4;
    }
  }
#elif HAVE(ARM_NEON_INTRINSICS)
  unsigned endSize = framesToProcess - framesToProcess % 4;
  while (i < endSize) {
    float32x4_t real1 = vld1q_f32(real1P + i);
    float32x4_t real2 = vld1q_f32(real2P + i);
    float32x4_t imag1 = vld1q_f32(imag1P + i);
    float32x4_t imag2 = vld1q_f32(imag2P + i);

    float32x4_t realResult = vmlsq_f32(vmulq_f32(real1, real2), imag1, imag2);
    float32x4_t imagResult = vmlaq_f32(vmulq_f32(real1, imag2), imag1, real2);

    vst1q_f32(realDestP + i, realResult);
    vst1q_f32(imagDestP + i, imagResult);

    i += 4;
  }
#endif
  for (; i < framesToProcess; ++i) {
    // Read and compute result before storing them, in case the
    // destination is the same as one of the sources.
    float realResult = real1P[i] * real2P[i] - imag1P[i] * imag2P[i];
    float imagResult = real1P[i] * imag2P[i] + imag1P[i] * real2P[i];

    realDestP[i] = realResult;
    imagDestP[i] = imagResult;
  }
}

void vsvesq(const float* sourceP,
            int sourceStride,
            float* sumP,
            size_t framesToProcess) {
  int n = framesToProcess;
  float sum = 0;

#if CPU(X86) || CPU(X86_64)
  if (sourceStride == 1) {
    // If the sourceP address is not 16-byte aligned, the first several frames
    // (at most three) should be processed separately.
    while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
      float sample = *sourceP;
      sum += sample * sample;
      sourceP++;
      n--;
    }

    // Now the sourceP is aligned, use SSE.
    int tailFrames = n % 4;
    const float* endP = sourceP + n - tailFrames;
    __m128 source;
    __m128 mSum = _mm_setzero_ps();

    while (sourceP < endP) {
      source = _mm_load_ps(sourceP);
      source = _mm_mul_ps(source, source);
      mSum = _mm_add_ps(mSum, source);
      sourceP += 4;
    }

    // Summarize the SSE results.
    const float* groupSumP = reinterpret_cast<float*>(&mSum);
    sum += groupSumP[0] + groupSumP[1] + groupSumP[2] + groupSumP[3];

    n = tailFrames;
  }
#elif HAVE(ARM_NEON_INTRINSICS)
  if (sourceStride == 1) {
    int tailFrames = n % 4;
    const float* endP = sourceP + n - tailFrames;

    float32x4_t fourSum = vdupq_n_f32(0);
    while (sourceP < endP) {
      float32x4_t source = vld1q_f32(sourceP);
      fourSum = vmlaq_f32(fourSum, source, source);
      sourceP += 4;
    }
    float32x2_t twoSum =
        vadd_f32(vget_low_f32(fourSum), vget_high_f32(fourSum));

    float groupSum[2];
    vst1_f32(groupSum, twoSum);
    sum += groupSum[0] + groupSum[1];

    n = tailFrames;
  }
#endif

  while (n--) {
    float sample = *sourceP;
    sum += sample * sample;
    sourceP += sourceStride;
  }

  ASSERT(sumP);
  *sumP = sum;
}

void vmaxmgv(const float* sourceP,
             int sourceStride,
             float* maxP,
             size_t framesToProcess) {
  int n = framesToProcess;
  float max = 0;

#if CPU(X86) || CPU(X86_64)
  if (sourceStride == 1) {
    // If the sourceP address is not 16-byte aligned, the first several frames
    // (at most three) should be processed separately.
    while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
      max = std::max(max, fabsf(*sourceP));
      sourceP++;
      n--;
    }

    // Now the sourceP is aligned, use SSE.
    int tailFrames = n % 4;
    const float* endP = sourceP + n - tailFrames;
    __m128 source;
    __m128 mMax = _mm_setzero_ps();
    int mask = 0x7FFFFFFF;
    __m128 mMask = _mm_set1_ps(*reinterpret_cast<float*>(&mask));

    while (sourceP < endP) {
      source = _mm_load_ps(sourceP);
      // Calculate the absolute value by anding source with mask, the sign bit
      // is set to 0.
      source = _mm_and_ps(source, mMask);
      mMax = _mm_max_ps(mMax, source);
      sourceP += 4;
    }

    // Get max from the SSE results.
    const float* groupMaxP = reinterpret_cast<float*>(&mMax);
    max = std::max(max, groupMaxP[0]);
    max = std::max(max, groupMaxP[1]);
    max = std::max(max, groupMaxP[2]);
    max = std::max(max, groupMaxP[3]);

    n = tailFrames;
  }
#elif HAVE(ARM_NEON_INTRINSICS)
  if (sourceStride == 1) {
    int tailFrames = n % 4;
    const float* endP = sourceP + n - tailFrames;

    float32x4_t fourMax = vdupq_n_f32(0);
    while (sourceP < endP) {
      float32x4_t source = vld1q_f32(sourceP);
      fourMax = vmaxq_f32(fourMax, vabsq_f32(source));
      sourceP += 4;
    }
    float32x2_t twoMax =
        vmax_f32(vget_low_f32(fourMax), vget_high_f32(fourMax));

    float groupMax[2];
    vst1_f32(groupMax, twoMax);
    max = std::max(groupMax[0], groupMax[1]);

    n = tailFrames;
  }
#endif

  while (n--) {
    max = std::max(max, fabsf(*sourceP));
    sourceP += sourceStride;
  }

  ASSERT(maxP);
  *maxP = max;
}

void vclip(const float* sourceP,
           int sourceStride,
           const float* lowThresholdP,
           const float* highThresholdP,
           float* destP,
           int destStride,
           size_t framesToProcess) {
  int n = framesToProcess;
  float lowThreshold = *lowThresholdP;
  float highThreshold = *highThresholdP;

// FIXME: Optimize for SSE2.
#if HAVE(ARM_NEON_INTRINSICS)
  if ((sourceStride == 1) && (destStride == 1)) {
    int tailFrames = n % 4;
    const float* endP = destP + n - tailFrames;

    float32x4_t low = vdupq_n_f32(lowThreshold);
    float32x4_t high = vdupq_n_f32(highThreshold);
    while (destP < endP) {
      float32x4_t source = vld1q_f32(sourceP);
      vst1q_f32(destP, vmaxq_f32(vminq_f32(source, high), low));
      sourceP += 4;
      destP += 4;
    }
    n = tailFrames;
  }
#endif
  while (n--) {
    *destP = clampTo(*sourceP, lowThreshold, highThreshold);
    sourceP += sourceStride;
    destP += destStride;
  }
}

#endif  // OS(MACOSX)

}  // namespace VectorMath

}  // namespace blink