falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
3441 Commits
16 Branches
200MB
Tree: f9387f9a34
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f9387f9a34'
${ noResults }
Carla/source/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1173 lines
52KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. namespace FloatVectorHelpers

  26. {

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

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

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

  30. 

  31.    #if JUCE_USE_SSE_INTRINSICS

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

  33.     {

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

  35.     }

  36. 

  37.     struct BasicOps32

  38.     {

  39.         typedef float Type;

  40.         typedef __m128 ParallelType;

  41.         typedef __m128 IntegerType;

  42.         enum { numParallel = 4 };

  43. 

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

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

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

  47. 

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

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

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

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

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

  53. 

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

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

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

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

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

  59. 

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

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

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

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

  64. 

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

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

  67.     };

  68. 

  69.     struct BasicOps64

  70.     {

  71.         typedef double Type;

  72.         typedef __m128d ParallelType;

  73.         typedef __m128d IntegerType;

  74.         enum { numParallel = 2 };

  75. 

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

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

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

  79. 

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

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

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

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

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

  85. 

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

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

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

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

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

  91. 

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

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

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

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

  96. 

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

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

  99.     };

  100. 

  101. 

  102. 

  103.     #define JUCE_BEGIN_VEC_OP \

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

  105.         { \

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

  107. 

  108.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  111.         } \

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

  113. 

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

  115.         JUCE_BEGIN_VEC_OP \

  116.         setupOp \

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

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

  119.         JUCE_FINISH_VEC_OP (normalOp)

  120. 

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

  122.         JUCE_BEGIN_VEC_OP \

  123.         setupOp \

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

  125.         { \

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

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

  128.         }\

  129.         else \

  130.         { \

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

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

  133.         } \

  134.         JUCE_FINISH_VEC_OP (normalOp)

  135. 

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

  137.         JUCE_BEGIN_VEC_OP \

  138.         setupOp \

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

  140.         { \

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

  142.             { \

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

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

  145.             } \

  146.             else \

  147.             { \

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

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

  150.             } \

  151.         } \

  152.         else \

  153.         { \

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

  155.             { \

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

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

  158.             } \

  159.             else \

  160.             { \

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

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

  163.             } \

  164.         } \

  165.         JUCE_FINISH_VEC_OP (normalOp)

  166. 

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

  168.         JUCE_BEGIN_VEC_OP \

  169.         setupOp \

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

  171.         { \

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

  173.             { \

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

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

  176.             } \

  177.             else \

  178.             { \

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

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

  181.             } \

  182.         } \

  183.         else \

  184.         { \

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

  186.             { \

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

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

  189.             } \

  190.             else \

  191.             { \

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

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

  194.             } \

  195.         } \

  196.         JUCE_FINISH_VEC_OP (normalOp)

  197. 

  198. 

  199.     //==============================================================================

  200.    #elif JUCE_USE_ARM_NEON

  201. 

  202.     struct BasicOps32

  203.     {

  204.         typedef float Type;

  205.         typedef float32x4_t ParallelType;

  206.         typedef uint32x4_t IntegerType;

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

  208.         enum { numParallel = 4 };

  209. 

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

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

  212. 

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

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

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

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

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

  218. 

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

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

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

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

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

  224. 

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

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

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

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

  229. 

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

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

  232.     };

  233. 

  234.     struct BasicOps64

  235.     {

  236.         typedef double Type;

  237.         typedef double ParallelType;

  238.         typedef uint64 IntegerType;

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

  240.         enum { numParallel = 1 };

  241. 

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

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

  244. 

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

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

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

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

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

  250. 

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

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

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

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

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

  256. 

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

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

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

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

  261. 

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

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

  264.     };

  265. 

  266.     #define JUCE_BEGIN_VEC_OP \

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

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

  269.         { \

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

  271. 

  272.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  275.         } \

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

  277. 

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

  279.         JUCE_BEGIN_VEC_OP \

  280.         setupOp \

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

  282.         JUCE_FINISH_VEC_OP (normalOp)

  283. 

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

  285.         JUCE_BEGIN_VEC_OP \

  286.         setupOp \

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

  288.         JUCE_FINISH_VEC_OP (normalOp)

  289. 

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

  291.         JUCE_BEGIN_VEC_OP \

  292.         setupOp \

  293.         JUCE_VEC_LOOP_TWO_SOURCES (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_DEST(normalOp, vecOp, locals, increment, setupOp) \

  297.         JUCE_BEGIN_VEC_OP \

  298.         setupOp \

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

  300.         JUCE_FINISH_VEC_OP (normalOp)

  301. 

  302. 

  303.     //==============================================================================

  304.    #else

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

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

  307. 

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

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

  310. 

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

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

  313. 

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

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

  316. 

  317.    #endif

  318. 

  319.     //==============================================================================

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

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

  322.         { \

  323.             locals (srcLoad, dstLoad); \

  324.             dstStore (dest, vecOp); \

  325.             increment; \

  326.         }

  327. 

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

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

  330.         { \

  331.             locals (src1Load, src2Load); \

  332.             dstStore (dest, vecOp); \

  333.             increment; \

  334.         }

  335. 

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

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

  338.         { \

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

  340.             dstStore (dest, vecOp); \

  341.             increment; \

  342.         }

  343. 

  344.     #define JUCE_LOAD_NONE(srcLoad, dstLoad)

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

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

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

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

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

  350. 

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

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

  353. 

  354.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

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

  357. 

  358.     template <typename Mode>

  359.     struct MinMax

  360.     {

  361.         typedef typename Mode::Type Type;

  362.         typedef typename Mode::ParallelType ParallelType;

  363. 

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

  365.         {

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

  367. 

  368.             if (numLongOps > 1)

  369.             {

  370.                 ParallelType val;

  371. 

  372.                #if ! JUCE_USE_ARM_NEON

  373.                 if (isAligned (src))

  374.                 {

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

  376. 

  377.                     if (isMinimum)

  378.                     {

  379.                         while (--numLongOps > 0)

  380.                         {

  381.                             src += Mode::numParallel;

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

  383.                         }

  384.                     }

  385.                     else

  386.                     {

  387.                         while (--numLongOps > 0)

  388.                         {

  389.                             src += Mode::numParallel;

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

  391.                         }

  392.                     }

  393.                 }

  394.                 else

  395.                #endif

  396.                 {

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

  398. 

  399.                     if (isMinimum)

  400.                     {

  401.                         while (--numLongOps > 0)

  402.                         {

  403.                             src += Mode::numParallel;

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

  405.                         }

  406.                     }

  407.                     else

  408.                     {

  409.                         while (--numLongOps > 0)

  410.                         {

  411.                             src += Mode::numParallel;

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

  413.                         }

  414.                     }

  415.                 }

  416. 

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

  418.                                         : Mode::max (val);

  419. 

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

  421.                 src += Mode::numParallel;

  422. 

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

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

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

  426. 

  427.                 return result;

  428.             }

  429. 

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

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

  432.         }

  433. 

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

  435.         {

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

  437. 

  438.             if (numLongOps > 1)

  439.             {

  440.                 ParallelType mn, mx;

  441. 

  442.                #if ! JUCE_USE_ARM_NEON

  443.                 if (isAligned (src))

  444.                 {

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

  446.                     mx = mn;

  447. 

  448.                     while (--numLongOps > 0)

  449.                     {

  450.                         src += Mode::numParallel;

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

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

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

  454.                     }

  455.                 }

  456.                 else

  457.                #endif

  458.                 {

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

  460.                     mx = mn;

  461. 

  462.                     while (--numLongOps > 0)

  463.                     {

  464.                         src += Mode::numParallel;

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

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

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

  468.                     }

  469.                 }

  470. 

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

  472.                                     Mode::max (mx));

  473. 

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

  475.                 src += Mode::numParallel;

  476. 

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

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

  479. 

  480.                 return result;

  481.             }

  482. 

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

  484.         }

  485.     };

  486.    #endif

  487. }

  488. 

  489. //==============================================================================

  490. namespace

  491. {

  492.    #if JUCE_USE_VDSP_FRAMEWORK

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

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

  495.     template <typename ValueType>

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

  497.    #endif

  498. }

  499. 

  500. //==============================================================================

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

  502. {

  503.    #if JUCE_USE_VDSP_FRAMEWORK

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

  505.    #else

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

  507.    #endif

  508. }

  509. 

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

  511. {

  512.    #if JUCE_USE_VDSP_FRAMEWORK

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

  514.    #else

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

  516.    #endif

  517. }

  518. 

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

  520. {

  521.    #if JUCE_USE_VDSP_FRAMEWORK

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

  523.    #else

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

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

  526.    #endif

  527. }

  528. 

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

  530. {

  531.    #if JUCE_USE_VDSP_FRAMEWORK

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

  533.    #else

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

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

  536.    #endif

  537. }

  538. 

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

  540. {

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

  542. }

  543. 

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

  545. {

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

  547. }

  548. 

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

  550. {

  551.    #if JUCE_USE_VDSP_FRAMEWORK

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

  553.    #else

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

  555.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  557.    #endif

  558. }

  559. 

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

  561. {

  562.    #if JUCE_USE_VDSP_FRAMEWORK

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

  564.    #else

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

  566.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  568.    #endif

  569. }

  570. 

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

  572. {

  573.    #if JUCE_USE_VDSP_FRAMEWORK

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

  575.    #else

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

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

  578.    #endif

  579. }

  580. 

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

  582. {

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

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

  585. }

  586. 

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

  588. {

  589.    #if JUCE_USE_VDSP_FRAMEWORK

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

  591.    #else

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

  593.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  595.    #endif

  596. }

  597. 

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

  599. {

  600.    #if JUCE_USE_VDSP_FRAMEWORK

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

  602.    #else

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

  604.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  606.    #endif

  607. }

  608. 

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

  610. {

  611.    #if JUCE_USE_VDSP_FRAMEWORK

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

  613.    #else

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

  615.    #endif

  616. }

  617. 

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

  619. {

  620.    #if JUCE_USE_VDSP_FRAMEWORK

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

  622.    #else

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

  624.    #endif

  625. }

  626. 

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

  628. {

  629.    #if JUCE_USE_VDSP_FRAMEWORK

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

  631.    #else

  632.     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, )

  633.    #endif

  634. }

  635. 

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

  637. {

  638.    #if JUCE_USE_VDSP_FRAMEWORK

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

  640.    #else

  641.     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, )

  642.    #endif

  643. }

  644. 

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

  646. {

  647.    #if JUCE_USE_VDSP_FRAMEWORK

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

  649.    #else

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

  651.    #endif

  652. }

  653. 

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

  655. {

  656.    #if JUCE_USE_VDSP_FRAMEWORK

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

  658.    #else

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

  660.    #endif

  661. }

  662. 

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

  664. {

  665.    #if JUCE_USE_VDSP_FRAMEWORK

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

  667.    #else

  668.     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, )

  669.    #endif

  670. }

  671. 

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

  673. {

  674.    #if JUCE_USE_VDSP_FRAMEWORK

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

  676.    #else

  677.     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, )

  678.    #endif

  679. }

  680. 

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

  682. {

  683.    #if JUCE_USE_VDSP_FRAMEWORK

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

  685.    #else

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

  687.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  689.    #endif

  690. }

  691. 

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

  693. {

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

  695.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  697. }

  698. 

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

  700. {

  701.    #if JUCE_USE_VDSP_FRAMEWORK

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

  703.    #else

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

  705.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  706.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  707.    #endif

  708. }

  709. 

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

  711. {

  712.    #if JUCE_USE_VDSP_FRAMEWORK

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

  714.    #else

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

  716.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  717.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  718.    #endif

  719. }

  720. 

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

  722. {

  723.    #if JUCE_USE_VDSP_FRAMEWORK

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

  725.    #else

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

  727.    #endif

  728. }

  729. 

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

  731. {

  732.    #if JUCE_USE_VDSP_FRAMEWORK

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

  734.    #else

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

  736.    #endif

  737. }

  738. 

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

  740. {

  741.    #if JUCE_USE_VDSP_FRAMEWORK

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

  743.    #else

  744.     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, )

  745.    #endif

  746. }

  747. 

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

  749. {

  750.    #if JUCE_USE_VDSP_FRAMEWORK

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

  752.    #else

  753.     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, )

  754.    #endif

  755. }

  756. 

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

  758. {

  759.    #if JUCE_USE_VDSP_FRAMEWORK

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

  761.    #else

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

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

  764.    #endif

  765. }

  766. 

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

  768. {

  769.    #if JUCE_USE_VDSP_FRAMEWORK

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

  771.    #else

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

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

  774.    #endif

  775. }

  776. 

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

  778. {

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

  780.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  782. }

  783. 

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

  785. {

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

  787.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  789. }

  790. 

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

  792. {

  793.    #if JUCE_USE_VDSP_FRAMEWORK

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

  795.    #else

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

  797.    #endif

  798. }

  799. 

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

  801. {

  802.    #if JUCE_USE_VDSP_FRAMEWORK

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

  804.    #else

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

  806.    #endif

  807. }

  808. 

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

  810. {

  811.    #if JUCE_USE_VDSP_FRAMEWORK

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

  813.    #else

  814.     FloatVectorHelpers::signMask32 signMask;

  815.     signMask.i = 0x7fffffffUL;

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

  817.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  819. 

  820.     ignoreUnused (signMask);

  821.    #endif

  822. }

  823. 

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

  825. {

  826.    #if JUCE_USE_VDSP_FRAMEWORK

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

  828.    #else

  829.     FloatVectorHelpers::signMask64 signMask;

  830.     signMask.i = 0x7fffffffffffffffULL;

  831. 

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

  833.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  835. 

  836.     ignoreUnused (signMask);

  837.    #endif

  838. }

  839. 

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

  841. {

  842.    #if JUCE_USE_ARM_NEON

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

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

  845.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  846.    #else

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

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

  849.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

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

  851.    #endif

  852. }

  853. 

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

  855. {

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

  857.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  859. }

  860. 

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

  862. {

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

  864.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  866. }

  867. 

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

  869. {

  870.    #if JUCE_USE_VDSP_FRAMEWORK

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

  872.    #else

  873.     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, )

  874.    #endif

  875. }

  876. 

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

  878. {

  879.    #if JUCE_USE_VDSP_FRAMEWORK

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

  881.    #else

  882.     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, )

  883.    #endif

  884. }

  885. 

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

  887. {

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

  889.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  891. }

  892. 

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

  894. {

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

  896.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  898. }

  899. 

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

  901. {

  902.    #if JUCE_USE_VDSP_FRAMEWORK

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

  904.    #else

  905.     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, )

  906.    #endif

  907. }

  908. 

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

  910. {

  911.    #if JUCE_USE_VDSP_FRAMEWORK

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

  913.    #else

  914.     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, )

  915.    #endif

  916. }

  917. 

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

  919. {

  920.     jassert(high >= low);

  921. 

  922.    #if JUCE_USE_VDSP_FRAMEWORK

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

  924.    #else

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

  926.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  928.    #endif

  929. }

  930. 

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

  932. {

  933.     jassert(high >= low);

  934. 

  935.    #if JUCE_USE_VDSP_FRAMEWORK

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

  937.    #else

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

  939.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  941.    #endif

  942. }

  943. 

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

  945. {

  946.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  948.    #else

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

  950.    #endif

  951. }

  952. 

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

  954. {

  955.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  957.    #else

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

  959.    #endif

  960. }

  961. 

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

  963. {

  964.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  966.    #else

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

  968.    #endif

  969. }

  970. 

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

  972. {

  973.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  975.    #else

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

  977.    #endif

  978. }

  979. 

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

  981. {

  982.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  984.    #else

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

  986.    #endif

  987. }

  988. 

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

  990. {

  991.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  993.    #else

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

  995.    #endif

  996. }

  997. 

  998. #if ! JUCE_MINGW

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

  1000. {

  1001.    #if JUCE_USE_SSE_INTRINSICS

  1002.     _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  1003.    #endif

  1004.     ignoreUnused (shouldEnable);

  1005. }

  1006. 

  1007. void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport() noexcept

  1008. {

  1009.    #if JUCE_USE_SSE_INTRINSICS

  1010.     const unsigned int mxcsr = _mm_getcsr();

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

  1012.    #endif

  1013. }

  1014. #endif

  1015. 

  1016. //==============================================================================

  1017. //==============================================================================

  1018. #if JUCE_UNIT_TESTS

  1019. 

  1020. class FloatVectorOperationsTests  : public UnitTest

  1021. {

  1022. public:

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

  1024. 

  1025.     template <typename ValueType>

  1026.     struct TestRunner

  1027.     {

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

  1029.         {

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

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

  1032. 

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

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

  1035. 

  1036.            #if JUCE_ARM

  1037.             ValueType* const data1 = buffer1;

  1038.             ValueType* const data2 = buffer2;

  1039.             int* const int1 = buffer3;

  1040.            #else

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

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

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

  1044.            #endif

  1045. 

  1046.             fillRandomly (random, data1, num);

  1047.             fillRandomly (random, data2, num);

  1048. 

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

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

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

  1052. 

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

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

  1055. 

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

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

  1058. 

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

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

  1061. 

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

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

  1064. 

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

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

  1067. 

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

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

  1070. 

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

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

  1073. 

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

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

  1076. 

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

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

  1079. 

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

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

  1082. 

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

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

  1085. 

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

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

  1088. 

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

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

  1091. 

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

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

  1094. 

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

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

  1097. 

  1098.             fillRandomly (random, int1, num);

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

  1100. 

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

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

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

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

  1105.         }

  1106. 

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

  1108.         {

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

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

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

  1112.         }

  1113. 

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

  1115. 

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

  1117.         {

  1118.             while (--num >= 0)

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

  1120.         }

  1121. 

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

  1123.         {

  1124.             while (--num >= 0)

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

  1126.         }

  1127. 

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

  1129.         {

  1130.             while (--num >= 0)

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

  1132.         }

  1133. 

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

  1135.         {

  1136.             while (--num >= 0)

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

  1138.                     return false;

  1139. 

  1140.             return true;

  1141.         }

  1142. 

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

  1144.         {

  1145.             while (--num >= 0)

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

  1147.                     return false;

  1148. 

  1149.             return true;

  1150.         }

  1151. 

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

  1153.         {

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

  1155.         }

  1156.     };

  1157. 

  1158.     void runTest() override

  1159.     {

  1160.         beginTest ("FloatVectorOperations");

  1161. 

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

  1163.         {

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

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

  1166.         }

  1167.     }

  1168. };

  1169. 

  1170. static FloatVectorOperationsTests vectorOpTests;

  1171. 

  1172. #endif