void IAAEffectProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer&)
{
const float gain = *parameters.getRawParameterValue ("gain");
const int totalNumInputChannels = getTotalNumInputChannels();
const int totalNumOutputChannels = getTotalNumOutputChannels();
const int numSamples = buffer.getNumSamples();
for (int i = totalNumInputChannels; i < totalNumOutputChannels; ++i)
buffer.clear (i, 0, buffer.getNumSamples());
// Apply the gain to the samples using a ramp to avoid discontinuities in
// the audio between processed buffers.
for (int channel = 0; channel < totalNumInputChannels; ++channel)
{
buffer.applyGainRamp (channel, 0, numSamples, previousGain, gain);
meterListeners.call (&IAAEffectProcessor::MeterListener::handleNewMeterValue,
channel,
buffer.getMagnitude (channel, 0, numSamples));
}
previousGain = gain;
// Now ask the host for the current time so we can store it to be displayed later.
updateCurrentTimeInfoFromHost (lastPosInfo);
}
void OOTrack::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
updatePendingLooperState(OOServer::getInstance()->looperState.timeInSamples);
OOServer::getInstance()->updateGlobalTime(this,buffer.getNumSamples());
// RECORDING
if (*isRecording)
{
if(recordNeedle.get() + buffer.getNumSamples()> getSampleRate() * MAX_LOOP_LENGTH_S){
*shouldRecord = false;
*isRecording = false;
};
monoLoopSample.copyFrom(0, recordNeedle.get(), buffer, 0, 0, buffer.getNumSamples());
recordNeedle += buffer.getNumSamples();
rmsOut = (1-rmsAlpha)*rmsOut+ rmsAlpha*buffer.getRMSLevel(0, 0, buffer.getNumSamples());
}
else{
streamBipBuffer.writeBlock(buffer);
}
// PLAYING
// allow circular reading , although not sure that overflow need to be handled as its written with same block sizes than read
// we may need it if we start to use a different clock than looperState in OOServer that has a granularity of blockSize
// or if we dynamicly change blockSize
if (*isPlaying && recordNeedle.get()>0 && monoLoopSample.getNumSamples())
{
if ( (playNeedle + buffer.getNumSamples()) > recordNeedle.get())
{
//assert false for now see above
// jassert(false);
int firstSegmentLength = recordNeedle.get() - playNeedle;
int secondSegmentLength = buffer.getNumSamples() - firstSegmentLength;
buffer.copyFrom(0, 0, monoLoopSample, 0, playNeedle, firstSegmentLength);
buffer.copyFrom(0, 0, monoLoopSample, 0, 0, secondSegmentLength);
playNeedle = secondSegmentLength;
}else{
buffer.copyFrom(0, 0, monoLoopSample, 0, playNeedle, buffer.getNumSamples());
playNeedle += buffer.getNumSamples();
playNeedle %= recordNeedle.get();
}
buffer.applyGainRamp(0, 0, buffer.getNumSamples(), lastVolume,*volume);
lastVolume = *volume;
rmsOut = (1-rmsAlpha)*rmsOut+ rmsAlpha*buffer.getRMSLevel(0, 0, buffer.getNumSamples());
}
else{
// silence output buffer
buffer.applyGain(0, 0, buffer.getNumSamples(), 0);
}
}
void Ambix_mirrorAudioProcessor::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
{
int NumSamples = buffer.getNumSamples();
// save old parameters for interpolation (start ramp)
_gain_factors = gain_factors;
calcParams();
for (int acn = 0; acn < getTotalNumInputChannels(); acn++)
{
buffer.applyGainRamp(acn, 0, NumSamples, _gain_factors.getUnchecked(acn), gain_factors.getUnchecked(acn));
}
}
void Processor::processBlock(AudioSampleBuffer& buffer, MidiBuffer& /*midiMessages*/)
{
const int numInputChannels = getTotalNumInputChannels();
const int numOutputChannels = getTotalNumOutputChannels();
const size_t samplesToProcess = buffer.getNumSamples();
// Determine channel data
const float* channelData0 = nullptr;
const float* channelData1 = nullptr;
if (numInputChannels == 1)
{
channelData0 = buffer.getReadPointer(0);
channelData1 = buffer.getReadPointer(0);
}
else if (numInputChannels == 2)
{
channelData0 = buffer.getReadPointer(0);
channelData1 = buffer.getReadPointer(1);
}
// Convolution
_wetBuffer.clear();
if (numInputChannels > 0 && numOutputChannels > 0)
{
float autoGain = 1.0f;
if (getParameter(Parameters::AutoGainOn))
{
autoGain = DecibelScaling::Db2Gain(getParameter(Parameters::AutoGainDecibels));
}
// Convolve
IRAgent* irAgent00 = getAgent(0, 0);
if (irAgent00 && irAgent00->getConvolver() && numInputChannels >= 1 && numOutputChannels >= 1)
{
irAgent00->process(channelData0, &_convolutionBuffer[0], samplesToProcess);
_wetBuffer.addFrom(0, 0, &_convolutionBuffer[0], samplesToProcess, autoGain);
}
IRAgent* irAgent01 = getAgent(0, 1);
if (irAgent01 && irAgent01->getConvolver() && numInputChannels >= 1 && numOutputChannels >= 2)
{
irAgent01->process(channelData0, &_convolutionBuffer[0], samplesToProcess);
_wetBuffer.addFrom(1, 0, &_convolutionBuffer[0], samplesToProcess, autoGain);
}
IRAgent* irAgent10 = getAgent(1, 0);
if (irAgent10 && irAgent10->getConvolver() && numInputChannels >= 2 && numOutputChannels >= 1)
{
irAgent10->process(channelData1, &_convolutionBuffer[0], samplesToProcess);
_wetBuffer.addFrom(0, 0, &_convolutionBuffer[0], samplesToProcess, autoGain);
}
IRAgent* irAgent11 = getAgent(1, 1);
if (irAgent11 && irAgent11->getConvolver() && numInputChannels >= 2 && numOutputChannels >= 2)
{
irAgent11->process(channelData1, &_convolutionBuffer[0], samplesToProcess);
_wetBuffer.addFrom(1, 0, &_convolutionBuffer[0], samplesToProcess, autoGain);
}
}
// Stereo width
if (numOutputChannels >= 2)
{
_stereoWidth.updateWidth(getParameter(Parameters::StereoWidth));
_stereoWidth.process(_wetBuffer.getWritePointer(0), _wetBuffer.getWritePointer(1), samplesToProcess);
}
// Dry/wet gain
{
float dryGain0, dryGain1;
_dryGain.updateValue(DecibelScaling::Db2Gain(getParameter(Parameters::DryDecibels)));
_dryGain.getSmoothValues(samplesToProcess, dryGain0, dryGain1);
buffer.applyGainRamp(0, samplesToProcess, dryGain0, dryGain1);
}
{
float wetGain0, wetGain1;
_wetGain.updateValue(DecibelScaling::Db2Gain(getParameter(Parameters::WetDecibels)));
_wetGain.getSmoothValues(samplesToProcess, wetGain0, wetGain1);
_wetBuffer.applyGainRamp(0, samplesToProcess, wetGain0, wetGain1);
}
// Level measurement (dry)
if (numInputChannels == 1)
{
_levelMeasurementsDry[0].process(samplesToProcess, buffer.getReadPointer(0));
_levelMeasurementsDry[1].reset();
}
else if (numInputChannels == 2)
{
_levelMeasurementsDry[0].process(samplesToProcess, buffer.getReadPointer(0));
_levelMeasurementsDry[1].process(samplesToProcess, buffer.getReadPointer(1));
}
// Sum wet to dry signal
{
float dryOnGain0, dryOnGain1;
_dryOn.updateValue(getParameter(Parameters::DryOn) ? 1.0f : 0.0f);
_dryOn.getSmoothValues(samplesToProcess, dryOnGain0, dryOnGain1);
buffer.applyGainRamp(0, samplesToProcess, dryOnGain0, dryOnGain1);
}
{
float wetOnGain0, wetOnGain1;
_wetOn.updateValue(getParameter(Parameters::WetOn) ? 1.0f : 0.0f);
_wetOn.getSmoothValues(samplesToProcess, wetOnGain0, wetOnGain1);
if (numOutputChannels > 0)
{
buffer.addFromWithRamp(0, 0, _wetBuffer.getReadPointer(0), samplesToProcess, wetOnGain0, wetOnGain1);
}
if (numOutputChannels > 1)
{
buffer.addFromWithRamp(1, 0, _wetBuffer.getReadPointer(1), samplesToProcess, wetOnGain0, wetOnGain1);
}
}
// Level measurement (wet/out)
if (numOutputChannels == 1)
{
_levelMeasurementsWet[0].process(samplesToProcess, _wetBuffer.getReadPointer(0));
_levelMeasurementsWet[1].reset();
_levelMeasurementsOut[0].process(samplesToProcess, buffer.getReadPointer(0));
_levelMeasurementsOut[1].reset();
}
else if (numOutputChannels == 2)
{
_levelMeasurementsWet[0].process(samplesToProcess, _wetBuffer.getReadPointer(0));
_levelMeasurementsWet[1].process(samplesToProcess, _wetBuffer.getReadPointer(1));
_levelMeasurementsOut[0].process(samplesToProcess, buffer.getReadPointer(0));
_levelMeasurementsOut[1].process(samplesToProcess, buffer.getReadPointer(1));
}
// In case we have more outputs than inputs, we'll clear any output
// channels that didn't contain input data, (because these aren't
// guaranteed to be empty - they may contain garbage).
for (int i=numInputChannels; i<numOutputChannels; ++i)
{
buffer.clear(i, 0, buffer.getNumSamples());
}
// Update beats per minute info
float beatsPerMinute = 0.0f;
juce::AudioPlayHead* playHead = getPlayHead();
if (playHead)
{
juce::AudioPlayHead::CurrentPositionInfo currentPositionInfo;
if (playHead->getCurrentPosition(currentPositionInfo))
{
beatsPerMinute = static_cast<float>(currentPositionInfo.bpm);
}
}
if (::fabs(_beatsPerMinute.exchange(beatsPerMinute)-beatsPerMinute) > 0.001f)
{
notifyAboutChange();
}
}
void AudioSourcePlayer::audioDeviceIOCallback (const float** inputChannelData,
int totalNumInputChannels,
float** outputChannelData,
int totalNumOutputChannels,
int numSamples)
{
// these should have been prepared by audioDeviceAboutToStart()...
jassert (sampleRate > 0 && bufferSize > 0);
const ScopedLock sl (readLock);
if (source != nullptr)
{
int numActiveChans = 0, numInputs = 0, numOutputs = 0;
// messy stuff needed to compact the channels down into an array
// of non-zero pointers..
for (int i = 0; i < totalNumInputChannels; ++i)
{
if (inputChannelData[i] != nullptr)
{
inputChans [numInputs++] = inputChannelData[i];
if (numInputs >= numElementsInArray (inputChans))
break;
}
}
for (int i = 0; i < totalNumOutputChannels; ++i)
{
if (outputChannelData[i] != nullptr)
{
outputChans [numOutputs++] = outputChannelData[i];
if (numOutputs >= numElementsInArray (outputChans))
break;
}
}
if (numInputs > numOutputs)
{
// if there aren't enough output channels for the number of
// inputs, we need to create some temporary extra ones (can't
// use the input data in case it gets written to)
tempBuffer.setSize (numInputs - numOutputs, numSamples,
false, false, true);
for (int i = 0; i < numOutputs; ++i)
{
channels[numActiveChans] = outputChans[i];
memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * (size_t) numSamples);
++numActiveChans;
}
for (int i = numOutputs; i < numInputs; ++i)
{
channels[numActiveChans] = tempBuffer.getSampleData (i - numOutputs, 0);
memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * (size_t) numSamples);
++numActiveChans;
}
}
else
{
for (int i = 0; i < numInputs; ++i)
{
channels[numActiveChans] = outputChans[i];
memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * (size_t) numSamples);
++numActiveChans;
}
for (int i = numInputs; i < numOutputs; ++i)
{
channels[numActiveChans] = outputChans[i];
zeromem (channels[numActiveChans], sizeof (float) * (size_t) numSamples);
++numActiveChans;
}
}
AudioSampleBuffer buffer (channels, numActiveChans, numSamples);
AudioSourceChannelInfo info (&buffer, 0, numSamples);
source->getNextAudioBlock (info);
for (int i = info.buffer->getNumChannels(); --i >= 0;)
buffer.applyGainRamp (i, info.startSample, info.numSamples, lastGain, gain);
lastGain = gain;
}
else
{
for (int i = 0; i < totalNumOutputChannels; ++i)
if (outputChannelData[i] != nullptr)
zeromem (outputChannelData[i], sizeof (float) * (size_t) numSamples);
}
}
