Mercurial > hg > beaglert

annotate projects/d-box/render.cpp @ 48:42a683058b6a newapi

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