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.
10494 Commits
9 Branches
4.1GB
Tree: 4edb0d2c90
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4edb0d2c90'
${ noResults }
JUCE/modules/juce_dsp/containers/juce_AudioBlock_test.cpp

343 lines
12KB
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.    By using JUCE, you agree to the terms of both the JUCE 5 End-User License

  11.    Agreement and JUCE 5 Privacy Policy (both updated and effective as of the

  12.    27th April 2017).

  13. 

  14.    End User License Agreement: www.juce.com/juce-5-licence

  15.    Privacy Policy: www.juce.com/juce-5-privacy-policy

  16. 

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

  18.    www.gnu.org/licenses).

  19. 

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

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

  22.    DISCLAIMED.

  23. 

  24.   ==============================================================================

  25. */

  26. 

  27. namespace juce

  28. {

  29. namespace dsp

  30. {

  31. 

  32. class AudioBlockUnitTests   : public UnitTest

  33. {

  34. public:

  35.     AudioBlockUnitTests()

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

  37.     {}

  38. 

  39.     void runTest() override

  40.     {

  41.         beginTest ("Equality");

  42.         {

  43.             expect (block == block);

  44.             expect (block != otherBlock);

  45.         }

  46. 

  47.         beginTest ("Constructors");

  48.         {

  49.             expect (block == AudioBlock<float> (data.getArrayOfWritePointers(), (size_t) data.getNumChannels(), (size_t) data.getNumSamples()));

  50.             expect (block == AudioBlock<float> (data.getArrayOfWritePointers(), (size_t) data.getNumChannels(), (size_t) 0, (size_t) data.getNumSamples()));

  51.             expect (block == AudioBlock<float> (block));

  52. 

  53.             expect (block == AudioBlock<const float> (data.getArrayOfWritePointers(), (size_t) data.getNumChannels(), (size_t) data.getNumSamples()));

  54.             expect (block == AudioBlock<const float> (data.getArrayOfWritePointers(), (size_t) data.getNumChannels(), (size_t) 0, (size_t) data.getNumSamples()));

  55.             expect (block == AudioBlock<const float> (block));

  56.         }

  57. 

  58.         beginTest ("Swap");

  59.         {

  60.             resetBlocks();

  61. 

  62.             expect (block != otherBlock);

  63.             expectEquals (block.getSample (0, 0), 1.0f);

  64.             expectEquals (block.getSample (0, 4), 5.0f);

  65.             expectEquals (otherBlock.getSample (0, 0), -1.0f);

  66.             expectEquals (otherBlock.getSample (0, 3), -4.0f);

  67. 

  68.             block.swap (otherBlock);

  69. 

  70.             expect (block != otherBlock);

  71.             expectEquals (otherBlock.getSample (0, 0), 1.0f);

  72.             expectEquals (otherBlock.getSample (0, 4), 5.0f);

  73.             expectEquals (block.getSample (0, 0), -1.0f);

  74.             expectEquals (block.getSample (0, 3), -4.0f);

  75.         }

  76. 

  77.         beginTest ("Getters and setters");

  78.         {

  79.             resetBlocks();

  80. 

  81.             expectEquals ((int) block.getNumChannels(), data.getNumChannels());

  82.             expectEquals ((int) block.getNumSamples(),  data.getNumSamples());

  83. 

  84.             expectEquals (block.getChannelPointer (0)[2], 3.0f);

  85.             block.getChannelPointer (0)[2] = 999.0f;

  86.             expectEquals (block.getChannelPointer (0)[2], 999.0f);

  87. 

  88.             expectEquals (block.getSample (0, 4), 5.0f);

  89.             expectEquals (block.getSample (1, 4), 11.0f);

  90. 

  91.             expectEquals (block.getSingleChannelBlock (1).getSample (0, 3), block.getSample (1, 3));

  92. 

  93.             expectEquals (block.getSubsetChannelBlock (0, 2).getSample (1, 3), block.getSample (1, 3));

  94.             expectEquals (block.getSubsetChannelBlock (1, 1).getSample (0, 3), block.getSample (1, 3));

  95. 

  96.             block.setSample (1, 1, 777.0f);

  97.             expectEquals (block.getSample (1, 1), 777.0f);

  98. 

  99.             block.addSample (1, 1, 1.0f);

  100.             expectEquals (block.getSample (1, 1), 778.0f);

  101.         }

  102. 

  103.         beginTest ("Copying");

  104.         {

  105.             block.clear();

  106.             expectEquals (block.getSample (0, 2), 0.0f);

  107.             expectEquals (block.getSample (1, 4), 0.0f);

  108. 

  109.             block.fill (456.0f);

  110.             expectEquals (block.getSample (0, 2), 456.0f);

  111.             expectEquals (block.getSample (1, 4), 456.0f);

  112. 

  113.             block.copyFrom (otherBlock);

  114.             expect (block != otherBlock);

  115.             expectEquals (block.getSample (0, 2), otherBlock.getSample (0, 2));

  116.             expectEquals (block.getSample (1, 4), otherBlock.getSample (1, 4));

  117. 

  118.             resetBlocks();

  119. 

  120.             AudioBuffer<float> otherBuffer ((int) block.getNumChannels(), (int) block.getNumSamples());

  121.             otherBlock.copyTo (otherBuffer);

  122.             expectEquals (otherBlock.getSample (0, 2), otherBuffer.getSample (0, 2));

  123.             expectEquals (otherBlock.getSample (1, 4), otherBuffer.getSample (1, 4));

  124. 

  125.             block.copyFrom (otherBuffer);

  126.             expectEquals (block.getSample (0, 2), otherBlock.getSample (0, 2));

  127.             expectEquals (block.getSample (1, 4), otherBlock.getSample (1, 4));

  128. 

  129.             float testSample1 = block.getSample (0, 2);

  130.             float testSample2 = block.getSample (1, 3);

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

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

  133.             block.move (0, 2);

  134.             expectEquals (block.getSample (0, 4), testSample1);

  135.             expectEquals (block.getSample (1, 5), testSample2);

  136.         }

  137. 

  138.         beginTest ("Addition");

  139.         {

  140.             resetBlocks();

  141. 

  142.             block.add (15.0f);

  143.             expectEquals (block.getSample (0, 4), 20.0f);

  144.             expectEquals (block.getSample (1, 4), 26.0f);

  145. 

  146.             block.add (otherBlock);

  147.             expectEquals (block.getSample (0, 4), 15.0f);

  148.             expectEquals (block.getSample (1, 4), 15.0f);

  149. 

  150.             block.replaceWithSumOf (otherBlock, 9.0f);

  151.             expectEquals (block.getSample (0, 4), 4.0f);

  152.             expectEquals (block.getSample (1, 4), -2.0f);

  153. 

  154.             resetBlocks();

  155. 

  156.             block.replaceWithSumOf (block, otherBlock);

  157.             expectEquals (block.getSample (0, 4), 0.0f);

  158.             expectEquals (block.getSample (1, 4), 0.0f);

  159.         }

  160. 

  161.         beginTest ("Subtraction");

  162.         {

  163.             resetBlocks();

  164. 

  165.             block.subtract (15.0f);

  166.             expectEquals (block.getSample (0, 4), -10.0f);

  167.             expectEquals (block.getSample (1, 4), -4.0f);

  168. 

  169.             block.subtract (otherBlock);

  170.             expectEquals (block.getSample (0, 4), -5.0f);

  171.             expectEquals (block.getSample (1, 4), 7.0f);

  172. 

  173.             block.replaceWithDifferenceOf (otherBlock, 9.0f);

  174.             expectEquals (block.getSample (0, 4), -14.0f);

  175.             expectEquals (block.getSample (1, 4), -20.0f);

  176. 

  177.             resetBlocks();

  178. 

  179.             block.replaceWithDifferenceOf (block, otherBlock);

  180.             expectEquals (block.getSample (0, 4), 10.0f);

  181.             expectEquals (block.getSample (1, 4), 22.0f);

  182.         }

  183. 

  184.         beginTest ("Multiplication");

  185.         {

  186.             resetBlocks();

  187. 

  188.             block.multiplyBy (10.0f);

  189.             expectEquals (block.getSample (0, 4), 50.0f);

  190.             expectEquals (block.getSample (1, 4), 110.0f);

  191. 

  192.             block.multiplyBy (otherBlock);

  193.             expectEquals (block.getSample (0, 4), -250.0f);

  194.             expectEquals (block.getSample (1, 4), -1210.0f);

  195. 

  196.             block.replaceWithProductOf (otherBlock, 3.0f);

  197.             expectEquals (block.getSample (0, 4), -15.0f);

  198.             expectEquals (block.getSample (1, 4), -33.0f);

  199. 

  200.             resetBlocks();

  201. 

  202.             block.replaceWithProductOf (block, otherBlock);

  203.             expectEquals (block.getSample (0, 4), -25.0f);

  204.             expectEquals (block.getSample (1, 4), -121.0f);

  205.         }

  206. 

  207.         beginTest ("Smoothing");

  208.         {

  209.             block.fill (1.0f);

  210.             SmoothedValue<float> sv { 1.0f };

  211.             sv.reset (1, 4);

  212.             sv.setTargetValue (0.0f);

  213. 

  214.             block.multiplyBy (sv);

  215.             expect (block.getSample (0, 2) < 1.0f);

  216.             expect (block.getSample (1, 2) < 1.0f);

  217.             expect (block.getSample (0, 2) > 0.0f);

  218.             expect (block.getSample (1, 2) > 0.0f);

  219.             expectEquals (block.getSample (0, 5), 0.0f);

  220.             expectEquals (block.getSample (1, 5), 0.0f);

  221. 

  222.             sv.setCurrentAndTargetValue (-1.0f);

  223.             sv.setTargetValue (0.0f);

  224.             otherBlock.fill (-1.0f);

  225.             block.replaceWithProductOf (otherBlock, sv);

  226.             expect (block.getSample (0, 2) < 1.0f);

  227.             expect (block.getSample (1, 2) < 1.0f);

  228.             expect (block.getSample (0, 2) > 0.0f);

  229.             expect (block.getSample (1, 2) > 0.0f);

  230.             expectEquals (block.getSample (0, 5), 0.0f);

  231.             expectEquals (block.getSample (1, 5), 0.0f);

  232.         }

  233. 

  234.         beginTest ("Multiply add");

  235.         {

  236.             resetBlocks();

  237. 

  238.             block.addProductOf (otherBlock, -1.0f);

  239.             expectEquals (block.getSample (0, 4), 10.0f);

  240.             expectEquals (block.getSample (1, 4), 22.0f);

  241. 

  242.             block.addProductOf (otherBlock, otherBlock);

  243.             expectEquals (block.getSample (0, 4), 35.0f);

  244.             expectEquals (block.getSample (1, 4), 143.0f);

  245.         }

  246. 

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

  248.         {

  249.             resetBlocks();

  250.             otherBlock.negate();

  251. 

  252.             block.add (otherBlock);

  253.             expectEquals (block.getSample (0, 4), 10.0f);

  254.             expectEquals (block.getSample (1, 4), 22.0f);

  255. 

  256.             block.replaceWithNegativeOf (otherBlock);

  257.             expectEquals (block.getSample (0, 4), -5.0f);

  258.             expectEquals (block.getSample (1, 4), -11.0f);

  259. 

  260.             block.clear();

  261.             otherBlock.negate();

  262.             block.replaceWithAbsoluteValueOf (otherBlock);

  263.             expectEquals (block.getSample (0, 4), 5.0f);

  264.             expectEquals (block.getSample (1, 4), 11.0f);

  265. 

  266.             resetBlocks();

  267.             block.replaceWithMinOf (block, otherBlock);

  268.             expectEquals (block.getSample (0, 4), -5.0f);

  269.             expectEquals (block.getSample (1, 4), -11.0f);

  270. 

  271.             resetBlocks();

  272.             block.replaceWithMaxOf (block, otherBlock);

  273.             expectEquals (block.getSample (0, 4), 5.0f);

  274.             expectEquals (block.getSample (1, 4), 11.0f);

  275. 

  276.             resetBlocks();

  277.             auto range = block.findMinAndMax();

  278.             expectEquals (range.getStart(), 1.0f);

  279.             expectEquals (range.getEnd(), 12.0f);

  280.         }

  281. 

  282.         beginTest ("Operators");

  283.         {

  284.             resetBlocks();

  285.             block += 10.0f;

  286.             expectEquals (block.getSample (0, 4), 15.0f);

  287.             expectEquals (block.getSample (1, 4), 21.0f);

  288.             block += otherBlock;

  289.             expectEquals (block.getSample (0, 4), 10.0f);

  290.             expectEquals (block.getSample (1, 4), 10.0f);

  291. 

  292.             resetBlocks();

  293.             block -= 10.0f;

  294.             expectEquals (block.getSample (0, 4), -5.0f);

  295.             expectEquals (block.getSample (1, 4), 1.0f);

  296.             block -= otherBlock;

  297.             expectEquals (block.getSample (0, 4), 0.0f);

  298.             expectEquals (block.getSample (1, 4), 12.0f);

  299. 

  300.             resetBlocks();

  301.             block *= 10.0f;

  302.             expectEquals (block.getSample (0, 4), 50.0f);

  303.             expectEquals (block.getSample (1, 4), 110.0f);

  304.             block *= otherBlock;

  305.             expectEquals (block.getSample (0, 4), -250.0f);

  306.             expectEquals (block.getSample (1, 4), -1210.0f);

  307.         }

  308. 

  309.         beginTest ("Process");

  310.         {

  311.             resetBlocks();

  312.             AudioBlock<float>::process (block, otherBlock, [](float x) { return x + 1.0f; });

  313.             expectEquals (otherBlock.getSample (0, 4), 6.0f);

  314.             expectEquals (otherBlock.getSample (1, 4), 12.0f);

  315.         }

  316.     }

  317. 

  318. private:

  319.     AudioBuffer<float> data { 2, 6 }, otherData { 2, 6 };

  320.     AudioBlock<float> block { data }, otherBlock { otherData };

  321. 

  322.     void resetBlocks()

  323.     {

  324.         auto value = 1.0f;

  325. 

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

  327.         {

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

  329.             {

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

  331.                 value += 1.0f;

  332.             }

  333.         }

  334. 

  335.         otherBlock.replaceWithNegativeOf (block);

  336.     }

  337. };

  338. 

  339. static AudioBlockUnitTests audioBlockUnitTests;

  340. 

  341. } // namespace dsp

  342. } // namespace juce