wirtz
/
OpenAudio_ArduinoLibrary
mirror of https://github.com/chipaudette/OpenAudio_ArduinoLibrary.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Compressor: add level-detector before the gain calc

Browse Source
pull/3/head
Chip Audette 8 years ago
parent d7dc90a7fc
commit c578607557
2 changed files with 198 additions and 89 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 188
      AudioEffectCompressor_F32.h
  2. 99
      examples/BasicCompressor_Float/BasicCompressor_Float.ino

188
AudioEffectCompressor_F32.h
Unescape View File

@ -1,7 +1,7 @@
/*
AudioEffectCompressor
Created: Chip Audette, December 2016
Created: Chip Audette, Dec 2016 - Jan 2017
Purpose; Apply dynamic range compression to the audio stream.
Assumes floating-point data.
@ -10,8 +10,8 @@
MIT License. use at your own risk.
*/
#ifndef _AudioEffectCompressor
#define _AudioEffectCompressor
#ifndef _AudioEffectCompressor_F32
#define _AudioEffectCompressor_F32
#include <arm_math.h> //ARM DSP extensions. https://www.keil.com/pack/doc/CMSIS/DSP/html/index.html
#include <AudioStream_F32.h>
@ -21,20 +21,18 @@ class AudioEffectCompressor_F32 : public AudioStream_F32
public:
//constructor
AudioEffectCompressor_F32(void) : AudioStream_F32(1, inputQueueArray_f32) {
setThresh_dBFS(-20.0f); //default to this threshold
setThresh_dBFS(-20.0f); //set the default value for the threshold for compression
setCompressionRatio(5.0f); //set the default copression ratio
setAttack_sec(0.005f, AUDIO_SAMPLE_RATE); //default to this value
setRelease_sec(0.200f, AUDIO_SAMPLE_RATE); //default to this value
setCompressionRatio(5.0f); //default to this value
setThresh_dBFS(-20.0f); //default to this value
setHPFilterCoeff();
setHPFilterCoeff(); enableHPFilter(true); //enable the HP filter to remove any DC offset from the audio
resetStates();
};
//here's the method that does all the work
void update(void) {
//Serial.println("AudioEffectGain_F32: updating."); //for debugging.
audio_block_f32_t *audio_block;
audio_block = AudioStream_F32::receiveWritable_f32();
audio_block_f32_t *audio_block = AudioStream_F32::receiveWritable_f32();
if (!audio_block) return;
//apply a high-pass filter to get rid of the DC offset
@ -43,61 +41,134 @@ class AudioEffectCompressor_F32 : public AudioStream_F32
//apply the pre-gain...a negative gain value will disable
if (pre_gain > 0.0f) arm_scale_f32(audio_block->data, pre_gain, audio_block->data, audio_block->length); //use ARM DSP for speed!
//compute the desired gain
//calculate the level of the audio (ie, calculate a smoothed version of the signal power)
audio_block_f32_t *audio_level_dB_block = AudioStream_F32::allocate_f32();
calcAudioLevel_dB(audio_block, audio_level_dB_block); //returns through audio_level_dB_block
//compute the desired gain based on the observed audio level
audio_block_f32_t *gain_block = AudioStream_F32::allocate_f32();
calcGain(audio_block, gain_block); //returns through gain_block
calcGain(audio_level_dB_block, gain_block); //returns through gain_block
//apply the gain...store it back into audio_block
//apply the desired gain...store the processed audio back into audio_block
arm_mult_f32(audio_block->data, gain_block->data, audio_block->data, audio_block->length);
///transmit the block and release memory
AudioStream_F32::transmit(audio_block);
AudioStream_F32::release(audio_block);
AudioStream_F32::release(gain_block);
AudioStream_F32::release(audio_level_dB_block);
}
void calcGain(audio_block_f32_t *wav_block, audio_block_f32_t *gain_block) {
//calculate the signal power...ie, square the signal: wav_pow = wav.^2
void calcAudioLevel_dB(audio_block_f32_t *wav_block, audio_block_f32_t *level_dB_block) {
//calculate the instantaneous signal power (square the signal)
audio_block_f32_t *wav_pow_block = AudioStream_F32::allocate_f32();
arm_mult_f32(wav_block->data, wav_block->data, wav_pow_block->data, wav_block->length);
//loop over each sample
float32_t gain_pow;
//apply a smoothing filter to wav_pow_block and convert to dB
float c1 = level_lp_const;
float c2 = 1.0f - c1;
for (int i = 0; i < wav_pow_block->length; i++) {
//compute target gain (well, we're actualy calculating gain^2) assuming we want to copress
gain_pow = thresh_pow_FS_wCR / powf(wav_pow_block->data[i], comp_ratio_const);
wav_pow_block->data[i] = c1*prev_level_lp_pow + c2*wav_pow_block->data[i];
//if our signal level is below the threshold, don't compress (set target gain to 0dB, which is 1.0)
if (wav_pow_block->data[i] < thresh_pow_FS) gain_pow = 1.0f;
//save state for next time (and for next data block)
prev_level_lp_pow = wav_pow_block->data[i];
//are we in the attack mode or release mode?
float32_t c = attack_const; //at first, assume that we're in the attack phase
if (gain_pow > prev_gain_pow) c = release_const; //here, we decide if we're really in the release phase
//convert to dB (but not yet multiplied by 10.0
level_dB_block->data[i] = log10f(wav_pow_block->data[i]);
}
//smooth the gain using the attack or release constants
gain_pow = c*prev_gain_pow + (1.0f-c)*gain_pow;
//limit the amount that the state of the smoothing filter can go toward negative infinity
if (prev_level_lp_pow < (1.0E-13)) prev_level_lp_pow = 1.0E-13; //never go less than -130 dBFS
//take he sqrt of gain^2 so that we simply get the gain
//arm_sqrt_f32(gain_pow, &(gain_block->data[i])); //should use the DSP acceleration, if the right CMSIS library is used
//gain_block->data[i] = __builtin_sqrtf(gain_pow); //seems to give the same speed as the arm_sqrt_f32
gain_block->data[i] = sqrtf(gain_pow); //also give the same speed and is more portable
//scale the wav_pow_block by 10.0 to complete the conversion to dB
arm_scale_f32(level_dB_block->data, 10.0f, level_dB_block->data, level_dB_block->length); //use ARM DSP for speed!
//release memory and return
AudioStream_F32::release(wav_pow_block);
return; //output is passed through level_dB_block
}
void calcGain(audio_block_f32_t *audio_level_dB_block, audio_block_f32_t *gain_block) {
//first, calculate the instantaneous target gain
audio_block_f32_t *inst_targ_gain_dB_block = AudioStream_F32::allocate_f32();
calcInstantaneousTargetGain(audio_level_dB_block, inst_targ_gain_dB_block);
//second, smooth in time (attack and release) by stepping through each sample
audio_block_f32_t *gain_dB_block = AudioStream_F32::allocate_f32();
calcSmoothedGain_dB(inst_targ_gain_dB_block,gain_dB_block);
//finally, convert from dB to linear gain: gain = 10^(gain_dB/20)
arm_scale_f32(gain_dB_block->data, 1.0f/20.0f, gain_dB_block->data, gain_dB_block->length); //divide by 20
for (int i = 0; i < gain_dB_block->length; i++) gain_block->data[i] = powf(10.0f,gain_dB_block->data[i]); //10^(x)
//release memory and return
AudioStream_F32::release(gain_dB_block);
AudioStream_F32::release(inst_targ_gain_dB_block);
return; //output is passed through gain_block
}
void calcInstantaneousTargetGain(audio_block_f32_t *audio_level_dB_block, audio_block_f32_t *inst_targ_gain_dB_block) {
// how much are we above the compression threshold?
audio_block_f32_t *above_thresh_dB_block = AudioStream_F32::allocate_f32();
arm_offset_f32(audio_level_dB_block->data, //CMSIS DSP for "add a constant value to all elements"
-thresh_dBFS, //this is the value to be added
above_thresh_dB_block->data, //this is the output
audio_level_dB_block->length);
// scale by the compression ratio...this is what the output level should be (this is our target level)
arm_scale_f32(above_thresh_dB_block->data, //CMSIS DSP for "multiply all elements by a constant value"
1.0f / comp_ratio, //this is the value to be multiplied
inst_targ_gain_dB_block->data, //this is the output
above_thresh_dB_block->length);
// compute the instantaneous gai...which is the difference between the target level and the original level
arm_sub_f32(inst_targ_gain_dB_block->data, //CMSIS DSP for "subtract two vectors element-by-element"
above_thresh_dB_block->data, //this is the vector to be subtracted
inst_targ_gain_dB_block->data, //this is the output
inst_targ_gain_dB_block->length);
// limit the target gain to attenuation only (this part of the compressor should not make things louder!)
for (int i=0; i < inst_targ_gain_dB_block->length; i++) {
if (inst_targ_gain_dB_block->data[i] > 0.0f) inst_targ_gain_dB_block->data[i] = 0.0f;
}
// release memory before returning
AudioStream_F32::release(above_thresh_dB_block);
return; //output is passed through inst_targ_gain_dB_block
}
void calcSmoothedGain_dB(audio_block_f32_t *inst_targ_gain_dB_block, audio_block_f32_t *gain_dB_block) {
float32_t gain_dB;
float32_t one_minus_attack_const = 1.0f - attack_const;
float32_t one_minus_release_const = 1.0f - release_const;
for (int i = 0; i < inst_targ_gain_dB_block->length; i++) {
gain_dB = inst_targ_gain_dB_block->data[i];
//smooth the gain using the attack or release constants
if (gain_dB < prev_gain_dB) { //are we in the attack phase?
gain_dB_block->data[i] = attack_const*prev_gain_dB + one_minus_attack_const*gain_dB;
} else { //or, we're in the release phase
gain_dB_block->data[i] = release_const*prev_gain_dB + one_minus_release_const*gain_dB;
}
//save value for the next time through this loop
prev_gain_pow = gain_pow;
prev_gain_dB = gain_dB_block->data[i];
}
//free up the memory and return
release(wav_pow_block);
//return
return; //the output here is gain_block
}
//methods to set parameters of this module
void resetStates(void) {
prev_gain_pow = 1.0f;
//initialize the HP filter (it also resets the filter states)
prev_level_lp_pow = 1.0f;
prev_gain_dB = 0.0f;
//initialize the HP filter. (This also resets the filter states,)
arm_biquad_cascade_df1_init_f32(&hp_filt_struct, hp_nstages, hp_coeff, hp_state);
}
void setPreGain(float g) { pre_gain = g; }
@ -109,30 +180,43 @@ class AudioEffectCompressor_F32 : public AudioStream_F32
void setAttack_sec(float a, float fs_Hz) {
attack_sec = a;
attack_const = expf(-1.0f / (attack_sec * fs_Hz)); //expf() is much faster than exp()
//also update the time constant for the envelope extraction
setLevelTimeConst_sec(min(attack_sec,release_sec) / 5.0, fs_Hz); //make the level time-constant one-fifth the gain time constants
}
void setRelease_sec(float r, float fs_Hz) {
release_sec = r;
release_const = expf(-1.0f / (release_sec * fs_Hz)); //expf() is much faster than exp()
}
void setThresh_dBFS(float thresh_dBFS) { setThreshPow(pow(10.0, thresh_dBFS / 10.0)); }
void setThreshPow(float t_pow) {
thresh_pow_FS = t_pow;
updateThresholdAndCompRatioConstants();
//also update the time constant for the envelope extraction
setLevelTimeConst_sec(min(attack_sec,release_sec) / 5.0, fs_Hz); //make the level time-constant one-fifth the gain time constants
}
void setLevelTimeConst_sec(float t_sec, float fs_Hz) {
const float min_t_sec = 0.002f; //this is the minimum allowed value
level_lp_sec = max(min_t_sec,t_sec);
level_lp_const = expf(-1.0f / (level_lp_sec * fs_Hz)); //expf() is much faster than exp()
}
void setThresh_dBFS(float val) {
thresh_dBFS = val;
setThreshPow(pow(10.0, thresh_dBFS / 10.0));
}
void enableHPFilter(boolean flag) { use_HP_prefilter = flag; };
//methods to return information about this module
float32_t getPreGain_dB(void) { return 20.0 * log10(pre_gain); }
float32_t getPreGain_dB(void) { return 20.0 * log10f(pre_gain); }
float32_t getAttack_sec(void) { return attack_sec; }
float32_t getRelease_sec(void) { return release_sec; }
float32_t getThresh_dBFS(void) { return 10.0 * log10(thresh_pow_FS); }
float32_t getLevelTimeConst_sec(void) { return level_lp_sec; }
float32_t getThresh_dBFS(void) { return thresh_dBFS; }
float32_t getCompressionRatio(void) { return comp_ratio; }
float32_t getCurrentGain_dB(void) { return 10.0 * log10(prev_gain_pow); }
float32_t getCurrentLevel_dBFS(void) { return 10.0* log10f(prev_level_lp_pow); }
float32_t getCurrentGain_dB(void) { return prev_gain_dB; }
private:
//state-related variables
audio_block_f32_t *inputQueueArray_f32[1]; //memory pointer for the input to this module
float32_t prev_gain_pow = 1.0; //last gain^2 used
float32_t prev_level_lp_pow = 1.0;
float32_t prev_gain_dB = 0.0; //last gain^2 used
//HP filter state-related variables
arm_biquad_casd_df1_inst_f32 hp_filt_struct;
@ -149,7 +233,7 @@ class AudioEffectCompressor_F32 : public AudioStream_F32
}
//private parameters related to gain calculation
float32_t attack_const, release_const; //used in calcGain(). set by setAttack_sec() and setRelease_sec();
float32_t attack_const, release_const, level_lp_const; //used in calcGain(). set by setAttack_sec() and setRelease_sec();
float32_t comp_ratio_const, thresh_pow_FS_wCR; //used in calcGain(); set in updateThresholdAndCompRatioConstants()
void updateThresholdAndCompRatioConstants(void) {
comp_ratio_const = 1.0f-(1.0f / comp_ratio);
@ -157,12 +241,18 @@ class AudioEffectCompressor_F32 : public AudioStream_F32
}
//settings
float32_t attack_sec, release_sec;
float32_t thresh_pow_FS = 1.0f; //threshold for compression, relative to digital full scale
float32_t attack_sec, release_sec, level_lp_sec;
float32_t thresh_dBFS = 0.0; //threshold for compression, relative to digital full scale
float32_t thresh_pow_FS = 1.0f; //same as above, but not in dB
void setThreshPow(float t_pow) {
thresh_pow_FS = t_pow;
updateThresholdAndCompRatioConstants();
}
float32_t comp_ratio = 1.0; //compression ratio
float32_t pre_gain = -1.0; //gain to apply before the compression. negative value disables
boolean use_HP_prefilter = false;
boolean use_HP_prefilter;
};
#endif

99
examples/BasicCompressor_Float/BasicCompressor_Float.ino
Unescape View File

@ -1,7 +1,7 @@
/*
BasicCompressor
BasicCompressor_Float
Created: Chip Audette, Dec 2016
Created: Chip Audette, Dec 2016 - Jan 2017
Purpose: Process audio by applying a single-band compressor
Demonstrates audio processing using floating point data type.
@ -26,17 +26,31 @@ AudioInputI2S i2s_in; //Digital audio *from* the Teensy
AudioOutputI2S i2s_out; //Digital audio *to* the Teensy Audio Board DAC. Expects Int16. Stereo
AudioConvert_I16toF32 int2Float1, int2Float2; //Converts Int16 to Float. See class in AudioStream_F32.h
AudioConvert_F32toI16 float2Int1, float2Int2; //Converts Float to Int16. See class in AudioStream_F32.h
AudioEffectCompressor_F32 comp1, comp2;
//Make all of the audio connections
AudioConnection patchCord1(i2s_in, 0, int2Float1, 0); //connect the Left input to the Left Int->Float converter
AudioConnection patchCord2(i2s_in, 1, int2Float2, 0); //connect the Right input to the Right Int->Float converter
AudioEffectCompressor_F32 comp1, comp2;
//Make all of the audio connections, with the option of USB audio in and out
//note that you ALWAYS have to have an I2S connection (either in or out) to have a clock
//that drives the system.
#define DO_USB 0 //set to 1 to enable USB audio. Be sure to go under the "Tools" menu and do "USB Type" -> "Audio"
#if DO_USB
AudioInputUSB usb_in;
AudioConnection patchCord1(usb_in, 0, int2Float1, 0);
AudioConnection patchCord2(usb_in, 1, int2Float2, 0);
#else
AudioConnection patchCord1(i2s_in, 0, int2Float1, 0); //connect the Left input to the Left Int->Float converter
AudioConnection patchCord2(i2s_in, 1, int2Float2, 0); //connect the Right input to the Right Int->Float converter
#endif
AudioConnection_F32 patchCord10(int2Float1, 0, comp1, 0); //Left. makes Float connections between objects
AudioConnection_F32 patchCord11(int2Float2, 0, comp2, 0); //Right. makes Float connections between objects
AudioConnection_F32 patchCord12(comp1, 0, float2Int1, 0); //Left. makes Float connections between objects
AudioConnection_F32 patchCord13(comp2, 0, float2Int2, 0); //Right. makes Float connections between objects
AudioConnection patchCord20(float2Int1, 0, i2s_out, 0); //connect the Left float processor to the Left output
AudioConnection patchCord21(float2Int2, 0, i2s_out, 1); //connect the Right float processor to the Right output
#if DO_USB
AudioOutputUSB usb_out;
AudioConnection patchCord30(float2Int1, 0, usb_out, 0); //connect the Left float processor to the Left output
AudioConnection patchCord31(float2Int2, 0, usb_out, 1); //connect the Right float processor to the Right output
#endif
// which input on the audio shield will be used?
const int myInput = AUDIO_INPUT_LINEIN;
@ -50,7 +64,7 @@ void setupMyAudioBoard(void) {
sgtl5000.enable(); //start the audio board
sgtl5000.inputSelect(myInput); //choose line-in or mic-in
sgtl5000.volume(0.8); //volume can be 0.0 to 1.0. 0.5 seems to be the usual default.
sgtl5000.lineInLevel(10,10); //level can be 0 to 15. 5 is the Teensy Audio Library's default
sgtl5000.lineInLevel(10, 10); //level can be 0 to 15. 5 is the Teensy Audio Library's default
sgtl5000.adcHighPassFilterDisable(); //reduces noise. https://forum.pjrc.com/threads/27215-24-bit-audio-boards?p=78831&viewfull=1#post78831
sgtl5000.micBiasEnable(3.0); //enable the mic bias voltage...only in AudioControlSGTL5000_Extended
}
@ -59,7 +73,7 @@ void setupMyAudioBoard(void) {
void setupMyCompressors(boolean use_HP_filter, float knee_dBFS, float comp_ratio, float attack_sec, float release_sec) {
comp1.enableHPFilter(use_HP_filter); comp2.enableHPFilter(use_HP_filter);
comp1.setThresh_dBFS(knee_dBFS); comp2.setThresh_dBFS(knee_dBFS);
comp1.setCompressionRatio(comp_ratio); comp2.setCompressionRatio(comp_ratio);
comp1.setCompressionRatio(comp_ratio); comp2.setCompressionRatio(comp_ratio);
float fs_Hz = AUDIO_SAMPLE_RATE;
comp1.setAttack_sec(attack_sec, fs_Hz); comp2.setAttack_sec(attack_sec, fs_Hz);
@ -72,28 +86,27 @@ void setup() {
delay(500); //give the computer's USB serial system a moment to catch up.
Serial.println("Teensy Hearing Aid: BasicCompressor_Float..."); //identify myself over the USB serial
// Audio connections require memory, and the record queue
// uses this memory to buffer incoming audio.
AudioMemory(12); //allocate Int16 audio data blocks
AudioMemory_F32(10); //allocate Float32 audio data blocks
// Audio connections require memory, and the record queue uses this memory to buffer incoming audio.
AudioMemory(14); //allocate Int16 audio data blocks
AudioMemory_F32(16); //allocate Float32 audio data blocks
// Enable the audio shield, select input, and enable output
setupMyAudioBoard();
//choose the compressor parameters...note that preGain is set by the potentiometer in the main loop()
boolean use_HP_filter = true; //enable the software HP filter to get rid of DC?
float knee_dBFS, comp_ratio, attack_sec, release_sec;
if (false) {
Serial.println("Configuring Compressor for fast response for use as a limitter.");
knee_dBFS = -15.0; comp_ratio = 8.0; attack_sec = 0.005; release_sec = 0.200;
Serial.println("Configuring Compressor for fast response for use as a limitter.");
knee_dBFS = -15.0f; comp_ratio = 5.0f; attack_sec = 0.005f; release_sec = 0.200f;
} else {
Serial.println("Configuring Compressor for slow response more like an automatic volume control.");
knee_dBFS = -50.0; comp_ratio = 5.0; attack_sec = 1.0; release_sec = 2.0;
Serial.println("Configuring Compressor for slow response more like an automatic volume control.");
knee_dBFS = -50.0; comp_ratio = 5.0; attack_sec = 1.0; release_sec = 2.0;
}
//configure the left and right compressors with the desired settings
setupMyCompressors(use_HP_filter, knee_dBFS, comp_ratio, attack_sec, release_sec);
// setup any other other features
pinMode(POT_PIN, INPUT); //set the potentiometer's input pin as an INPUT
@ -105,32 +118,34 @@ unsigned long updatePeriod_millis = 100; //how many milliseconds between updatin
unsigned long lastUpdate_millis = 0;
unsigned long curTime_millis = 0;
int prev_gain_dB = 0;
unsigned long lastMemUpdate_millis=0;
unsigned long lastMemUpdate_millis = 0;
void loop() {
//choose to sleep ("wait for interrupt") instead of spinning our wheels doing nothing but consuming power
asm(" WFI"); //ARM-specific. Will wake on next interrupt. The audio library issues tons of interrupts, so we wake up often.
//has enough time passed to try updating the GUI?
curTime_millis = millis(); //what time is it right now
if (curTime_millis < lastUpdate_millis) lastUpdate_millis = 0; //handle wrap-around of the clock
if ((curTime_millis - lastUpdate_millis) > updatePeriod_millis) { //is it time to update the user interface?
//read potentiometer
float32_t val = float(analogRead(POT_PIN)) / 1024.0f; //0.0 to 1.0
val = 0.1*(float)((int)(10.0*val + 0.5)); //quantize so that it doesn't chatter
val = 0.1 * (float)((int)(10.0 * val + 0.5)); //quantize so that it doesn't chatter
//compute desired digital gain
const float min_gain_dB = -20.0, max_gain_dB = 40.0; //set desired gain range
float gain_dB = min_gain_dB + (max_gain_dB - min_gain_dB)*val; //computed desired gain value in dB
float gain_dB = min_gain_dB + (max_gain_dB - min_gain_dB) * val; //computed desired gain value in dB
//if the gain is different than before, set the new gain value
if (abs(gain_dB - prev_gain_dB) > 1.0) { //is it different than before
prev_gain_dB = gain_dB; //we will use this value the next time around
//gain_dB = 0.0; //force to 0 dB for debugging
comp1.setPreGain_dB(gain_dB); //set the gain of the Left-channel gain processor
comp2.setPreGain_dB(gain_dB); //set the gain of the Right-channel gain processor
Serial.print("Setting Digital Pre-Gain dB = "); Serial.println(gain_dB); //print text to Serial port for debugging
prev_gain_dB = gain_dB; //we will use this value the next time around
}
lastUpdate_millis = curTime_millis; //we will use this value the next time around.
} // end if
@ -145,21 +160,25 @@ void loop() {
} //end loop();
void printCompressorState(Stream *s) {
s->print("Current Compressor: Pre-Gain (dB) = ");
s->print(comp1.getPreGain_dB());
s->print(", Dynamic Gain L/R (dB) = ");
s->print(comp1.getCurrentGain_dB());
s->print(", ");
s->print(comp2.getCurrentGain_dB());
s->println();
s->print("Current Compressor: Pre-Gain (dB) = ");
s->print(comp1.getPreGain_dB());
s->print(", Level (dBFS) = ");
s->print(comp1.getCurrentLevel_dBFS());
s->print(", ");
s->print(comp2.getCurrentLevel_dBFS());
s->print(", Dynamic Gain L/R (dB) = ");
s->print(comp1.getCurrentGain_dB());
s->print(", ");
s->print(comp2.getCurrentGain_dB());
s->println();
};
void printCPUandMemoryUsage(Stream *s) {
s->print("Usage/Max: ");
s->print("comp1 CPU = "); s->print(comp1.processorUsage()); s->print("/"); s->print(comp1.processorUsageMax());s->print(", ");
s->print("all CPU = " ); s->print(AudioProcessorUsage()); s->print("/"); s->print(AudioProcessorUsageMax());s->print(", ");
s->print("Int16 Mem = ");s->print(AudioMemoryUsage()); s->print("/"); s->print(AudioMemoryUsageMax());s->print(", ");
s->print("Float Mem = ");s->print(AudioMemoryUsage_F32());s->print("/"); s->print(AudioMemoryUsageMax_F32()); s->print(", ");
s->println();
s->print("Usage/Max: ");
s->print("comp1 CPU = "); s->print(comp1.processorUsage()); s->print("/"); s->print(comp1.processorUsageMax()); s->print(", ");
s->print("all CPU = " ); s->print(AudioProcessorUsage()); s->print("/"); s->print(AudioProcessorUsageMax()); s->print(", ");
s->print("Int16 Mem = "); s->print(AudioMemoryUsage()); s->print("/"); s->print(AudioMemoryUsageMax()); s->print(", ");
s->print("Float Mem = "); s->print(AudioMemoryUsage_F32()); s->print("/"); s->print(AudioMemoryUsageMax_F32()); s->print(", ");
s->println();
};

Write Preview
Loading…
Cancel
Save