VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
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.
1265 Commits
4 Branches
604MB
Tree: 9125cf9dfd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '9125cf9dfd'
${ noResults }
Rack/plugins/community/repos/Valley/src/Amalgam/VecAmalgam.cpp

298 lines
12KB
Raw Blame History 

  1. //

  2. //  VecAmalgam.cpp

  3. //  BitCombiner

  4. //

  5. //  Created by Dale Johnson on 26/11/2018.

  6. //  Copyright © 2018 Dale Johnson. All rights reserved.

  7. //

  8. 

  9. #include "VecAmalgam.hpp"

  10. 

  11. VecAmalgam::VecAmalgam() {

  12.     __zeros = _mm_set1_ps(0.f);

  13.     __ones = _mm_set1_ps(1.f);

  14.     __negOnes = _mm_set1_ps(-1.f);

  15.     __halfs = _mm_set1_ps(0.5f);

  16.     __ffTarget = __zeros;

  17.     __high = _mm_castsi128_ps(_mm_set1_epi32(0xFFFFFFFF));

  18. 

  19.     __x = __zeros;

  20.     __y = __zeros;

  21.     __z = __zeros;

  22.     __xFolded = __zeros;

  23.     __yFolded = __zeros;

  24. 

  25.     __zero16 = Dmm_set1_pi16(0);

  26.     __one16 = Dmm_set1_pi16(1);

  27.     __a = __zero16;

  28.     __b = __zero16;

  29.     __c = __zero16;

  30.     __aPrev = __zero16;

  31.     __bPrev = __zero16;

  32.     __aREdge = __zero16;

  33.     __bREdge = __zero16;

  34.     __count = Dmm_set1_pi16(0xFFFF);

  35.     _step = 1.f;

  36.     __xDS = __zeros;

  37.     __yDS = __zeros;

  38.     __zDS = __zeros;

  39. 

  40.     p[RING_MOD_1_MODE] = &VecAmalgam::ringMod1;

  41.     p[RING_MOD_2_MODE] = &VecAmalgam::ringMod2;

  42.     p[RING_MOD_3_MODE] = &VecAmalgam::ringMod3;

  43.     p[DIODE_RING_MOD_MODE] = &VecAmalgam::diodeRingMod;

  44.     p[MIN_MAX_MODE] = &VecAmalgam::minMax;

  45.     p[SIGN_SWITCH_1_MODE] = &VecAmalgam::signSwitch1;

  46.     p[SIGN_SWITCH_2_MODE] = &VecAmalgam::signSwitch2;

  47.     p[X_FADE_MODE] = &VecAmalgam::xFade;

  48.     p[FLIP_FLOP_MODE] = &VecAmalgam::flipFlop;

  49.     p[ALPHA_PWM_MODE] = &VecAmalgam::alphaPWM;

  50.     p[BIT_AND_MODE] = &VecAmalgam::bitAND;

  51.     p[BIT_XOR_MODE] = &VecAmalgam::bitXOR;

  52.     p[BIT_INTERLEAVE_MODE] = &VecAmalgam::bitInterleave;

  53.     p[BIT_HACK_MODE] = &VecAmalgam::bitHack;

  54.     p[BIT_AND_FLOAT_MODE] = &VecAmalgam::bitANDFloat;

  55.     p[BIT_INTERLEAVE_FLOAT_MODE] = &VecAmalgam::bitInterleaveFloat;

  56.     p[BIT_HACK_FLOAT_MODE] = &VecAmalgam::bitHackFloat;

  57. 

  58.     _mode = RING_MOD_1_MODE;

  59. 

  60.     std::srand(std::time(NULL));

  61.     for(auto i = 0; i < 4; ++i) {

  62.         _z[i] = std::rand();

  63.         _w[i] = std::rand();

  64.         _k[i] = 0;

  65.     }

  66.     setSampleRate(44100.f);

  67. }

  68. 

  69. void VecAmalgam::setMode(int mode) {

  70.     _mode = mode;

  71.     if(_mode < 0) {

  72.         _mode = 0;

  73.     }

  74.     else if(_mode >= NUM_MODES) {

  75.         _mode = NUM_MODES - 1;

  76.     }

  77. }

  78. 

  79. void VecAmalgam::setSampleRate(float sampleRate) {

  80.     _engineSampleRate = sampleRate;

  81.     _quarterNyquist = _engineSampleRate / 32.f;

  82.     calcStepSize();

  83. }

  84. 

  85. void VecAmalgam::calcStepSize() {

  86.     _internalSampleRate = _quarterNyquist * powf(2.f, (_updateRate * 5.f));

  87.     _stepSize = _internalSampleRate / _engineSampleRate;

  88. }

  89. 

  90. __m128 VecAmalgam::ringMod1(const __m128& x, const __m128& y, float paramA, float paramB) {

  91.     __z = _mm_or_ps(_mm_cmpgt_ps(y, _mm_set1_ps(paramB * 1.066f)),

  92.                     _mm_cmplt_ps(y, _mm_set1_ps(paramB * -1.066f)));

  93.     __z = _mm_and_ps(y, __z);

  94.     return _mm_mul_ps(_mm_add_ps(_mm_mul_ps(x, _mm_set1_ps(1.f - 0.5f * paramA)),

  95.                                                _mm_set1_ps(paramA * 0.5f)), __z);

  96. }

  97. 

  98. __m128 VecAmalgam::ringMod2(const __m128& x, const __m128& y, float paramA, float paramB) {

  99.     __xFolded = _mm_add_ps(_mm_mul_ps(x, __halfs), __halfs);

  100.     __yFolded = _mm_add_ps(_mm_mul_ps(y, __halfs), __halfs);

  101.     __xFolded = _mm_mirror_ps(__xFolded, _mm_set1_ps(paramA + 0.00001f));

  102.     __yFolded = _mm_mirror_ps(__yFolded, _mm_set1_ps(paramB + 0.00001f));

  103.     __xFolded = _mm_mul_ps(_mm_add_ps(__xFolded, _mm_set1_ps(-0.5f)),_mm_set1_ps(2.f));

  104.     __yFolded = _mm_mul_ps(_mm_add_ps(__yFolded, _mm_set1_ps(-0.5f)),_mm_set1_ps(2.f));

  105. 

  106.     return _mm_mul_ps(__xFolded, __yFolded);

  107. }

  108. 

  109. __m128 VecAmalgam::ringMod3(const __m128& x, const __m128& y, float paramA, float paramB) {

  110.     __xFolded = _mm_add_ps(_mm_mul_ps(x, __halfs), __halfs);

  111.     __yFolded = _mm_add_ps(_mm_mul_ps(y, __halfs), __halfs);

  112.     __xFolded = _mm_mirror_ps(__xFolded, _mm_set1_ps(paramA + 0.00001f));

  113.     __yFolded = _mm_mirror_ps(__yFolded, _mm_set1_ps(paramA + 0.00001f));

  114.     __xFolded = _mm_mul_ps(_mm_add_ps(__xFolded, _mm_set1_ps(-0.5f)),_mm_set1_ps(2.f));

  115.     __yFolded = _mm_mul_ps(_mm_add_ps(__yFolded, _mm_set1_ps(-0.5f)),_mm_set1_ps(-2.f));

  116. 

  117.     __xLogic = _mm_cmpgt_ps(__xFolded, __zeros);

  118.     __yLogic = _mm_cmpgt_ps(__yFolded, __zeros);

  119.     __zLogic = _mm_xor_ps(__xLogic, __yLogic);

  120.     __z = _mm_and_ps(__zLogic, __ones);

  121.     __z = _mm_add_ps(_mm_mul_ps(__z, _mm_set1_ps(-2.f)), __ones);

  122. 

  123.     return _mm_linterp_ps(_mm_mul_ps(__xFolded, __yFolded), __z, _mm_set1_ps(paramB));

  124. }

  125. 

  126. __m128 VecAmalgam::diodeRingMod(const __m128& x, const __m128& y, float paramA, float paramB) {

  127.     return _d.process(x, y, paramA, paramB);

  128. }

  129. 

  130. __m128 VecAmalgam::minMax(const __m128& x, const __m128& y, float paramA, float paramB) {

  131.     __m128 select = _mm_cmpgt_ps(x, y);

  132.     __m128 max = _mm_switch_ps(y, x, select);

  133.     __m128 min = _mm_switch_ps(x, y, select);

  134.     __m128 delta = _mm_sub_ps(max, min);

  135.     __z = _mm_linterp_ps(min, max, _mm_set1_ps(paramA));

  136.     return _mm_linterp_ps(__z, _mm_mul_ps(__z, delta), _mm_set1_ps(paramB));

  137. }

  138. 

  139. __m128 VecAmalgam::signSwitch1(const __m128& x, const __m128& y, float paramA, float paramB) {

  140.     __m128 midPoint = _mm_set1_ps(paramA * 2.f - 1.f);

  141.     __m128 thresh = _mm_set1_ps(paramB);

  142.     return _mm_add_ps(_mm_and_ps(x, _mm_cmpge_ps(x, _mm_add_ps(midPoint, thresh))),

  143.                       _mm_and_ps(y, _mm_cmplt_ps(y,_mm_sub_ps(midPoint, thresh))));

  144. }

  145. 

  146. __m128 VecAmalgam::signSwitch2(const __m128& x, const __m128& y, float paramA, float paramB) {

  147.     __m128 midPoint = _mm_set1_ps(paramA * 2.f - 1.f);

  148.     __m128 thresh = _mm_set1_ps(paramB);

  149.     __z = _mm_switch_ps(__zeros, x, _mm_cmpgt_ps(x, _mm_add_ps(midPoint, thresh)));

  150.     return _mm_switch_ps(__z, y, _mm_cmplt_ps(y, _mm_sub_ps(midPoint, thresh)));

  151. }

  152. 

  153. __m128 VecAmalgam::xFade(const __m128& x, const __m128& y, float paramA, float paramB) {

  154.     __m128 xScaled = _mm_add_ps(_mm_mul_ps(x, __halfs), __halfs);

  155.     xScaled = _mm_mul_ps(xScaled, _mm_set1_ps(paramB));

  156.     return _mm_linterp_ps(x,y, _mm_clamp_ps(_mm_add_ps(_mm_set1_ps(paramA), xScaled), __zeros, __ones));

  157. }

  158. 

  159. __m128 VecAmalgam::flipFlop(const __m128& x, const __m128& y, float paramA, float paramB) {

  160.     __m128 thresh = _mm_set1_ps(paramB);

  161.     for(auto i = 0; i < 4; ++i) {

  162.         _k[i] = (float)mwcRand(_z[i], _w[i]) / (float)UINT32_MAX;

  163.     }

  164.     __chanceX = _mm_loadu_ps(_k);

  165.     __chanceX = _mm_and_ps(_mm_cmpgt_ps(__chanceX, _mm_set1_ps(paramA)), __high);

  166. 

  167.     for(auto i = 0; i < 4; ++i) {

  168.         _k[i] = (float)mwcRand(_z[i], _w[i]) / (float)UINT32_MAX;

  169.     }

  170.     __chanceY = _mm_loadu_ps(_k);

  171.     __chanceY = _mm_and_ps(_mm_cmpgt_ps(__chanceY, _mm_set1_ps(1.f - paramA)), __high);

  172. 

  173.     __xREdge = _mm_and_ps(_mm_cmpgt_ps(x, thresh), _mm_cmple_ps(__xPrev, thresh));

  174.     __yREdge = _mm_and_ps(_mm_cmpgt_ps(y, thresh), _mm_cmple_ps(__yPrev, thresh));

  175.     __xREdge = _mm_and_ps(__xREdge, __chanceX);

  176.     __yREdge = _mm_and_ps(__yREdge, __chanceY);

  177. 

  178.     __ffTarget = _mm_switch_ps(__ffTarget, __zeros, __xREdge);

  179.     __ffTarget = _mm_switch_ps(__ffTarget, __high, __yREdge);

  180.     __xPrev = x;

  181.     __yPrev = y;

  182.     return _mm_switch_ps(x, y, __ffTarget);

  183. }

  184. 

  185. __m128 VecAmalgam::alphaPWM(const __m128& x, const __m128& y, float paramA, float paramB) {

  186.     __z = _mm_mul_ps(_mm_abs_ps(x), __halfs);

  187.     __z = _mm_mul_ps(__z, _mm_add_ps(_mm_mul_ps(_mm_set1_ps(paramA), _mm_set1_ps(16.f)), __ones));

  188.     __m128i xInt = _mm_cvttps_epi32(__z);

  189.     __m128 xIntF = _mm_cvtepi32_ps(xInt);

  190.     __z = _mm_sub_ps(__z, xIntF);

  191.     return _mm_mul_ps(_mm_switch_ps(x, _mm_set1_ps(0.f), _mm_cmpgt_ps(__z, _mm_set1_ps(1.f - paramB))), y);

  192. }

  193. 

  194. __m128 VecAmalgam::bitAND(const __m128& x, const __m128& y, float paramA, float paramB) {

  195.     paramA = 1.f - paramA * 0.8f;

  196.     paramA *= paramA;

  197.     downSample(_mm_varStep_ps(x, _mm_set1_ps(1.f - paramA)),_mm_varStep_ps(y, _mm_set1_ps(1.f - paramA)));

  198.     __a32 = _mm_cvttps_epi32(_mm_mul_ps(__xDS, _mm_set1_ps(0x7FFFFFFF)));

  199.     __b32 = _mm_cvttps_epi32(_mm_mul_ps(__yDS, _mm_set1_ps(0x7FFFFFFF)));

  200.     __c32 = _mm_and_si128(__a32, __b32);

  201.     return _mm_div_ps(_mm_cvtepi32_ps(__c32), _mm_set1_ps(0x7FFFFFFF));

  202. }

  203. 

  204. __m128 VecAmalgam::bitXOR(const __m128& x, const __m128& y, float paramA, float paramB) {

  205.     paramA = 1.f - paramA * 0.8f;

  206.     paramA *= paramA;

  207.     downSample(_mm_varStep_ps(x, _mm_set1_ps(1.f - paramA)),_mm_varStep_ps(y, _mm_set1_ps(1.f - paramA)));

  208.     __a32 = _mm_cvttps_epi32(_mm_mul_ps(__xDS, _mm_set1_ps(0x7FFFFFFF)));

  209.     __b32 = _mm_cvttps_epi32(_mm_mul_ps(__yDS, _mm_set1_ps(0x7FFFFFFF)));

  210.     __c32 = _mm_xor_si128(__a32, __b32);

  211.     return _mm_div_ps(_mm_cvtepi32_ps(__c32), _mm_set1_ps(0x7FFFFFFF));

  212. }

  213. 

  214. __m128 VecAmalgam::bitInterleave(const __m128& x, const __m128& y, float paramA, float paramB) {

  215.     paramA = 1.f - paramA * 0.8f;

  216.     paramA *= paramA;

  217.     downSample(_mm_varStep_ps(x, _mm_set1_ps(1.f - paramA)),_mm_varStep_ps(y, _mm_set1_ps(1.f - paramA)));

  218.     __a32 = _mm_cvttps_epi32(_mm_mul_ps(__xDS, _mm_set1_ps(0x7FFFFFFF)));

  219.     __b32 = _mm_cvttps_epi32(_mm_mul_ps(__yDS, _mm_set1_ps(0x7FFFFFFF)));

  220.     __c32 = _mm_xor_si128(__a32, __b32);

  221.     __c32 = _mm_or_si128(_mm_and_si128(__a32, _mm_set1_epi32(0x55555555)), _mm_and_si128(__b32, _mm_set1_epi32(0xAAAAAAAA)));

  222.     return _mm_div_ps(_mm_cvtepi32_ps(__c32), _mm_set1_ps(0x7FFFFFFF));

  223. }

  224. 

  225. __m128 VecAmalgam::bitHack(const __m128& x, const __m128& y, float paramA, float paramB) {

  226.     __chance32 = __high;

  227.     int random = 0;

  228.     for(auto i = 0; i < 4; ++i) {

  229.         random = mwcRand(_z[i], _w[i]);

  230.         _k32[i] = (float)random / (float)UINT32_MAX > (0.5f - paramA * paramA * 0.5f) ? random : 0xFFFFFFFF;

  231.     }

  232.     __chance32 = _mm_castsi128_ps(_mm_set_epi32(_k32[3], _k32[2], _k32[1], _k32[0]));

  233. 

  234.     downSample(x,y);

  235.     __a32 = _mm_cvttps_epi32(_mm_mul_ps(__xDS, _mm_set1_ps(0x7FFFFFFF)));

  236.     __b32 = _mm_cvttps_epi32(_mm_mul_ps(__yDS, _mm_set1_ps(0x7FFFFFFF)));

  237.     __c32 = _mm_and_si128(_mm_or_si128(__c32, _mm_and_si128(__a32, __b32)), _mm_castps_si128(__chance32)); // Make 1 if a == 1 AND b == 1

  238. #ifdef _MSC_VER

  239.     {

  240.        // workaround for MSVC "error C2675: unary '~': '__m128i' does not define this operator or a conversion to a  type acceptable to the predefined operator"

  241.        __m128i a32inv;

  242.        a32inv.m128i_u64[0] = ~__a32.m128i_u64[0];

  243.        a32inv.m128i_u64[1] = ~__a32.m128i_u64[1];

  244.        __m128i b32inv;

  245.        b32inv.m128i_u64[0] = ~__b32.m128i_u64[0];

  246.        b32inv.m128i_u64[1] = ~__b32.m128i_u64[1];

  247.        __m128i tinv = _mm_and_si128(_mm_and_si128(a32inv, b32inv), _mm_castps_si128(__chance32));

  248.        tinv.m128i_u64[0] = ~tinv.m128i_u64[0];

  249.        tinv.m128i_u64[1] = ~tinv.m128i_u64[1];

  250.        __c32 = _mm_and_si128(__c32, tinv); // Make 0 if a == 0 AND b == 0

  251.     }

  252. #else

  253.     __c32 = _mm_and_si128(__c32, ~_mm_and_si128(_mm_and_si128(~__a32, ~__b32), _mm_castps_si128(__chance32))); // Make 0 if a == 0 AND b == 0

  254. #endif

  255.     __z = _mm_div_ps(_mm_cvtepi32_ps(__c32), _mm_set1_ps(0x7FFFFFFF));

  256.     __zDS = _mm_switch_ps(__zDS, __z, __sample);

  257.     return __zDS;

  258. }

  259. 

  260. __m128 VecAmalgam::bitANDFloat(const __m128& x, const __m128& y, float paramA, float paramB) {

  261.     __chance32 = __high;

  262.     int random = 0;

  263.     for(auto i = 0; i < 4; ++i) {

  264.         random = mwcRand(_z[i], _w[i]);

  265.         _k32[i] = (float)random / (float)UINT32_MAX > (0.5f - paramA * paramA * 0.5f) ? random : 0xFFFFFFFF;

  266.     }

  267.     __chance32 = _mm_castsi128_ps(_mm_set_epi32(_k32[3], _k32[2], _k32[1], _k32[0]));

  268. 

  269.     downSample(x,y);

  270.     __z = _mm_and_ps(_mm_and_ps(__xDS,__yDS), __chance32);

  271.     __zDS = _mm_switch_ps(__zDS, __z, __sample);

  272.     return __zDS;

  273. }

  274. 

  275. __m128 VecAmalgam::bitInterleaveFloat(const __m128& x, const __m128& y, float paramA, float paramB) {

  276.     paramA = 1.f - paramA * 0.8f;

  277.     paramA *= paramA;

  278.     downSample(_mm_varStep_ps(x, _mm_set1_ps(1.f - paramA)),_mm_varStep_ps(y, _mm_set1_ps(1.f - paramA)));

  279.     return _mm_or_ps(_mm_and_ps(__xDS, _mm_castsi128_ps(_mm_set1_epi32(0x55555555))),

  280.                      _mm_and_ps(__yDS, _mm_castsi128_ps(_mm_set1_epi32(0xAAAAAAAA))));

  281. }

  282. 

  283. __m128 VecAmalgam::bitHackFloat(const __m128& x, const __m128& y, float paramA, float paramB) {

  284.     __chance32 = __high;

  285.     int random = 0;

  286.     for(auto i = 0; i < 4; ++i) {

  287.         random = mwcRand(_z[i], _w[i]);

  288.         _k32[i] = (float)random / (float)UINT32_MAX > (0.5f - paramA * paramA * 0.5f) ? random : 0xFFFFFFFF;

  289.     }

  290.     __chance32 = _mm_castsi128_ps(_mm_set_epi32(_k32[3], _k32[2], _k32[1], _k32[0]));

  291. 

  292.     downSample(x,y);

  293.     __z = _mm_and_ps(_mm_or_ps(__z, _mm_and_ps(__xDS,__yDS)), __chance32);

  294.     __z = _mm_andnot_ps(_mm_and_ps(_mm_and_ps(_mm_xor_ps(__xDS, __high), _mm_xor_ps(__yDS, __high)),__chance32), __z);

  295.     __zDS = _mm_switch_ps(__zDS, __z, __sample);

  296.     return __zDS;

  297. }