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.
12859 Commits
11 Branches
1.3GB
Tree: d69706e08a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd69706e08a'
${ noResults }
JUCE/modules/juce_dsp/containers/juce_AudioBlock_test.cpp

504 lines
19KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2020 - Raw Material Software Limited

  6. 

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

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 6 End-User License

  11.    Agreement and JUCE Privacy Policy (both effective as of the 16th June 2020).

  12. 

  13.    End User License Agreement: www.juce.com/juce-6-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

  16.    Or: You may also use this code under the terms of the GPL v3 (see

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. namespace juce

  27. {

  28. namespace dsp

  29. {

  30. 

  31. template <typename SampleType>

  32. class AudioBlockUnitTests   : public UnitTest

  33. {

  34. public:

  35.     //==============================================================================

  36.     using NumericType = typename SampleTypeHelpers::ElementType<SampleType>::Type;

  37. 

  38.     AudioBlockUnitTests()

  39.         : UnitTest ("AudioBlock", UnitTestCategories::dsp)

  40.     {

  41.         for (auto v : { &data, &otherData })

  42.             for (auto& channel : *v)

  43.                 channel = allocateAlignedMemory (numSamples);

  44. 

  45.         block      = { data.data(),      data.size(),      (size_t) numSamples };

  46.         otherBlock = { otherData.data(), otherData.size(), (size_t) numSamples };

  47. 

  48.         resetBlocks();

  49.     }

  50. 

  51.     ~AudioBlockUnitTests() override

  52.     {

  53.         for (auto v : { &data, &otherData })

  54.             for (auto channel : *v)

  55.                 deallocateAlignedMemory (channel);

  56.     }

  57. 

  58.     void runTest() override

  59.     {

  60.         beginTest ("Equality");

  61.         {

  62.             expect (block == block);

  63.             expect (block != otherBlock);

  64.         }

  65. 

  66.         beginTest ("Constructors");

  67.         {

  68.             expect (block == AudioBlock<SampleType> (data.data(), data.size(), numSamples));

  69.             expect (block == AudioBlock<SampleType> (data.data(), data.size(), (size_t) 0, numSamples));

  70.             expect (block == AudioBlock<SampleType> (block));

  71. 

  72.             expect (block == AudioBlock<const SampleType> (data.data(), data.size(), numSamples));

  73.             expect (block == AudioBlock<const SampleType> (data.data(), data.size(), (size_t) 0, numSamples));

  74.             expect (block == AudioBlock<const SampleType> (block));

  75.         }

  76. 

  77.         beginTest ("Swap");

  78.         {

  79.             resetBlocks();

  80. 

  81.             expect (block != otherBlock);

  82.             expect (block.getSample (0, 0) == SampleType (1.0));

  83.             expect (block.getSample (0, 4) == SampleType (5.0));

  84.             expect (otherBlock.getSample (0, 0) == SampleType (-1.0));

  85.             expect (otherBlock.getSample (0, 3) == SampleType (-4.0));

  86. 

  87.             block.swap (otherBlock);

  88. 

  89.             expect (block != otherBlock);

  90.             expect (otherBlock.getSample (0, 0) == SampleType (1.0));

  91.             expect (otherBlock.getSample (0, 4) == SampleType (5.0));

  92.             expect (block.getSample (0, 0) == SampleType (-1.0));

  93.             expect (block.getSample (0, 3) == SampleType (-4.0));

  94. 

  95.             block.swap (otherBlock);

  96. 

  97.             expect (block.getSample (0, 0) == SampleType (1.0));

  98.             expect (block.getSample (0, 4) == SampleType (5.0));

  99.             expect (otherBlock.getSample (0, 0) == SampleType (-1.0));

  100.             expect (otherBlock.getSample (0, 3) == SampleType (-4.0));

  101.         }

  102. 

  103.         beginTest ("Getters and setters");

  104.         {

  105.             resetBlocks();

  106. 

  107.             expectEquals ((int) block.getNumChannels(), (int) data.size());

  108.             expectEquals ((int) block.getNumSamples(), numSamples);

  109. 

  110.             expect (block.getChannelPointer (0)[2] == SampleType (3.0));

  111.             block.getChannelPointer (0)[2] = SampleType (999.0);

  112.             expect (block.getChannelPointer (0)[2] == SampleType (999.0));

  113. 

  114.             expect (block.getSample (0, 4) == SampleType (5.0));

  115.             expect (block.getSample (1, 4) == SampleType (11.0));

  116. 

  117.             expect (block.getSingleChannelBlock (1).getSample (0, 3) == block.getSample (1, 3));

  118. 

  119.             expect (block.getSubsetChannelBlock (0, 2).getSample (1, 3) == block.getSample (1, 3));

  120.             expect (block.getSubsetChannelBlock (1, 1).getSample (0, 3) == block.getSample (1, 3));

  121. 

  122.             block.setSample (1, 1, SampleType (777.0));

  123.             expect (block.getSample (1, 1) == SampleType (777.0));

  124. 

  125.             block.addSample (1, 1, SampleType (1.0));

  126.             expect (block.getSample (1, 1) == SampleType (778.0));

  127.         }

  128. 

  129.         beginTest ("Basic copying");

  130.         {

  131.             block.clear();

  132.             expect (block.getSample (0, 2) == SampleType (0.0));

  133.             expect (block.getSample (1, 4) == SampleType (0.0));

  134. 

  135.             block.fill ((NumericType) 456.0);

  136.             expect (block.getSample (0, 2) == SampleType (456.0));

  137.             expect (block.getSample (1, 4) == SampleType (456.0));

  138. 

  139.             block.copyFrom (otherBlock);

  140.             expect (block != otherBlock);

  141.             expect (block.getSample (0, 2) == otherBlock.getSample (0, 2));

  142.             expect (block.getSample (1, 4) == otherBlock.getSample (1, 4));

  143. 

  144.             resetBlocks();

  145. 

  146.             SampleType testSample1 = block.getSample (0, 2);

  147.             SampleType testSample2 = block.getSample (1, 3);

  148.             expect (testSample1 != block.getSample (0, 4));

  149.             expect (testSample2 != block.getSample (1, 5));

  150.             block.move (0, 2);

  151.             expect (block.getSample (0, 4) == testSample1);

  152.             expect (block.getSample (1, 5) == testSample2);

  153.         }

  154. 

  155.         beginTest ("Addition");

  156.         {

  157.             resetBlocks();

  158. 

  159.             block.add ((NumericType) 15.0);

  160.             expect (block.getSample (0, 4) == SampleType (20.0));

  161.             expect (block.getSample (1, 4) == SampleType (26.0));

  162. 

  163.             block.add (otherBlock);

  164.             expect (block.getSample (0, 4) == SampleType (15.0));

  165.             expect (block.getSample (1, 4) == SampleType (15.0));

  166. 

  167.             block.replaceWithSumOf (otherBlock, (NumericType) 9.0);

  168.             expect (block.getSample (0, 4) == SampleType (4.0));

  169.             expect (block.getSample (1, 4) == SampleType (-2.0));

  170. 

  171.             resetBlocks();

  172. 

  173.             block.replaceWithSumOf (block, otherBlock);

  174.             expect (block.getSample (0, 4) == SampleType (0.0));

  175.             expect (block.getSample (1, 4) == SampleType (0.0));

  176.         }

  177. 

  178.         beginTest ("Subtraction");

  179.         {

  180.             resetBlocks();

  181. 

  182.             block.subtract ((NumericType) 15.0);

  183.             expect (block.getSample (0, 4) == SampleType (-10.0));

  184.             expect (block.getSample (1, 4) == SampleType (-4.0));

  185. 

  186.             block.subtract (otherBlock);

  187.             expect (block.getSample (0, 4) == SampleType (-5.0));

  188.             expect (block.getSample (1, 4) == SampleType (7.0));

  189. 

  190.             block.replaceWithDifferenceOf (otherBlock, (NumericType) 9.0);

  191.             expect (block.getSample (0, 4) == SampleType (-14.0));

  192.             expect (block.getSample (1, 4) == SampleType (-20.0));

  193. 

  194.             resetBlocks();

  195. 

  196.             block.replaceWithDifferenceOf (block, otherBlock);

  197.             expect (block.getSample (0, 4) == SampleType (10.0));

  198.             expect (block.getSample (1, 4) == SampleType (22.0));

  199.         }

  200. 

  201.         beginTest ("Multiplication");

  202.         {

  203.             resetBlocks();

  204. 

  205.             block.multiplyBy ((NumericType) 10.0);

  206.             expect (block.getSample (0, 4) == SampleType (50.0));

  207.             expect (block.getSample (1, 4) == SampleType (110.0));

  208. 

  209.             block.multiplyBy (otherBlock);

  210.             expect (block.getSample (0, 4) == SampleType (-250.0));

  211.             expect (block.getSample (1, 4) == SampleType (-1210.0));

  212. 

  213.             block.replaceWithProductOf (otherBlock, (NumericType) 3.0);

  214.             expect (block.getSample (0, 4) == SampleType (-15.0));

  215.             expect (block.getSample (1, 4) == SampleType (-33.0));

  216. 

  217.             resetBlocks();

  218. 

  219.             block.replaceWithProductOf (block, otherBlock);

  220.             expect (block.getSample (0, 4) == SampleType (-25.0));

  221.             expect (block.getSample (1, 4) == SampleType (-121.0));

  222.         }

  223. 

  224.         beginTest ("Multiply add");

  225.         {

  226.             resetBlocks();

  227. 

  228.             block.addProductOf (otherBlock, (NumericType) -1.0);

  229.             expect (block.getSample (0, 4) == SampleType (10.0));

  230.             expect (block.getSample (1, 4) == SampleType (22.0));

  231. 

  232.             block.addProductOf (otherBlock, otherBlock);

  233.             expect (block.getSample (0, 4) == SampleType (35.0));

  234.             expect (block.getSample (1, 4) == SampleType (143.0));

  235.         }

  236. 

  237.         beginTest ("Negative abs min max");

  238.         {

  239.             resetBlocks();

  240.             otherBlock.negate();

  241. 

  242.             block.add (otherBlock);

  243.             expect (block.getSample (0, 4) == SampleType (10.0));

  244.             expect (block.getSample (1, 4) == SampleType (22.0));

  245. 

  246.             block.replaceWithNegativeOf (otherBlock);

  247.             expect (block.getSample (0, 4) == SampleType (-5.0));

  248.             expect (block.getSample (1, 4) == SampleType (-11.0));

  249. 

  250.             block.clear();

  251.             otherBlock.negate();

  252.             block.replaceWithAbsoluteValueOf (otherBlock);

  253.             expect (block.getSample (0, 4) == SampleType (5.0));

  254.             expect (block.getSample (1, 4) == SampleType (11.0));

  255. 

  256.             resetBlocks();

  257.             block.replaceWithMinOf (block, otherBlock);

  258.             expect (block.getSample (0, 4) == SampleType (-5.0));

  259.             expect (block.getSample (1, 4) == SampleType (-11.0));

  260. 

  261.             resetBlocks();

  262.             block.replaceWithMaxOf (block, otherBlock);

  263.             expect (block.getSample (0, 4) == SampleType (5.0));

  264.             expect (block.getSample (1, 4) == SampleType (11.0));

  265. 

  266.             resetBlocks();

  267.             auto range = block.findMinAndMax();

  268.             expect (SampleType (range.getStart()) == SampleType (1.0));

  269.             expect (SampleType (range.getEnd()) == SampleType (12.0));

  270.         }

  271. 

  272.         beginTest ("Operators");

  273.         {

  274.             resetBlocks();

  275.             block += (NumericType) 10.0;

  276.             expect (block.getSample (0, 4) == SampleType (15.0));

  277.             expect (block.getSample (1, 4) == SampleType (21.0));

  278.             block += otherBlock;

  279.             expect (block.getSample (0, 4) == SampleType (10.0));

  280.             expect (block.getSample (1, 4) == SampleType (10.0));

  281. 

  282.             resetBlocks();

  283.             block -= (NumericType) 10.0;

  284.             expect (block.getSample (0, 4) == SampleType (-5.0));

  285.             expect (block.getSample (1, 4) == SampleType (1.0));

  286.             block -= otherBlock;

  287.             expect (block.getSample (0, 4) == SampleType (0.0));

  288.             expect (block.getSample (1, 4) == SampleType (12.0));

  289. 

  290.             resetBlocks();

  291.             block *= (NumericType) 10.0;

  292.             expect (block.getSample (0, 4) == SampleType (50.0));

  293.             expect (block.getSample (1, 4) == SampleType (110.0));

  294.             block *= otherBlock;

  295.             expect (block.getSample (0, 4) == SampleType (-250.0));

  296.             expect (block.getSample (1, 4) == SampleType (-1210.0));

  297.         }

  298. 

  299.         beginTest ("Process");

  300.         {

  301.             resetBlocks();

  302.             AudioBlock<SampleType>::process (block, otherBlock, [] (SampleType x) { return x + (NumericType) 1.0; });

  303.             expect (otherBlock.getSample (0, 4) == SampleType (6.0));

  304.             expect (otherBlock.getSample (1, 4) == SampleType (12.0));

  305.         }

  306. 

  307.         beginTest ("Copying");

  308.         {

  309.             resetBlocks();

  310.             copyingTests();

  311.         }

  312. 

  313.         beginTest ("Smoothing");

  314.         {

  315.             resetBlocks();

  316.             smoothedValueTests();

  317.         }

  318.     }

  319. 

  320. private:

  321.     //==============================================================================

  322.     template <typename T>

  323.     using ScalarVoid = typename std::enable_if_t <  std::is_scalar <T>::value, void>;

  324. 

  325.     template <typename T>

  326.     using SIMDVoid   = typename std::enable_if_t <! std::is_scalar <T>::value, void>;

  327. 

  328.     //==============================================================================

  329.     template <typename T = SampleType>

  330.     ScalarVoid<T> copyingTests()

  331.     {

  332.         auto unchangedElement1 = block.getSample (0, 4);

  333.         auto unchangedElement2 = block.getSample (1, 1);

  334. 

  335.         AudioBuffer<SampleType> otherBuffer (otherData.data(), (int) otherData.size(), numSamples);

  336. 

  337.         block.copyFrom (otherBuffer, 1, 2, 2);

  338. 

  339.         expectEquals (block.getSample (0, 4), unchangedElement1);

  340.         expectEquals (block.getSample (1, 1), unchangedElement2);

  341.         expectEquals (block.getSample (0, 2), otherBuffer.getSample (0, 1));

  342.         expectEquals (block.getSample (1, 3), otherBuffer.getSample (1, 2));

  343. 

  344.         resetBlocks();

  345. 

  346.         unchangedElement1 = otherBuffer.getSample (0, 4);

  347.         unchangedElement2 = otherBuffer.getSample (1, 3);

  348. 

  349.         block.copyTo (otherBuffer, 2, 1, 2);

  350. 

  351.         expectEquals (otherBuffer.getSample (0, 4), unchangedElement1);

  352.         expectEquals (otherBuffer.getSample (1, 3), unchangedElement2);

  353.         expectEquals (otherBuffer.getSample (0, 1), block.getSample (0, 2));

  354.         expectEquals (otherBuffer.getSample (1, 2), block.getSample (1, 3));

  355.     }

  356. 

  357.    #if JUCE_USE_SIMD

  358.     template <typename T = SampleType>

  359.     SIMDVoid<T> copyingTests()

  360.     {

  361.         auto numSIMDElements = SIMDRegister<NumericType>::SIMDNumElements;

  362.         AudioBuffer<NumericType> numericData ((int) block.getNumChannels(),

  363.                                               (int) (block.getNumSamples() * numSIMDElements));

  364. 

  365.         for (int c = 0; c < numericData.getNumChannels(); ++c)

  366.             std::fill_n (numericData.getWritePointer (c), numericData.getNumSamples(), (NumericType) 1.0);

  367. 

  368.         numericData.applyGainRamp (0, numericData.getNumSamples(), (NumericType) 0.127, (NumericType) 17.3);

  369. 

  370.         auto lastUnchangedIndexBeforeCopiedRange = (int) ((numSIMDElements * 2) - 1);

  371.         auto firstUnchangedIndexAfterCopiedRange = (int) ((numSIMDElements * 4) + 1);

  372.         auto unchangedElement1 = numericData.getSample (0, lastUnchangedIndexBeforeCopiedRange);

  373.         auto unchangedElement2 = numericData.getSample (1, firstUnchangedIndexAfterCopiedRange);

  374. 

  375.         block.copyTo (numericData, 1, 2, 2);

  376. 

  377.         expectEquals (numericData.getSample (0, lastUnchangedIndexBeforeCopiedRange), unchangedElement1);

  378.         expectEquals (numericData.getSample (1, firstUnchangedIndexAfterCopiedRange), unchangedElement2);

  379.         expect (SampleType (numericData.getSample (0, 2 * (int) numSIMDElements)) == block.getSample (0, 1));

  380.         expect (SampleType (numericData.getSample (1, 3 * (int) numSIMDElements)) == block.getSample (1, 2));

  381. 

  382.         numericData.applyGainRamp (0, numericData.getNumSamples(), (NumericType) 15.1, (NumericType) 0.7);

  383. 

  384.         auto unchangedSIMDElement1 = block.getSample (0, 1);

  385.         auto unchangedSIMDElement2 = block.getSample (1, 4);

  386. 

  387.         block.copyFrom (numericData, 1, 2, 2);

  388. 

  389.         expect (block.getSample (0, 1) == unchangedSIMDElement1);

  390.         expect (block.getSample (1, 4) == unchangedSIMDElement2);

  391.         expectEquals (block.getSample (0, 2).get (0), numericData.getSample (0, (int) numSIMDElements));

  392.         expectEquals (block.getSample (1, 3).get (0), numericData.getSample (1, (int) (numSIMDElements * 2)));

  393. 

  394.         if (numSIMDElements > 1)

  395.         {

  396.             expectEquals (block.getSample (0, 2).get (1), numericData.getSample (0, (int) (numSIMDElements + 1)));

  397.             expectEquals (block.getSample (1, 3).get (1), numericData.getSample (1, (int) ((numSIMDElements * 2) + 1)));

  398.         }

  399.     }

  400.    #endif

  401. 

  402.     //==============================================================================

  403.     template <typename T = SampleType>

  404.     ScalarVoid<T> smoothedValueTests()

  405.     {

  406.         block.fill ((SampleType) 1.0);

  407.         SmoothedValue<SampleType> sv { (SampleType) 1.0 };

  408.         sv.reset (1, 4);

  409.         sv.setTargetValue ((SampleType) 0.0);

  410. 

  411.         block.multiplyBy (sv);

  412.         expect (block.getSample (0, 2) < (SampleType) 1.0);

  413.         expect (block.getSample (1, 2) < (SampleType) 1.0);

  414.         expect (block.getSample (0, 2) > (SampleType) 0.0);

  415.         expect (block.getSample (1, 2) > (SampleType) 0.0);

  416.         expectEquals (block.getSample (0, 5), (SampleType) 0.0);

  417.         expectEquals (block.getSample (1, 5), (SampleType) 0.0);

  418. 

  419.         sv.setCurrentAndTargetValue (-1.0f);

  420.         sv.setTargetValue (0.0f);

  421.         otherBlock.fill (-1.0f);

  422.         block.replaceWithProductOf (otherBlock, sv);

  423.         expect (block.getSample (0, 2) < (SampleType) 1.0);

  424.         expect (block.getSample (1, 2) < (SampleType) 1.0);

  425.         expect (block.getSample (0, 2) > (SampleType) 0.0);

  426.         expect (block.getSample (1, 2) > (SampleType) 0.0);

  427.         expectEquals (block.getSample (0, 5), (SampleType) 0.0);

  428.         expectEquals (block.getSample (1, 5), (SampleType) 0.0);

  429.     }

  430. 

  431.     template <typename T = SampleType>

  432.     SIMDVoid<T> smoothedValueTests() {}

  433. 

  434.     //==============================================================================

  435.     void resetBlocks()

  436.     {

  437.         auto value = SampleType (1.0);

  438. 

  439.         for (size_t c = 0; c < block.getNumChannels(); ++c)

  440.         {

  441.             for (size_t i = 0; i < block.getNumSamples(); ++i)

  442.             {

  443.                 block.setSample ((int) c, (int) i, value);

  444.                 value += SampleType (1.0);

  445.             }

  446.         }

  447. 

  448.         otherBlock.replaceWithNegativeOf (block);

  449.     }

  450. 

  451.     //==============================================================================

  452.     static SampleType* allocateAlignedMemory (int numSamplesToAllocate)

  453.     {

  454.         auto alignmentLowerBound = std::alignment_of<SampleType>::value;

  455.        #if ! JUCE_WINDOWS

  456.         alignmentLowerBound = jmax (sizeof (void*), alignmentLowerBound);

  457.        #endif

  458.         auto alignmentOrder = std::ceil (std::log2 (alignmentLowerBound));

  459.         auto requiredAlignment = (size_t) std::pow (2, alignmentOrder);

  460. 

  461.         auto size = (size_t) numSamplesToAllocate * sizeof (SampleType);

  462. 

  463.        #if JUCE_WINDOWS

  464.         auto* memory = _aligned_malloc (size, requiredAlignment);

  465.        #else

  466.         void* memory;

  467.         auto result = posix_memalign (&memory, requiredAlignment, size);

  468. 

  469.         if (result != 0)

  470.         {

  471.             jassertfalse;

  472.             return nullptr;

  473.         }

  474.        #endif

  475. 

  476.         return static_cast<SampleType*> (memory);

  477.     }

  478. 

  479.     void deallocateAlignedMemory (void* address)

  480.     {

  481.        #if JUCE_WINDOWS

  482.         _aligned_free (address);

  483.        #else

  484.         free (address);

  485.        #endif

  486.     }

  487. 

  488.     //==============================================================================

  489.     static constexpr int numChannels = 2, numSamples = 6;

  490.     std::array<SampleType*, numChannels> data, otherData;

  491.     AudioBlock<SampleType> block, otherBlock;

  492. };

  493. 

  494. static AudioBlockUnitTests<float> audioBlockFloatUnitTests;

  495. static AudioBlockUnitTests<double> audioBlockDoubleUnitTests;

  496. 

  497. #if JUCE_USE_SIMD

  498. static AudioBlockUnitTests<SIMDRegister<float>> audioBlockSIMDFloatUnitTests;

  499. static AudioBlockUnitTests<SIMDRegister<double>> audioBlockSIMDDoubleUnitTests;

  500. #endif

  501. 

  502. } // namespace dsp

  503. } // namespace juce