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.
7774 Commits
9 Branches
407MB
Tree: 9b687968db
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9b687968db'
${ noResults }
JUCE/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp

1203 lines
54KB
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.    #if JUCE_USE_VDSP_FRAMEWORK

  693.     vDSP_vsmaD (src, 1, &multiplier, dest, 1, dest, 1, (vDSP_Length) num);

  694.    #else

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

  696.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  698.    #endif

  699. }

  700. 

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

  702. {

  703.    #if JUCE_USE_VDSP_FRAMEWORK

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

  705.    #else

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

  707.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  708.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  709.    #endif

  710. }

  711. 

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

  713. {

  714.    #if JUCE_USE_VDSP_FRAMEWORK

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

  716.    #else

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

  718.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  719.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  720.    #endif

  721. }

  722. 

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

  724. {

  725.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] -= src[i] * multiplier, Mode::sub (d, Mode::mul (mult, s)),

  726.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  728. }

  729. 

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

  731. {

  732.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] -= src[i] * multiplier, Mode::sub (d, Mode::mul (mult, s)),

  733.                                   JUCE_LOAD_SRC_DEST, JUCE_INCREMENT_SRC_DEST,

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

  735. }

  736. 

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

  738. {

  739.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST (dest[i] -= src1[i] * src2[i], Mode::sub (d, Mode::mul (s1, s2)),

  740.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  741.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  742. }

  743. 

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

  745. {

  746.     JUCE_PERFORM_VEC_OP_SRC1_SRC2_DEST_DEST (dest[i] -= src1[i] * src2[i], Mode::sub (d, Mode::mul (s1, s2)),

  747.                                              JUCE_LOAD_SRC1_SRC2_DEST,

  748.                                              JUCE_INCREMENT_SRC1_SRC2_DEST, )

  749. }

  750. 

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

  752. {

  753.    #if JUCE_USE_VDSP_FRAMEWORK

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

  755.    #else

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

  757.    #endif

  758. }

  759. 

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

  761. {

  762.    #if JUCE_USE_VDSP_FRAMEWORK

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

  764.    #else

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

  766.    #endif

  767. }

  768. 

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

  770. {

  771.    #if JUCE_USE_VDSP_FRAMEWORK

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

  773.    #else

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

  775.    #endif

  776. }

  777. 

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

  779. {

  780.    #if JUCE_USE_VDSP_FRAMEWORK

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

  782.    #else

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

  784.    #endif

  785. }

  786. 

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

  788. {

  789.    #if JUCE_USE_VDSP_FRAMEWORK

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

  791.    #else

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

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

  794.    #endif

  795. }

  796. 

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

  798. {

  799.    #if JUCE_USE_VDSP_FRAMEWORK

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

  801.    #else

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

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

  804.    #endif

  805. }

  806. 

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

  808. {

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

  810.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  812. }

  813. 

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

  815. {

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

  817.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  819. }

  820. 

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

  822. {

  823.    #if JUCE_USE_VDSP_FRAMEWORK

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

  825.    #else

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

  827.    #endif

  828. }

  829. 

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

  831. {

  832.    #if JUCE_USE_VDSP_FRAMEWORK

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

  834.    #else

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

  836.    #endif

  837. }

  838. 

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

  840. {

  841.    #if JUCE_USE_VDSP_FRAMEWORK

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

  843.    #else

  844.     FloatVectorHelpers::signMask32 signMask;

  845.     signMask.i = 0x7fffffffUL;

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

  847.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  849. 

  850.     ignoreUnused (signMask);

  851.    #endif

  852. }

  853. 

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

  855. {

  856.    #if JUCE_USE_VDSP_FRAMEWORK

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

  858.    #else

  859.     FloatVectorHelpers::signMask64 signMask;

  860.     signMask.i = 0x7fffffffffffffffULL;

  861. 

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

  863.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  865. 

  866.     ignoreUnused (signMask);

  867.    #endif

  868. }

  869. 

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

  871. {

  872.    #if JUCE_USE_ARM_NEON

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

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

  875.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST, )

  876.    #else

  877.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = (float) src[i] * multiplier,

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

  879.                                   JUCE_LOAD_NONE, JUCE_INCREMENT_SRC_DEST,

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

  881.    #endif

  882. }

  883. 

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

  885. {

  886.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmin (src[i], comp), Mode::min (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::min (double* dest, const double* src, double comp, int num) noexcept

  892. {

  893.     JUCE_PERFORM_VEC_OP_SRC_DEST (dest[i] = jmin (src[i], comp), Mode::min (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::min (float* dest, const float* src1, const float* src2, int num) noexcept

  899. {

  900.    #if JUCE_USE_VDSP_FRAMEWORK

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

  902.    #else

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

  904.    #endif

  905. }

  906. 

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

  908. {

  909.    #if JUCE_USE_VDSP_FRAMEWORK

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

  911.    #else

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

  913.    #endif

  914. }

  915. 

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

  917. {

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

  919.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  921. }

  922. 

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

  924. {

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

  926.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  928. }

  929. 

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

  931. {

  932.    #if JUCE_USE_VDSP_FRAMEWORK

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

  934.    #else

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

  936.    #endif

  937. }

  938. 

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

  940. {

  941.    #if JUCE_USE_VDSP_FRAMEWORK

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

  943.    #else

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

  945.    #endif

  946. }

  947. 

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

  949. {

  950.     jassert(high >= low);

  951. 

  952.    #if JUCE_USE_VDSP_FRAMEWORK

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

  954.    #else

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

  956.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  958.    #endif

  959. }

  960. 

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

  962. {

  963.     jassert(high >= low);

  964. 

  965.    #if JUCE_USE_VDSP_FRAMEWORK

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

  967.    #else

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

  969.                                   JUCE_LOAD_SRC, JUCE_INCREMENT_SRC_DEST,

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

  971.    #endif

  972. }

  973. 

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

  975. {

  976.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  978.    #else

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

  980.    #endif

  981. }

  982. 

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

  984. {

  985.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  987.    #else

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

  989.    #endif

  990. }

  991. 

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

  993. {

  994.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  996.    #else

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

  998.    #endif

  999. }

  1000. 

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

  1002. {

  1003.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  1005.    #else

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

  1007.    #endif

  1008. }

  1009. 

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

  1011. {

  1012.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  1014.    #else

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

  1016.    #endif

  1017. }

  1018. 

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

  1020. {

  1021.    #if JUCE_USE_SSE_INTRINSICS || JUCE_USE_ARM_NEON

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

  1023.    #else

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

  1025.    #endif

  1026. }

  1027. 

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

  1029. {

  1030.    #if JUCE_USE_SSE_INTRINSICS

  1031.     _MM_SET_FLUSH_ZERO_MODE (shouldEnable ? _MM_FLUSH_ZERO_ON : _MM_FLUSH_ZERO_OFF);

  1032.    #endif

  1033.     ignoreUnused (shouldEnable);

  1034. }

  1035. 

  1036. void JUCE_CALLTYPE FloatVectorOperations::disableDenormalisedNumberSupport() noexcept

  1037. {

  1038.    #if JUCE_USE_SSE_INTRINSICS

  1039.     const unsigned int mxcsr = _mm_getcsr();

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

  1041.    #endif

  1042. }

  1043. 

  1044. //==============================================================================

  1045. //==============================================================================

  1046. #if JUCE_UNIT_TESTS

  1047. 

  1048. class FloatVectorOperationsTests  : public UnitTest

  1049. {

  1050. public:

  1051.     FloatVectorOperationsTests() : UnitTest ("FloatVectorOperations", "Audio") {}

  1052. 

  1053.     template <typename ValueType>

  1054.     struct TestRunner

  1055.     {

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

  1057.         {

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

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

  1060. 

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

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

  1063. 

  1064.            #if JUCE_ARM

  1065.             ValueType* const data1 = buffer1;

  1066.             ValueType* const data2 = buffer2;

  1067.             int* const int1 = buffer3;

  1068.            #else

  1069.             // These tests deliberately operate on misaligned memory and will be flagged up by

  1070.             // checks for undefined behavior!

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

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

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

  1074.            #endif

  1075. 

  1076.             fillRandomly (random, data1, num);

  1077.             fillRandomly (random, data2, num);

  1078. 

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

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

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

  1082. 

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

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

  1085. 

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

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

  1088. 

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

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

  1091. 

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

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

  1094. 

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

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

  1097. 

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

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

  1100. 

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

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

  1103. 

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

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

  1106. 

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

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

  1109. 

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

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

  1112. 

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

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

  1115. 

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

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

  1118. 

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

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

  1121. 

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

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

  1124. 

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

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

  1127. 

  1128.             fillRandomly (random, int1, num);

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

  1130. 

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

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

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

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

  1135.         }

  1136. 

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

  1138.         {

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

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

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

  1142.         }

  1143. 

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

  1145. 

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

  1147.         {

  1148.             while (--num >= 0)

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

  1150.         }

  1151. 

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

  1153.         {

  1154.             while (--num >= 0)

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

  1156.         }

  1157. 

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

  1159.         {

  1160.             while (--num >= 0)

  1161.                 *d++ = (float) *s++ * multiplier;

  1162.         }

  1163. 

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

  1165.         {

  1166.             while (--num >= 0)

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

  1168.                     return false;

  1169. 

  1170.             return true;

  1171.         }

  1172. 

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

  1174.         {

  1175.             while (--num >= 0)

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

  1177.                     return false;

  1178. 

  1179.             return true;

  1180.         }

  1181. 

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

  1183.         {

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

  1185.         }

  1186.     };

  1187. 

  1188.     void runTest() override

  1189.     {

  1190.         beginTest ("FloatVectorOperations");

  1191. 

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

  1193.         {

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

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

  1196.         }

  1197.     }

  1198. };

  1199. 

  1200. static FloatVectorOperationsTests vectorOpTests;

  1201. 

  1202. #endif