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

492 lines
19KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE 6 technical preview.

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

  6. 

  7.    You may use this code under the terms of the GPL v3

  8.    (see www.gnu.org/licenses).

  9. 

  10.    For this technical preview, this file is not subject to commercial licensing.

  11. 

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

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

  14.    DISCLAIMED.

  15. 

  16.   ==============================================================================

  17. */

  18. 

  19. namespace juce

  20. {

  21. namespace dsp

  22. {

  23. 

  24. template <typename SampleType>

  25. class AudioBlockUnitTests   : public UnitTest

  26. {

  27. public:

  28.     //==============================================================================

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

  30. 

  31.     AudioBlockUnitTests()

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

  33.     {

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

  35.             for (auto& channel : *v)

  36.                 channel = allocateAlignedMemory (numSamples);

  37. 

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

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

  40. 

  41.         resetBlocks();

  42.     }

  43. 

  44.     ~AudioBlockUnitTests() override

  45.     {

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

  47.             for (auto channel : *v)

  48.                 deallocateAlignedMemory (channel);

  49.     }

  50. 

  51.     void runTest() override

  52.     {

  53.         beginTest ("Equality");

  54.         {

  55.             expect (block == block);

  56.             expect (block != otherBlock);

  57.         }

  58. 

  59.         beginTest ("Constructors");

  60.         {

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

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

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

  64. 

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

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

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

  68.         }

  69. 

  70.         beginTest ("Swap");

  71.         {

  72.             resetBlocks();

  73. 

  74.             expect (block != otherBlock);

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

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

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

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

  79. 

  80.             block.swap (otherBlock);

  81. 

  82.             expect (block != otherBlock);

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

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

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

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

  87. 

  88.             block.swap (otherBlock);

  89. 

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

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

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

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

  94.         }

  95. 

  96.         beginTest ("Getters and setters");

  97.         {

  98.             resetBlocks();

  99. 

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

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

  102. 

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

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

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

  106. 

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

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

  109. 

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

  111. 

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

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

  114. 

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

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

  117. 

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

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

  120.         }

  121. 

  122.         beginTest ("Basic copying");

  123.         {

  124.             block.clear();

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

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

  127. 

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

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

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

  131. 

  132.             block.copyFrom (otherBlock);

  133.             expect (block != otherBlock);

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

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

  136. 

  137.             resetBlocks();

  138. 

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

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

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

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

  143.             block.move (0, 2);

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

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

  146.         }

  147. 

  148.         beginTest ("Addition");

  149.         {

  150.             resetBlocks();

  151. 

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

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

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

  155. 

  156.             block.add (otherBlock);

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

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

  159. 

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

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

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

  163. 

  164.             resetBlocks();

  165. 

  166.             block.replaceWithSumOf (block, otherBlock);

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

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

  169.         }

  170. 

  171.         beginTest ("Subtraction");

  172.         {

  173.             resetBlocks();

  174. 

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

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

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

  178. 

  179.             block.subtract (otherBlock);

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

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

  182. 

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

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

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

  186. 

  187.             resetBlocks();

  188. 

  189.             block.replaceWithDifferenceOf (block, otherBlock);

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

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

  192.         }

  193. 

  194.         beginTest ("Multiplication");

  195.         {

  196.             resetBlocks();

  197. 

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

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

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

  201. 

  202.             block.multiplyBy (otherBlock);

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

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

  205. 

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

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

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

  209. 

  210.             resetBlocks();

  211. 

  212.             block.replaceWithProductOf (block, otherBlock);

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

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

  215.         }

  216. 

  217.         beginTest ("Multiply add");

  218.         {

  219.             resetBlocks();

  220. 

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

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

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

  224. 

  225.             block.addProductOf (otherBlock, otherBlock);

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

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

  228.         }

  229. 

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

  231.         {

  232.             resetBlocks();

  233.             otherBlock.negate();

  234. 

  235.             block.add (otherBlock);

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

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

  238. 

  239.             block.replaceWithNegativeOf (otherBlock);

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

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

  242. 

  243.             block.clear();

  244.             otherBlock.negate();

  245.             block.replaceWithAbsoluteValueOf (otherBlock);

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

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

  248. 

  249.             resetBlocks();

  250.             block.replaceWithMinOf (block, otherBlock);

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

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

  253. 

  254.             resetBlocks();

  255.             block.replaceWithMaxOf (block, otherBlock);

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

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

  258. 

  259.             resetBlocks();

  260.             auto range = block.findMinAndMax();

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

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

  263.         }

  264. 

  265.         beginTest ("Operators");

  266.         {

  267.             resetBlocks();

  268.             block += (NumericType) 10.0;

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

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

  271.             block += otherBlock;

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

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

  274. 

  275.             resetBlocks();

  276.             block -= (NumericType) 10.0;

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

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

  279.             block -= otherBlock;

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

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

  282. 

  283.             resetBlocks();

  284.             block *= (NumericType) 10.0;

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

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

  287.             block *= otherBlock;

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

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

  290.         }

  291. 

  292.         beginTest ("Process");

  293.         {

  294.             resetBlocks();

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

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

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

  298.         }

  299. 

  300.         beginTest ("Copying");

  301.         {

  302.             resetBlocks();

  303.             copyingTests();

  304.         }

  305. 

  306.         beginTest ("Smoothing");

  307.         {

  308.             resetBlocks();

  309.             smoothedValueTests();

  310.         }

  311.     }

  312. 

  313. private:

  314.     //==============================================================================

  315.     template <typename T>

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

  317. 

  318.     template <typename T>

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

  320. 

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

  322.     template <typename T = SampleType>

  323.     ScalarVoid<T> copyingTests()

  324.     {

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

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

  327. 

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

  329. 

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

  331. 

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

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

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

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

  336. 

  337.         resetBlocks();

  338. 

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

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

  341. 

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

  343. 

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

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

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

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

  348.     }

  349. 

  350.     template <typename T = SampleType>

  351.     SIMDVoid<T> copyingTests()

  352.     {

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

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

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

  356. 

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

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

  359. 

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

  361. 

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

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

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

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

  366. 

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

  368. 

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

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

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

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

  373. 

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

  375. 

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

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

  378. 

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

  380. 

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

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

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

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

  385. 

  386.         if (numSIMDElements > 1)

  387.         {

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

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

  390.         }

  391.     }

  392. 

  393.     //==============================================================================

  394.     template <typename T = SampleType>

  395.     ScalarVoid<T> smoothedValueTests()

  396.     {

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

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

  399.         sv.reset (1, 4);

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

  401. 

  402.         block.multiplyBy (sv);

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

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

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

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

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

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

  409. 

  410.         sv.setCurrentAndTargetValue (-1.0f);

  411.         sv.setTargetValue (0.0f);

  412.         otherBlock.fill (-1.0f);

  413.         block.replaceWithProductOf (otherBlock, sv);

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

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

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

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

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

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

  420.     }

  421. 

  422.     template <typename T = SampleType>

  423.     SIMDVoid<T> smoothedValueTests() {}

  424. 

  425.     //==============================================================================

  426.     void resetBlocks()

  427.     {

  428.         auto value = SampleType (1.0);

  429. 

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

  431.         {

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

  433.             {

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

  435.                 value += SampleType (1.0);

  436.             }

  437.         }

  438. 

  439.         otherBlock.replaceWithNegativeOf (block);

  440.     }

  441. 

  442.     //==============================================================================

  443.     static SampleType* allocateAlignedMemory (int numSamplesToAllocate)

  444.     {

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

  446.        #if ! JUCE_WINDOWS

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

  448.        #endif

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

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

  451. 

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

  453. 

  454.        #if JUCE_WINDOWS

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

  456.        #else

  457.         void* memory;

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

  459. 

  460.         if (result != 0)

  461.         {

  462.             jassertfalse;

  463.             return nullptr;

  464.         }

  465.        #endif

  466. 

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

  468.     }

  469. 

  470.     void deallocateAlignedMemory (void* address)

  471.     {

  472.        #if JUCE_WINDOWS

  473.         _aligned_free (address);

  474.        #else

  475.         free (address);

  476.        #endif

  477.     }

  478. 

  479.     //==============================================================================

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

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

  482.     AudioBlock<SampleType> block, otherBlock;

  483. };

  484. 

  485. static AudioBlockUnitTests<float> audioBlockFloatUnitTests;

  486. static AudioBlockUnitTests<double> audioBlockDoubleUnitTests;

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

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

  489. 

  490. } // namespace dsp

  491. } // namespace juce