andrewm@0
|
1 /*
|
andrewm@0
|
2 * render.cpp
|
andrewm@0
|
3 *
|
andrewm@0
|
4 * Created on: May 28, 2014
|
andrewm@0
|
5 * Author: Victor Zappi
|
andrewm@0
|
6 */
|
andrewm@0
|
7
|
andrewm@50
|
8 #include "../../include/BeagleRT.h"
|
andrewm@0
|
9 #include "../../include/PRU.h"
|
andrewm@0
|
10 #include "StatusLED.h"
|
andrewm@0
|
11 #include "config.h"
|
andrewm@0
|
12 #include "OscillatorBank.h"
|
andrewm@0
|
13 #include "FeedbackOscillator.h"
|
andrewm@0
|
14 #include "ADSR.h"
|
andrewm@0
|
15 #include "FIRfilter.h"
|
andrewm@0
|
16 #include <assert.h>
|
andrewm@0
|
17 #include <cmath>
|
andrewm@0
|
18 #include <vector>
|
andrewm@0
|
19
|
andrewm@0
|
20 #undef DBOX_CAPE_TEST
|
andrewm@0
|
21
|
andrewm@48
|
22 // Mappings from pin numbers on PCB to actual DAC channels
|
andrewm@48
|
23 // This gives the DAC and ADC connectors the same effective pinout
|
andrewm@48
|
24 #define DAC_PIN0 6
|
andrewm@48
|
25 #define DAC_PIN1 4
|
andrewm@48
|
26 #define DAC_PIN2 2
|
andrewm@48
|
27 #define DAC_PIN3 0
|
andrewm@48
|
28 #define DAC_PIN4 1
|
andrewm@48
|
29 #define DAC_PIN5 3
|
andrewm@48
|
30 #define DAC_PIN6 5
|
andrewm@48
|
31 #define DAC_PIN7 7
|
andrewm@48
|
32
|
andrewm@48
|
33 #define ADC_PIN0 0
|
andrewm@48
|
34 #define ADC_PIN1 1
|
andrewm@48
|
35 #define ADC_PIN2 2
|
andrewm@48
|
36 #define ADC_PIN3 3
|
andrewm@48
|
37 #define ADC_PIN4 4
|
andrewm@48
|
38 #define ADC_PIN5 5
|
andrewm@48
|
39 #define ADC_PIN6 6
|
andrewm@48
|
40 #define ADC_PIN7 7
|
andrewm@48
|
41
|
andrewm@0
|
42 #define N_OCT 4.0 // maximum number of octaves on sensor 1
|
andrewm@0
|
43
|
andrewm@0
|
44 extern vector<OscillatorBank*> gOscBanks;
|
andrewm@0
|
45 extern int gCurrentOscBank;
|
andrewm@0
|
46 extern int gNextOscBank;
|
andrewm@0
|
47 extern PRU *gPRU;
|
andrewm@0
|
48 extern StatusLED gStatusLED;
|
andrewm@0
|
49 extern bool gIsLoading;
|
andrewm@0
|
50 extern bool gAudioIn;
|
andrewm@0
|
51
|
andrewm@0
|
52 float *gOscillatorBuffer1, *gOscillatorBuffer2;
|
andrewm@0
|
53 float *gOscillatorBufferRead, *gOscillatorBufferWrite;
|
andrewm@0
|
54 int gOscillatorBufferReadPointer = 0;
|
andrewm@0
|
55 int gOscillatorBufferReadCurrentSize = 0;
|
andrewm@0
|
56 int gOscillatorBufferWriteCurrentSize = 0;
|
andrewm@0
|
57 bool gOscillatorNeedsRender = false;
|
andrewm@0
|
58
|
andrewm@0
|
59 int gMatrixSampleCount = 0; // How many samples have elapsed on the matrix
|
andrewm@0
|
60
|
andrewm@0
|
61 // Wavetable which changes in response to an oscillator
|
andrewm@0
|
62 float *gDynamicWavetable;
|
andrewm@0
|
63 int gDynamicWavetableLength;
|
andrewm@0
|
64 bool gDynamicWavetableNeedsRender = false;
|
andrewm@0
|
65
|
andrewm@0
|
66 // These variables handle the hysteresis oscillator used for setting the playback speed
|
andrewm@0
|
67 bool gSpeedHysteresisOscillatorRising = false;
|
andrewm@0
|
68 int gSpeedHysteresisLastTrigger = 0;
|
andrewm@0
|
69
|
andrewm@0
|
70 // These variables handle the feedback oscillator used for controlling the wavetable
|
andrewm@0
|
71 FeedbackOscillator gFeedbackOscillator;
|
andrewm@0
|
72 float *gFeedbackOscillatorTable;
|
andrewm@0
|
73 int gFeedbackOscillatorTableLength;
|
andrewm@0
|
74
|
andrewm@0
|
75 // This comes from sensor.cpp where it records the most recent touch location on
|
andrewm@0
|
76 // sensor 0.
|
andrewm@0
|
77 extern float gSensor0LatestTouchPos;
|
andrewm@0
|
78 extern int gSensor0LatestTouchNum;
|
andrewm@50
|
79 float gPitchLatestInput = 0;
|
andrewm@0
|
80
|
andrewm@0
|
81 extern float gSensor1LatestTouchPos[];
|
andrewm@0
|
82 //extern float gSensor1LatestTouchSizes[];
|
andrewm@0
|
83 extern int gSensor1LatestTouchCount;
|
andrewm@0
|
84 extern int gSensor1LatestTouchIndex;
|
andrewm@0
|
85 int gSensor1LastTouchIndex = -1;
|
andrewm@0
|
86 int gSensor1InputDelayCounter = -1;
|
andrewm@0
|
87 int gSensor1InputIndex = 0;
|
andrewm@0
|
88 float gSensor1MatrixTouchPos[5] = {0};
|
andrewm@0
|
89
|
andrewm@0
|
90 // FSR value from matrix input
|
andrewm@0
|
91 extern int gLastFSRValue;
|
andrewm@0
|
92
|
andrewm@0
|
93 // Loop points from matrix input 4
|
andrewm@0
|
94 const int gLoopPointsInputBufferSize = 256;
|
andrewm@50
|
95 float gLoopPointsInputBuffer[gLoopPointsInputBufferSize];
|
andrewm@0
|
96 int gLoopPointsInputBufferPointer = 0;
|
andrewm@50
|
97 float gLoopPointMin = 0, gLoopPointMax = 0;
|
andrewm@0
|
98
|
andrewm@0
|
99 // multiplier to activate or mute audio in
|
andrewm@0
|
100 int audioInStatus = 0;
|
andrewm@0
|
101
|
andrewm@0
|
102 // xenomai timer
|
andrewm@0
|
103 SRTIME prevChangeNs = 0;
|
andrewm@0
|
104
|
andrewm@0
|
105 // pitch vars
|
andrewm@0
|
106 float octaveSplitter;
|
andrewm@50
|
107 float semitones[((int)N_OCT*12)+1];
|
andrewm@0
|
108 float deltaTouch = 0;
|
andrewm@0
|
109 float deltaWeightP = 0.5;
|
andrewm@0
|
110 float deltaWeightI = 0.0005;
|
andrewm@0
|
111
|
andrewm@0
|
112 // filter vars
|
andrewm@0
|
113 ne10_fir_instance_f32_t filter[2];
|
andrewm@0
|
114 ne10_float32_t *filterIn[2];
|
andrewm@0
|
115 ne10_float32_t *filterOut[2];
|
andrewm@0
|
116 ne10_uint32_t blockSize;
|
andrewm@0
|
117 ne10_float32_t *filterState[2];
|
andrewm@0
|
118 ne10_float32_t prevFiltered[2];
|
andrewm@0
|
119 int filterGain = 80;
|
andrewm@0
|
120 ADSR PeakBurst[2];
|
andrewm@0
|
121 float peak[2];
|
andrewm@0
|
122 float peakThresh = 0.2;
|
andrewm@0
|
123
|
andrewm@0
|
124 // Tasks for lower-priority calculation
|
andrewm@0
|
125 AuxiliaryTask gMediumPriorityRender, gLowPriorityRender;
|
andrewm@0
|
126
|
andrewm@0
|
127
|
andrewm@0
|
128 extern "C" {
|
andrewm@0
|
129 // Function prototype for ARM assembly implementation of oscillator bank
|
andrewm@0
|
130 void oscillator_bank_neon(int numAudioFrames, float *audioOut,
|
andrewm@0
|
131 int activePartialNum, int lookupTableSize,
|
andrewm@0
|
132 float *phases, float *frequencies, float *amplitudes,
|
andrewm@0
|
133 float *freqDerivatives, float *ampDerivatives,
|
andrewm@0
|
134 float *lookupTable);
|
andrewm@0
|
135
|
andrewm@0
|
136 void wavetable_interpolate_neon(int numSamplesIn, int numSamplesOut,
|
andrewm@0
|
137 float *tableIn, float *tableOut);
|
andrewm@0
|
138 }
|
andrewm@0
|
139
|
andrewm@0
|
140 void wavetable_interpolate(int numSamplesIn, int numSamplesOut,
|
andrewm@0
|
141 float *tableIn, float *tableOut,
|
andrewm@0
|
142 float *sineTable, float sineMix);
|
andrewm@0
|
143
|
andrewm@50
|
144 inline float hysteresis_oscillator(float input, float risingThreshold,
|
andrewm@50
|
145 float fallingThreshold, bool *rising);
|
andrewm@50
|
146
|
andrewm@50
|
147 void render_medium_prio();
|
andrewm@50
|
148 void render_low_prio();
|
andrewm@0
|
149
|
andrewm@0
|
150 #ifdef DBOX_CAPE_TEST
|
andrewm@0
|
151 void render_capetest(int numMatrixFrames, int numAudioFrames, float *audioIn, float *audioOut,
|
andrewm@0
|
152 uint16_t *matrixIn, uint16_t *matrixOut);
|
andrewm@0
|
153 #endif
|
andrewm@0
|
154
|
andrewm@50
|
155 bool initialise_render(BeagleRTContext *context, void *userData) {
|
andrewm@0
|
156 int oscBankHopSize = *(int *)userData;
|
andrewm@0
|
157
|
andrewm@50
|
158 if(context->analogChannels != 8) {
|
andrewm@14
|
159 printf("Error: D-Box needs matrix enabled with 8 channels.\n");
|
andrewm@14
|
160 return false;
|
andrewm@14
|
161 }
|
andrewm@14
|
162
|
andrewm@0
|
163 // Allocate two buffers for rendering oscillator bank samples
|
andrewm@0
|
164 // One will be used for writing in the background while the other is used for reading
|
andrewm@0
|
165 // on the audio thread. 8-byte alignment needed for the NEON code.
|
andrewm@50
|
166 if(posix_memalign((void **)&gOscillatorBuffer1, 8, oscBankHopSize * context->audioChannels * sizeof(float))) {
|
andrewm@0
|
167 printf("Error allocating render buffers\n");
|
andrewm@0
|
168 return false;
|
andrewm@0
|
169 }
|
andrewm@50
|
170 if(posix_memalign((void **)&gOscillatorBuffer2, 8, oscBankHopSize * context->audioChannels * sizeof(float))) {
|
andrewm@0
|
171 printf("Error allocating render buffers\n");
|
andrewm@0
|
172 return false;
|
andrewm@0
|
173 }
|
andrewm@0
|
174 gOscillatorBufferWrite = gOscillatorBuffer1;
|
andrewm@0
|
175 gOscillatorBufferRead = gOscillatorBuffer2;
|
andrewm@0
|
176
|
andrewm@50
|
177 memset(gOscillatorBuffer1, 0, oscBankHopSize * context->audioChannels * sizeof(float));
|
andrewm@50
|
178 memset(gOscillatorBuffer2, 0, oscBankHopSize * context->audioChannels * sizeof(float));
|
andrewm@0
|
179
|
andrewm@0
|
180 // Initialise the dynamic wavetable used by the oscillator bank
|
andrewm@0
|
181 // It should match the size of the static one already allocated in the OscillatorBank object
|
andrewm@0
|
182 // Don't forget a guard point at the end of the table
|
andrewm@0
|
183 gDynamicWavetableLength = gOscBanks[gCurrentOscBank]->lookupTableSize;
|
andrewm@0
|
184 if(posix_memalign((void **)&gDynamicWavetable, 8, (gDynamicWavetableLength + 1) * sizeof(float))) {
|
andrewm@0
|
185 printf("Error allocating wavetable\n");
|
andrewm@0
|
186 return false;
|
andrewm@0
|
187 }
|
andrewm@0
|
188
|
andrewm@50
|
189 gFeedbackOscillator.initialise(8192, 10.0, context->analogSampleRate);
|
andrewm@0
|
190
|
andrewm@0
|
191 for(int n = 0; n < gDynamicWavetableLength + 1; n++)
|
andrewm@0
|
192 gDynamicWavetable[n] = 0;
|
andrewm@0
|
193
|
andrewm@0
|
194 // pitch
|
andrewm@50
|
195 float midPos = 0.5;
|
andrewm@50
|
196 octaveSplitter = 1.0 / N_OCT;
|
andrewm@0
|
197 int numOfSemi = 12*N_OCT;
|
andrewm@0
|
198 int middleSemitone = 12*N_OCT/2;
|
andrewm@0
|
199 int lastSemitone = middleSemitone+numOfSemi/2;
|
andrewm@50
|
200 float inc = 1.0 / (N_OCT*12.0);
|
andrewm@0
|
201 int i = -1;
|
andrewm@0
|
202 for(int semi=middleSemitone; semi<=lastSemitone; semi++)
|
andrewm@0
|
203 semitones[semi] = ( midPos + (++i)*inc) + 0.5;
|
andrewm@0
|
204 i = 0;
|
andrewm@0
|
205 for(int semi=middleSemitone-1; semi>=0; semi--)
|
andrewm@0
|
206 semitones[semi] = ( midPos - (++i)*inc) + 0.5;
|
andrewm@0
|
207
|
andrewm@0
|
208 if(gAudioIn)
|
andrewm@0
|
209 audioInStatus = 1;
|
andrewm@0
|
210
|
andrewm@0
|
211 // filter
|
andrewm@50
|
212 blockSize = context->audioFrames;
|
andrewm@0
|
213 filterState[0] = (ne10_float32_t *) NE10_MALLOC ((FILTER_TAP_NUM+blockSize-1) * sizeof (ne10_float32_t));
|
andrewm@0
|
214 filterState[1] = (ne10_float32_t *) NE10_MALLOC ((FILTER_TAP_NUM+blockSize-1) * sizeof (ne10_float32_t));
|
andrewm@0
|
215 filterIn[0] = (ne10_float32_t *) NE10_MALLOC (blockSize * sizeof (ne10_float32_t));
|
andrewm@0
|
216 filterIn[1] = (ne10_float32_t *) NE10_MALLOC (blockSize * sizeof (ne10_float32_t));
|
andrewm@0
|
217 filterOut[0] = (ne10_float32_t *) NE10_MALLOC (blockSize * sizeof (ne10_float32_t));
|
andrewm@0
|
218 filterOut[1] = (ne10_float32_t *) NE10_MALLOC (blockSize * sizeof (ne10_float32_t));
|
andrewm@0
|
219 ne10_fir_init_float(&filter[0], FILTER_TAP_NUM, filterTaps, filterState[0], blockSize);
|
andrewm@0
|
220 ne10_fir_init_float(&filter[1], FILTER_TAP_NUM, filterTaps, filterState[1], blockSize);
|
andrewm@0
|
221
|
andrewm@0
|
222 // peak outputs
|
andrewm@50
|
223 PeakBurst[0].setAttackRate(.00001 * context->analogSampleRate);
|
andrewm@50
|
224 PeakBurst[1].setAttackRate(.00001 * context->analogSampleRate);
|
andrewm@50
|
225 PeakBurst[0].setDecayRate(.5 * context->analogSampleRate);
|
andrewm@50
|
226 PeakBurst[1].setDecayRate(.5 * context->analogSampleRate);
|
andrewm@0
|
227 PeakBurst[0].setSustainLevel(0.0);
|
andrewm@0
|
228 PeakBurst[1].setSustainLevel(0.0);
|
andrewm@0
|
229
|
andrewm@0
|
230 // Initialise auxiliary tasks
|
andrewm@50
|
231 if((gMediumPriorityRender = BeagleRT_createAuxiliaryTask(&render_medium_prio, BEAGLERT_AUDIO_PRIORITY - 10, "dbox-calculation-medium")) == 0)
|
andrewm@0
|
232 return false;
|
andrewm@50
|
233 if((gLowPriorityRender = BeagleRT_createAuxiliaryTask(&render_low_prio, BEAGLERT_AUDIO_PRIORITY - 15, "dbox-calculation-low")) == 0)
|
andrewm@0
|
234 return false;
|
andrewm@0
|
235
|
andrewm@0
|
236 return true;
|
andrewm@0
|
237 }
|
andrewm@0
|
238
|
andrewm@50
|
239 void render(BeagleRTContext *context, void *userData)
|
andrewm@0
|
240 {
|
andrewm@0
|
241 #ifdef DBOX_CAPE_TEST
|
andrewm@0
|
242 render_capetest(numMatrixFrames, numAudioFrames, audioIn, audioOut, matrixIn, matrixOut);
|
andrewm@0
|
243 #else
|
andrewm@0
|
244 if(gOscBanks[gCurrentOscBank]->state==bank_toreset)
|
andrewm@0
|
245 gOscBanks[gCurrentOscBank]->resetOscillators();
|
andrewm@0
|
246
|
andrewm@0
|
247 if(gOscBanks[gCurrentOscBank]->state==bank_playing)
|
andrewm@0
|
248 {
|
andrewm@50
|
249 assert(context->audioChannels == 2);
|
andrewm@0
|
250
|
andrewm@0
|
251 #ifdef OLD_OSCBANK
|
andrewm@50
|
252 memset(audioOut, 0, numAudioFrames * * sizeof(float));
|
andrewm@0
|
253
|
andrewm@0
|
254 /* Render the oscillator bank. The oscillator bank function is written in NEON assembly
|
andrewm@0
|
255 * and it strips out all extra checks, so find out in advance whether we can render a whole
|
andrewm@0
|
256 * block or whether the frame will increment in the middle of this buffer.
|
andrewm@0
|
257 */
|
andrewm@0
|
258
|
andrewm@0
|
259 int framesRemaining = numAudioFrames;
|
andrewm@0
|
260 float *audioOutWithOffset = audioOut;
|
andrewm@0
|
261
|
andrewm@0
|
262 while(framesRemaining > 0) {
|
andrewm@0
|
263 if(gOscBanks[gCurrentOscBank]->hopCounter >= framesRemaining) {
|
andrewm@0
|
264 /* More frames left in this hop than we need this time. Render and finish */
|
andrewm@0
|
265 oscillator_bank_neon(framesRemaining, audioOutWithOffset,
|
andrewm@0
|
266 gOscBanks[gCurrentOscBank]->actPartNum, gOscBanks[gCurrentOscBank]->lookupTableSize,
|
andrewm@0
|
267 gOscBanks[gCurrentOscBank]->oscillatorPhases, gOscBanks[gCurrentOscBank]->oscillatorNormFrequencies,
|
andrewm@0
|
268 gOscBanks[gCurrentOscBank]->oscillatorAmplitudes,
|
andrewm@0
|
269 gOscBanks[gCurrentOscBank]->oscillatorNormFreqDerivatives,
|
andrewm@0
|
270 gOscBanks[gCurrentOscBank]->oscillatorAmplitudeDerivatives,
|
andrewm@0
|
271 gDynamicWavetable/*gOscBanks[gCurrentOscBank]->lookupTable*/);
|
andrewm@0
|
272 gOscBanks[gCurrentOscBank]->hopCounter -= framesRemaining;
|
andrewm@0
|
273 if(gOscBanks[gCurrentOscBank]->hopCounter <= 0)
|
andrewm@0
|
274 gOscBanks[gCurrentOscBank]->nextHop();
|
andrewm@0
|
275 framesRemaining = 0;
|
andrewm@0
|
276 }
|
andrewm@0
|
277 else {
|
andrewm@0
|
278 /* More frames to render than are left in this hop. Render and decrement the
|
andrewm@0
|
279 * number of remaining frames; then advance to the next oscillator frame.
|
andrewm@0
|
280 */
|
andrewm@0
|
281 oscillator_bank_neon(gOscBanks[gCurrentOscBank]->hopCounter, audioOutWithOffset,
|
andrewm@0
|
282 gOscBanks[gCurrentOscBank]->actPartNum, gOscBanks[gCurrentOscBank]->lookupTableSize,
|
andrewm@0
|
283 gOscBanks[gCurrentOscBank]->oscillatorPhases, gOscBanks[gCurrentOscBank]->oscillatorNormFrequencies,
|
andrewm@0
|
284 gOscBanks[gCurrentOscBank]->oscillatorAmplitudes,
|
andrewm@0
|
285 gOscBanks[gCurrentOscBank]->oscillatorNormFreqDerivatives,
|
andrewm@0
|
286 gOscBanks[gCurrentOscBank]->oscillatorAmplitudeDerivatives,
|
andrewm@0
|
287 gDynamicWavetable/*gOscBanks[gCurrentOscBank]->lookupTable*/);
|
andrewm@0
|
288 framesRemaining -= gOscBanks[gCurrentOscBank]->hopCounter;
|
andrewm@50
|
289 audioOutWithOffset += * gOscBanks[gCurrentOscBank]->hopCounter;
|
andrewm@0
|
290 gOscBanks[gCurrentOscBank]->sampleCount += gOscBanks[gCurrentOscBank]->hopCounter;
|
andrewm@0
|
291 gOscBanks[gCurrentOscBank]->nextHop();
|
andrewm@0
|
292 }
|
andrewm@0
|
293 }
|
andrewm@0
|
294 #else
|
andrewm@50
|
295 for(unsigned int n = 0; n < context->audioFrames; n++) {
|
andrewm@50
|
296 context->audioOut[2*n] = gOscillatorBufferRead[gOscillatorBufferReadPointer++]+context->audioIn[2*n]*audioInStatus;
|
andrewm@50
|
297 context->audioOut[2*n + 1] = gOscillatorBufferRead[gOscillatorBufferReadPointer++]+context->audioIn[2*n+1]*audioInStatus;
|
andrewm@0
|
298
|
andrewm@50
|
299 filterIn[0][n] = fabs(context->audioIn[2*n]); // rectify for peak detection in 1
|
andrewm@50
|
300 filterIn[1][n] = fabs(context->audioIn[2*n+1]); // rectify for peak detection in 2
|
andrewm@0
|
301
|
andrewm@0
|
302 /* FIXME why doesn't this work? */
|
andrewm@0
|
303 /*
|
andrewm@0
|
304 if(gOscillatorBufferReadPointer == gOscillatorBufferCurrentSize/2) {
|
andrewm@0
|
305 gOscillatorNeedsRender = true;
|
andrewm@0
|
306 scheduleAuxiliaryTask(gLowPriorityRender);
|
andrewm@0
|
307 } */
|
andrewm@0
|
308
|
andrewm@0
|
309 if(gOscillatorBufferReadPointer >= gOscillatorBufferReadCurrentSize) {
|
andrewm@0
|
310 // Finished reading from the buffer: swap to the next buffer
|
andrewm@0
|
311 if(gOscillatorBufferRead == gOscillatorBuffer1) {
|
andrewm@0
|
312 gOscillatorBufferRead = gOscillatorBuffer2;
|
andrewm@0
|
313 gOscillatorBufferWrite = gOscillatorBuffer1;
|
andrewm@0
|
314 }
|
andrewm@0
|
315 else {
|
andrewm@0
|
316 gOscillatorBufferRead = gOscillatorBuffer1;
|
andrewm@0
|
317 gOscillatorBufferWrite = gOscillatorBuffer2;
|
andrewm@0
|
318 }
|
andrewm@0
|
319
|
andrewm@0
|
320 // New buffer size is whatever finished writing last hop
|
andrewm@0
|
321 gOscillatorBufferReadCurrentSize = gOscillatorBufferWriteCurrentSize;
|
andrewm@0
|
322 gOscillatorBufferReadPointer = 0;
|
andrewm@0
|
323
|
andrewm@0
|
324 gOscillatorNeedsRender = true;
|
andrewm@50
|
325 BeagleRT_scheduleAuxiliaryTask(gMediumPriorityRender);
|
andrewm@0
|
326 }
|
andrewm@0
|
327 }
|
andrewm@0
|
328 #endif
|
andrewm@0
|
329 }
|
andrewm@0
|
330 else
|
andrewm@0
|
331 {
|
andrewm@50
|
332 for(unsigned int n = 0; n < context->audioFrames; n++) {
|
andrewm@50
|
333 context->audioOut[2*n] = context->audioIn[2*n]*audioInStatus;
|
andrewm@50
|
334 context->audioOut[2*n + 1] = context->audioIn[2*n+1]*audioInStatus;
|
andrewm@0
|
335
|
andrewm@50
|
336 filterIn[0][n] = fabs(context->audioIn[2*n]); // rectify for peak detection in 1
|
andrewm@50
|
337 filterIn[1][n] = fabs(context->audioIn[2*n+1]); // rectify for peak detection in 2
|
andrewm@0
|
338 }
|
andrewm@0
|
339 }
|
andrewm@0
|
340
|
andrewm@0
|
341 // low pass filter audio in 1 and 2 for peak detection
|
andrewm@0
|
342 ne10_fir_float_neon(&filter[0], filterIn[0], filterOut[0], blockSize);
|
andrewm@0
|
343 ne10_fir_float_neon(&filter[1], filterIn[1], filterOut[1], blockSize);
|
andrewm@0
|
344
|
andrewm@50
|
345 for(unsigned int n = 0; n < context->analogFrames; n++) {
|
andrewm@0
|
346
|
andrewm@0
|
347
|
andrewm@0
|
348 /* Matrix Out 0, In 0
|
andrewm@0
|
349 *
|
andrewm@0
|
350 * CV loop
|
andrewm@0
|
351 * Controls pitch of sound
|
andrewm@0
|
352 */
|
andrewm@50
|
353 float touchPosInt = gSensor0LatestTouchPos;
|
andrewm@0
|
354 if(touchPosInt < 0) touchPosInt = 0;
|
andrewm@50
|
355 if(touchPosInt > 1.0) touchPosInt = 1.0;
|
andrewm@50
|
356 context->analogOut[n*8 + DAC_PIN0] = touchPosInt;
|
andrewm@0
|
357
|
andrewm@50
|
358 gPitchLatestInput = context->analogIn[n*8 + ADC_PIN0];
|
andrewm@0
|
359
|
andrewm@0
|
360
|
andrewm@0
|
361 /* Matrix Out 7
|
andrewm@0
|
362 *
|
andrewm@0
|
363 * Loop feedback with Matrix In 0
|
andrewm@0
|
364 * Controls discreet pitch
|
andrewm@0
|
365 */
|
andrewm@0
|
366 float deltaTarget = 0;
|
andrewm@0
|
367 int semitoneIndex = 0;
|
andrewm@0
|
368 if(gSensor0LatestTouchNum>0)
|
andrewm@0
|
369 {
|
andrewm@0
|
370 // current pitch is gPitchLatestInput, already retrieved
|
andrewm@50
|
371 semitoneIndex = ( gPitchLatestInput * 12 * N_OCT )+0.5; // closest semitone
|
andrewm@0
|
372 deltaTarget = (semitones[semitoneIndex]-gPitchLatestInput); // delta between pitch and target
|
andrewm@0
|
373 deltaTouch += deltaTarget*deltaWeightI; // update feedback [previous + current]
|
andrewm@0
|
374 }
|
andrewm@0
|
375 else
|
andrewm@0
|
376 deltaTouch = 0;
|
andrewm@0
|
377
|
andrewm@50
|
378 float nextOut = touchPosInt + deltaTarget*deltaWeightP + deltaTouch; // add feedback to touch -> next out
|
andrewm@0
|
379 if(nextOut < 0) nextOut = 0; // clamp
|
andrewm@50
|
380 if(nextOut > 1.0) nextOut = 1.0; // clamp
|
andrewm@50
|
381 context->analogOut[n*8 + DAC_PIN7] = nextOut; // send next nextOut
|
andrewm@0
|
382
|
andrewm@0
|
383
|
andrewm@0
|
384 /*
|
andrewm@0
|
385 * Matrix Out 1, In 1
|
andrewm@0
|
386 *
|
andrewm@0
|
387 * Hysteresis (comparator) oscillator
|
andrewm@0
|
388 * Controls speed of playback
|
andrewm@0
|
389 */
|
andrewm@0
|
390 bool wasRising = gSpeedHysteresisOscillatorRising;
|
andrewm@50
|
391 context->analogOut[n*8 + DAC_PIN1] = hysteresis_oscillator(context->analogIn[n*8 + ADC_PIN1], 48000.0/65536.0,
|
andrewm@50
|
392 16000.0/65536.0, &gSpeedHysteresisOscillatorRising);
|
andrewm@0
|
393
|
andrewm@0
|
394 // Find interval of zero crossing
|
andrewm@0
|
395 if(wasRising && !gSpeedHysteresisOscillatorRising) {
|
andrewm@0
|
396 int interval = gMatrixSampleCount - gSpeedHysteresisLastTrigger;
|
andrewm@0
|
397
|
andrewm@0
|
398 // Interval since last trigger will be the new hop size; calculate to set speed
|
andrewm@0
|
399 if(interval < 1)
|
andrewm@0
|
400 interval = 1;
|
andrewm@0
|
401 //float speed = (float)gOscBanks[gCurrentOscBank]->getHopSize() / (float)interval;
|
andrewm@0
|
402 float speed = 144.0 / interval; // Normalise to a fixed expected speed
|
andrewm@0
|
403 gOscBanks[gCurrentOscBank]->setSpeed(speed);
|
andrewm@0
|
404
|
andrewm@0
|
405 gSpeedHysteresisLastTrigger = gMatrixSampleCount;
|
andrewm@0
|
406 }
|
andrewm@0
|
407
|
andrewm@0
|
408 /*
|
andrewm@0
|
409 * Matrix Out 2, In 2
|
andrewm@0
|
410 *
|
andrewm@0
|
411 * Feedback (phase shift) oscillator
|
andrewm@0
|
412 * Controls wavetable used for oscillator bank
|
andrewm@0
|
413 */
|
andrewm@0
|
414
|
andrewm@50
|
415 int tableLength = gFeedbackOscillator.process(context->analogIn[n*8 + ADC_PIN2], &context->analogOut[n*8 + DAC_PIN2]);
|
andrewm@0
|
416 if(tableLength != 0) {
|
andrewm@0
|
417 gFeedbackOscillatorTableLength = tableLength;
|
andrewm@0
|
418 gFeedbackOscillatorTable = gFeedbackOscillator.wavetable();
|
andrewm@0
|
419 gDynamicWavetableNeedsRender = true;
|
andrewm@50
|
420 BeagleRT_scheduleAuxiliaryTask(gLowPriorityRender);
|
andrewm@0
|
421 }
|
andrewm@0
|
422
|
andrewm@0
|
423 /*
|
andrewm@0
|
424 * Matrix Out 3, In 3
|
andrewm@0
|
425 *
|
andrewm@0
|
426 * CV loop with delay for time alignment
|
andrewm@0
|
427 * Touch positions from sensor 1
|
andrewm@0
|
428 * Change every 32 samples (ca. 1.5 ms)
|
andrewm@0
|
429 */
|
andrewm@0
|
430 volatile int touchCount = gSensor1LatestTouchCount;
|
andrewm@0
|
431 if(touchCount == 0)
|
andrewm@50
|
432 context->analogOut[n*8 + DAC_PIN3] = 0;
|
andrewm@0
|
433 else {
|
andrewm@0
|
434 int touchIndex = (gMatrixSampleCount >> 5) % touchCount;
|
andrewm@50
|
435 context->analogOut[n*8 + DAC_PIN3] = gSensor1LatestTouchPos[touchIndex] * 56000.0f / 65536.0f;
|
andrewm@0
|
436 if(touchIndex != gSensor1LastTouchIndex) {
|
andrewm@0
|
437 // Just changed to a new touch output. Reset the counter.
|
andrewm@0
|
438 // It will take 2*matrixFrames samples for this output to come back to the
|
andrewm@0
|
439 // ADC input. But we also want to read near the end of the 32 sample block;
|
andrewm@0
|
440 // let's say 24 samples into it.
|
andrewm@0
|
441
|
andrewm@0
|
442 // FIXME this won't work for p > 2
|
andrewm@50
|
443 gSensor1InputDelayCounter = 24 + 2*context->analogFrames;
|
andrewm@0
|
444 gSensor1InputIndex = touchIndex;
|
andrewm@0
|
445 }
|
andrewm@0
|
446 gSensor1LastTouchIndex = touchIndex;
|
andrewm@0
|
447 }
|
andrewm@0
|
448
|
andrewm@0
|
449 if(gSensor1InputDelayCounter-- >= 0 && touchCount > 0) {
|
andrewm@50
|
450 gSensor1MatrixTouchPos[gSensor1InputIndex] = context->analogIn[n*8 + ADC_PIN3];
|
andrewm@0
|
451 }
|
andrewm@0
|
452
|
andrewm@0
|
453 /* Matrix Out 4
|
andrewm@0
|
454 *
|
andrewm@0
|
455 * Sensor 1 last pos
|
andrewm@0
|
456 */
|
andrewm@50
|
457 touchPosInt = gSensor1LatestTouchPos[gSensor1LatestTouchIndex];
|
andrewm@0
|
458 if(touchPosInt < 0) touchPosInt = 0;
|
andrewm@50
|
459 if(touchPosInt > 1.0) touchPosInt = 1.0;
|
andrewm@50
|
460 context->analogOut[n*8 + DAC_PIN4] = touchPosInt;
|
andrewm@0
|
461
|
andrewm@0
|
462 /* Matrix In 4
|
andrewm@0
|
463 *
|
andrewm@0
|
464 * Loop points selector
|
andrewm@0
|
465 */
|
andrewm@50
|
466 gLoopPointsInputBuffer[gLoopPointsInputBufferPointer++] = context->analogIn[n*8 + ADC_PIN4];
|
andrewm@0
|
467 if(gLoopPointsInputBufferPointer >= gLoopPointsInputBufferSize) {
|
andrewm@0
|
468 // Find min and max values
|
andrewm@50
|
469 float loopMax = 0, loopMin = 1.0;
|
andrewm@0
|
470 for(int i = 0; i < gLoopPointsInputBufferSize; i++) {
|
andrewm@0
|
471 if(gLoopPointsInputBuffer[i] < loopMin)
|
andrewm@0
|
472 loopMin = gLoopPointsInputBuffer[i];
|
andrewm@0
|
473 if(gLoopPointsInputBuffer[i] > loopMax/* && gLoopPointsInputBuffer[i] != 65535*/)
|
andrewm@0
|
474 loopMax = gLoopPointsInputBuffer[i];
|
andrewm@0
|
475 }
|
andrewm@0
|
476
|
andrewm@0
|
477 if(loopMin >= loopMax)
|
andrewm@0
|
478 loopMax = loopMin;
|
andrewm@0
|
479
|
andrewm@0
|
480 gLoopPointMax = loopMax;
|
andrewm@0
|
481 gLoopPointMin = loopMin;
|
andrewm@0
|
482 gLoopPointsInputBufferPointer = 0;
|
andrewm@0
|
483 }
|
andrewm@0
|
484
|
andrewm@0
|
485 /* Matrix Out 5
|
andrewm@0
|
486 *
|
andrewm@0
|
487 * Audio In 1 peak detection and peak burst output
|
andrewm@0
|
488 */
|
andrewm@0
|
489
|
andrewm@0
|
490 filterOut[0][n*2+1] *= filterGain;
|
andrewm@0
|
491 float burstOut = PeakBurst[0].getOutput();
|
andrewm@0
|
492 if( burstOut < 0.1)
|
andrewm@0
|
493 {
|
andrewm@0
|
494 if( (prevFiltered[0]>=peakThresh) && (prevFiltered[0]>=filterOut[0][n*2+1]) )
|
andrewm@0
|
495 {
|
andrewm@0
|
496 peak[0] = prevFiltered[0];
|
andrewm@0
|
497 PeakBurst[0].gate(1);
|
andrewm@0
|
498 }
|
andrewm@0
|
499 }
|
andrewm@0
|
500
|
andrewm@0
|
501 PeakBurst[0].process(1);
|
andrewm@0
|
502
|
andrewm@50
|
503 float convAudio = burstOut*peak[0];
|
andrewm@50
|
504 context->analogOut[n*8 + DAC_PIN5] = convAudio;
|
andrewm@0
|
505 prevFiltered[0] = filterOut[0][n*2+1];
|
andrewm@0
|
506 if(prevFiltered[0]>1)
|
andrewm@0
|
507 prevFiltered[0] = 1;
|
andrewm@0
|
508
|
andrewm@0
|
509 /* Matrix In 5
|
andrewm@0
|
510 *
|
andrewm@0
|
511 * Dissonance, via changing frequency motion of partials
|
andrewm@0
|
512 */
|
andrewm@50
|
513 float amount = (float)context->analogIn[n*8 + ADC_PIN5];
|
andrewm@50
|
514 gOscBanks[gCurrentOscBank]->freqMovement = 1.0 - amount;
|
andrewm@0
|
515
|
andrewm@0
|
516
|
andrewm@0
|
517
|
andrewm@0
|
518
|
andrewm@0
|
519 /* Matrix Out 6
|
andrewm@0
|
520 *
|
andrewm@0
|
521 * Audio In 2 peak detection and peak burst output
|
andrewm@0
|
522 */
|
andrewm@0
|
523
|
andrewm@0
|
524 filterOut[1][n*2+1] *= filterGain;
|
andrewm@0
|
525 burstOut = PeakBurst[1].getOutput();
|
andrewm@0
|
526 if( burstOut < 0.1)
|
andrewm@0
|
527 {
|
andrewm@0
|
528 if( (prevFiltered[1]>=peakThresh) && (prevFiltered[1]>=filterOut[1][n*2+1]) )
|
andrewm@0
|
529 {
|
andrewm@0
|
530 peak[1] = prevFiltered[1];
|
andrewm@0
|
531 PeakBurst[1].gate(1);
|
andrewm@0
|
532 }
|
andrewm@0
|
533 }
|
andrewm@0
|
534
|
andrewm@0
|
535 PeakBurst[1].process(1);
|
andrewm@0
|
536
|
andrewm@50
|
537 convAudio = burstOut*peak[1];
|
andrewm@50
|
538 context->analogOut[n*8 + DAC_PIN6] = convAudio;
|
andrewm@0
|
539 prevFiltered[1] = filterOut[1][n*2+1];
|
andrewm@0
|
540 if(prevFiltered[1]>1)
|
andrewm@0
|
541 prevFiltered[1] = 1;
|
andrewm@0
|
542
|
andrewm@0
|
543 /* Matrix In 6
|
andrewm@0
|
544 *
|
andrewm@0
|
545 * Sound selector
|
andrewm@0
|
546 */
|
andrewm@0
|
547 if(!gIsLoading) {
|
andrewm@0
|
548 // Use hysteresis to avoid jumping back and forth between sounds
|
andrewm@0
|
549 if(gOscBanks.size() > 1) {
|
andrewm@50
|
550 float input = context->analogIn[n*8 + ADC_PIN6];
|
andrewm@50
|
551 const float hystValue = 16000.0 / 65536.0;
|
andrewm@0
|
552
|
andrewm@50
|
553 float upHysteresisValue = ((gCurrentOscBank + 1) + hystValue) / gOscBanks.size();
|
andrewm@50
|
554 float downHysteresisValue = (gCurrentOscBank - hystValue) / gOscBanks.size();
|
andrewm@0
|
555
|
andrewm@0
|
556 if(input > upHysteresisValue || input < downHysteresisValue) {
|
andrewm@50
|
557 gNextOscBank = input * gOscBanks.size();
|
andrewm@0
|
558 if(gNextOscBank < 0)
|
andrewm@0
|
559 gNextOscBank = 0;
|
andrewm@0
|
560 if((unsigned)gNextOscBank >= gOscBanks.size())
|
andrewm@0
|
561 gNextOscBank = gOscBanks.size() - 1;
|
andrewm@0
|
562 }
|
andrewm@0
|
563 }
|
andrewm@0
|
564 }
|
andrewm@0
|
565
|
andrewm@0
|
566 /*
|
andrewm@0
|
567 * Matrix In 7
|
andrewm@0
|
568 *
|
andrewm@0
|
569 * FSR from primary touch sensor
|
andrewm@0
|
570 * Value ranges from 0-1799
|
andrewm@0
|
571 */
|
andrewm@50
|
572 gLastFSRValue = context->analogIn[n*8 + ADC_PIN7] * 1799.0;
|
andrewm@50
|
573 //gLastFSRValue = 1799 - context->analogIn[n*8 + ADC_PIN7] * (1799.0 / 65535.0);
|
andrewm@0
|
574 //dbox_printf("%i\n",gLastFSRValue);
|
andrewm@0
|
575
|
andrewm@0
|
576 gMatrixSampleCount++;
|
andrewm@0
|
577 }
|
andrewm@0
|
578
|
andrewm@0
|
579 #endif /* DBOX_CAPE_TEST */
|
andrewm@0
|
580 }
|
andrewm@0
|
581
|
andrewm@0
|
582 // Medium-priority render function used for audio hop calculations
|
andrewm@0
|
583 void render_medium_prio()
|
andrewm@0
|
584 {
|
andrewm@0
|
585
|
andrewm@0
|
586 if(gOscillatorNeedsRender) {
|
andrewm@0
|
587 gOscillatorNeedsRender = false;
|
andrewm@0
|
588
|
andrewm@0
|
589 /* Render one frame into the write buffer */
|
andrewm@50
|
590 memset(gOscillatorBufferWrite, 0, gOscBanks[gCurrentOscBank]->hopCounter * 2 * sizeof(float)); /* assumes 2 audio channels */
|
andrewm@0
|
591
|
andrewm@0
|
592 oscillator_bank_neon(gOscBanks[gCurrentOscBank]->hopCounter, gOscillatorBufferWrite,
|
andrewm@0
|
593 gOscBanks[gCurrentOscBank]->actPartNum, gOscBanks[gCurrentOscBank]->lookupTableSize,
|
andrewm@0
|
594 gOscBanks[gCurrentOscBank]->oscillatorPhases, gOscBanks[gCurrentOscBank]->oscillatorNormFrequencies,
|
andrewm@0
|
595 gOscBanks[gCurrentOscBank]->oscillatorAmplitudes,
|
andrewm@0
|
596 gOscBanks[gCurrentOscBank]->oscillatorNormFreqDerivatives,
|
andrewm@0
|
597 gOscBanks[gCurrentOscBank]->oscillatorAmplitudeDerivatives,
|
andrewm@0
|
598 /*gOscBanks[gCurrentOscBank]->lookupTable*/gDynamicWavetable);
|
andrewm@0
|
599
|
andrewm@50
|
600 gOscillatorBufferWriteCurrentSize = gOscBanks[gCurrentOscBank]->hopCounter * 2;
|
andrewm@0
|
601
|
andrewm@0
|
602 /* Update the pitch right before the hop
|
andrewm@0
|
603 * Total CV range +/- N_OCT octaves
|
andrewm@0
|
604 */
|
andrewm@0
|
605 float pitch = (float)gPitchLatestInput / octaveSplitter - N_OCT/2;
|
andrewm@0
|
606 //gOscBanks[gCurrentOscBank]->pitchMultiplier = powf(2.0f, pitch);
|
andrewm@0
|
607 gOscBanks[gCurrentOscBank]->pitchMultiplier = pow(2.0f, pitch);
|
andrewm@0
|
608
|
andrewm@0
|
609 #ifdef FIXME_LATER // This doesn't work very well yet
|
andrewm@0
|
610 gOscBanks[gCurrentOscBank]->filterNum = gSensor1LatestTouchCount;
|
andrewm@0
|
611 float freqScaler = gOscBanks[gCurrentOscBank]->getFrequencyScaler();
|
andrewm@0
|
612 for(int i=0; i < gOscBanks[gCurrentOscBank]->filterNum; i++)
|
andrewm@0
|
613 {
|
andrewm@0
|
614 // touch pos is linear but freqs are log
|
andrewm@0
|
615 gOscBanks[gCurrentOscBank]->filterFreqs[i] = ((expf(gSensor1MatrixTouchPos[i]*4)-1)/(expf(4)-1))*gOscBanks[gCurrentOscBank]->filterMaxF*freqScaler;
|
andrewm@0
|
616 gOscBanks[gCurrentOscBank]->filterQ[i] = gSensor1LatestTouchSizes[i];
|
andrewm@0
|
617 if(gOscBanks[gCurrentOscBank]->filterFreqs[i]>500*freqScaler)
|
andrewm@0
|
618 gOscBanks[gCurrentOscBank]->filterPadding[i] = 1+100000*( (gOscBanks[gCurrentOscBank]->filterFreqs[i]-500*freqScaler)/(gOscBanks[gCurrentOscBank]->filterMaxF-500)*freqScaler );
|
andrewm@0
|
619 else
|
andrewm@0
|
620 gOscBanks[gCurrentOscBank]->filterPadding[i] = 1;
|
andrewm@0
|
621 }
|
andrewm@0
|
622 #endif
|
andrewm@0
|
623
|
andrewm@0
|
624 RTIME ticks = rt_timer_read();
|
andrewm@0
|
625 SRTIME ns = rt_timer_tsc2ns(ticks);
|
andrewm@0
|
626 SRTIME delta = ns-prevChangeNs;
|
andrewm@0
|
627
|
andrewm@0
|
628 // switch to next bank cannot be too frequent, to avoid seg fault! [for example sef fault happens when removing both VDD and GND from breadboard]
|
andrewm@0
|
629 if(gNextOscBank != gCurrentOscBank && delta>100000000) {
|
andrewm@0
|
630
|
andrewm@0
|
631 /*printf("ticks %llu\n", (unsigned long long)ticks);
|
andrewm@0
|
632 printf("ns %llu\n", (unsigned long long)ns);
|
andrewm@0
|
633 printf("prevChangeNs %llu\n", (unsigned long long)prevChangeNs);
|
andrewm@0
|
634 printf("-------------------------->%llud\n", (unsigned long long)(ns-prevChangeNs));*/
|
andrewm@0
|
635
|
andrewm@0
|
636 prevChangeNs = ns;
|
andrewm@0
|
637 dbox_printf("Changing to bank %d...\n", gNextOscBank);
|
andrewm@0
|
638 if(gOscBanks[gCurrentOscBank]->state==bank_playing){
|
andrewm@0
|
639 gOscBanks[gCurrentOscBank]->stop();
|
andrewm@0
|
640 }
|
andrewm@0
|
641
|
andrewm@0
|
642 gCurrentOscBank = gNextOscBank;
|
andrewm@0
|
643 gOscBanks[gCurrentOscBank]->hopNumTh = 0;
|
andrewm@0
|
644 }
|
andrewm@0
|
645 else {
|
andrewm@0
|
646 /* Advance to the next oscillator frame */
|
andrewm@0
|
647 gOscBanks[gCurrentOscBank]->nextHop();
|
andrewm@0
|
648 }
|
andrewm@0
|
649 }
|
andrewm@0
|
650 }
|
andrewm@0
|
651
|
andrewm@0
|
652 // Lower-priority render function which performs matrix calculations
|
andrewm@0
|
653 // State should be transferred in via global variables
|
andrewm@0
|
654 void render_low_prio()
|
andrewm@0
|
655 {
|
andrewm@0
|
656 gPRU->setGPIOTestPin();
|
andrewm@0
|
657 if(gDynamicWavetableNeedsRender) {
|
andrewm@0
|
658 // Find amplitude of wavetable
|
andrewm@0
|
659 float meanAmplitude = 0;
|
andrewm@0
|
660 float sineMix;
|
andrewm@0
|
661
|
andrewm@0
|
662 for(int i = 0; i < gFeedbackOscillatorTableLength; i++) {
|
andrewm@0
|
663 //meanAmplitude += fabsf(gFeedbackOscillatorTable[i]);
|
andrewm@0
|
664 meanAmplitude += fabs(gFeedbackOscillatorTable[i]);
|
andrewm@0
|
665 }
|
andrewm@0
|
666 meanAmplitude /= (float)gFeedbackOscillatorTableLength;
|
andrewm@0
|
667
|
andrewm@0
|
668 if(meanAmplitude > 0.35)
|
andrewm@0
|
669 sineMix = 0;
|
andrewm@0
|
670 else
|
andrewm@0
|
671 sineMix = (.35 - meanAmplitude) / .35;
|
andrewm@0
|
672
|
andrewm@0
|
673 //dbox_printf("amp %f mix %f\n", meanAmplitude, sineMix);
|
andrewm@0
|
674
|
andrewm@0
|
675 // Copy to main wavetable
|
andrewm@0
|
676 wavetable_interpolate(gFeedbackOscillatorTableLength, gDynamicWavetableLength,
|
andrewm@0
|
677 gFeedbackOscillatorTable, gDynamicWavetable,
|
andrewm@0
|
678 gOscBanks[gCurrentOscBank]->lookupTable, sineMix);
|
andrewm@0
|
679 }
|
andrewm@0
|
680
|
andrewm@50
|
681 if(gLoopPointMin >= 60000.0/65536.0 && gLoopPointMax >= 60000.0/65536.0) {
|
andrewm@0
|
682 // KLUDGE!
|
andrewm@0
|
683 if(gCurrentOscBank == 0)
|
andrewm@0
|
684 gOscBanks[gCurrentOscBank]->setLoopHops(50, ((float)gOscBanks[gCurrentOscBank]->getLastHop() * 0.6) - 1);
|
andrewm@0
|
685 else
|
andrewm@0
|
686 gOscBanks[gCurrentOscBank]->setLoopHops(5, ((float)gOscBanks[gCurrentOscBank]->getLastHop() * 0.7) - 1);
|
andrewm@0
|
687 }
|
andrewm@0
|
688 else {
|
andrewm@50
|
689 float normLoopPointMin = (float)gLoopPointMin * gOscBanks[gCurrentOscBank]->getLastHop();
|
andrewm@50
|
690 float normLoopPointMax = (float)gLoopPointMax * gOscBanks[gCurrentOscBank]->getLastHop();
|
andrewm@0
|
691
|
andrewm@0
|
692 int intLoopPointMin = normLoopPointMin;
|
andrewm@0
|
693 if(intLoopPointMin < 1)
|
andrewm@0
|
694 intLoopPointMin = 1;
|
andrewm@0
|
695 int intLoopPointMax = normLoopPointMax;
|
andrewm@0
|
696 if(intLoopPointMax <= intLoopPointMin)
|
andrewm@0
|
697 intLoopPointMax = intLoopPointMin + 1;
|
andrewm@0
|
698 if(intLoopPointMax > gOscBanks[gCurrentOscBank]->getLastHop() - 1)
|
andrewm@0
|
699 intLoopPointMax = gOscBanks[gCurrentOscBank]->getLastHop() - 1;
|
andrewm@0
|
700
|
andrewm@0
|
701 //dbox_printf("Loop points %d-%d / %d-%d\n", gLoopPointMin, gLoopPointMax, intLoopPointMin, intLoopPointMax);
|
andrewm@0
|
702
|
andrewm@0
|
703 /* WORKS, jsut need to fix the glitch when jumps!
|
andrewm@0
|
704 * *int currentHop = gOscBanks[gCurrentOscBank]->getCurrentHop();
|
andrewm@0
|
705 if(currentHop < intLoopPointMin -1 )
|
andrewm@0
|
706 gOscBanks[gCurrentOscBank]->setJumpHop(intLoopPointMin + 1);
|
andrewm@0
|
707 else if(currentHop > intLoopPointMax + 1)
|
andrewm@0
|
708 gOscBanks[gCurrentOscBank]->setJumpHop(intLoopPointMax - 1);*/
|
andrewm@0
|
709 gOscBanks[gCurrentOscBank]->setLoopHops(intLoopPointMin, intLoopPointMax);
|
andrewm@0
|
710 }
|
andrewm@0
|
711
|
andrewm@0
|
712 if(gIsLoading)
|
andrewm@0
|
713 gStatusLED.blink(25, 75); // Blink quickly until load finished
|
andrewm@0
|
714 else
|
andrewm@0
|
715 gStatusLED.blink(250 / gOscBanks[gCurrentOscBank]->getSpeed(), 250 / gOscBanks[gCurrentOscBank]->getSpeed());
|
andrewm@0
|
716 gPRU->clearGPIOTestPin();
|
andrewm@0
|
717
|
andrewm@0
|
718 // static int counter = 32;
|
andrewm@0
|
719 // if(--counter == 0) {
|
andrewm@0
|
720 // for(int i = 0; i < gLoopPointsInputBufferSize; i++) {
|
andrewm@0
|
721 // dbox_printf("%d ", gLoopPointsInputBuffer[i]);
|
andrewm@0
|
722 // if(i % 32 == 31)
|
andrewm@0
|
723 // dbox_printf("\n");
|
andrewm@0
|
724 // }
|
andrewm@0
|
725 // dbox_printf("\n\n");
|
andrewm@0
|
726 // counter = 32;
|
andrewm@0
|
727 // }
|
andrewm@0
|
728
|
andrewm@0
|
729 //dbox_printf("min %d max %d\n", gLoopPointMin, gLoopPointMax);
|
andrewm@0
|
730 }
|
andrewm@0
|
731
|
andrewm@0
|
732 // Clean up at the end of render
|
andrewm@50
|
733 void cleanup_render(BeagleRTContext *context, void *userData)
|
andrewm@0
|
734 {
|
andrewm@0
|
735 free(gOscillatorBuffer1);
|
andrewm@0
|
736 free(gOscillatorBuffer2);
|
andrewm@0
|
737 free(gDynamicWavetable);
|
andrewm@0
|
738 }
|
andrewm@0
|
739
|
andrewm@0
|
740 // Interpolate one wavetable into another. The output size
|
andrewm@0
|
741 // does not include the guard point at the end which will be identical
|
andrewm@0
|
742 // to the first point
|
andrewm@0
|
743 void wavetable_interpolate(int numSamplesIn, int numSamplesOut,
|
andrewm@0
|
744 float *tableIn, float *tableOut,
|
andrewm@0
|
745 float *sineTable, float sineMix)
|
andrewm@0
|
746 {
|
andrewm@0
|
747 float fractionalScaler = (float)numSamplesIn / (float)numSamplesOut;
|
andrewm@0
|
748
|
andrewm@0
|
749 for(int k = 0; k < numSamplesOut; k++) {
|
andrewm@0
|
750 float fractionalIndex = (float) k * fractionalScaler;
|
andrewm@0
|
751 //int sB = (int)floorf(fractionalIndex);
|
andrewm@0
|
752 int sB = (int)floor(fractionalIndex);
|
andrewm@0
|
753 int sA = sB + 1;
|
andrewm@0
|
754 if(sA >= numSamplesIn)
|
andrewm@0
|
755 sA = 0;
|
andrewm@0
|
756 float fraction = fractionalIndex - sB;
|
andrewm@0
|
757 tableOut[k] = fraction * tableIn[sA] + (1.0f - fraction) * tableIn[sB];
|
andrewm@0
|
758 tableOut[k] = sineMix * sineTable[k] + (1.0 - sineMix) * tableOut[k];
|
andrewm@0
|
759 }
|
andrewm@0
|
760
|
andrewm@0
|
761 tableOut[numSamplesOut] = tableOut[0];
|
andrewm@0
|
762 }
|
andrewm@0
|
763
|
andrewm@0
|
764 // Create a hysteresis oscillator with a matrix input and output
|
andrewm@50
|
765 inline float hysteresis_oscillator(float input, float risingThreshold, float fallingThreshold, bool *rising)
|
andrewm@0
|
766 {
|
andrewm@50
|
767 float value;
|
andrewm@0
|
768
|
andrewm@0
|
769 if(*rising) {
|
andrewm@0
|
770 if(input > risingThreshold) {
|
andrewm@0
|
771 *rising = false;
|
andrewm@0
|
772 value = 0;
|
andrewm@0
|
773 }
|
andrewm@0
|
774 else
|
andrewm@50
|
775 value = 1.0;
|
andrewm@0
|
776 }
|
andrewm@0
|
777 else {
|
andrewm@0
|
778 if(input < fallingThreshold) {
|
andrewm@0
|
779 *rising = true;
|
andrewm@50
|
780 value = 1.0;
|
andrewm@0
|
781 }
|
andrewm@0
|
782 else
|
andrewm@0
|
783 value = 0;
|
andrewm@0
|
784 }
|
andrewm@0
|
785
|
andrewm@0
|
786 return value;
|
andrewm@0
|
787 }
|
andrewm@0
|
788
|
andrewm@0
|
789 #ifdef DBOX_CAPE_TEST
|
andrewm@0
|
790 // Test the functionality of the D-Box cape by checking each input and output
|
andrewm@0
|
791 // Loopback cable from ADC to DAC needed
|
andrewm@0
|
792 void render_capetest(int numMatrixFrames, int numAudioFrames, float *audioIn, float *audioOut,
|
andrewm@0
|
793 uint16_t *matrixIn, uint16_t *matrixOut)
|
andrewm@0
|
794 {
|
andrewm@0
|
795 static float phase = 0.0;
|
andrewm@0
|
796 static int sampleCounter = 0;
|
andrewm@0
|
797 static int invertChannel = 0;
|
andrewm@0
|
798
|
andrewm@0
|
799 // Play a sine wave on the audio output
|
andrewm@0
|
800 for(int n = 0; n < numAudioFrames; n++) {
|
andrewm@0
|
801 audioOut[2*n] = audioOut[2*n + 1] = 0.5*sinf(phase);
|
andrewm@0
|
802 phase += 2.0 * M_PI * 440.0 / 44100.0;
|
andrewm@0
|
803 if(phase >= 2.0 * M_PI)
|
andrewm@0
|
804 phase -= 2.0 * M_PI;
|
andrewm@0
|
805 }
|
andrewm@0
|
806
|
andrewm@0
|
807 for(int n = 0; n < numMatrixFrames; n++) {
|
andrewm@0
|
808 // Change outputs every 512 samples
|
andrewm@0
|
809 if(sampleCounter < 512) {
|
andrewm@0
|
810 for(int k = 0; k < 8; k++) {
|
andrewm@0
|
811 if(k == invertChannel)
|
andrewm@0
|
812 matrixOut[n*8 + k] = 50000;
|
andrewm@0
|
813 else
|
andrewm@0
|
814 matrixOut[n*8 + k] = 0;
|
andrewm@0
|
815 }
|
andrewm@0
|
816 }
|
andrewm@0
|
817 else {
|
andrewm@0
|
818 for(int k = 0; k < 8; k++) {
|
andrewm@0
|
819 if(k == invertChannel)
|
andrewm@0
|
820 matrixOut[n*8 + k] = 0;
|
andrewm@0
|
821 else
|
andrewm@0
|
822 matrixOut[n*8 + k] = 50000;
|
andrewm@0
|
823 }
|
andrewm@0
|
824 }
|
andrewm@0
|
825
|
andrewm@0
|
826 // Read after 256 samples: input should be low
|
andrewm@0
|
827 if(sampleCounter == 256) {
|
andrewm@0
|
828 for(int k = 0; k < 8; k++) {
|
andrewm@0
|
829 if(k == invertChannel) {
|
andrewm@0
|
830 if(matrixIn[n*8 + k] < 50000) {
|
andrewm@0
|
831 dbox_printf("FAIL channel %d -- output HIGH input %d (inverted)\n", k, matrixIn[n*8 + k]);
|
andrewm@0
|
832 }
|
andrewm@0
|
833 }
|
andrewm@0
|
834 else {
|
andrewm@0
|
835 if(matrixIn[n*8 + k] > 2048) {
|
andrewm@0
|
836 dbox_printf("FAIL channel %d -- output LOW input %d\n", k, matrixIn[n*8 + k]);
|
andrewm@0
|
837 }
|
andrewm@0
|
838 }
|
andrewm@0
|
839 }
|
andrewm@0
|
840 }
|
andrewm@0
|
841 else if(sampleCounter == 768) {
|
andrewm@0
|
842 for(int k = 0; k < 8; k++) {
|
andrewm@0
|
843 if(k == invertChannel) {
|
andrewm@0
|
844 if(matrixIn[n*8 + k] > 2048) {
|
andrewm@0
|
845 dbox_printf("FAIL channel %d -- output LOW input %d (inverted)\n", k, matrixIn[n*8 + k]);
|
andrewm@0
|
846 }
|
andrewm@0
|
847 }
|
andrewm@0
|
848 else {
|
andrewm@0
|
849 if(matrixIn[n*8 + k] < 50000) {
|
andrewm@0
|
850 dbox_printf("FAIL channel %d -- output HIGH input %d\n", k, matrixIn[n*8 + k]);
|
andrewm@0
|
851 }
|
andrewm@0
|
852 }
|
andrewm@0
|
853 }
|
andrewm@0
|
854 }
|
andrewm@0
|
855
|
andrewm@0
|
856 if(++sampleCounter >= 1024) {
|
andrewm@0
|
857 sampleCounter = 0;
|
andrewm@0
|
858 invertChannel++;
|
andrewm@0
|
859 if(invertChannel >= 8)
|
andrewm@0
|
860 invertChannel = 0;
|
andrewm@0
|
861 }
|
andrewm@0
|
862 }
|
andrewm@0
|
863 }
|
andrewm@0
|
864 #endif
|
andrewm@0
|
865
|
andrewm@0
|
866
|