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.
5905 Commits
11 Branches
1.4GB
Tree: a53eda27d4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a53eda27d4'
${ noResults }
JUCE/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1168 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.     static bool sse2Present = false;

  33. 

  34.     static bool isSSE2Available() noexcept

  35.     {

  36.         if (sse2Present)

  37.             return true;

  38. 

  39.         sse2Present = SystemStats::hasSSE2();

  40.         return sse2Present;

  41.     }

  42. 

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

  44.     {

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

  46.     }

  47. 

  48.     struct BasicOps32

  49.     {

  50.         typedef float Type;

  51.         typedef __m128 ParallelType;

  52.         typedef __m128 IntegerType;

  53.         enum { numParallel = 4 };

  54. 

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

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

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

  58. 

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

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

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

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

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

  64. 

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

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

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

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

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

  70. 

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

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

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

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

  75. 

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

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

  78.     };

  79. 

  80.     struct BasicOps64

  81.     {

  82.         typedef double Type;

  83.         typedef __m128d ParallelType;

  84.         typedef __m128d IntegerType;

  85.         enum { numParallel = 2 };

  86. 

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

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

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

  90. 

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

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

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

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

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

  96. 

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

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

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

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

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

  102. 

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

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

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

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

  107. 

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

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

  110.     };

  111. 

  112. 

  113. 

  114.     #define JUCE_BEGIN_VEC_OP \

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

  116.         if (FloatVectorHelpers::isSSE2Available()) \

  117.         { \

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

  119. 

  120.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  123.         } \

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

  125. 

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

  127.         JUCE_BEGIN_VEC_OP \

  128.         setupOp \

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

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

  131.         JUCE_FINISH_VEC_OP (normalOp)

  132. 

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

  134.         JUCE_BEGIN_VEC_OP \

  135.         setupOp \

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

  137.         { \

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

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

  140.         }\

  141.         else \

  142.         { \

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

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

  145.         } \

  146.         JUCE_FINISH_VEC_OP (normalOp)

  147. 

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

  149.         JUCE_BEGIN_VEC_OP \

  150.         setupOp \

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

  152.         { \

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

  154.             { \

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

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

  157.             } \

  158.             else \

  159.             { \

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

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

  162.             } \

  163.         } \

  164.         else \

  165.         { \

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

  167.             { \

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

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

  170.             } \

  171.             else \

  172.             { \

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

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

  175.             } \

  176.         } \

  177.         JUCE_FINISH_VEC_OP (normalOp)

  178. 

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

  180.         JUCE_BEGIN_VEC_OP \

  181.         setupOp \

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

  183.         { \

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

  185.             { \

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

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

  188.             } \

  189.             else \

  190.             { \

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

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

  193.             } \

  194.         } \

  195.         else \

  196.         { \

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

  198.             { \

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

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

  201.             } \

  202.             else \

  203.             { \

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

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

  206.             } \

  207.         } \

  208.         JUCE_FINISH_VEC_OP (normalOp)

  209. 

  210. 

  211.     //==============================================================================

  212.    #elif JUCE_USE_ARM_NEON

  213. 

  214.     struct BasicOps32

  215.     {

  216.         typedef float Type;

  217.         typedef float32x4_t ParallelType;

  218.         typedef uint32x4_t IntegerType;

  219.         enum { numParallel = 4 };

  220. 

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

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

  223. 

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

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

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

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

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

  229. 

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

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

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

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

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

  235. 

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

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

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

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

  240. 

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

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

  243.     };

  244. 

  245.     struct BasicOps64

  246.     {

  247.         typedef double Type;

  248.         typedef double ParallelType;

  249.         typedef uint64 IntegerType;

  250.         enum { numParallel = 1 };

  251. 

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

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

  254. 

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

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

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

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

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

  260. 

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

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

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

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

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

  266. 

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

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

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

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

  271. 

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

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

  274.     };

  275. 

  276.     #define JUCE_BEGIN_VEC_OP \

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

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

  279.         { \

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

  281. 

  282.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  285.         } \

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

  287. 

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

  289.         JUCE_BEGIN_VEC_OP \

  290.         setupOp \

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

  292.         JUCE_FINISH_VEC_OP (normalOp)

  293. 

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

  295.         JUCE_BEGIN_VEC_OP \

  296.         setupOp \

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

  298.         JUCE_FINISH_VEC_OP (normalOp)

  299. 

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

  301.         JUCE_BEGIN_VEC_OP \

  302.         setupOp \

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

  304.         JUCE_FINISH_VEC_OP (normalOp)

  305. 

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

  307.         JUCE_BEGIN_VEC_OP \

  308.         setupOp \

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

  310.         JUCE_FINISH_VEC_OP (normalOp)

  311. 

  312. 

  313.     //==============================================================================

  314.    #else

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

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

  317. 

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

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

  320. 

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

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

  323. 

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

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

  326. 

  327.    #endif

  328. 

  329.     //==============================================================================

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

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

  332.         { \

  333.             locals (srcLoad, dstLoad); \

  334.             dstStore (dest, vecOp); \

  335.             increment; \

  336.         }

  337. 

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

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

  340.         { \

  341.             locals (src1Load, src2Load); \

  342.             dstStore (dest, vecOp); \

  343.             increment; \

  344.         }

  345. 

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

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

  348.         { \

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

  350.             dstStore (dest, vecOp); \

  351.             increment; \

  352.         }

  353. 

  354.     #define JUCE_LOAD_NONE(srcLoad, dstLoad)

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

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

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

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

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

  360. 

  361.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

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

  364. 

  365.     template <typename Mode>

  366.     struct MinMax

  367.     {

  368.         typedef typename Mode::Type Type;

  369.         typedef typename Mode::ParallelType ParallelType;

  370. 

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

  372.         {

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

  374. 

  375.            #if JUCE_USE_SSE_INTRINSICS

  376.             if (numLongOps > 1 && isSSE2Available())

  377.            #else

  378.             if (numLongOps > 1)

  379.            #endif

  380.             {

  381.                 ParallelType val;

  382. 

  383.                #if ! JUCE_USE_ARM_NEON

  384.                 if (isAligned (src))

  385.                 {

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

  387. 

  388.                     if (isMinimum)

  389.                     {

  390.                         while (--numLongOps > 0)

  391.                         {

  392.                             src += Mode::numParallel;

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

  394.                         }

  395.                     }

  396.                     else

  397.                     {

  398.                         while (--numLongOps > 0)

  399.                         {

  400.                             src += Mode::numParallel;

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

  402.                         }

  403.                     }

  404.                 }

  405.                 else

  406.                #endif

  407.                 {

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

  409. 

  410.                     if (isMinimum)

  411.                     {

  412.                         while (--numLongOps > 0)

  413.                         {

  414.                             src += Mode::numParallel;

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

  416.                         }

  417.                     }

  418.                     else

  419.                     {

  420.                         while (--numLongOps > 0)

  421.                         {

  422.                             src += Mode::numParallel;

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

  424.                         }

  425.                     }

  426.                 }

  427. 

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

  429.                                         : Mode::max (val);

  430. 

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

  432.                 src += Mode::numParallel;

  433. 

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

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

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

  437. 

  438.                 return result;

  439.             }

  440. 

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

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

  443.         }

  444. 

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

  446.         {

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

  448. 

  449.            #if JUCE_USE_SSE_INTRINSICS

  450.             if (numLongOps > 1 && isSSE2Available())

  451.            #else

  452.             if (numLongOps > 1)

  453.            #endif

  454.             {

  455.                 ParallelType mn, mx;

  456. 

  457.                #if ! JUCE_USE_ARM_NEON

  458.                 if (isAligned (src))

  459.                 {

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

  461.                     mx = mn;

  462. 

  463.                     while (--numLongOps > 0)

  464.                     {

  465.                         src += Mode::numParallel;

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

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

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

  469.                     }

  470.                 }

  471.                 else

  472.                #endif

  473.                 {

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

  475.                     mx = mn;

  476. 

  477.                     while (--numLongOps > 0)

  478.                     {

  479.                         src += Mode::numParallel;

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

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

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

  483.                     }

  484.                 }

  485. 

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

  487.                                     Mode::max (mx));

  488. 

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

  490.                 src += Mode::numParallel;

  491. 

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

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

  494. 

  495.                 return result;

  496.             }

  497. 

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

  499.         }

  500.     };

  501.    #endif

  502. }

  503. 

  504. //==============================================================================

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

  506. {

  507.    #if JUCE_USE_VDSP_FRAMEWORK

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

  509.    #else

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

  511.    #endif

  512. }

  513. 

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

  515. {

  516.    #if JUCE_USE_VDSP_FRAMEWORK

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

  518.    #else

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

  520.    #endif

  521. }

  522. 

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

  524. {

  525.    #if JUCE_USE_VDSP_FRAMEWORK

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

  527.    #else

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

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

  530.    #endif

  531. }

  532. 

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

  534. {

  535.    #if JUCE_USE_VDSP_FRAMEWORK

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

  537.    #else

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

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

  540.    #endif

  541. }

  542. 

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

  544. {

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

  546. }

  547. 

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

  549. {

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

  551. }

  552. 

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

  554. {

  555.    #if JUCE_USE_VDSP_FRAMEWORK

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

  557.    #else

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

  559.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  561.    #endif

  562. }

  563. 

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

  565. {

  566.    #if JUCE_USE_VDSP_FRAMEWORK

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

  568.    #else

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

  570.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  572.    #endif

  573. }

  574. 

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

  576. {

  577.    #if JUCE_USE_VDSP_FRAMEWORK

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

  579.    #else

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

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

  582.    #endif

  583. }

  584. 

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

  586. {

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

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

  589. }

  590. 

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

  592. {

  593.    #if JUCE_USE_VDSP_FRAMEWORK

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

  595.    #else

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

  597.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  599.    #endif

  600. }

  601. 

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

  603. {

  604.    #if JUCE_USE_VDSP_FRAMEWORK

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

  606.    #else

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

  608.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  610.    #endif

  611. }

  612. 

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

  614. {

  615.    #if JUCE_USE_VDSP_FRAMEWORK

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

  617.    #else

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

  619.    #endif

  620. }

  621. 

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

  623. {

  624.    #if JUCE_USE_VDSP_FRAMEWORK

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

  626.    #else

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

  628.    #endif

  629. }

  630. 

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

  632. {

  633.    #if JUCE_USE_VDSP_FRAMEWORK

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

  635.    #else

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

  637.    #endif

  638. }

  639. 

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

  641. {

  642.    #if JUCE_USE_VDSP_FRAMEWORK

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

  644.    #else

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

  646.    #endif

  647. }

  648. 

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

  650. {

  651.    #if JUCE_USE_VDSP_FRAMEWORK

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

  653.    #else

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

  655.    #endif

  656. }

  657. 

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

  659. {

  660.    #if JUCE_USE_VDSP_FRAMEWORK

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

  662.    #else

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

  664.    #endif

  665. }

  666. 

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

  668. {

  669.    #if JUCE_USE_VDSP_FRAMEWORK

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

  671.    #else

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

  673.    #endif

  674. }

  675. 

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

  677. {

  678.    #if JUCE_USE_VDSP_FRAMEWORK

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

  680.    #else

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

  682.    #endif

  683. }

  684. 

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

  686. {

  687.    #if JUCE_USE_VDSP_FRAMEWORK

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

  689.    #else

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

  691.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  693.    #endif

  694. }

  695. 

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

  697. {

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

  699.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  701. }

  702. 

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

  704. {

  705.    #if JUCE_USE_VDSP_FRAMEWORK

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

  707.    #else

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

  709.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  710.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  711.    #endif

  712. }

  713. 

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

  715. {

  716.    #if JUCE_USE_VDSP_FRAMEWORK

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

  718.    #else

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

  720.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  721.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  722.    #endif

  723. }

  724. 

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

  726. {

  727.    #if JUCE_USE_VDSP_FRAMEWORK

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

  729.    #else

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

  731.    #endif

  732. }

  733. 

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

  735. {

  736.    #if JUCE_USE_VDSP_FRAMEWORK

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

  738.    #else

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

  740.    #endif

  741. }

  742. 

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

  744. {

  745.    #if JUCE_USE_VDSP_FRAMEWORK

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

  747.    #else

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

  749.    #endif

  750. }

  751. 

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

  753. {

  754.    #if JUCE_USE_VDSP_FRAMEWORK

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

  756.    #else

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

  758.    #endif

  759. }

  760. 

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

  762. {

  763.    #if JUCE_USE_VDSP_FRAMEWORK

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

  765.    #else

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

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

  768.    #endif

  769. }

  770. 

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

  772. {

  773.    #if JUCE_USE_VDSP_FRAMEWORK

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

  775.    #else

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

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

  778.    #endif

  779. }

  780. 

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

  782. {

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

  784.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  786. }

  787. 

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

  789. {

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

  791.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  793. }

  794. 

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

  796. {

  797.    #if JUCE_USE_VDSP_FRAMEWORK

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

  799.    #else

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

  801.    #endif

  802. }

  803. 

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

  805. {

  806.    #if JUCE_USE_VDSP_FRAMEWORK

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

  808.    #else

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

  810.    #endif

  811. }

  812. 

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

  814. {

  815.    #if JUCE_USE_VDSP_FRAMEWORK

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

  817.    #else

  818.     union { float f; uint32 i; } signMask;

  819.     signMask.i = 0x7fffffffUL;

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

  821.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  823. 

  824.     ignoreUnused (signMask);

  825.    #endif

  826. }

  827. 

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

  829. {

  830.    #if JUCE_USE_VDSP_FRAMEWORK

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

  832.    #else

  833.     union {double d; uint64 i;} signMask;

  834.     signMask.i = 0x7fffffffffffffffULL;

  835. 

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

  837.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  839. 

  840.     ignoreUnused (signMask);

  841.    #endif

  842. }

  843. 

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

  845. {

  846.    #if JUCE_USE_ARM_NEON

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

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

  849.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  850.    #else

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

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

  853.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

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

  855.    #endif

  856. }

  857. 

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

  859. {

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

  861.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  863. }

  864. 

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

  866. {

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

  868.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  870. }

  871. 

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

  873. {

  874.    #if JUCE_USE_VDSP_FRAMEWORK

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

  876.    #else

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

  878.    #endif

  879. }

  880. 

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

  882. {

  883.    #if JUCE_USE_VDSP_FRAMEWORK

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

  885.    #else

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

  887.    #endif

  888. }

  889. 

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

  891. {

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

  893.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  895. }

  896. 

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

  898. {

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

  900.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  902. }

  903. 

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

  905. {

  906.    #if JUCE_USE_VDSP_FRAMEWORK

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

  908.    #else

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

  910.    #endif

  911. }

  912. 

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

  914. {

  915.    #if JUCE_USE_VDSP_FRAMEWORK

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

  917.    #else

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

  919.    #endif

  920. }

  921. 

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

  923. {

  924.     jassert(high >= low);

  925. 

  926.    #if JUCE_USE_VDSP_FRAMEWORK

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

  928.    #else

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

  930.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  932.    #endif

  933. }

  934. 

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

  936. {

  937.     jassert(high >= low);

  938. 

  939.    #if JUCE_USE_VDSP_FRAMEWORK

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

  941.    #else

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

  943.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  945.    #endif

  946. }

  947. 

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

  949. {

  950.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  952.    #else

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

  954.    #endif

  955. }

  956. 

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

  958. {

  959.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  961.    #else

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

  963.    #endif

  964. }

  965. 

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

  967. {

  968.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  970.    #else

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

  972.    #endif

  973. }

  974. 

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

  976. {

  977.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  979.    #else

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

  981.    #endif

  982. }

  983. 

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

  985. {

  986.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  988.    #else

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

  990.    #endif

  991. }

  992. 

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

  994. {

  995.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  997.    #else

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

  999.    #endif

  1000. }

  1001. 

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

  1003. {

  1004.    #if JUCE_USE_SSE_INTRINSICS

  1005.     if (FloatVectorHelpers::isSSE2Available())

  1006.         _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  1007.    #endif

  1008.     ignoreUnused (shouldEnable);

  1009. }

  1010. 

  1011. //==============================================================================

  1012. //==============================================================================

  1013. #if JUCE_UNIT_TESTS

  1014. 

  1015. class FloatVectorOperationsTests  : public UnitTest

  1016. {

  1017. public:

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

  1019. 

  1020.     template <typename ValueType>

  1021.     struct TestRunner

  1022.     {

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

  1024.         {

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

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

  1027. 

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

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

  1030. 

  1031.            #if JUCE_ARM

  1032.             ValueType* const data1 = buffer1;

  1033.             ValueType* const data2 = buffer2;

  1034.             int* const int1 = buffer3;

  1035.            #else

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

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

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

  1039.            #endif

  1040. 

  1041.             fillRandomly (random, data1, num);

  1042.             fillRandomly (random, data2, num);

  1043. 

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

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

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

  1047. 

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

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

  1050. 

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

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

  1053. 

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

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

  1056. 

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

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

  1059. 

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

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

  1062. 

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

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

  1065. 

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

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

  1068. 

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

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

  1071. 

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

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

  1074. 

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

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

  1077. 

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

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

  1080. 

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

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

  1083. 

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

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

  1086. 

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

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

  1089. 

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

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

  1092. 

  1093.             fillRandomly (random, int1, num);

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

  1095. 

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

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

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

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

  1100.         }

  1101. 

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

  1103.         {

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

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

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

  1107.         }

  1108. 

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

  1110. 

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

  1112.         {

  1113.             while (--num >= 0)

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

  1115.         }

  1116. 

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

  1118.         {

  1119.             while (--num >= 0)

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

  1121.         }

  1122. 

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

  1124.         {

  1125.             while (--num >= 0)

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

  1127.         }

  1128. 

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

  1130.         {

  1131.             while (--num >= 0)

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

  1133.                     return false;

  1134. 

  1135.             return true;

  1136.         }

  1137. 

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

  1139.         {

  1140.             while (--num >= 0)

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

  1142.                     return false;

  1143. 

  1144.             return true;

  1145.         }

  1146. 

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

  1148.         {

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

  1150.         }

  1151.     };

  1152. 

  1153.     void runTest() override

  1154.     {

  1155.         beginTest ("FloatVectorOperations");

  1156. 

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

  1158.         {

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

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

  1161.         }

  1162.     }

  1163. };

  1164. 

  1165. static FloatVectorOperationsTests vectorOpTests;

  1166. 

  1167. #endif