falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3323 Commits
16 Branches
16GB
Tree: e1ff768f37
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e1ff768f37'
${ noResults }
Carla/source/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.h

211 lines
12KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI Ltd.

  6. 

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

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

  9.    b) the Affero GPL v3

  10. 

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

  12. 

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

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

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

  16. 

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

  18. 

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

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

  21. 

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

  23. */

  24. 

  25. #ifndef JUCE_FLOATVECTOROPERATIONS_H_INCLUDED

  26. #define JUCE_FLOATVECTOROPERATIONS_H_INCLUDED

  27. 

  28. 

  29. //==============================================================================

  30. /**

  31.     A collection of simple vector operations on arrays of floats, accelerated with

  32.     SIMD instructions where possible.

  33. */

  34. class JUCE_API  FloatVectorOperations

  35. {

  36. public:

  37.     //==============================================================================

  38.     /** Clears a vector of floats. */

  39.     static void JUCE_CALLTYPE clear (float* dest, int numValues) noexcept;

  40. 

  41.     /** Clears a vector of doubles. */

  42.     static void JUCE_CALLTYPE clear (double* dest, int numValues) noexcept;

  43. 

  44.     /** Copies a repeated value into a vector of floats. */

  45.     static void JUCE_CALLTYPE fill (float* dest, float valueToFill, int numValues) noexcept;

  46. 

  47.     /** Copies a repeated value into a vector of doubles. */

  48.     static void JUCE_CALLTYPE fill (double* dest, double valueToFill, int numValues) noexcept;

  49. 

  50.     /** Copies a vector of floats. */

  51.     static void JUCE_CALLTYPE copy (float* dest, const float* src, int numValues) noexcept;

  52. 

  53.     /** Copies a vector of doubles. */

  54.     static void JUCE_CALLTYPE copy (double* dest, const double* src, int numValues) noexcept;

  55. 

  56.     /** Copies a vector of floats, multiplying each value by a given multiplier */

  57.     static void JUCE_CALLTYPE copyWithMultiply (float* dest, const float* src, float multiplier, int numValues) noexcept;

  58. 

  59.     /** Copies a vector of doubles, multiplying each value by a given multiplier */

  60.     static void JUCE_CALLTYPE copyWithMultiply (double* dest, const double* src, double multiplier, int numValues) noexcept;

  61. 

  62.     /** Adds a fixed value to the destination values. */

  63.     static void JUCE_CALLTYPE add (float* dest, float amountToAdd, int numValues) noexcept;

  64. 

  65.     /** Adds a fixed value to the destination values. */

  66.     static void JUCE_CALLTYPE add (double* dest, double amountToAdd, int numValues) noexcept;

  67. 

  68.     /** Adds a fixed value to each source value and stores it in the destination array. */

  69.     static void JUCE_CALLTYPE add (float* dest, float* src, float amount, int numValues) noexcept;

  70. 

  71.     /** Adds a fixed value to each source value and stores it in the destination array. */

  72.     static void JUCE_CALLTYPE add (double* dest, double* src, double amount, int numValues) noexcept;

  73. 

  74.     /** Adds the source values to the destination values. */

  75.     static void JUCE_CALLTYPE add (float* dest, const float* src, int numValues) noexcept;

  76. 

  77.     /** Adds the source values to the destination values. */

  78.     static void JUCE_CALLTYPE add (double* dest, const double* src, int numValues) noexcept;

  79. 

  80.     /** Adds each source1 value to the corresponding source2 value and stores the result in the destination array. */

  81.     static void JUCE_CALLTYPE add (float* dest, const float* src1, const float* src2, int num) noexcept;

  82. 

  83.     /** Adds each source1 value to the corresponding source2 value and stores the result in the destination array. */

  84.     static void JUCE_CALLTYPE add (double* dest, const double* src1, const double* src2, int num) noexcept;

  85. 

  86.     /** Subtracts the source values from the destination values. */

  87.     static void JUCE_CALLTYPE subtract (float* dest, const float* src, int numValues) noexcept;

  88. 

  89.     /** Subtracts the source values from the destination values. */

  90.     static void JUCE_CALLTYPE subtract (double* dest, const double* src, int numValues) noexcept;

  91. 

  92.     /** Subtracts each source2 value from the corresponding source1 value and stores the result in the destination array. */

  93.     static void JUCE_CALLTYPE subtract (float* dest, const float* src1, const float* src2, int num) noexcept;

  94. 

  95.     /** Subtracts each source2 value from the corresponding source1 value and stores the result in the destination array. */

  96.     static void JUCE_CALLTYPE subtract (double* dest, const double* src1, const double* src2, int num) noexcept;

  97. 

  98.     /** Multiplies each source value by the given multiplier, then adds it to the destination value. */

  99.     static void JUCE_CALLTYPE addWithMultiply (float* dest, const float* src, float multiplier, int numValues) noexcept;

  100. 

  101.     /** Multiplies each source value by the given multiplier, then adds it to the destination value. */

  102.     static void JUCE_CALLTYPE addWithMultiply (double* dest, const double* src, double multiplier, int numValues) noexcept;

  103. 

  104.     /** Multiplies each source1 value by the corresponding source2 value, then adds it to the destination value. */

  105.     static void JUCE_CALLTYPE addWithMultiply (float* dest, const float* src1, const float* src2, int num) noexcept;

  106. 

  107.     /** Multiplies each source1 value by the corresponding source2 value, then adds it to the destination value. */

  108.     static void JUCE_CALLTYPE addWithMultiply (double* dest, const double* src1, const double* src2, int num) noexcept;

  109. 

  110.     /** Multiplies the destination values by the source values. */

  111.     static void JUCE_CALLTYPE multiply (float* dest, const float* src, int numValues) noexcept;

  112. 

  113.     /** Multiplies the destination values by the source values. */

  114.     static void JUCE_CALLTYPE multiply (double* dest, const double* src, int numValues) noexcept;

  115. 

  116.     /** Multiplies each source1 value by the correspinding source2 value, then stores it in the destination array. */

  117.     static void JUCE_CALLTYPE multiply (float* dest, const float* src1, const float* src2, int numValues) noexcept;

  118. 

  119.     /** Multiplies each source1 value by the correspinding source2 value, then stores it in the destination array. */

  120.     static void JUCE_CALLTYPE multiply (double* dest, const double* src1, const double* src2, int numValues) noexcept;

  121. 

  122.     /** Multiplies each of the destination values by a fixed multiplier. */

  123.     static void JUCE_CALLTYPE multiply (float* dest, float multiplier, int numValues) noexcept;

  124. 

  125.     /** Multiplies each of the destination values by a fixed multiplier. */

  126.     static void JUCE_CALLTYPE multiply (double* dest, double multiplier, int numValues) noexcept;

  127. 

  128.     /** Multiplies each of the source values by a fixed multiplier and stores the result in the destination array. */

  129.     static void JUCE_CALLTYPE multiply (float* dest, const float* src, float multiplier, int num) noexcept;

  130. 

  131.     /** Multiplies each of the source values by a fixed multiplier and stores the result in the destination array. */

  132.     static void JUCE_CALLTYPE multiply (double* dest, const double* src, double multiplier, int num) noexcept;

  133. 

  134.     /** Copies a source vector to a destination, negating each value. */

  135.     static void JUCE_CALLTYPE negate (float* dest, const float* src, int numValues) noexcept;

  136. 

  137.     /** Copies a source vector to a destination, negating each value. */

  138.     static void JUCE_CALLTYPE negate (double* dest, const double* src, int numValues) noexcept;

  139. 

  140.     /** Copies a source vector to a destination, taking the absolute of each value. */

  141.     static void JUCE_CALLTYPE abs (float* dest, const float* src, int numValues) noexcept;

  142. 

  143.     /** Copies a source vector to a destination, taking the absolute of each value. */

  144.     static void JUCE_CALLTYPE abs (double* dest, const double* src, int numValues) noexcept;

  145. 

  146.     /** Converts a stream of integers to floats, multiplying each one by the given multiplier. */

  147.     static void JUCE_CALLTYPE convertFixedToFloat (float* dest, const int* src, float multiplier, int numValues) noexcept;

  148. 

  149.     /** Each element of dest will be the minimum of the corresponding element of the source array and the given comp value. */

  150.     static void JUCE_CALLTYPE min (float* dest, const float* src, float comp, int num) noexcept;

  151. 

  152.     /** Each element of dest will be the minimum of the corresponding element of the source array and the given comp value. */

  153.     static void JUCE_CALLTYPE min (double* dest, const double* src, double comp, int num) noexcept;

  154. 

  155.     /** Each element of dest will be the minimum of the corresponding source1 and source2 values. */

  156.     static void JUCE_CALLTYPE min (float* dest, const float* src1, const float* src2, int num) noexcept;

  157. 

  158.     /** Each element of dest will be the minimum of the corresponding source1 and source2 values. */

  159.     static void JUCE_CALLTYPE min (double* dest, const double* src1, const double* src2, int num) noexcept;

  160. 

  161.     /** Each element of dest will be the maximum of the corresponding element of the source array and the given comp value. */

  162.     static void JUCE_CALLTYPE max (float* dest, const float* src, float comp, int num) noexcept;

  163. 

  164.     /** Each element of dest will be the maximum of the corresponding element of the source array and the given comp value. */

  165.     static void JUCE_CALLTYPE max (double* dest, const double* src, double comp, int num) noexcept;

  166. 

  167.     /** Each element of dest will be the maximum of the corresponding source1 and source2 values. */

  168.     static void JUCE_CALLTYPE max (float* dest, const float* src1, const float* src2, int num) noexcept;

  169. 

  170.     /** Each element of dest will be the maximum of the corresponding source1 and source2 values. */

  171.     static void JUCE_CALLTYPE max (double* dest, const double* src1, const double* src2, int num) noexcept;

  172. 

  173.     /** Each element of dest is calculated by hard clipping the corresponding src element so that it is in the range specified by the arguments low and high. */

  174.     static void JUCE_CALLTYPE clip (float* dest, const float* src, float low, float high, int num) noexcept;

  175. 

  176.     /** Each element of dest is calculated by hard clipping the corresponding src element so that it is in the range specified by the arguments low and high. */

  177.     static void JUCE_CALLTYPE clip (double* dest, const double* src, double low, double high, int num) noexcept;

  178. 

  179.     /** Finds the miniumum and maximum values in the given array. */

  180.     static Range<float> JUCE_CALLTYPE findMinAndMax (const float* src, int numValues) noexcept;

  181. 

  182.     /** Finds the miniumum and maximum values in the given array. */

  183.     static Range<double> JUCE_CALLTYPE findMinAndMax (const double* src, int numValues) noexcept;

  184. 

  185.     /** Finds the miniumum value in the given array. */

  186.     static float JUCE_CALLTYPE findMinimum (const float* src, int numValues) noexcept;

  187. 

  188.     /** Finds the miniumum value in the given array. */

  189.     static double JUCE_CALLTYPE findMinimum (const double* src, int numValues) noexcept;

  190. 

  191.     /** Finds the maximum value in the given array. */

  192.     static float JUCE_CALLTYPE findMaximum (const float* src, int numValues) noexcept;

  193. 

  194.     /** Finds the maximum value in the given array. */

  195.     static double JUCE_CALLTYPE findMaximum (const double* src, int numValues) noexcept;

  196. 

  197.     /** On Intel CPUs, this method enables or disables the SSE flush-to-zero mode.

  198.         Effectively, this is a wrapper around a call to _MM_SET_FLUSH_ZERO_MODE

  199.     */

  200.     static void JUCE_CALLTYPE enableFlushToZeroMode (bool shouldEnable) noexcept;

  201. 

  202.     /** On Intel CPUs, this method enables the SSE flush-to-zero and denormalised-are-zero modes.

  203.         This effectively sets the DAZ and FZ bits of the MXCSR register. It's a convenient thing to

  204.         call before audio processing code where you really want to avoid denormalisation performance hits.

  205.     */

  206.     static void JUCE_CALLTYPE disableDenormalisedNumberSupport() noexcept;

  207. };

  208. 

  209. 

  210. #endif   // JUCE_FLOATVECTOROPERATIONS_H_INCLUDED