Mercurial > hg > beaglert

annotate projects/d-box/render.cpp @ 4:f34c63568523

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