DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7007 Commits
9 Branches
440MB
Tree: 4c59a920b4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4c59a920b4'
${ noResults }
JUCE/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1177 lines
53KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2016 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of the ISC license

  8.    http://www.isc.org/downloads/software-support-policy/isc-license/

  9. 

  10.    Permission to use, copy, modify, and/or distribute this software for any

  11.    purpose with or without fee is hereby granted, provided that the above

  12.    copyright notice and this permission notice appear in all copies.

  13. 

  14.    THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH REGARD

  15.    TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND

  16.    FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT,

  17.    OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF

  18.    USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER

  19.    TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE

  20.    OF THIS SOFTWARE.

  21. 

  22.    -----------------------------------------------------------------------------

  23. 

  24.    To release a closed-source product which uses other parts of JUCE not

  25.    licensed under the ISC terms, commercial licenses are available: visit

  26.    www.juce.com for more information.

  27. 

  28.   ==============================================================================

  29. */

  30. 

  31. namespace FloatVectorHelpers

  32. {

  33.     #define JUCE_INCREMENT_SRC_DEST         dest += (16 / sizeof (*dest)); src += (16 / sizeof (*dest));

  34.     #define JUCE_INCREMENT_SRC1_SRC2_DEST   dest += (16 / sizeof (*dest)); src1 += (16 / sizeof (*dest)); src2 += (16 / sizeof (*dest));

  35.     #define JUCE_INCREMENT_DEST             dest += (16 / sizeof (*dest));

  36. 

  37.    #if JUCE_USE_SSE_INTRINSICS

  38.     inline static bool isAligned (const void* p) noexcept

  39.     {

  40.         return (((pointer_sized_int) p) & 15) == 0;

  41.     }

  42. 

  43.     struct BasicOps32

  44.     {

  45.         typedef float Type;

  46.         typedef __m128 ParallelType;

  47.         typedef __m128 IntegerType;

  48.         enum { numParallel = 4 };

  49. 

  50.         // Integer and parallel types are the same for SSE. On neon they have different types

  51.         static forcedinline IntegerType toint (ParallelType v) noexcept                 { return v; }

  52.         static forcedinline ParallelType toflt (IntegerType v) noexcept                 { return v; }

  53. 

  54.         static forcedinline ParallelType load1 (Type v) noexcept                        { return _mm_load1_ps (&v); }

  55.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return _mm_load_ps (v); }

  56.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return _mm_loadu_ps (v); }

  57.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { _mm_store_ps (dest, a); }

  58.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { _mm_storeu_ps (dest, a); }

  59. 

  60.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return _mm_add_ps (a, b); }

  61.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return _mm_sub_ps (a, b); }

  62.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return _mm_mul_ps (a, b); }

  63.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return _mm_max_ps (a, b); }

  64.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return _mm_min_ps (a, b); }

  65. 

  66.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  { return _mm_and_ps (a, b); }

  67.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  { return _mm_andnot_ps (a, b); }

  68.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  { return _mm_or_ps (a, b); }

  69.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  { return _mm_xor_ps (a, b); }

  70. 

  71.         static forcedinline Type max (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmax (v[0], v[1], v[2], v[3]); }

  72.         static forcedinline Type min (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmin (v[0], v[1], v[2], v[3]); }

  73.     };

  74. 

  75.     struct BasicOps64

  76.     {

  77.         typedef double Type;

  78.         typedef __m128d ParallelType;

  79.         typedef __m128d IntegerType;

  80.         enum { numParallel = 2 };

  81. 

  82.         // Integer and parallel types are the same for SSE. On neon they have different types

  83.         static forcedinline IntegerType toint (ParallelType v) noexcept                 { return v; }

  84.         static forcedinline ParallelType toflt (IntegerType v) noexcept                 { return v; }

  85. 

  86.         static forcedinline ParallelType load1 (Type v) noexcept                        { return _mm_load1_pd (&v); }

  87.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return _mm_load_pd (v); }

  88.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return _mm_loadu_pd (v); }

  89.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { _mm_store_pd (dest, a); }

  90.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { _mm_storeu_pd (dest, a); }

  91. 

  92.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return _mm_add_pd (a, b); }

  93.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return _mm_sub_pd (a, b); }

  94.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return _mm_mul_pd (a, b); }

  95.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return _mm_max_pd (a, b); }

  96.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return _mm_min_pd (a, b); }

  97. 

  98.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  { return _mm_and_pd (a, b); }

  99.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  { return _mm_andnot_pd (a, b); }

  100.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  { return _mm_or_pd (a, b); }

  101.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  { return _mm_xor_pd (a, b); }

  102. 

  103.         static forcedinline Type max (ParallelType a) noexcept  { Type v[numParallel]; storeU (v, a); return jmax (v[0], v[1]); }

  104.         static forcedinline Type min (ParallelType a) noexcept  { Type v[numParallel]; storeU (v, a); return jmin (v[0], v[1]); }

  105.     };

  106. 

  107. 

  108. 

  109.     #define JUCE_BEGIN_VEC_OP \

  110.         typedef FloatVectorHelpers::ModeType<sizeof(*dest)>::Mode Mode; \

  111.         { \

  112.             const int numLongOps = num / Mode::numParallel;

  113. 

  114.     #define JUCE_FINISH_VEC_OP(normalOp) \

  115.             num &= (Mode::numParallel - 1); \

  116.             if (num == 0) return; \

  117.         } \

  118.         for (int i = 0; i < num; ++i) normalOp;

  119. 

  120.     #define JUCE_PERFORM_VEC_OP_DEST(normalOp, vecOp, locals, setupOp) \

  121.         JUCE_BEGIN_VEC_OP \

  122.         setupOp \

  123.         if (FloatVectorHelpers::isAligned (dest))   JUCE_VEC_LOOP (vecOp, dummy, Mode::loadA, Mode::storeA, locals, JUCE_INCREMENT_DEST) \

  124.         else                                        JUCE_VEC_LOOP (vecOp, dummy, Mode::loadU, Mode::storeU, locals, JUCE_INCREMENT_DEST) \

  125.         JUCE_FINISH_VEC_OP (normalOp)

  126. 

  127.     #define JUCE_PERFORM_VEC_OP_SRC_DEST(normalOp, vecOp, locals, increment, setupOp) \

  128.         JUCE_BEGIN_VEC_OP \

  129.         setupOp \

  130.         if (FloatVectorHelpers::isAligned (dest)) \

  131.         { \

  132.             if (FloatVectorHelpers::isAligned (src)) JUCE_VEC_LOOP (vecOp, Mode::loadA, Mode::loadA, Mode::storeA, locals, increment) \

  133.             else                                     JUCE_VEC_LOOP (vecOp, Mode::loadU, Mode::loadA, Mode::storeA, locals, increment) \

  134.         }\

  135.         else \

  136.         { \

  137.             if (FloatVectorHelpers::isAligned (src)) JUCE_VEC_LOOP (vecOp, Mode::loadA, Mode::loadU, Mode::storeU, locals, increment) \

  138.             else                                     JUCE_VEC_LOOP (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  139.         } \

  140.         JUCE_FINISH_VEC_OP (normalOp)

  141. 

  142.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST(normalOp, vecOp, locals, increment, setupOp) \

  143.         JUCE_BEGIN_VEC_OP \

  144.         setupOp \

  145.         if (FloatVectorHelpers::isAligned (dest)) \

  146.         { \

  147.             if (FloatVectorHelpers::isAligned (src1)) \

  148.             { \

  149.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadA, Mode::loadA, Mode::storeA, locals, increment) \

  150.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadA, Mode::loadU, Mode::storeA, locals, increment) \

  151.             } \

  152.             else \

  153.             { \

  154.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadU, Mode::loadA, Mode::storeA, locals, increment) \

  155.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadU, Mode::loadU, Mode::storeA, locals, increment) \

  156.             } \

  157.         } \

  158.         else \

  159.         { \

  160.             if (FloatVectorHelpers::isAligned (src1)) \

  161.             { \

  162.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadA, Mode::loadA, Mode::storeU, locals, increment) \

  163.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadA, Mode::loadU, Mode::storeU, locals, increment) \

  164.             } \

  165.             else \

  166.             { \

  167.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadU, Mode::loadA, Mode::storeU, locals, increment) \

  168.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  169.             } \

  170.         } \

  171.         JUCE_FINISH_VEC_OP (normalOp)

  172. 

  173.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST(normalOp, vecOp, locals, increment, setupOp) \

  174.         JUCE_BEGIN_VEC_OP \

  175.         setupOp \

  176.         if (FloatVectorHelpers::isAligned (dest)) \

  177.         { \

  178.             if (FloatVectorHelpers::isAligned (src1)) \

  179.             { \

  180.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadA, Mode::loadA, Mode::loadA, Mode::storeA, locals, increment) \

  181.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadA, Mode::loadU, Mode::loadA, Mode::storeA, locals, increment) \

  182.             } \

  183.             else \

  184.             { \

  185.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadU, Mode::loadA, Mode::loadA, Mode::storeA, locals, increment) \

  186.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadU, Mode::loadU, Mode::loadA, Mode::storeA, locals, increment) \

  187.             } \

  188.         } \

  189.         else \

  190.         { \

  191.             if (FloatVectorHelpers::isAligned (src1)) \

  192.             { \

  193.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadA, Mode::loadA, Mode::loadU, Mode::storeU, locals, increment) \

  194.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadA, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  195.             } \

  196.             else \

  197.             { \

  198.                 if (FloatVectorHelpers::isAligned (src2))   JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadU, Mode::loadA, Mode::loadU, Mode::storeU, locals, increment) \

  199.                 else                                        JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadU, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  200.             } \

  201.         } \

  202.         JUCE_FINISH_VEC_OP (normalOp)

  203. 

  204. 

  205.     //==============================================================================

  206.    #elif JUCE_USE_ARM_NEON

  207. 

  208.     struct BasicOps32

  209.     {

  210.         typedef float Type;

  211.         typedef float32x4_t ParallelType;

  212.         typedef uint32x4_t IntegerType;

  213.         union signMaskUnion { ParallelType f; IntegerType i; };

  214.         enum { numParallel = 4 };

  215. 

  216.         static forcedinline IntegerType toint (ParallelType v) noexcept                 { signMaskUnion u; u.f = v; return u.i; }

  217.         static forcedinline ParallelType toflt (IntegerType v) noexcept                 { signMaskUnion u; u.i = v; return u.f; }

  218. 

  219.         static forcedinline ParallelType load1 (Type v) noexcept                        { return vld1q_dup_f32 (&v); }

  220.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return vld1q_f32 (v); }

  221.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return vld1q_f32 (v); }

  222.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { vst1q_f32 (dest, a); }

  223.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { vst1q_f32 (dest, a); }

  224. 

  225.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return vaddq_f32 (a, b); }

  226.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return vsubq_f32 (a, b); }

  227.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return vmulq_f32 (a, b); }

  228.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return vmaxq_f32 (a, b); }

  229.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return vminq_f32 (a, b); }

  230. 

  231.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  {  return toflt (vandq_u32 (toint (a), toint (b))); }

  232.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  {  return toflt (vbicq_u32 (toint (a), toint (b))); }

  233.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  {  return toflt (vorrq_u32 (toint (a), toint (b))); }

  234.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  {  return toflt (veorq_u32 (toint (a), toint (b))); }

  235. 

  236.         static forcedinline Type max (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmax (v[0], v[1], v[2], v[3]); }

  237.         static forcedinline Type min (ParallelType a) noexcept { Type v[numParallel]; storeU (v, a); return jmin (v[0], v[1], v[2], v[3]); }

  238.     };

  239. 

  240.     struct BasicOps64

  241.     {

  242.         typedef double Type;

  243.         typedef double ParallelType;

  244.         typedef uint64 IntegerType;

  245.         union signMaskUnion { ParallelType f; IntegerType i; };

  246.         enum { numParallel = 1 };

  247. 

  248.         static forcedinline IntegerType toint (ParallelType v) noexcept                 { signMaskUnion u; u.f = v; return u.i; }

  249.         static forcedinline ParallelType toflt (IntegerType v) noexcept                 { signMaskUnion u; u.i = v; return u.f; }

  250. 

  251.         static forcedinline ParallelType load1 (Type v) noexcept                        { return v; }

  252.         static forcedinline ParallelType loadA (const Type* v) noexcept                 { return *v; }

  253.         static forcedinline ParallelType loadU (const Type* v) noexcept                 { return *v; }

  254.         static forcedinline void storeA (Type* dest, ParallelType a) noexcept           { *dest = a; }

  255.         static forcedinline void storeU (Type* dest, ParallelType a) noexcept           { *dest = a; }

  256. 

  257.         static forcedinline ParallelType add (ParallelType a, ParallelType b) noexcept  { return a + b; }

  258.         static forcedinline ParallelType sub (ParallelType a, ParallelType b) noexcept  { return a - b; }

  259.         static forcedinline ParallelType mul (ParallelType a, ParallelType b) noexcept  { return a * b; }

  260.         static forcedinline ParallelType max (ParallelType a, ParallelType b) noexcept  { return jmax (a, b); }

  261.         static forcedinline ParallelType min (ParallelType a, ParallelType b) noexcept  { return jmin (a, b); }

  262. 

  263.         static forcedinline ParallelType bit_and (ParallelType a, ParallelType b) noexcept  {  return toflt (toint (a) & toint (b)); }

  264.         static forcedinline ParallelType bit_not (ParallelType a, ParallelType b) noexcept  {  return toflt ((~toint (a)) & toint (b)); }

  265.         static forcedinline ParallelType bit_or  (ParallelType a, ParallelType b) noexcept  {  return toflt (toint (a) | toint (b)); }

  266.         static forcedinline ParallelType bit_xor (ParallelType a, ParallelType b) noexcept  {  return toflt (toint (a) ^ toint (b)); }

  267. 

  268.         static forcedinline Type max (ParallelType a) noexcept  { return a; }

  269.         static forcedinline Type min (ParallelType a) noexcept  { return a; }

  270.     };

  271. 

  272.     #define JUCE_BEGIN_VEC_OP \

  273.         typedef FloatVectorHelpers::ModeType<sizeof(*dest)>::Mode Mode; \

  274.         if (Mode::numParallel > 1) \

  275.         { \

  276.             const int numLongOps = num / Mode::numParallel;

  277. 

  278.     #define JUCE_FINISH_VEC_OP(normalOp) \

  279.             num &= (Mode::numParallel - 1); \

  280.             if (num == 0) return; \

  281.         } \

  282.         for (int i = 0; i < num; ++i) normalOp;

  283. 

  284.     #define JUCE_PERFORM_VEC_OP_DEST(normalOp, vecOp, locals, setupOp) \

  285.         JUCE_BEGIN_VEC_OP \

  286.         setupOp \

  287.         JUCE_VEC_LOOP (vecOp, dummy, Mode::loadU, Mode::storeU, locals, JUCE_INCREMENT_DEST) \

  288.         JUCE_FINISH_VEC_OP (normalOp)

  289. 

  290.     #define JUCE_PERFORM_VEC_OP_SRC_DEST(normalOp, vecOp, locals, increment, setupOp) \

  291.         JUCE_BEGIN_VEC_OP \

  292.         setupOp \

  293.         JUCE_VEC_LOOP (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  294.         JUCE_FINISH_VEC_OP (normalOp)

  295. 

  296.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST(normalOp, vecOp, locals, increment, setupOp) \

  297.         JUCE_BEGIN_VEC_OP \

  298.         setupOp \

  299.         JUCE_VEC_LOOP_TWO_SOURCES (vecOp, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  300.         JUCE_FINISH_VEC_OP (normalOp)

  301. 

  302.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST(normalOp, vecOp, locals, increment, setupOp) \

  303.         JUCE_BEGIN_VEC_OP \

  304.         setupOp \

  305.         JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD (vecOp, Mode::loadU, Mode::loadU, Mode::loadU, Mode::storeU, locals, increment) \

  306.         JUCE_FINISH_VEC_OP (normalOp)

  307. 

  308. 

  309.     //==============================================================================

  310.    #else

  311.     #define JUCE_PERFORM_VEC_OP_DEST(normalOp, vecOp, locals, setupOp) \

  312.         for (int i = 0; i < num; ++i) normalOp;

  313. 

  314.     #define JUCE_PERFORM_VEC_OP_SRC_DEST(normalOp, vecOp, locals, increment, setupOp) \

  315.         for (int i = 0; i < num; ++i) normalOp;

  316. 

  317.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST(normalOp, vecOp, locals, increment, setupOp) \

  318.         for (int i = 0; i < num; ++i) normalOp;

  319. 

  320.     #define JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST(normalOp, vecOp, locals, increment, setupOp) \

  321.         for (int i = 0; i < num; ++i) normalOp;

  322. 

  323.    #endif

  324. 

  325.     //==============================================================================

  326.     #define JUCE_VEC_LOOP(vecOp, srcLoad, dstLoad, dstStore, locals, increment) \

  327.         for (int i = 0; i < numLongOps; ++i) \

  328.         { \

  329.             locals (srcLoad, dstLoad); \

  330.             dstStore (dest, vecOp); \

  331.             increment; \

  332.         }

  333. 

  334.     #define JUCE_VEC_LOOP_TWO_SOURCES(vecOp, src1Load, src2Load, dstStore, locals, increment) \

  335.         for (int i = 0; i < numLongOps; ++i) \

  336.         { \

  337.             locals (src1Load, src2Load); \

  338.             dstStore (dest, vecOp); \

  339.             increment; \

  340.         }

  341. 

  342.     #define JUCE_VEC_LOOP_TWO_SOURCES_WITH_DEST_LOAD(vecOp, src1Load, src2Load, dstLoad, dstStore, locals, increment) \

  343.         for (int i = 0; i < numLongOps; ++i) \

  344.         { \

  345.             locals (src1Load, src2Load, dstLoad); \

  346.             dstStore (dest, vecOp); \

  347.             increment; \

  348.         }

  349. 

  350.     #define JUCE_LOAD_NONE(srcLoad, dstLoad)

  351.     #define JUCE_LOAD_DEST(srcLoad, dstLoad)                        const Mode::ParallelType d = dstLoad (dest);

  352.     #define JUCE_LOAD_SRC(srcLoad, dstLoad)                         const Mode::ParallelType s = srcLoad (src);

  353.     #define JUCE_LOAD_SRC1_SRC2(src1Load, src2Load)                 const Mode::ParallelType s1 = src1Load (src1), s2 = src2Load (src2);

  354.     #define JUCE_LOAD_SRC1_SRC2_DEST(src1Load, src2Load, dstLoad)   const Mode::ParallelType d = dstLoad (dest), s1 = src1Load (src1), s2 = src2Load (src2);

  355.     #define JUCE_LOAD_SRC_DEST(srcLoad, dstLoad)                    const Mode::ParallelType d = dstLoad (dest), s = srcLoad (src);

  356. 

  357.     union signMask32 { float  f; uint32 i; };

  358.     union signMask64 { double d; uint64 i; };

  359. 

  360.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  361.     template<int typeSize> struct ModeType    { typedef BasicOps32 Mode; };

  362.     template<>             struct ModeType<8> { typedef BasicOps64 Mode; };

  363. 

  364.     template <typename Mode>

  365.     struct MinMax

  366.     {

  367.         typedef typename Mode::Type Type;

  368.         typedef typename Mode::ParallelType ParallelType;

  369. 

  370.         static Type findMinOrMax (const Type* src, int num, const bool isMinimum) noexcept

  371.         {

  372.             int numLongOps = num / Mode::numParallel;

  373. 

  374.             if (numLongOps > 1)

  375.             {

  376.                 ParallelType val;

  377. 

  378.                #if ! JUCE_USE_ARM_NEON

  379.                 if (isAligned (src))

  380.                 {

  381.                     val = Mode::loadA (src);

  382. 

  383.                     if (isMinimum)

  384.                     {

  385.                         while (--numLongOps > 0)

  386.                         {

  387.                             src += Mode::numParallel;

  388.                             val = Mode::min (val, Mode::loadA (src));

  389.                         }

  390.                     }

  391.                     else

  392.                     {

  393.                         while (--numLongOps > 0)

  394.                         {

  395.                             src += Mode::numParallel;

  396.                             val = Mode::max (val, Mode::loadA (src));

  397.                         }

  398.                     }

  399.                 }

  400.                 else

  401.                #endif

  402.                 {

  403.                     val = Mode::loadU (src);

  404. 

  405.                     if (isMinimum)

  406.                     {

  407.                         while (--numLongOps > 0)

  408.                         {

  409.                             src += Mode::numParallel;

  410.                             val = Mode::min (val, Mode::loadU (src));

  411.                         }

  412.                     }

  413.                     else

  414.                     {

  415.                         while (--numLongOps > 0)

  416.                         {

  417.                             src += Mode::numParallel;

  418.                             val = Mode::max (val, Mode::loadU (src));

  419.                         }

  420.                     }

  421.                 }

  422. 

  423.                 Type result = isMinimum ? Mode::min (val)

  424.                                         : Mode::max (val);

  425. 

  426.                 num &= (Mode::numParallel - 1);

  427.                 src += Mode::numParallel;

  428. 

  429.                 for (int i = 0; i < num; ++i)

  430.                     result = isMinimum ? jmin (result, src[i])

  431.                                        : jmax (result, src[i]);

  432. 

  433.                 return result;

  434.             }

  435. 

  436.             return isMinimum ? juce::findMinimum (src, num)

  437.                              : juce::findMaximum (src, num);

  438.         }

  439. 

  440.         static Range<Type> findMinAndMax (const Type* src, int num) noexcept

  441.         {

  442.             int numLongOps = num / Mode::numParallel;

  443. 

  444.             if (numLongOps > 1)

  445.             {

  446.                 ParallelType mn, mx;

  447. 

  448.                #if ! JUCE_USE_ARM_NEON

  449.                 if (isAligned (src))

  450.                 {

  451.                     mn = Mode::loadA (src);

  452.                     mx = mn;

  453. 

  454.                     while (--numLongOps > 0)

  455.                     {

  456.                         src += Mode::numParallel;

  457.                         const ParallelType v = Mode::loadA (src);

  458.                         mn = Mode::min (mn, v);

  459.                         mx = Mode::max (mx, v);

  460.                     }

  461.                 }

  462.                 else

  463.                #endif

  464.                 {

  465.                     mn = Mode::loadU (src);

  466.                     mx = mn;

  467. 

  468.                     while (--numLongOps > 0)

  469.                     {

  470.                         src += Mode::numParallel;

  471.                         const ParallelType v = Mode::loadU (src);

  472.                         mn = Mode::min (mn, v);

  473.                         mx = Mode::max (mx, v);

  474.                     }

  475.                 }

  476. 

  477.                 Range<Type> result (Mode::min (mn),

  478.                                     Mode::max (mx));

  479. 

  480.                 num &= (Mode::numParallel - 1);

  481.                 src += Mode::numParallel;

  482. 

  483.                 for (int i = 0; i < num; ++i)

  484.                     result = result.getUnionWith (src[i]);

  485. 

  486.                 return result;

  487.             }

  488. 

  489.             return Range<Type>::findMinAndMax (src, num);

  490.         }

  491.     };

  492.    #endif

  493. }

  494. 

  495. //==============================================================================

  496. namespace

  497. {

  498.    #if JUCE_USE_VDSP_FRAMEWORK

  499.     // This casts away constness to account for slightly different vDSP function signatures

  500.     // in OSX 10.8 SDK and below. Can be safely removed once those SDKs are obsolete.

  501.     template <typename ValueType>

  502.     ValueType* osx108sdkCompatibilityCast (const ValueType* arg) noexcept { return const_cast<ValueType*> (arg); }

  503.    #endif

  504. }

  505. 

  506. //==============================================================================

  507. void JUCE_CALLTYPE FloatVectorOperations::clear (float* dest, int num) noexcept

  508. {

  509.    #if JUCE_USE_VDSP_FRAMEWORK

  510.     vDSP_vclr (dest, 1, (size_t) num);

  511.    #else

  512.     zeromem (dest, (size_t) num * sizeof (float));

  513.    #endif

  514. }

  515. 

  516. void JUCE_CALLTYPE FloatVectorOperations::clear (double* dest, int num) noexcept

  517. {

  518.    #if JUCE_USE_VDSP_FRAMEWORK

  519.     vDSP_vclrD (dest, 1, (size_t) num);

  520.    #else

  521.     zeromem (dest, (size_t) num * sizeof (double));

  522.    #endif

  523. }

  524. 

  525. void JUCE_CALLTYPE FloatVectorOperations::fill (float* dest, float valueToFill, int num) noexcept

  526. {

  527.    #if JUCE_USE_VDSP_FRAMEWORK

  528.     vDSP_vfill (&valueToFill, dest, 1, (size_t) num);

  529.    #else

  530.     JUCE_PERFORM_VEC_OP_DEST (dest[i] = valueToFill, val, JUCE_LOAD_NONE,

  531.                               const Mode::ParallelType val = Mode::load1 (valueToFill);)

  532.    #endif

  533. }

  534. 

  535. void JUCE_CALLTYPE FloatVectorOperations::fill (double* dest, double valueToFill, int num) noexcept

  536. {

  537.    #if JUCE_USE_VDSP_FRAMEWORK

  538.     vDSP_vfillD (&valueToFill, dest, 1, (size_t) num);

  539.    #else

  540.     JUCE_PERFORM_VEC_OP_DEST (dest[i] = valueToFill, val, JUCE_LOAD_NONE,

  541.                               const Mode::ParallelType val = Mode::load1 (valueToFill);)

  542.    #endif

  543. }

  544. 

  545. void JUCE_CALLTYPE FloatVectorOperations::copy (float* dest, const float* src, int num) noexcept

  546. {

  547.     memcpy (dest, src, (size_t) num * sizeof (float));

  548. }

  549. 

  550. void JUCE_CALLTYPE FloatVectorOperations::copy (double* dest, const double* src, int num) noexcept

  551. {

  552.     memcpy (dest, src, (size_t) num * sizeof (double));

  553. }

  554. 

  555. void JUCE_CALLTYPE FloatVectorOperations::copyWithMultiply (float* dest, const float* src, float multiplier, int num) noexcept

  556. {

  557.    #if JUCE_USE_VDSP_FRAMEWORK

  558.     vDSP_vsmul (src, 1, &multiplier, dest, 1, (vDSP_Length) num);

  559.    #else

  560.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  561.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  562.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  563.    #endif

  564. }

  565. 

  566. void JUCE_CALLTYPE FloatVectorOperations::copyWithMultiply (double* dest, const double* src, double multiplier, int num) noexcept

  567. {

  568.    #if JUCE_USE_VDSP_FRAMEWORK

  569.     vDSP_vsmulD (src, 1, &multiplier, dest, 1, (vDSP_Length) num);

  570.    #else

  571.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  572.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  573.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  574.    #endif

  575. }

  576. 

  577. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, float amount, int num) noexcept

  578. {

  579.    #if JUCE_USE_VDSP_FRAMEWORK

  580.     vDSP_vsadd (dest, 1, &amount, dest, 1, (vDSP_Length) num);

  581.    #else

  582.     JUCE_PERFORM_VEC_OP_DEST (dest[i] += amount, Mode::add (d, amountToAdd), JUCE_LOAD_DEST,

  583.                               const Mode::ParallelType amountToAdd = Mode::load1 (amount);)

  584.    #endif

  585. }

  586. 

  587. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, double amount, int num) noexcept

  588. {

  589.     JUCE_PERFORM_VEC_OP_DEST (dest[i] += amount, Mode::add (d, amountToAdd), JUCE_LOAD_DEST,

  590.                               const Mode::ParallelType amountToAdd = Mode::load1 (amount);)

  591. }

  592. 

  593. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, const float* src, float amount, int num) noexcept

  594. {

  595.    #if JUCE_USE_VDSP_FRAMEWORK

  596.     vDSP_vsadd (osx108sdkCompatibilityCast (src), 1, &amount, dest, 1, (vDSP_Length) num);

  597.    #else

  598.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] + amount, Mode::add (am, s),

  599.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  600.                                   const Mode::ParallelType am = Mode::load1 (amount);)

  601.    #endif

  602. }

  603. 

  604. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, const double* src, double amount, int num) noexcept

  605. {

  606.    #if JUCE_USE_VDSP_FRAMEWORK

  607.     vDSP_vsaddD (osx108sdkCompatibilityCast (src), 1, &amount, dest, 1, (vDSP_Length) num);

  608.    #else

  609.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] + amount, Mode::add (am, s),

  610.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  611.                                   const Mode::ParallelType am = Mode::load1 (amount);)

  612.    #endif

  613. }

  614. 

  615. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, const float* src, int num) noexcept

  616. {

  617.    #if JUCE_USE_VDSP_FRAMEWORK

  618.     vDSP_vadd (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  619.    #else

  620.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i], Mode::add (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  621.    #endif

  622. }

  623. 

  624. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, const double* src, int num) noexcept

  625. {

  626.    #if JUCE_USE_VDSP_FRAMEWORK

  627.     vDSP_vaddD (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  628.    #else

  629.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i], Mode::add (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  630.    #endif

  631. }

  632. 

  633. void JUCE_CALLTYPE FloatVectorOperations::add (float* dest, const float* src1, const float* src2, int num) noexcept

  634. {

  635.    #if JUCE_USE_VDSP_FRAMEWORK

  636.     vDSP_vadd (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  637.    #else

  638.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] + src2[i], Mode::add (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  639.    #endif

  640. }

  641. 

  642. void JUCE_CALLTYPE FloatVectorOperations::add (double* dest, const double* src1, const double* src2, int num) noexcept

  643. {

  644.    #if JUCE_USE_VDSP_FRAMEWORK

  645.     vDSP_vaddD (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  646.    #else

  647.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] + src2[i], Mode::add (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  648.    #endif

  649. }

  650. 

  651. void JUCE_CALLTYPE FloatVectorOperations::subtract (float* dest, const float* src, int num) noexcept

  652. {

  653.    #if JUCE_USE_VDSP_FRAMEWORK

  654.     vDSP_vsub (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  655.    #else

  656.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] -= src[i], Mode::sub (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  657.    #endif

  658. }

  659. 

  660. void JUCE_CALLTYPE FloatVectorOperations::subtract (double* dest, const double* src, int num) noexcept

  661. {

  662.    #if JUCE_USE_VDSP_FRAMEWORK

  663.     vDSP_vsubD (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  664.    #else

  665.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] -= src[i], Mode::sub (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  666.    #endif

  667. }

  668. 

  669. void JUCE_CALLTYPE FloatVectorOperations::subtract (float* dest, const float* src1, const float* src2, int num) noexcept

  670. {

  671.    #if JUCE_USE_VDSP_FRAMEWORK

  672.     vDSP_vsub (src2, 1, src1, 1, dest, 1, (vDSP_Length) num);

  673.    #else

  674.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] - src2[i], Mode::sub (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  675.    #endif

  676. }

  677. 

  678. void JUCE_CALLTYPE FloatVectorOperations::subtract (double* dest, const double* src1, const double* src2, int num) noexcept

  679. {

  680.    #if JUCE_USE_VDSP_FRAMEWORK

  681.     vDSP_vsubD (src2, 1, src1, 1, dest, 1, (vDSP_Length) num);

  682.    #else

  683.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] - src2[i], Mode::sub (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  684.    #endif

  685. }

  686. 

  687. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (float* dest, const float* src, float multiplier, int num) noexcept

  688. {

  689.    #if JUCE_USE_VDSP_FRAMEWORK

  690.     vDSP_vsma (src, 1, &multiplier, dest, 1, dest, 1, (vDSP_Length) num);

  691.    #else

  692.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i] * multiplier, Mode::add (d, Mode::mul (mult, s)),

  693.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

  694.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  695.    #endif

  696. }

  697. 

  698. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (double* dest, const double* src, double multiplier, int num) noexcept

  699. {

  700.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] += src[i] * multiplier, Mode::add (d, Mode::mul (mult, s)),

  701.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

  702.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  703. }

  704. 

  705. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (float* dest, const float* src1, const float* src2, int num) noexcept

  706. {

  707.    #if JUCE_USE_VDSP_FRAMEWORK

  708.     vDSP_vma ((float*) src1, 1, (float*) src2, 1, dest, 1, dest, 1, (vDSP_Length) num);

  709.    #else

  710.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST (dest[i] += src1[i] * src2[i], Mode::add (d, Mode::mul (s1, s2)),

  711.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  712.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  713.    #endif

  714. }

  715. 

  716. void JUCE_CALLTYPE FloatVectorOperations::addWithMultiply (double* dest, const double* src1, const double* src2, int num) noexcept

  717. {

  718.    #if JUCE_USE_VDSP_FRAMEWORK

  719.     vDSP_vmaD ((double*) src1, 1, (double*) src2, 1, dest, 1, dest, 1, (vDSP_Length) num);

  720.    #else

  721.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST (dest[i] += src1[i] * src2[i], Mode::add (d, Mode::mul (s1, s2)),

  722.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  723.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  724.    #endif

  725. }

  726. 

  727. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, const float* src, int num) noexcept

  728. {

  729.    #if JUCE_USE_VDSP_FRAMEWORK

  730.     vDSP_vmul (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  731.    #else

  732.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] *= src[i], Mode::mul (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  733.    #endif

  734. }

  735. 

  736. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, const double* src, int num) noexcept

  737. {

  738.    #if JUCE_USE_VDSP_FRAMEWORK

  739.     vDSP_vmulD (src, 1, dest, 1, dest, 1, (vDSP_Length) num);

  740.    #else

  741.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] *= src[i], Mode::mul (d, s), JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST, )

  742.    #endif

  743. }

  744. 

  745. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, const float* src1, const float* src2, int num) noexcept

  746. {

  747.    #if JUCE_USE_VDSP_FRAMEWORK

  748.     vDSP_vmul (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  749.    #else

  750.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] * src2[i], Mode::mul (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  751.    #endif

  752. }

  753. 

  754. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, const double* src1, const double* src2, int num) noexcept

  755. {

  756.    #if JUCE_USE_VDSP_FRAMEWORK

  757.     vDSP_vmulD (src1, 1, src2, 1, dest, 1, (vDSP_Length) num);

  758.    #else

  759.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = src1[i] * src2[i], Mode::mul (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  760.    #endif

  761. }

  762. 

  763. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, float multiplier, int num) noexcept

  764. {

  765.    #if JUCE_USE_VDSP_FRAMEWORK

  766.     vDSP_vsmul (dest, 1, &multiplier, dest, 1, (vDSP_Length) num);

  767.    #else

  768.     JUCE_PERFORM_VEC_OP_DEST (dest[i] *= multiplier, Mode::mul (d, mult), JUCE_LOAD_DEST,

  769.                               const Mode::ParallelType mult = Mode::load1 (multiplier);)

  770.    #endif

  771. }

  772. 

  773. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, double multiplier, int num) noexcept

  774. {

  775.    #if JUCE_USE_VDSP_FRAMEWORK

  776.     vDSP_vsmulD (dest, 1, &multiplier, dest, 1, (vDSP_Length) num);

  777.    #else

  778.     JUCE_PERFORM_VEC_OP_DEST (dest[i] *= multiplier, Mode::mul (d, mult), JUCE_LOAD_DEST,

  779.                               const Mode::ParallelType mult = Mode::load1 (multiplier);)

  780.    #endif

  781. }

  782. 

  783. void JUCE_CALLTYPE FloatVectorOperations::multiply (float* dest, const float* src, float multiplier, int num) noexcept

  784. {

  785.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  786.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  787.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  788. }

  789. 

  790. void JUCE_CALLTYPE FloatVectorOperations::multiply (double* dest, const double* src, double multiplier, int num) noexcept

  791. {

  792.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier, Mode::mul (mult, s),

  793.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  794.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  795. }

  796. 

  797. void FloatVectorOperations::negate (float* dest, const float* src, int num) noexcept

  798. {

  799.    #if JUCE_USE_VDSP_FRAMEWORK

  800.     vDSP_vneg ((float*) src, 1, dest, 1, (vDSP_Length) num);

  801.    #else

  802.     copyWithMultiply (dest, src, -1.0f, num);

  803.    #endif

  804. }

  805. 

  806. void FloatVectorOperations::negate (double* dest, const double* src, int num) noexcept

  807. {

  808.    #if JUCE_USE_VDSP_FRAMEWORK

  809.     vDSP_vnegD ((double*) src, 1, dest, 1, (vDSP_Length) num);

  810.    #else

  811.     copyWithMultiply (dest, src, -1.0f, num);

  812.    #endif

  813. }

  814. 

  815. void FloatVectorOperations::abs (float* dest, const float* src, int num) noexcept

  816. {

  817.    #if JUCE_USE_VDSP_FRAMEWORK

  818.     vDSP_vabs ((float*) src, 1, dest, 1, (vDSP_Length) num);

  819.    #else

  820.     FloatVectorHelpers::signMask32 signMask;

  821.     signMask.i = 0x7fffffffUL;

  822.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = fabsf (src[i]), Mode::bit_and (s, mask),

  823.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  824.                                   const Mode::ParallelType mask = Mode::load1 (signMask.f);)

  825. 

  826.     ignoreUnused (signMask);

  827.    #endif

  828. }

  829. 

  830. void FloatVectorOperations::abs (double* dest, const double* src, int num) noexcept

  831. {

  832.    #if JUCE_USE_VDSP_FRAMEWORK

  833.     vDSP_vabsD ((double*) src, 1, dest, 1, (vDSP_Length) num);

  834.    #else

  835.     FloatVectorHelpers::signMask64 signMask;

  836.     signMask.i = 0x7fffffffffffffffULL;

  837. 

  838.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = fabs (src[i]), Mode::bit_and (s, mask),

  839.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  840.                                   const Mode::ParallelType mask = Mode::load1 (signMask.d);)

  841. 

  842.     ignoreUnused (signMask);

  843.    #endif

  844. }

  845. 

  846. void JUCE_CALLTYPE FloatVectorOperations::convertFixedToFloat (float* dest, const int* src, float multiplier, int num) noexcept

  847. {

  848.    #if JUCE_USE_ARM_NEON

  849.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier,

  850.                                   vmulq_n_f32 (vcvtq_f32_s32 (vld1q_s32 (src)), multiplier),

  851.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  852.    #else

  853.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = src[i] * multiplier,

  854.                                   Mode::mul (mult, _mm_cvtepi32_ps (_mm_loadu_si128 ((const __m128i*) src))),

  855.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

  856.                                   const Mode::ParallelType mult = Mode::load1 (multiplier);)

  857.    #endif

  858. }

  859. 

  860. void JUCE_CALLTYPE FloatVectorOperations::min (float* dest, const float* src, float comp, int num) noexcept

  861. {

  862.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmin (src[i], comp), Mode::min (s, cmp),

  863.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  864.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  865. }

  866. 

  867. void JUCE_CALLTYPE FloatVectorOperations::min (double* dest, const double* src, double comp, int num) noexcept

  868. {

  869.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmin (src[i], comp), Mode::min (s, cmp),

  870.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  871.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  872. }

  873. 

  874. void JUCE_CALLTYPE FloatVectorOperations::min (float* dest, const float* src1, const float* src2, int num) noexcept

  875. {

  876.    #if JUCE_USE_VDSP_FRAMEWORK

  877.     vDSP_vmin ((float*) src1, 1, (float*) src2, 1, dest, 1, (vDSP_Length) num);

  878.    #else

  879.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmin (src1[i], src2[i]), Mode::min (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  880.    #endif

  881. }

  882. 

  883. void JUCE_CALLTYPE FloatVectorOperations::min (double* dest, const double* src1, const double* src2, int num) noexcept

  884. {

  885.    #if JUCE_USE_VDSP_FRAMEWORK

  886.     vDSP_vminD ((double*) src1, 1, (double*) src2, 1, dest, 1, (vDSP_Length) num);

  887.    #else

  888.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmin (src1[i], src2[i]), Mode::min (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  889.    #endif

  890. }

  891. 

  892. void JUCE_CALLTYPE FloatVectorOperations::max (float* dest, const float* src, float comp, int num) noexcept

  893. {

  894.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (src[i], comp), Mode::max (s, cmp),

  895.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  896.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  897. }

  898. 

  899. void JUCE_CALLTYPE FloatVectorOperations::max (double* dest, const double* src, double comp, int num) noexcept

  900. {

  901.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (src[i], comp), Mode::max (s, cmp),

  902.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  903.                                   const Mode::ParallelType cmp = Mode::load1 (comp);)

  904. }

  905. 

  906. void JUCE_CALLTYPE FloatVectorOperations::max (float* dest, const float* src1, const float* src2, int num) noexcept

  907. {

  908.    #if JUCE_USE_VDSP_FRAMEWORK

  909.     vDSP_vmax ((float*) src1, 1, (float*) src2, 1, dest, 1, (vDSP_Length) num);

  910.    #else

  911.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmax (src1[i], src2[i]), Mode::max (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  912.    #endif

  913. }

  914. 

  915. void JUCE_CALLTYPE FloatVectorOperations::max (double* dest, const double* src1, const double* src2, int num) noexcept

  916. {

  917.    #if JUCE_USE_VDSP_FRAMEWORK

  918.     vDSP_vmaxD ((double*) src1, 1, (double*) src2, 1, dest, 1, (vDSP_Length) num);

  919.    #else

  920.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST (dest[i] = jmax (src1[i], src2[i]), Mode::max (s1, s2), JUCE_LOAD_SRC1_SRC2, JUCE_INCREMENT_SRC1_SRC2_DEST, )

  921.    #endif

  922. }

  923. 

  924. void JUCE_CALLTYPE FloatVectorOperations::clip (float* dest, const float* src, float low, float high, int num) noexcept

  925. {

  926.     jassert(high >= low);

  927. 

  928.    #if JUCE_USE_VDSP_FRAMEWORK

  929.     vDSP_vclip ((float*) src, 1, &low, &high, dest, 1, (vDSP_Length) num);

  930.    #else

  931.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (jmin (src[i], high), low), Mode::max (Mode::min (s, hi), lo),

  932.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  933.                                   const Mode::ParallelType lo = Mode::load1 (low); const Mode::ParallelType hi = Mode::load1 (high);)

  934.    #endif

  935. }

  936. 

  937. void JUCE_CALLTYPE FloatVectorOperations::clip (double* dest, const double* src, double low, double high, int num) noexcept

  938. {

  939.     jassert(high >= low);

  940. 

  941.    #if JUCE_USE_VDSP_FRAMEWORK

  942.     vDSP_vclipD ((double*) src, 1, &low, &high, dest, 1, (vDSP_Length) num);

  943.    #else

  944.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmax (jmin (src[i], high), low), Mode::max (Mode::min (s, hi), lo),

  945.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

  946.                                   const Mode::ParallelType lo = Mode::load1 (low); const Mode::ParallelType hi = Mode::load1 (high);)

  947.    #endif

  948. }

  949. 

  950. Range<float> JUCE_CALLTYPE FloatVectorOperations::findMinAndMax (const float* src, int num) noexcept

  951. {

  952.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  953.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps32>::findMinAndMax (src, num);

  954.    #else

  955.     return Range<float>::findMinAndMax (src, num);

  956.    #endif

  957. }

  958. 

  959. Range<double> JUCE_CALLTYPE FloatVectorOperations::findMinAndMax (const double* src, int num) noexcept

  960. {

  961.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  962.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps64>::findMinAndMax (src, num);

  963.    #else

  964.     return Range<double>::findMinAndMax (src, num);

  965.    #endif

  966. }

  967. 

  968. float JUCE_CALLTYPE FloatVectorOperations::findMinimum (const float* src, int num) noexcept

  969. {

  970.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  971.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps32>::findMinOrMax (src, num, true);

  972.    #else

  973.     return juce::findMinimum (src, num);

  974.    #endif

  975. }

  976. 

  977. double JUCE_CALLTYPE FloatVectorOperations::findMinimum (const double* src, int num) noexcept

  978. {

  979.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  980.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps64>::findMinOrMax (src, num, true);

  981.    #else

  982.     return juce::findMinimum (src, num);

  983.    #endif

  984. }

  985. 

  986. float JUCE_CALLTYPE FloatVectorOperations::findMaximum (const float* src, int num) noexcept

  987. {

  988.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  989.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps32>::findMinOrMax (src, num, false);

  990.    #else

  991.     return juce::findMaximum (src, num);

  992.    #endif

  993. }

  994. 

  995. double JUCE_CALLTYPE FloatVectorOperations::findMaximum (const double* src, int num) noexcept

  996. {

  997.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

  998.     return FloatVectorHelpers::MinMax<FloatVectorHelpers::BasicOps64>::findMinOrMax (src, num, false);

  999.    #else

  1000.     return juce::findMaximum (src, num);

  1001.    #endif

  1002. }

  1003. 

  1004. void JUCE_CALLTYPE FloatVectorOperations::enableFlushToZeroMode (bool shouldEnable) noexcept

  1005. {

  1006.    #if JUCE_USE_SSE_INTRINSICS

  1007.     _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  1008.    #endif

  1009.     ignoreUnused (shouldEnable);

  1010. }

  1011. 

  1012. void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport() noexcept

  1013. {

  1014.    #if JUCE_USE_SSE_INTRINSICS

  1015.     const unsigned int mxcsr = _mm_getcsr();

  1016.     _mm_setcsr (mxcsr | 0x8040); // add the DAZ and FZ bits

  1017.    #endif

  1018. }

  1019. 

  1020. //==============================================================================

  1021. //==============================================================================

  1022. #if JUCE_UNIT_TESTS

  1023. 

  1024. class FloatVectorOperationsTests  : public UnitTest

  1025. {

  1026. public:

  1027.     FloatVectorOperationsTests() : UnitTest ("FloatVectorOperations") {}

  1028. 

  1029.     template <typename ValueType>

  1030.     struct TestRunner

  1031.     {

  1032.         static void runTest (UnitTest& u, Random random)

  1033.         {

  1034.             const int range = random.nextBool() ? 500 : 10;

  1035.             const int num = random.nextInt (range) + 1;

  1036. 

  1037.             HeapBlock<ValueType> buffer1 ((size_t) num + 16), buffer2 ((size_t) num + 16);

  1038.             HeapBlock<int> buffer3 ((size_t) num + 16);

  1039. 

  1040.            #if JUCE_ARM

  1041.             ValueType* const data1 = buffer1;

  1042.             ValueType* const data2 = buffer2;

  1043.             int* const int1 = buffer3;

  1044.            #else

  1045.             ValueType* const data1 = addBytesToPointer (buffer1.getData(), random.nextInt (16));

  1046.             ValueType* const data2 = addBytesToPointer (buffer2.getData(), random.nextInt (16));

  1047.             int* const int1 = addBytesToPointer (buffer3.getData(), random.nextInt (16));

  1048.            #endif

  1049. 

  1050.             fillRandomly (random, data1, num);

  1051.             fillRandomly (random, data2, num);

  1052. 

  1053.             Range<ValueType> minMax1 (FloatVectorOperations::findMinAndMax (data1, num));

  1054.             Range<ValueType> minMax2 (Range<ValueType>::findMinAndMax (data1, num));

  1055.             u.expect (minMax1 == minMax2);

  1056. 

  1057.             u.expect (valuesMatch (FloatVectorOperations::findMinimum (data1, num), juce::findMinimum (data1, num)));

  1058.             u.expect (valuesMatch (FloatVectorOperations::findMaximum (data1, num), juce::findMaximum (data1, num)));

  1059. 

  1060.             u.expect (valuesMatch (FloatVectorOperations::findMinimum (data2, num), juce::findMinimum (data2, num)));

  1061.             u.expect (valuesMatch (FloatVectorOperations::findMaximum (data2, num), juce::findMaximum (data2, num)));

  1062. 

  1063.             FloatVectorOperations::clear (data1, num);

  1064.             u.expect (areAllValuesEqual (data1, num, 0));

  1065. 

  1066.             FloatVectorOperations::fill (data1, (ValueType) 2, num);

  1067.             u.expect (areAllValuesEqual (data1, num, (ValueType) 2));

  1068. 

  1069.             FloatVectorOperations::add (data1, (ValueType) 2, num);

  1070.             u.expect (areAllValuesEqual (data1, num, (ValueType) 4));

  1071. 

  1072.             FloatVectorOperations::copy (data2, data1, num);

  1073.             u.expect (areAllValuesEqual (data2, num, (ValueType) 4));

  1074. 

  1075.             FloatVectorOperations::add (data2, data1, num);

  1076.             u.expect (areAllValuesEqual (data2, num, (ValueType) 8));

  1077. 

  1078.             FloatVectorOperations::copyWithMultiply (data2, data1, (ValueType) 4, num);

  1079.             u.expect (areAllValuesEqual (data2, num, (ValueType) 16));

  1080. 

  1081.             FloatVectorOperations::addWithMultiply (data2, data1, (ValueType) 4, num);

  1082.             u.expect (areAllValuesEqual (data2, num, (ValueType) 32));

  1083. 

  1084.             FloatVectorOperations::multiply (data1, (ValueType) 2, num);

  1085.             u.expect (areAllValuesEqual (data1, num, (ValueType) 8));

  1086. 

  1087.             FloatVectorOperations::multiply (data1, data2, num);

  1088.             u.expect (areAllValuesEqual (data1, num, (ValueType) 256));

  1089. 

  1090.             FloatVectorOperations::negate (data2, data1, num);

  1091.             u.expect (areAllValuesEqual (data2, num, (ValueType) -256));

  1092. 

  1093.             FloatVectorOperations::subtract (data1, data2, num);

  1094.             u.expect (areAllValuesEqual (data1, num, (ValueType) 512));

  1095. 

  1096.             FloatVectorOperations::abs (data1, data2, num);

  1097.             u.expect (areAllValuesEqual (data1, num, (ValueType) 256));

  1098. 

  1099.             FloatVectorOperations::abs (data2, data1, num);

  1100.             u.expect (areAllValuesEqual (data2, num, (ValueType) 256));

  1101. 

  1102.             fillRandomly (random, int1, num);

  1103.             doConversionTest (u, data1, data2, int1, num);

  1104. 

  1105.             FloatVectorOperations::fill (data1, (ValueType) 2, num);

  1106.             FloatVectorOperations::fill (data2, (ValueType) 3, num);

  1107.             FloatVectorOperations::addWithMultiply (data1, data1, data2, num);

  1108.             u.expect (areAllValuesEqual (data1, num, (ValueType) 8));

  1109.         }

  1110. 

  1111.         static void doConversionTest (UnitTest& u, float* data1, float* data2, int* const int1, int num)

  1112.         {

  1113.             FloatVectorOperations::convertFixedToFloat (data1, int1, 2.0f, num);

  1114.             convertFixed (data2, int1, 2.0f, num);

  1115.             u.expect (buffersMatch (data1, data2, num));

  1116.         }

  1117. 

  1118.         static void doConversionTest (UnitTest&, double*, double*, int*, int) {}

  1119. 

  1120.         static void fillRandomly (Random& random, ValueType* d, int num)

  1121.         {

  1122.             while (--num >= 0)

  1123.                 *d++ = (ValueType) (random.nextDouble() * 1000.0);

  1124.         }

  1125. 

  1126.         static void fillRandomly (Random& random, int* d, int num)

  1127.         {

  1128.             while (--num >= 0)

  1129.                 *d++ = random.nextInt();

  1130.         }

  1131. 

  1132.         static void convertFixed (float* d, const int* s, ValueType multiplier, int num)

  1133.         {

  1134.             while (--num >= 0)

  1135.                 *d++ = *s++ * multiplier;

  1136.         }

  1137. 

  1138.         static bool areAllValuesEqual (const ValueType* d, int num, ValueType target)

  1139.         {

  1140.             while (--num >= 0)

  1141.                 if (*d++ != target)

  1142.                     return false;

  1143. 

  1144.             return true;

  1145.         }

  1146. 

  1147.         static bool buffersMatch (const ValueType* d1, const ValueType* d2, int num)

  1148.         {

  1149.             while (--num >= 0)

  1150.                 if (! valuesMatch (*d1++, *d2++))

  1151.                     return false;

  1152. 

  1153.             return true;

  1154.         }

  1155. 

  1156.         static bool valuesMatch (ValueType v1, ValueType v2)

  1157.         {

  1158.             return std::abs (v1 - v2) < std::numeric_limits<ValueType>::epsilon();

  1159.         }

  1160.     };

  1161. 

  1162.     void runTest() override

  1163.     {

  1164.         beginTest ("FloatVectorOperations");

  1165. 

  1166.         for (int i = 1000; --i >= 0;)

  1167.         {

  1168.             TestRunner<float>::runTest (*this, getRandom());

  1169.             TestRunner<double>::runTest (*this, getRandom());

  1170.         }

  1171.     }

  1172. };

  1173. 

  1174. static FloatVectorOperationsTests vectorOpTests;

  1175. 

  1176. #endif