annotate projects/d-box/render.cpp @ 50:be427da6fb9c newapi

Removed old testing code that stopped audio after 10 seconds; command line parameter updates; D-Box updates (not fully working yet)
author andrewm
date Sat, 30 May 2015 12:34:32 -0500
parents 42a683058b6a
children 4f8db16f17b5
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@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