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.
7311 Commits
9 Branches
2.6GB
Tree: 2fdff085b6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2fdff085b6'
${ noResults }
JUCE/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1169 lines
52KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2017 - ROLI Ltd.

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    The code included in this file is provided under the terms of the ISC license

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

  12.    To use, copy, modify, and/or distribute this software for any purpose with or

  13.    without fee is hereby granted provided that the above copyright notice and

  14.    this permission notice appear in all copies.

  15. 

  16.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  17.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  18.    DISCLAIMED.

  19. 

  20.   ==============================================================================

  21. */

  22. 

  23. namespace FloatVectorHelpers

  24. {

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

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

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

  28. 

  29.    #if JUCE_USE_SSE_INTRINSICS

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

  31.     {

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

  33.     }

  34. 

  35.     struct BasicOps32

  36.     {

  37.         typedef float Type;

  38.         typedef __m128 ParallelType;

  39.         typedef __m128 IntegerType;

  40.         enum { numParallel = 4 };

  41. 

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

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

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

  45. 

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

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

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

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

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

  51. 

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

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

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

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

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

  57. 

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

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

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

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

  62. 

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

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

  65.     };

  66. 

  67.     struct BasicOps64

  68.     {

  69.         typedef double Type;

  70.         typedef __m128d ParallelType;

  71.         typedef __m128d IntegerType;

  72.         enum { numParallel = 2 };

  73. 

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

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

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

  77. 

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

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

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

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

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

  83. 

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

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

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

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

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

  89. 

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

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

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

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

  94. 

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

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

  97.     };

  98. 

  99. 

  100. 

  101.     #define JUCE_BEGIN_VEC_OP \

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

  103.         { \

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

  105. 

  106.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  109.         } \

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

  111. 

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

  113.         JUCE_BEGIN_VEC_OP \

  114.         setupOp \

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

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

  117.         JUCE_FINISH_VEC_OP (normalOp)

  118. 

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

  120.         JUCE_BEGIN_VEC_OP \

  121.         setupOp \

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

  123.         { \

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

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

  126.         }\

  127.         else \

  128.         { \

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

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

  131.         } \

  132.         JUCE_FINISH_VEC_OP (normalOp)

  133. 

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

  135.         JUCE_BEGIN_VEC_OP \

  136.         setupOp \

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

  138.         { \

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

  140.             { \

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

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

  143.             } \

  144.             else \

  145.             { \

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

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

  148.             } \

  149.         } \

  150.         else \

  151.         { \

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

  153.             { \

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

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

  156.             } \

  157.             else \

  158.             { \

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

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

  161.             } \

  162.         } \

  163.         JUCE_FINISH_VEC_OP (normalOp)

  164. 

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

  166.         JUCE_BEGIN_VEC_OP \

  167.         setupOp \

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

  169.         { \

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

  171.             { \

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

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

  174.             } \

  175.             else \

  176.             { \

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

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

  179.             } \

  180.         } \

  181.         else \

  182.         { \

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

  184.             { \

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

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

  187.             } \

  188.             else \

  189.             { \

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

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

  192.             } \

  193.         } \

  194.         JUCE_FINISH_VEC_OP (normalOp)

  195. 

  196. 

  197.     //==============================================================================

  198.    #elif JUCE_USE_ARM_NEON

  199. 

  200.     struct BasicOps32

  201.     {

  202.         typedef float Type;

  203.         typedef float32x4_t ParallelType;

  204.         typedef uint32x4_t IntegerType;

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

  206.         enum { numParallel = 4 };

  207. 

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

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

  210. 

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

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

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

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

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

  216. 

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

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

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

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

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

  222. 

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

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

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

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

  227. 

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

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

  230.     };

  231. 

  232.     struct BasicOps64

  233.     {

  234.         typedef double Type;

  235.         typedef double ParallelType;

  236.         typedef uint64 IntegerType;

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

  238.         enum { numParallel = 1 };

  239. 

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

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

  242. 

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

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

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

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

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

  248. 

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

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

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

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

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

  254. 

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

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

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

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

  259. 

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

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

  262.     };

  263. 

  264.     #define JUCE_BEGIN_VEC_OP \

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

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

  267.         { \

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

  269. 

  270.     #define JUCE_FINISH_VEC_OP(normalOp) \

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

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

  273.         } \

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

  275. 

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

  277.         JUCE_BEGIN_VEC_OP \

  278.         setupOp \

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

  280.         JUCE_FINISH_VEC_OP (normalOp)

  281. 

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

  283.         JUCE_BEGIN_VEC_OP \

  284.         setupOp \

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

  286.         JUCE_FINISH_VEC_OP (normalOp)

  287. 

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

  289.         JUCE_BEGIN_VEC_OP \

  290.         setupOp \

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

  292.         JUCE_FINISH_VEC_OP (normalOp)

  293. 

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

  295.         JUCE_BEGIN_VEC_OP \

  296.         setupOp \

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

  298.         JUCE_FINISH_VEC_OP (normalOp)

  299. 

  300. 

  301.     //==============================================================================

  302.    #else

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

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

  305. 

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

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

  308. 

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

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

  311. 

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

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

  314. 

  315.    #endif

  316. 

  317.     //==============================================================================

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

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

  320.         { \

  321.             locals (srcLoad, dstLoad); \

  322.             dstStore (dest, vecOp); \

  323.             increment; \

  324.         }

  325. 

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

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

  328.         { \

  329.             locals (src1Load, src2Load); \

  330.             dstStore (dest, vecOp); \

  331.             increment; \

  332.         }

  333. 

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

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

  336.         { \

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

  338.             dstStore (dest, vecOp); \

  339.             increment; \

  340.         }

  341. 

  342.     #define JUCE_LOAD_NONE(srcLoad, dstLoad)

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

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

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

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

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

  348. 

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

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

  351. 

  352.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

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

  355. 

  356.     template <typename Mode>

  357.     struct MinMax

  358.     {

  359.         typedef typename Mode::Type Type;

  360.         typedef typename Mode::ParallelType ParallelType;

  361. 

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

  363.         {

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

  365. 

  366.             if (numLongOps > 1)

  367.             {

  368.                 ParallelType val;

  369. 

  370.                #if ! JUCE_USE_ARM_NEON

  371.                 if (isAligned (src))

  372.                 {

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

  374. 

  375.                     if (isMinimum)

  376.                     {

  377.                         while (--numLongOps > 0)

  378.                         {

  379.                             src += Mode::numParallel;

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

  381.                         }

  382.                     }

  383.                     else

  384.                     {

  385.                         while (--numLongOps > 0)

  386.                         {

  387.                             src += Mode::numParallel;

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

  389.                         }

  390.                     }

  391.                 }

  392.                 else

  393.                #endif

  394.                 {

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

  396. 

  397.                     if (isMinimum)

  398.                     {

  399.                         while (--numLongOps > 0)

  400.                         {

  401.                             src += Mode::numParallel;

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

  403.                         }

  404.                     }

  405.                     else

  406.                     {

  407.                         while (--numLongOps > 0)

  408.                         {

  409.                             src += Mode::numParallel;

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

  411.                         }

  412.                     }

  413.                 }

  414. 

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

  416.                                         : Mode::max (val);

  417. 

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

  419.                 src += Mode::numParallel;

  420. 

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

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

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

  424. 

  425.                 return result;

  426.             }

  427. 

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

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

  430.         }

  431. 

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

  433.         {

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

  435. 

  436.             if (numLongOps > 1)

  437.             {

  438.                 ParallelType mn, mx;

  439. 

  440.                #if ! JUCE_USE_ARM_NEON

  441.                 if (isAligned (src))

  442.                 {

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

  444.                     mx = mn;

  445. 

  446.                     while (--numLongOps > 0)

  447.                     {

  448.                         src += Mode::numParallel;

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

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

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

  452.                     }

  453.                 }

  454.                 else

  455.                #endif

  456.                 {

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

  458.                     mx = mn;

  459. 

  460.                     while (--numLongOps > 0)

  461.                     {

  462.                         src += Mode::numParallel;

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

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

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

  466.                     }

  467.                 }

  468. 

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

  470.                                     Mode::max (mx));

  471. 

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

  473.                 src += Mode::numParallel;

  474. 

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

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

  477. 

  478.                 return result;

  479.             }

  480. 

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

  482.         }

  483.     };

  484.    #endif

  485. }

  486. 

  487. //==============================================================================

  488. namespace

  489. {

  490.    #if JUCE_USE_VDSP_FRAMEWORK

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

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

  493.     template <typename ValueType>

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

  495.    #endif

  496. }

  497. 

  498. //==============================================================================

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

  500. {

  501.    #if JUCE_USE_VDSP_FRAMEWORK

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

  503.    #else

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

  505.    #endif

  506. }

  507. 

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

  509. {

  510.    #if JUCE_USE_VDSP_FRAMEWORK

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

  512.    #else

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

  514.    #endif

  515. }

  516. 

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

  518. {

  519.    #if JUCE_USE_VDSP_FRAMEWORK

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

  521.    #else

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

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

  524.    #endif

  525. }

  526. 

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

  528. {

  529.    #if JUCE_USE_VDSP_FRAMEWORK

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

  531.    #else

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

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

  534.    #endif

  535. }

  536. 

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

  538. {

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

  540. }

  541. 

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

  543. {

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

  545. }

  546. 

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

  548. {

  549.    #if JUCE_USE_VDSP_FRAMEWORK

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

  551.    #else

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

  553.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  555.    #endif

  556. }

  557. 

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

  559. {

  560.    #if JUCE_USE_VDSP_FRAMEWORK

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

  562.    #else

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

  564.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  566.    #endif

  567. }

  568. 

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

  570. {

  571.    #if JUCE_USE_VDSP_FRAMEWORK

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

  573.    #else

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

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

  576.    #endif

  577. }

  578. 

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

  580. {

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

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

  583. }

  584. 

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

  586. {

  587.    #if JUCE_USE_VDSP_FRAMEWORK

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

  589.    #else

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

  591.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  593.    #endif

  594. }

  595. 

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

  597. {

  598.    #if JUCE_USE_VDSP_FRAMEWORK

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

  600.    #else

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

  602.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  604.    #endif

  605. }

  606. 

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

  608. {

  609.    #if JUCE_USE_VDSP_FRAMEWORK

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

  611.    #else

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

  613.    #endif

  614. }

  615. 

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

  617. {

  618.    #if JUCE_USE_VDSP_FRAMEWORK

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

  620.    #else

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

  622.    #endif

  623. }

  624. 

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

  626. {

  627.    #if JUCE_USE_VDSP_FRAMEWORK

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

  629.    #else

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

  631.    #endif

  632. }

  633. 

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

  635. {

  636.    #if JUCE_USE_VDSP_FRAMEWORK

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

  638.    #else

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

  640.    #endif

  641. }

  642. 

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

  644. {

  645.    #if JUCE_USE_VDSP_FRAMEWORK

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

  647.    #else

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

  649.    #endif

  650. }

  651. 

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

  653. {

  654.    #if JUCE_USE_VDSP_FRAMEWORK

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

  656.    #else

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

  658.    #endif

  659. }

  660. 

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

  662. {

  663.    #if JUCE_USE_VDSP_FRAMEWORK

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

  665.    #else

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

  667.    #endif

  668. }

  669. 

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

  671. {

  672.    #if JUCE_USE_VDSP_FRAMEWORK

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

  674.    #else

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

  676.    #endif

  677. }

  678. 

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

  680. {

  681.    #if JUCE_USE_VDSP_FRAMEWORK

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

  683.    #else

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

  685.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  687.    #endif

  688. }

  689. 

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

  691. {

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

  693.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  695. }

  696. 

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

  698. {

  699.    #if JUCE_USE_VDSP_FRAMEWORK

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

  701.    #else

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

  703.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  704.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  705.    #endif

  706. }

  707. 

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

  709. {

  710.    #if JUCE_USE_VDSP_FRAMEWORK

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

  712.    #else

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

  714.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  715.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  716.    #endif

  717. }

  718. 

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

  720. {

  721.    #if JUCE_USE_VDSP_FRAMEWORK

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

  723.    #else

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

  725.    #endif

  726. }

  727. 

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

  729. {

  730.    #if JUCE_USE_VDSP_FRAMEWORK

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

  732.    #else

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

  734.    #endif

  735. }

  736. 

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

  738. {

  739.    #if JUCE_USE_VDSP_FRAMEWORK

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

  741.    #else

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

  743.    #endif

  744. }

  745. 

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

  747. {

  748.    #if JUCE_USE_VDSP_FRAMEWORK

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

  750.    #else

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

  752.    #endif

  753. }

  754. 

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

  756. {

  757.    #if JUCE_USE_VDSP_FRAMEWORK

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

  759.    #else

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

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

  762.    #endif

  763. }

  764. 

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

  766. {

  767.    #if JUCE_USE_VDSP_FRAMEWORK

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

  769.    #else

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

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

  772.    #endif

  773. }

  774. 

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

  776. {

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

  778.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  780. }

  781. 

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

  783. {

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

  785.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  787. }

  788. 

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

  790. {

  791.    #if JUCE_USE_VDSP_FRAMEWORK

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

  793.    #else

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

  795.    #endif

  796. }

  797. 

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

  799. {

  800.    #if JUCE_USE_VDSP_FRAMEWORK

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

  802.    #else

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

  804.    #endif

  805. }

  806. 

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

  808. {

  809.    #if JUCE_USE_VDSP_FRAMEWORK

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

  811.    #else

  812.     FloatVectorHelpers::signMask32 signMask;

  813.     signMask.i = 0x7fffffffUL;

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

  815.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  817. 

  818.     ignoreUnused (signMask);

  819.    #endif

  820. }

  821. 

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

  823. {

  824.    #if JUCE_USE_VDSP_FRAMEWORK

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

  826.    #else

  827.     FloatVectorHelpers::signMask64 signMask;

  828.     signMask.i = 0x7fffffffffffffffULL;

  829. 

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

  831.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  833. 

  834.     ignoreUnused (signMask);

  835.    #endif

  836. }

  837. 

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

  839. {

  840.    #if JUCE_USE_ARM_NEON

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

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

  843.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  844.    #else

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

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

  847.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

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

  849.    #endif

  850. }

  851. 

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

  853. {

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

  855.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  857. }

  858. 

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

  860. {

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

  862.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  864. }

  865. 

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

  867. {

  868.    #if JUCE_USE_VDSP_FRAMEWORK

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

  870.    #else

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

  872.    #endif

  873. }

  874. 

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

  876. {

  877.    #if JUCE_USE_VDSP_FRAMEWORK

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

  879.    #else

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

  881.    #endif

  882. }

  883. 

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

  885. {

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

  887.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  889. }

  890. 

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

  892. {

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

  894.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  896. }

  897. 

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

  899. {

  900.    #if JUCE_USE_VDSP_FRAMEWORK

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

  902.    #else

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

  904.    #endif

  905. }

  906. 

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

  908. {

  909.    #if JUCE_USE_VDSP_FRAMEWORK

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

  911.    #else

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

  913.    #endif

  914. }

  915. 

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

  917. {

  918.     jassert(high >= low);

  919. 

  920.    #if JUCE_USE_VDSP_FRAMEWORK

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

  922.    #else

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

  924.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  926.    #endif

  927. }

  928. 

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

  930. {

  931.     jassert(high >= low);

  932. 

  933.    #if JUCE_USE_VDSP_FRAMEWORK

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

  935.    #else

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

  937.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  939.    #endif

  940. }

  941. 

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

  943. {

  944.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  946.    #else

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

  948.    #endif

  949. }

  950. 

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

  952. {

  953.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  955.    #else

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

  957.    #endif

  958. }

  959. 

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

  961. {

  962.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  964.    #else

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

  966.    #endif

  967. }

  968. 

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

  970. {

  971.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  973.    #else

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

  975.    #endif

  976. }

  977. 

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

  979. {

  980.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  982.    #else

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

  984.    #endif

  985. }

  986. 

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

  988. {

  989.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  991.    #else

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

  993.    #endif

  994. }

  995. 

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

  997. {

  998.    #if JUCE_USE_SSE_INTRINSICS

  999.     _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  1000.    #endif

  1001.     ignoreUnused (shouldEnable);

  1002. }

  1003. 

  1004. void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport() noexcept

  1005. {

  1006.    #if JUCE_USE_SSE_INTRINSICS

  1007.     const unsigned int mxcsr = _mm_getcsr();

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

  1009.    #endif

  1010. }

  1011. 

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

  1013. //==============================================================================

  1014. #if JUCE_UNIT_TESTS

  1015. 

  1016. class FloatVectorOperationsTests  : public UnitTest

  1017. {

  1018. public:

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

  1020. 

  1021.     template <typename ValueType>

  1022.     struct TestRunner

  1023.     {

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

  1025.         {

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

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

  1028. 

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

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

  1031. 

  1032.            #if JUCE_ARM

  1033.             ValueType* const data1 = buffer1;

  1034.             ValueType* const data2 = buffer2;

  1035.             int* const int1 = buffer3;

  1036.            #else

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

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

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

  1040.            #endif

  1041. 

  1042.             fillRandomly (random, data1, num);

  1043.             fillRandomly (random, data2, num);

  1044. 

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

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

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

  1048. 

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

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

  1051. 

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

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

  1054. 

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

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

  1057. 

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

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

  1060. 

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

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

  1063. 

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

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

  1066. 

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

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

  1069. 

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

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

  1072. 

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

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

  1075. 

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

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

  1078. 

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

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

  1081. 

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

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

  1084. 

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

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

  1087. 

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

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

  1090. 

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

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

  1093. 

  1094.             fillRandomly (random, int1, num);

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

  1096. 

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

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

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

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

  1101.         }

  1102. 

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

  1104.         {

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

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

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

  1108.         }

  1109. 

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

  1111. 

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

  1113.         {

  1114.             while (--num >= 0)

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

  1116.         }

  1117. 

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

  1119.         {

  1120.             while (--num >= 0)

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

  1122.         }

  1123. 

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

  1125.         {

  1126.             while (--num >= 0)

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

  1128.         }

  1129. 

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

  1131.         {

  1132.             while (--num >= 0)

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

  1134.                     return false;

  1135. 

  1136.             return true;

  1137.         }

  1138. 

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

  1140.         {

  1141.             while (--num >= 0)

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

  1143.                     return false;

  1144. 

  1145.             return true;

  1146.         }

  1147. 

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

  1149.         {

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

  1151.         }

  1152.     };

  1153. 

  1154.     void runTest() override

  1155.     {

  1156.         beginTest ("FloatVectorOperations");

  1157. 

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

  1159.         {

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

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

  1162.         }

  1163.     }

  1164. };

  1165. 

  1166. static FloatVectorOperationsTests vectorOpTests;

  1167. 

  1168. #endif