fix macOS build (following Projucer changes made in Windows, which removed /Applications/JUCE/modules from its headers). move JUCE headers under source control, so that Windows and macOS can both build against same version of JUCE. remove AUv3 target (I think it's an iOS thing, so it will never work with this macOS fluidsynth dylib).
This commit is contained in:
Alex Birch
181
modules/juce_audio_basics/sources/juce_AudioSource.h
Normal file
181
modules/juce_audio_basics/sources/juce_AudioSource.h
Normal file
@ -0,0 +1,181 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Used by AudioSource::getNextAudioBlock().
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
struct JUCE_API AudioSourceChannelInfo
|
||||
{
|
||||
/** Creates an uninitialised AudioSourceChannelInfo. */
|
||||
AudioSourceChannelInfo() noexcept
|
||||
{
|
||||
}
|
||||
|
||||
/** Creates an AudioSourceChannelInfo. */
|
||||
AudioSourceChannelInfo (AudioBuffer<float>* bufferToUse,
|
||||
int startSampleOffset, int numSamplesToUse) noexcept
|
||||
: buffer (bufferToUse),
|
||||
startSample (startSampleOffset),
|
||||
numSamples (numSamplesToUse)
|
||||
{
|
||||
}
|
||||
|
||||
/** Creates an AudioSourceChannelInfo that uses the whole of a buffer.
|
||||
Note that the buffer provided must not be deleted while the
|
||||
AudioSourceChannelInfo is still using it.
|
||||
*/
|
||||
explicit AudioSourceChannelInfo (AudioBuffer<float>& bufferToUse) noexcept
|
||||
: buffer (&bufferToUse),
|
||||
startSample (0),
|
||||
numSamples (bufferToUse.getNumSamples())
|
||||
{
|
||||
}
|
||||
|
||||
/** The destination buffer to fill with audio data.
|
||||
|
||||
When the AudioSource::getNextAudioBlock() method is called, the active section
|
||||
of this buffer should be filled with whatever output the source produces.
|
||||
|
||||
Only the samples specified by the startSample and numSamples members of this structure
|
||||
should be affected by the call.
|
||||
|
||||
The contents of the buffer when it is passed to the AudioSource::getNextAudioBlock()
|
||||
method can be treated as the input if the source is performing some kind of filter operation,
|
||||
but should be cleared if this is not the case - the clearActiveBufferRegion() is
|
||||
a handy way of doing this.
|
||||
|
||||
The number of channels in the buffer could be anything, so the AudioSource
|
||||
must cope with this in whatever way is appropriate for its function.
|
||||
*/
|
||||
AudioBuffer<float>* buffer;
|
||||
|
||||
/** The first sample in the buffer from which the callback is expected
|
||||
to write data. */
|
||||
int startSample;
|
||||
|
||||
/** The number of samples in the buffer which the callback is expected to
|
||||
fill with data. */
|
||||
int numSamples;
|
||||
|
||||
/** Convenient method to clear the buffer if the source is not producing any data. */
|
||||
void clearActiveBufferRegion() const
|
||||
{
|
||||
if (buffer != nullptr)
|
||||
buffer->clear (startSample, numSamples);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
Base class for objects that can produce a continuous stream of audio.
|
||||
|
||||
An AudioSource has two states: 'prepared' and 'unprepared'.
|
||||
|
||||
When a source needs to be played, it is first put into a 'prepared' state by a call to
|
||||
prepareToPlay(), and then repeated calls will be made to its getNextAudioBlock() method to
|
||||
process the audio data.
|
||||
|
||||
Once playback has finished, the releaseResources() method is called to put the stream
|
||||
back into an 'unprepared' state.
|
||||
|
||||
@see AudioFormatReaderSource, ResamplingAudioSource
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API AudioSource
|
||||
{
|
||||
protected:
|
||||
//==============================================================================
|
||||
/** Creates an AudioSource. */
|
||||
AudioSource() noexcept {}
|
||||
|
||||
public:
|
||||
/** Destructor. */
|
||||
virtual ~AudioSource() {}
|
||||
|
||||
//==============================================================================
|
||||
/** Tells the source to prepare for playing.
|
||||
|
||||
An AudioSource has two states: prepared and unprepared.
|
||||
|
||||
The prepareToPlay() method is guaranteed to be called at least once on an 'unpreprared'
|
||||
source to put it into a 'prepared' state before any calls will be made to getNextAudioBlock().
|
||||
This callback allows the source to initialise any resources it might need when playing.
|
||||
|
||||
Once playback has finished, the releaseResources() method is called to put the stream
|
||||
back into an 'unprepared' state.
|
||||
|
||||
Note that this method could be called more than once in succession without
|
||||
a matching call to releaseResources(), so make sure your code is robust and
|
||||
can handle that kind of situation.
|
||||
|
||||
@param samplesPerBlockExpected the number of samples that the source
|
||||
will be expected to supply each time its
|
||||
getNextAudioBlock() method is called. This
|
||||
number may vary slightly, because it will be dependent
|
||||
on audio hardware callbacks, and these aren't
|
||||
guaranteed to always use a constant block size, so
|
||||
the source should be able to cope with small variations.
|
||||
@param sampleRate the sample rate that the output will be used at - this
|
||||
is needed by sources such as tone generators.
|
||||
@see releaseResources, getNextAudioBlock
|
||||
*/
|
||||
virtual void prepareToPlay (int samplesPerBlockExpected,
|
||||
double sampleRate) = 0;
|
||||
|
||||
/** Allows the source to release anything it no longer needs after playback has stopped.
|
||||
|
||||
This will be called when the source is no longer going to have its getNextAudioBlock()
|
||||
method called, so it should release any spare memory, etc. that it might have
|
||||
allocated during the prepareToPlay() call.
|
||||
|
||||
Note that there's no guarantee that prepareToPlay() will actually have been called before
|
||||
releaseResources(), and it may be called more than once in succession, so make sure your
|
||||
code is robust and doesn't make any assumptions about when it will be called.
|
||||
|
||||
@see prepareToPlay, getNextAudioBlock
|
||||
*/
|
||||
virtual void releaseResources() = 0;
|
||||
|
||||
/** Called repeatedly to fetch subsequent blocks of audio data.
|
||||
|
||||
After calling the prepareToPlay() method, this callback will be made each
|
||||
time the audio playback hardware (or whatever other destination the audio
|
||||
data is going to) needs another block of data.
|
||||
|
||||
It will generally be called on a high-priority system thread, or possibly even
|
||||
an interrupt, so be careful not to do too much work here, as that will cause
|
||||
audio glitches!
|
||||
|
||||
@see AudioSourceChannelInfo, prepareToPlay, releaseResources
|
||||
*/
|
||||
virtual void getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill) = 0;
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
315
modules/juce_audio_basics/sources/juce_BufferingAudioSource.cpp
Normal file
315
modules/juce_audio_basics/sources/juce_BufferingAudioSource.cpp
Normal file
@ -0,0 +1,315 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
BufferingAudioSource::BufferingAudioSource (PositionableAudioSource* s,
|
||||
TimeSliceThread& thread,
|
||||
bool deleteSourceWhenDeleted,
|
||||
int bufferSizeSamples,
|
||||
int numChannels,
|
||||
bool prefillBufferOnPrepareToPlay)
|
||||
: source (s, deleteSourceWhenDeleted),
|
||||
backgroundThread (thread),
|
||||
numberOfSamplesToBuffer (jmax (1024, bufferSizeSamples)),
|
||||
numberOfChannels (numChannels),
|
||||
prefillBuffer (prefillBufferOnPrepareToPlay)
|
||||
{
|
||||
jassert (source != nullptr);
|
||||
|
||||
jassert (numberOfSamplesToBuffer > 1024); // not much point using this class if you're
|
||||
// not using a larger buffer..
|
||||
}
|
||||
|
||||
BufferingAudioSource::~BufferingAudioSource()
|
||||
{
|
||||
releaseResources();
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void BufferingAudioSource::prepareToPlay (int samplesPerBlockExpected, double newSampleRate)
|
||||
{
|
||||
auto bufferSizeNeeded = jmax (samplesPerBlockExpected * 2, numberOfSamplesToBuffer);
|
||||
|
||||
if (newSampleRate != sampleRate
|
||||
|| bufferSizeNeeded != buffer.getNumSamples()
|
||||
|| ! isPrepared)
|
||||
{
|
||||
backgroundThread.removeTimeSliceClient (this);
|
||||
|
||||
isPrepared = true;
|
||||
sampleRate = newSampleRate;
|
||||
|
||||
source->prepareToPlay (samplesPerBlockExpected, newSampleRate);
|
||||
|
||||
buffer.setSize (numberOfChannels, bufferSizeNeeded);
|
||||
buffer.clear();
|
||||
|
||||
bufferValidStart = 0;
|
||||
bufferValidEnd = 0;
|
||||
|
||||
backgroundThread.addTimeSliceClient (this);
|
||||
|
||||
do
|
||||
{
|
||||
backgroundThread.moveToFrontOfQueue (this);
|
||||
Thread::sleep (5);
|
||||
}
|
||||
while (prefillBuffer
|
||||
&& (bufferValidEnd - bufferValidStart < jmin (((int) newSampleRate) / 4, buffer.getNumSamples() / 2)));
|
||||
}
|
||||
}
|
||||
|
||||
void BufferingAudioSource::releaseResources()
|
||||
{
|
||||
isPrepared = false;
|
||||
backgroundThread.removeTimeSliceClient (this);
|
||||
|
||||
buffer.setSize (numberOfChannels, 0);
|
||||
|
||||
// MSVC2015 seems to need this if statement to not generate a warning during linking.
|
||||
// As source is set in the constructor, there is no way that source could
|
||||
// ever equal this, but it seems to make MSVC2015 happy.
|
||||
if (source != this)
|
||||
source->releaseResources();
|
||||
}
|
||||
|
||||
void BufferingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
|
||||
{
|
||||
const ScopedLock sl (bufferStartPosLock);
|
||||
|
||||
auto start = bufferValidStart.load();
|
||||
auto end = bufferValidEnd.load();
|
||||
auto pos = nextPlayPos.load();
|
||||
|
||||
auto validStart = (int) (jlimit (start, end, pos) - pos);
|
||||
auto validEnd = (int) (jlimit (start, end, pos + info.numSamples) - pos);
|
||||
|
||||
if (validStart == validEnd)
|
||||
{
|
||||
// total cache miss
|
||||
info.clearActiveBufferRegion();
|
||||
}
|
||||
else
|
||||
{
|
||||
if (validStart > 0)
|
||||
info.buffer->clear (info.startSample, validStart); // partial cache miss at start
|
||||
|
||||
if (validEnd < info.numSamples)
|
||||
info.buffer->clear (info.startSample + validEnd,
|
||||
info.numSamples - validEnd); // partial cache miss at end
|
||||
|
||||
if (validStart < validEnd)
|
||||
{
|
||||
for (int chan = jmin (numberOfChannels, info.buffer->getNumChannels()); --chan >= 0;)
|
||||
{
|
||||
jassert (buffer.getNumSamples() > 0);
|
||||
auto startBufferIndex = (int) ((validStart + nextPlayPos) % buffer.getNumSamples());
|
||||
auto endBufferIndex = (int) ((validEnd + nextPlayPos) % buffer.getNumSamples());
|
||||
|
||||
if (startBufferIndex < endBufferIndex)
|
||||
{
|
||||
info.buffer->copyFrom (chan, info.startSample + validStart,
|
||||
buffer,
|
||||
chan, startBufferIndex,
|
||||
validEnd - validStart);
|
||||
}
|
||||
else
|
||||
{
|
||||
auto initialSize = buffer.getNumSamples() - startBufferIndex;
|
||||
|
||||
info.buffer->copyFrom (chan, info.startSample + validStart,
|
||||
buffer,
|
||||
chan, startBufferIndex,
|
||||
initialSize);
|
||||
|
||||
info.buffer->copyFrom (chan, info.startSample + validStart + initialSize,
|
||||
buffer,
|
||||
chan, 0,
|
||||
(validEnd - validStart) - initialSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
nextPlayPos += info.numSamples;
|
||||
}
|
||||
}
|
||||
|
||||
bool BufferingAudioSource::waitForNextAudioBlockReady (const AudioSourceChannelInfo& info, uint32 timeout)
|
||||
{
|
||||
if (!source || source->getTotalLength() <= 0)
|
||||
return false;
|
||||
|
||||
if (nextPlayPos + info.numSamples < 0)
|
||||
return true;
|
||||
|
||||
if (! isLooping() && nextPlayPos > getTotalLength())
|
||||
return true;
|
||||
|
||||
auto now = Time::getMillisecondCounter();
|
||||
auto startTime = now;
|
||||
|
||||
auto elapsed = (now >= startTime ? now - startTime
|
||||
: (std::numeric_limits<uint32>::max() - startTime) + now);
|
||||
|
||||
while (elapsed <= timeout)
|
||||
{
|
||||
{
|
||||
const ScopedLock sl (bufferStartPosLock);
|
||||
|
||||
auto start = bufferValidStart.load();
|
||||
auto end = bufferValidEnd.load();
|
||||
auto pos = nextPlayPos.load();
|
||||
|
||||
auto validStart = static_cast<int> (jlimit (start, end, pos) - pos);
|
||||
auto validEnd = static_cast<int> (jlimit (start, end, pos + info.numSamples) - pos);
|
||||
|
||||
if (validStart <= 0 && validStart < validEnd && validEnd >= info.numSamples)
|
||||
return true;
|
||||
}
|
||||
|
||||
if (elapsed < timeout && (! bufferReadyEvent.wait (static_cast<int> (timeout - elapsed))))
|
||||
return false;
|
||||
|
||||
now = Time::getMillisecondCounter();
|
||||
elapsed = (now >= startTime ? now - startTime
|
||||
: (std::numeric_limits<uint32>::max() - startTime) + now);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
int64 BufferingAudioSource::getNextReadPosition() const
|
||||
{
|
||||
jassert (source->getTotalLength() > 0);
|
||||
auto pos = nextPlayPos.load();
|
||||
|
||||
return (source->isLooping() && nextPlayPos > 0)
|
||||
? pos % source->getTotalLength()
|
||||
: pos;
|
||||
}
|
||||
|
||||
void BufferingAudioSource::setNextReadPosition (int64 newPosition)
|
||||
{
|
||||
const ScopedLock sl (bufferStartPosLock);
|
||||
|
||||
nextPlayPos = newPosition;
|
||||
backgroundThread.moveToFrontOfQueue (this);
|
||||
}
|
||||
|
||||
bool BufferingAudioSource::readNextBufferChunk()
|
||||
{
|
||||
int64 newBVS, newBVE, sectionToReadStart, sectionToReadEnd;
|
||||
|
||||
{
|
||||
const ScopedLock sl (bufferStartPosLock);
|
||||
|
||||
if (wasSourceLooping != isLooping())
|
||||
{
|
||||
wasSourceLooping = isLooping();
|
||||
bufferValidStart = 0;
|
||||
bufferValidEnd = 0;
|
||||
}
|
||||
|
||||
newBVS = jmax ((int64) 0, nextPlayPos.load());
|
||||
newBVE = newBVS + buffer.getNumSamples() - 4;
|
||||
sectionToReadStart = 0;
|
||||
sectionToReadEnd = 0;
|
||||
|
||||
const int maxChunkSize = 2048;
|
||||
|
||||
if (newBVS < bufferValidStart || newBVS >= bufferValidEnd)
|
||||
{
|
||||
newBVE = jmin (newBVE, newBVS + maxChunkSize);
|
||||
|
||||
sectionToReadStart = newBVS;
|
||||
sectionToReadEnd = newBVE;
|
||||
|
||||
bufferValidStart = 0;
|
||||
bufferValidEnd = 0;
|
||||
}
|
||||
else if (std::abs ((int) (newBVS - bufferValidStart)) > 512
|
||||
|| std::abs ((int) (newBVE - bufferValidEnd)) > 512)
|
||||
{
|
||||
newBVE = jmin (newBVE, bufferValidEnd + maxChunkSize);
|
||||
|
||||
sectionToReadStart = bufferValidEnd;
|
||||
sectionToReadEnd = newBVE;
|
||||
|
||||
bufferValidStart = newBVS;
|
||||
bufferValidEnd = jmin (bufferValidEnd.load(), newBVE);
|
||||
}
|
||||
}
|
||||
|
||||
if (sectionToReadStart == sectionToReadEnd)
|
||||
return false;
|
||||
|
||||
jassert (buffer.getNumSamples() > 0);
|
||||
auto bufferIndexStart = (int) (sectionToReadStart % buffer.getNumSamples());
|
||||
auto bufferIndexEnd = (int) (sectionToReadEnd % buffer.getNumSamples());
|
||||
|
||||
if (bufferIndexStart < bufferIndexEnd)
|
||||
{
|
||||
readBufferSection (sectionToReadStart,
|
||||
(int) (sectionToReadEnd - sectionToReadStart),
|
||||
bufferIndexStart);
|
||||
}
|
||||
else
|
||||
{
|
||||
auto initialSize = buffer.getNumSamples() - bufferIndexStart;
|
||||
|
||||
readBufferSection (sectionToReadStart,
|
||||
initialSize,
|
||||
bufferIndexStart);
|
||||
|
||||
readBufferSection (sectionToReadStart + initialSize,
|
||||
(int) (sectionToReadEnd - sectionToReadStart) - initialSize,
|
||||
0);
|
||||
}
|
||||
|
||||
{
|
||||
const ScopedLock sl2 (bufferStartPosLock);
|
||||
|
||||
bufferValidStart = newBVS;
|
||||
bufferValidEnd = newBVE;
|
||||
}
|
||||
|
||||
bufferReadyEvent.signal();
|
||||
return true;
|
||||
}
|
||||
|
||||
void BufferingAudioSource::readBufferSection (int64 start, int length, int bufferOffset)
|
||||
{
|
||||
if (source->getNextReadPosition() != start)
|
||||
source->setNextReadPosition (start);
|
||||
|
||||
AudioSourceChannelInfo info (&buffer, bufferOffset, length);
|
||||
source->getNextAudioBlock (info);
|
||||
}
|
||||
|
||||
int BufferingAudioSource::useTimeSlice()
|
||||
{
|
||||
return readNextBufferChunk() ? 1 : 100;
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
119
modules/juce_audio_basics/sources/juce_BufferingAudioSource.h
Normal file
119
modules/juce_audio_basics/sources/juce_BufferingAudioSource.h
Normal file
@ -0,0 +1,119 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An AudioSource which takes another source as input, and buffers it using a thread.
|
||||
|
||||
Create this as a wrapper around another thread, and it will read-ahead with
|
||||
a background thread to smooth out playback. You can either create one of these
|
||||
directly, or use it indirectly using an AudioTransportSource.
|
||||
|
||||
@see PositionableAudioSource, AudioTransportSource
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API BufferingAudioSource : public PositionableAudioSource,
|
||||
private TimeSliceClient
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a BufferingAudioSource.
|
||||
|
||||
@param source the input source to read from
|
||||
@param backgroundThread a background thread that will be used for the
|
||||
background read-ahead. This object must not be deleted
|
||||
until after any BufferingAudioSources that are using it
|
||||
have been deleted!
|
||||
@param deleteSourceWhenDeleted if true, then the input source object will
|
||||
be deleted when this object is deleted
|
||||
@param numberOfSamplesToBuffer the size of buffer to use for reading ahead
|
||||
@param numberOfChannels the number of channels that will be played
|
||||
@param prefillBufferOnPrepareToPlay if true, then calling prepareToPlay on this object will
|
||||
block until the buffer has been filled
|
||||
*/
|
||||
BufferingAudioSource (PositionableAudioSource* source,
|
||||
TimeSliceThread& backgroundThread,
|
||||
bool deleteSourceWhenDeleted,
|
||||
int numberOfSamplesToBuffer,
|
||||
int numberOfChannels = 2,
|
||||
bool prefillBufferOnPrepareToPlay = true);
|
||||
|
||||
/** Destructor.
|
||||
|
||||
The input source may be deleted depending on whether the deleteSourceWhenDeleted
|
||||
flag was set in the constructor.
|
||||
*/
|
||||
~BufferingAudioSource();
|
||||
|
||||
//==============================================================================
|
||||
/** Implementation of the AudioSource method. */
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void releaseResources() override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
//==============================================================================
|
||||
/** Implements the PositionableAudioSource method. */
|
||||
void setNextReadPosition (int64 newPosition) override;
|
||||
|
||||
/** Implements the PositionableAudioSource method. */
|
||||
int64 getNextReadPosition() const override;
|
||||
|
||||
/** Implements the PositionableAudioSource method. */
|
||||
int64 getTotalLength() const override { return source->getTotalLength(); }
|
||||
|
||||
/** Implements the PositionableAudioSource method. */
|
||||
bool isLooping() const override { return source->isLooping(); }
|
||||
|
||||
/** A useful function to block until the next the buffer info can be filled.
|
||||
|
||||
This is useful for offline rendering.
|
||||
*/
|
||||
bool waitForNextAudioBlockReady (const AudioSourceChannelInfo& info, const uint32 timeout);
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
OptionalScopedPointer<PositionableAudioSource> source;
|
||||
TimeSliceThread& backgroundThread;
|
||||
int numberOfSamplesToBuffer, numberOfChannels;
|
||||
AudioBuffer<float> buffer;
|
||||
CriticalSection bufferStartPosLock;
|
||||
WaitableEvent bufferReadyEvent;
|
||||
std::atomic<int64> bufferValidStart { 0 }, bufferValidEnd { 0 }, nextPlayPos { 0 };
|
||||
double sampleRate = 0;
|
||||
bool wasSourceLooping = false, isPrepared = false, prefillBuffer;
|
||||
|
||||
bool readNextBufferChunk();
|
||||
void readBufferSection (int64 start, int length, int bufferOffset);
|
||||
int useTimeSlice() override;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (BufferingAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,187 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
ChannelRemappingAudioSource::ChannelRemappingAudioSource (AudioSource* const source_,
|
||||
const bool deleteSourceWhenDeleted)
|
||||
: source (source_, deleteSourceWhenDeleted),
|
||||
requiredNumberOfChannels (2)
|
||||
{
|
||||
remappedInfo.buffer = &buffer;
|
||||
remappedInfo.startSample = 0;
|
||||
}
|
||||
|
||||
ChannelRemappingAudioSource::~ChannelRemappingAudioSource() {}
|
||||
|
||||
//==============================================================================
|
||||
void ChannelRemappingAudioSource::setNumberOfChannelsToProduce (const int requiredNumberOfChannels_)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
requiredNumberOfChannels = requiredNumberOfChannels_;
|
||||
}
|
||||
|
||||
void ChannelRemappingAudioSource::clearAllMappings()
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
remappedInputs.clear();
|
||||
remappedOutputs.clear();
|
||||
}
|
||||
|
||||
void ChannelRemappingAudioSource::setInputChannelMapping (const int destIndex, const int sourceIndex)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
while (remappedInputs.size() < destIndex)
|
||||
remappedInputs.add (-1);
|
||||
|
||||
remappedInputs.set (destIndex, sourceIndex);
|
||||
}
|
||||
|
||||
void ChannelRemappingAudioSource::setOutputChannelMapping (const int sourceIndex, const int destIndex)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
while (remappedOutputs.size() < sourceIndex)
|
||||
remappedOutputs.add (-1);
|
||||
|
||||
remappedOutputs.set (sourceIndex, destIndex);
|
||||
}
|
||||
|
||||
int ChannelRemappingAudioSource::getRemappedInputChannel (const int inputChannelIndex) const
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
if (inputChannelIndex >= 0 && inputChannelIndex < remappedInputs.size())
|
||||
return remappedInputs.getUnchecked (inputChannelIndex);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
int ChannelRemappingAudioSource::getRemappedOutputChannel (const int outputChannelIndex) const
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
if (outputChannelIndex >= 0 && outputChannelIndex < remappedOutputs.size())
|
||||
return remappedOutputs .getUnchecked (outputChannelIndex);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void ChannelRemappingAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
|
||||
{
|
||||
source->prepareToPlay (samplesPerBlockExpected, sampleRate);
|
||||
}
|
||||
|
||||
void ChannelRemappingAudioSource::releaseResources()
|
||||
{
|
||||
source->releaseResources();
|
||||
}
|
||||
|
||||
void ChannelRemappingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
buffer.setSize (requiredNumberOfChannels, bufferToFill.numSamples, false, false, true);
|
||||
|
||||
const int numChans = bufferToFill.buffer->getNumChannels();
|
||||
|
||||
for (int i = 0; i < buffer.getNumChannels(); ++i)
|
||||
{
|
||||
const int remappedChan = getRemappedInputChannel (i);
|
||||
|
||||
if (remappedChan >= 0 && remappedChan < numChans)
|
||||
{
|
||||
buffer.copyFrom (i, 0, *bufferToFill.buffer,
|
||||
remappedChan,
|
||||
bufferToFill.startSample,
|
||||
bufferToFill.numSamples);
|
||||
}
|
||||
else
|
||||
{
|
||||
buffer.clear (i, 0, bufferToFill.numSamples);
|
||||
}
|
||||
}
|
||||
|
||||
remappedInfo.numSamples = bufferToFill.numSamples;
|
||||
|
||||
source->getNextAudioBlock (remappedInfo);
|
||||
|
||||
bufferToFill.clearActiveBufferRegion();
|
||||
|
||||
for (int i = 0; i < requiredNumberOfChannels; ++i)
|
||||
{
|
||||
const int remappedChan = getRemappedOutputChannel (i);
|
||||
|
||||
if (remappedChan >= 0 && remappedChan < numChans)
|
||||
{
|
||||
bufferToFill.buffer->addFrom (remappedChan, bufferToFill.startSample,
|
||||
buffer, i, 0, bufferToFill.numSamples);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
XmlElement* ChannelRemappingAudioSource::createXml() const
|
||||
{
|
||||
XmlElement* e = new XmlElement ("MAPPINGS");
|
||||
String ins, outs;
|
||||
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = 0; i < remappedInputs.size(); ++i)
|
||||
ins << remappedInputs.getUnchecked(i) << ' ';
|
||||
|
||||
for (int i = 0; i < remappedOutputs.size(); ++i)
|
||||
outs << remappedOutputs.getUnchecked(i) << ' ';
|
||||
|
||||
e->setAttribute ("inputs", ins.trimEnd());
|
||||
e->setAttribute ("outputs", outs.trimEnd());
|
||||
|
||||
return e;
|
||||
}
|
||||
|
||||
void ChannelRemappingAudioSource::restoreFromXml (const XmlElement& e)
|
||||
{
|
||||
if (e.hasTagName ("MAPPINGS"))
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
clearAllMappings();
|
||||
|
||||
StringArray ins, outs;
|
||||
ins.addTokens (e.getStringAttribute ("inputs"), false);
|
||||
outs.addTokens (e.getStringAttribute ("outputs"), false);
|
||||
|
||||
for (int i = 0; i < ins.size(); ++i)
|
||||
remappedInputs.add (ins[i].getIntValue());
|
||||
|
||||
for (int i = 0; i < outs.size(); ++i)
|
||||
remappedOutputs.add (outs[i].getIntValue());
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,141 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An AudioSource that takes the audio from another source, and re-maps its
|
||||
input and output channels to a different arrangement.
|
||||
|
||||
You can use this to increase or decrease the number of channels that an
|
||||
audio source uses, or to re-order those channels.
|
||||
|
||||
Call the reset() method before using it to set up a default mapping, and then
|
||||
the setInputChannelMapping() and setOutputChannelMapping() methods to
|
||||
create an appropriate mapping, otherwise no channels will be connected and
|
||||
it'll produce silence.
|
||||
|
||||
@see AudioSource
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class ChannelRemappingAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a remapping source that will pass on audio from the given input.
|
||||
|
||||
@param source the input source to use. Make sure that this doesn't
|
||||
get deleted before the ChannelRemappingAudioSource object
|
||||
@param deleteSourceWhenDeleted if true, the input source will be deleted
|
||||
when this object is deleted, if false, the caller is
|
||||
responsible for its deletion
|
||||
*/
|
||||
ChannelRemappingAudioSource (AudioSource* source,
|
||||
bool deleteSourceWhenDeleted);
|
||||
|
||||
/** Destructor. */
|
||||
~ChannelRemappingAudioSource();
|
||||
|
||||
//==============================================================================
|
||||
/** Specifies a number of channels that this audio source must produce from its
|
||||
getNextAudioBlock() callback.
|
||||
*/
|
||||
void setNumberOfChannelsToProduce (int requiredNumberOfChannels);
|
||||
|
||||
/** Clears any mapped channels.
|
||||
|
||||
After this, no channels are mapped, so this object will produce silence. Create
|
||||
some mappings with setInputChannelMapping() and setOutputChannelMapping().
|
||||
*/
|
||||
void clearAllMappings();
|
||||
|
||||
/** Creates an input channel mapping.
|
||||
|
||||
When the getNextAudioBlock() method is called, the data in channel sourceChannelIndex of the incoming
|
||||
data will be sent to destChannelIndex of our input source.
|
||||
|
||||
@param destChannelIndex the index of an input channel in our input audio source (i.e. the
|
||||
source specified when this object was created).
|
||||
@param sourceChannelIndex the index of the input channel in the incoming audio data buffer
|
||||
during our getNextAudioBlock() callback
|
||||
*/
|
||||
void setInputChannelMapping (int destChannelIndex,
|
||||
int sourceChannelIndex);
|
||||
|
||||
/** Creates an output channel mapping.
|
||||
|
||||
When the getNextAudioBlock() method is called, the data returned in channel sourceChannelIndex by
|
||||
our input audio source will be copied to channel destChannelIndex of the final buffer.
|
||||
|
||||
@param sourceChannelIndex the index of an output channel coming from our input audio source
|
||||
(i.e. the source specified when this object was created).
|
||||
@param destChannelIndex the index of the output channel in the incoming audio data buffer
|
||||
during our getNextAudioBlock() callback
|
||||
*/
|
||||
void setOutputChannelMapping (int sourceChannelIndex,
|
||||
int destChannelIndex);
|
||||
|
||||
/** Returns the channel from our input that will be sent to channel inputChannelIndex of
|
||||
our input audio source.
|
||||
*/
|
||||
int getRemappedInputChannel (int inputChannelIndex) const;
|
||||
|
||||
/** Returns the output channel to which channel outputChannelIndex of our input audio
|
||||
source will be sent to.
|
||||
*/
|
||||
int getRemappedOutputChannel (int outputChannelIndex) const;
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/** Returns an XML object to encapsulate the state of the mappings.
|
||||
@see restoreFromXml
|
||||
*/
|
||||
XmlElement* createXml() const;
|
||||
|
||||
/** Restores the mappings from an XML object created by createXML().
|
||||
@see createXml
|
||||
*/
|
||||
void restoreFromXml (const XmlElement&);
|
||||
|
||||
//==============================================================================
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
void releaseResources() override;
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
OptionalScopedPointer<AudioSource> source;
|
||||
Array<int> remappedInputs, remappedOutputs;
|
||||
int requiredNumberOfChannels;
|
||||
|
||||
AudioBuffer<float> buffer;
|
||||
AudioSourceChannelInfo remappedInfo;
|
||||
CriticalSection lock;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ChannelRemappingAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,80 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
IIRFilterAudioSource::IIRFilterAudioSource (AudioSource* const inputSource,
|
||||
const bool deleteInputWhenDeleted)
|
||||
: input (inputSource, deleteInputWhenDeleted)
|
||||
{
|
||||
jassert (inputSource != nullptr);
|
||||
|
||||
for (int i = 2; --i >= 0;)
|
||||
iirFilters.add (new IIRFilter());
|
||||
}
|
||||
|
||||
IIRFilterAudioSource::~IIRFilterAudioSource() {}
|
||||
|
||||
//==============================================================================
|
||||
void IIRFilterAudioSource::setCoefficients (const IIRCoefficients& newCoefficients)
|
||||
{
|
||||
for (int i = iirFilters.size(); --i >= 0;)
|
||||
iirFilters.getUnchecked(i)->setCoefficients (newCoefficients);
|
||||
}
|
||||
|
||||
void IIRFilterAudioSource::makeInactive()
|
||||
{
|
||||
for (int i = iirFilters.size(); --i >= 0;)
|
||||
iirFilters.getUnchecked(i)->makeInactive();
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void IIRFilterAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
|
||||
{
|
||||
input->prepareToPlay (samplesPerBlockExpected, sampleRate);
|
||||
|
||||
for (int i = iirFilters.size(); --i >= 0;)
|
||||
iirFilters.getUnchecked(i)->reset();
|
||||
}
|
||||
|
||||
void IIRFilterAudioSource::releaseResources()
|
||||
{
|
||||
input->releaseResources();
|
||||
}
|
||||
|
||||
void IIRFilterAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
|
||||
{
|
||||
input->getNextAudioBlock (bufferToFill);
|
||||
|
||||
const int numChannels = bufferToFill.buffer->getNumChannels();
|
||||
|
||||
while (numChannels > iirFilters.size())
|
||||
iirFilters.add (new IIRFilter (*iirFilters.getUnchecked (0)));
|
||||
|
||||
for (int i = 0; i < numChannels; ++i)
|
||||
iirFilters.getUnchecked(i)
|
||||
->processSamples (bufferToFill.buffer->getWritePointer (i, bufferToFill.startSample),
|
||||
bufferToFill.numSamples);
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,68 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An AudioSource that performs an IIR filter on another source.
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API IIRFilterAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a IIRFilterAudioSource for a given input source.
|
||||
|
||||
@param inputSource the input source to read from - this must not be null
|
||||
@param deleteInputWhenDeleted if true, the input source will be deleted when
|
||||
this object is deleted
|
||||
*/
|
||||
IIRFilterAudioSource (AudioSource* inputSource,
|
||||
bool deleteInputWhenDeleted);
|
||||
|
||||
/** Destructor. */
|
||||
~IIRFilterAudioSource();
|
||||
|
||||
//==============================================================================
|
||||
/** Changes the filter to use the same parameters as the one being passed in. */
|
||||
void setCoefficients (const IIRCoefficients& newCoefficients);
|
||||
|
||||
/** Calls IIRFilter::makeInactive() on all the filters being used internally. */
|
||||
void makeInactive();
|
||||
|
||||
//==============================================================================
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
void releaseResources() override;
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
OptionalScopedPointer<AudioSource> input;
|
||||
OwnedArray<IIRFilter> iirFilters;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (IIRFilterAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
70
modules/juce_audio_basics/sources/juce_MemoryAudioSource.cpp
Normal file
70
modules/juce_audio_basics/sources/juce_MemoryAudioSource.cpp
Normal file
@ -0,0 +1,70 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
MemoryAudioSource::MemoryAudioSource (AudioBuffer<float>& bufferToUse, bool copyMemory, bool shouldLoop)
|
||||
: isLooping (shouldLoop)
|
||||
{
|
||||
if (copyMemory)
|
||||
buffer.makeCopyOf (bufferToUse);
|
||||
else
|
||||
buffer.setDataToReferTo (bufferToUse.getArrayOfWritePointers(),
|
||||
bufferToUse.getNumChannels(),
|
||||
bufferToUse.getNumSamples());
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void MemoryAudioSource::prepareToPlay (int /*samplesPerBlockExpected*/, double /*sampleRate*/)
|
||||
{
|
||||
position = 0;
|
||||
}
|
||||
|
||||
void MemoryAudioSource::releaseResources() {}
|
||||
|
||||
void MemoryAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
|
||||
{
|
||||
auto& dst = *bufferToFill.buffer;
|
||||
auto channels = jmin (dst.getNumChannels(), buffer.getNumChannels());
|
||||
auto max = 0, pos = 0;
|
||||
auto n = buffer.getNumSamples(), m = bufferToFill.numSamples;
|
||||
|
||||
for (auto i = position; (i < n || isLooping) && (pos < m); i += max)
|
||||
{
|
||||
max = jmin (m - pos, n - (i % n));
|
||||
|
||||
int ch = 0;
|
||||
for (; ch < channels; ++ch)
|
||||
dst.copyFrom (ch, bufferToFill.startSample + pos, buffer, ch, i % n, max);
|
||||
|
||||
for (; ch < dst.getNumChannels(); ++ch)
|
||||
dst.clear (ch, bufferToFill.startSample + pos, max);
|
||||
|
||||
pos += max;
|
||||
}
|
||||
|
||||
if (pos < m)
|
||||
dst.clear (bufferToFill.startSample + pos, m - pos);
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
65
modules/juce_audio_basics/sources/juce_MemoryAudioSource.h
Normal file
65
modules/juce_audio_basics/sources/juce_MemoryAudioSource.h
Normal file
@ -0,0 +1,65 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An AudioSource which takes some float audio data as an input.
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API MemoryAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a MemoryAudioSource by providing an audio buffer.
|
||||
|
||||
If copyMemory is true then the buffer will be copied into an internal
|
||||
buffer which will be owned by the MemoryAudioSource. If copyMemory is
|
||||
false, then you must ensure that the lifetime of the audio buffer is
|
||||
at least as long as the MemoryAudioSource.
|
||||
*/
|
||||
MemoryAudioSource (AudioBuffer<float>& audioBuffer, bool copyMemory, bool shouldLoop = false);
|
||||
|
||||
//==============================================================================
|
||||
/** Implementation of the AudioSource method. */
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void releaseResources() override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill) override;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
AudioBuffer<float> buffer;
|
||||
int position = 0;
|
||||
bool isLooping;
|
||||
|
||||
//==============================================================================
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MemoryAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
158
modules/juce_audio_basics/sources/juce_MixerAudioSource.cpp
Normal file
158
modules/juce_audio_basics/sources/juce_MixerAudioSource.cpp
Normal file
@ -0,0 +1,158 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
MixerAudioSource::MixerAudioSource()
|
||||
: currentSampleRate (0.0), bufferSizeExpected (0)
|
||||
{
|
||||
}
|
||||
|
||||
MixerAudioSource::~MixerAudioSource()
|
||||
{
|
||||
removeAllInputs();
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void MixerAudioSource::addInputSource (AudioSource* input, const bool deleteWhenRemoved)
|
||||
{
|
||||
if (input != nullptr && ! inputs.contains (input))
|
||||
{
|
||||
double localRate;
|
||||
int localBufferSize;
|
||||
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
localRate = currentSampleRate;
|
||||
localBufferSize = bufferSizeExpected;
|
||||
}
|
||||
|
||||
if (localRate > 0.0)
|
||||
input->prepareToPlay (localBufferSize, localRate);
|
||||
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
inputsToDelete.setBit (inputs.size(), deleteWhenRemoved);
|
||||
inputs.add (input);
|
||||
}
|
||||
}
|
||||
|
||||
void MixerAudioSource::removeInputSource (AudioSource* const input)
|
||||
{
|
||||
if (input != nullptr)
|
||||
{
|
||||
std::unique_ptr<AudioSource> toDelete;
|
||||
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
const int index = inputs.indexOf (input);
|
||||
|
||||
if (index < 0)
|
||||
return;
|
||||
|
||||
if (inputsToDelete [index])
|
||||
toDelete.reset (input);
|
||||
|
||||
inputsToDelete.shiftBits (-1, index);
|
||||
inputs.remove (index);
|
||||
}
|
||||
|
||||
input->releaseResources();
|
||||
}
|
||||
}
|
||||
|
||||
void MixerAudioSource::removeAllInputs()
|
||||
{
|
||||
OwnedArray<AudioSource> toDelete;
|
||||
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = inputs.size(); --i >= 0;)
|
||||
if (inputsToDelete[i])
|
||||
toDelete.add (inputs.getUnchecked(i));
|
||||
|
||||
inputs.clear();
|
||||
}
|
||||
|
||||
for (int i = toDelete.size(); --i >= 0;)
|
||||
toDelete.getUnchecked(i)->releaseResources();
|
||||
}
|
||||
|
||||
void MixerAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
|
||||
{
|
||||
tempBuffer.setSize (2, samplesPerBlockExpected);
|
||||
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
currentSampleRate = sampleRate;
|
||||
bufferSizeExpected = samplesPerBlockExpected;
|
||||
|
||||
for (int i = inputs.size(); --i >= 0;)
|
||||
inputs.getUnchecked(i)->prepareToPlay (samplesPerBlockExpected, sampleRate);
|
||||
}
|
||||
|
||||
void MixerAudioSource::releaseResources()
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
for (int i = inputs.size(); --i >= 0;)
|
||||
inputs.getUnchecked(i)->releaseResources();
|
||||
|
||||
tempBuffer.setSize (2, 0);
|
||||
|
||||
currentSampleRate = 0;
|
||||
bufferSizeExpected = 0;
|
||||
}
|
||||
|
||||
void MixerAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
if (inputs.size() > 0)
|
||||
{
|
||||
inputs.getUnchecked(0)->getNextAudioBlock (info);
|
||||
|
||||
if (inputs.size() > 1)
|
||||
{
|
||||
tempBuffer.setSize (jmax (1, info.buffer->getNumChannels()),
|
||||
info.buffer->getNumSamples());
|
||||
|
||||
AudioSourceChannelInfo info2 (&tempBuffer, 0, info.numSamples);
|
||||
|
||||
for (int i = 1; i < inputs.size(); ++i)
|
||||
{
|
||||
inputs.getUnchecked(i)->getNextAudioBlock (info2);
|
||||
|
||||
for (int chan = 0; chan < info.buffer->getNumChannels(); ++chan)
|
||||
info.buffer->addFrom (chan, info.startSample, tempBuffer, chan, 0, info.numSamples);
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
info.clearActiveBufferRegion();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
99
modules/juce_audio_basics/sources/juce_MixerAudioSource.h
Normal file
99
modules/juce_audio_basics/sources/juce_MixerAudioSource.h
Normal file
@ -0,0 +1,99 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An AudioSource that mixes together the output of a set of other AudioSources.
|
||||
|
||||
Input sources can be added and removed while the mixer is running as long as their
|
||||
prepareToPlay() and releaseResources() methods are called before and after adding
|
||||
them to the mixer.
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API MixerAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a MixerAudioSource. */
|
||||
MixerAudioSource();
|
||||
|
||||
/** Destructor. */
|
||||
~MixerAudioSource();
|
||||
|
||||
//==============================================================================
|
||||
/** Adds an input source to the mixer.
|
||||
|
||||
If the mixer is running you'll need to make sure that the input source
|
||||
is ready to play by calling its prepareToPlay() method before adding it.
|
||||
If the mixer is stopped, then its input sources will be automatically
|
||||
prepared when the mixer's prepareToPlay() method is called.
|
||||
|
||||
@param newInput the source to add to the mixer
|
||||
@param deleteWhenRemoved if true, then this source will be deleted when
|
||||
no longer needed by the mixer.
|
||||
*/
|
||||
void addInputSource (AudioSource* newInput, bool deleteWhenRemoved);
|
||||
|
||||
/** Removes an input source.
|
||||
If the source was added by calling addInputSource() with the deleteWhenRemoved
|
||||
flag set, it will be deleted by this method.
|
||||
*/
|
||||
void removeInputSource (AudioSource* input);
|
||||
|
||||
/** Removes all the input sources.
|
||||
Any sources which were added by calling addInputSource() with the deleteWhenRemoved
|
||||
flag set will be deleted by this method.
|
||||
*/
|
||||
void removeAllInputs();
|
||||
|
||||
//==============================================================================
|
||||
/** Implementation of the AudioSource method.
|
||||
This will call prepareToPlay() on all its input sources.
|
||||
*/
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
|
||||
/** Implementation of the AudioSource method.
|
||||
This will call releaseResources() on all its input sources.
|
||||
*/
|
||||
void releaseResources() override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
Array<AudioSource*> inputs;
|
||||
BigInteger inputsToDelete;
|
||||
CriticalSection lock;
|
||||
AudioBuffer<float> tempBuffer;
|
||||
double currentSampleRate;
|
||||
int bufferSizeExpected;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MixerAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,76 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
A type of AudioSource which can be repositioned.
|
||||
|
||||
The basic AudioSource just streams continuously with no idea of a current
|
||||
time or length, so the PositionableAudioSource is used for a finite stream
|
||||
that has a current read position.
|
||||
|
||||
@see AudioSource, AudioTransportSource
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API PositionableAudioSource : public AudioSource
|
||||
{
|
||||
protected:
|
||||
//==============================================================================
|
||||
/** Creates the PositionableAudioSource. */
|
||||
PositionableAudioSource() noexcept {}
|
||||
|
||||
public:
|
||||
/** Destructor */
|
||||
~PositionableAudioSource() {}
|
||||
|
||||
//==============================================================================
|
||||
/** Tells the stream to move to a new position.
|
||||
|
||||
Calling this indicates that the next call to AudioSource::getNextAudioBlock()
|
||||
should return samples from this position.
|
||||
|
||||
Note that this may be called on a different thread to getNextAudioBlock(),
|
||||
so the subclass should make sure it's synchronised.
|
||||
*/
|
||||
virtual void setNextReadPosition (int64 newPosition) = 0;
|
||||
|
||||
/** Returns the position from which the next block will be returned.
|
||||
|
||||
@see setNextReadPosition
|
||||
*/
|
||||
virtual int64 getNextReadPosition() const = 0;
|
||||
|
||||
/** Returns the total length of the stream (in samples). */
|
||||
virtual int64 getTotalLength() const = 0;
|
||||
|
||||
/** Returns true if this source is actually playing in a loop. */
|
||||
virtual bool isLooping() const = 0;
|
||||
|
||||
/** Tells the source whether you'd like it to play in a loop. */
|
||||
virtual void setLooping (bool shouldLoop) { ignoreUnused (shouldLoop); }
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
266
modules/juce_audio_basics/sources/juce_ResamplingAudioSource.cpp
Normal file
266
modules/juce_audio_basics/sources/juce_ResamplingAudioSource.cpp
Normal file
@ -0,0 +1,266 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
ResamplingAudioSource::ResamplingAudioSource (AudioSource* const inputSource,
|
||||
const bool deleteInputWhenDeleted,
|
||||
const int channels)
|
||||
: input (inputSource, deleteInputWhenDeleted),
|
||||
ratio (1.0),
|
||||
lastRatio (1.0),
|
||||
bufferPos (0),
|
||||
sampsInBuffer (0),
|
||||
subSampleOffset (0),
|
||||
numChannels (channels)
|
||||
{
|
||||
jassert (input != nullptr);
|
||||
zeromem (coefficients, sizeof (coefficients));
|
||||
}
|
||||
|
||||
ResamplingAudioSource::~ResamplingAudioSource() {}
|
||||
|
||||
void ResamplingAudioSource::setResamplingRatio (const double samplesInPerOutputSample)
|
||||
{
|
||||
jassert (samplesInPerOutputSample > 0);
|
||||
|
||||
const SpinLock::ScopedLockType sl (ratioLock);
|
||||
ratio = jmax (0.0, samplesInPerOutputSample);
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
|
||||
{
|
||||
const SpinLock::ScopedLockType sl (ratioLock);
|
||||
|
||||
auto scaledBlockSize = roundToInt (samplesPerBlockExpected * ratio);
|
||||
input->prepareToPlay (scaledBlockSize, sampleRate * ratio);
|
||||
|
||||
buffer.setSize (numChannels, scaledBlockSize + 32);
|
||||
|
||||
filterStates.calloc (numChannels);
|
||||
srcBuffers.calloc (numChannels);
|
||||
destBuffers.calloc (numChannels);
|
||||
createLowPass (ratio);
|
||||
|
||||
flushBuffers();
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::flushBuffers()
|
||||
{
|
||||
buffer.clear();
|
||||
bufferPos = 0;
|
||||
sampsInBuffer = 0;
|
||||
subSampleOffset = 0.0;
|
||||
resetFilters();
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::releaseResources()
|
||||
{
|
||||
input->releaseResources();
|
||||
buffer.setSize (numChannels, 0);
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
|
||||
{
|
||||
double localRatio;
|
||||
|
||||
{
|
||||
const SpinLock::ScopedLockType sl (ratioLock);
|
||||
localRatio = ratio;
|
||||
}
|
||||
|
||||
if (lastRatio != localRatio)
|
||||
{
|
||||
createLowPass (localRatio);
|
||||
lastRatio = localRatio;
|
||||
}
|
||||
|
||||
const int sampsNeeded = roundToInt (info.numSamples * localRatio) + 3;
|
||||
|
||||
int bufferSize = buffer.getNumSamples();
|
||||
|
||||
if (bufferSize < sampsNeeded + 8)
|
||||
{
|
||||
bufferPos %= bufferSize;
|
||||
bufferSize = sampsNeeded + 32;
|
||||
buffer.setSize (buffer.getNumChannels(), bufferSize, true, true);
|
||||
}
|
||||
|
||||
bufferPos %= bufferSize;
|
||||
|
||||
int endOfBufferPos = bufferPos + sampsInBuffer;
|
||||
const int channelsToProcess = jmin (numChannels, info.buffer->getNumChannels());
|
||||
|
||||
while (sampsNeeded > sampsInBuffer)
|
||||
{
|
||||
endOfBufferPos %= bufferSize;
|
||||
|
||||
int numToDo = jmin (sampsNeeded - sampsInBuffer,
|
||||
bufferSize - endOfBufferPos);
|
||||
|
||||
AudioSourceChannelInfo readInfo (&buffer, endOfBufferPos, numToDo);
|
||||
input->getNextAudioBlock (readInfo);
|
||||
|
||||
if (localRatio > 1.0001)
|
||||
{
|
||||
// for down-sampling, pre-apply the filter..
|
||||
|
||||
for (int i = channelsToProcess; --i >= 0;)
|
||||
applyFilter (buffer.getWritePointer (i, endOfBufferPos), numToDo, filterStates[i]);
|
||||
}
|
||||
|
||||
sampsInBuffer += numToDo;
|
||||
endOfBufferPos += numToDo;
|
||||
}
|
||||
|
||||
for (int channel = 0; channel < channelsToProcess; ++channel)
|
||||
{
|
||||
destBuffers[channel] = info.buffer->getWritePointer (channel, info.startSample);
|
||||
srcBuffers[channel] = buffer.getReadPointer (channel);
|
||||
}
|
||||
|
||||
int nextPos = (bufferPos + 1) % bufferSize;
|
||||
|
||||
for (int m = info.numSamples; --m >= 0;)
|
||||
{
|
||||
jassert (sampsInBuffer > 0 && nextPos != endOfBufferPos);
|
||||
|
||||
const float alpha = (float) subSampleOffset;
|
||||
|
||||
for (int channel = 0; channel < channelsToProcess; ++channel)
|
||||
*destBuffers[channel]++ = srcBuffers[channel][bufferPos]
|
||||
+ alpha * (srcBuffers[channel][nextPos] - srcBuffers[channel][bufferPos]);
|
||||
|
||||
subSampleOffset += localRatio;
|
||||
|
||||
while (subSampleOffset >= 1.0)
|
||||
{
|
||||
if (++bufferPos >= bufferSize)
|
||||
bufferPos = 0;
|
||||
|
||||
--sampsInBuffer;
|
||||
|
||||
nextPos = (bufferPos + 1) % bufferSize;
|
||||
subSampleOffset -= 1.0;
|
||||
}
|
||||
}
|
||||
|
||||
if (localRatio < 0.9999)
|
||||
{
|
||||
// for up-sampling, apply the filter after transposing..
|
||||
for (int i = channelsToProcess; --i >= 0;)
|
||||
applyFilter (info.buffer->getWritePointer (i, info.startSample), info.numSamples, filterStates[i]);
|
||||
}
|
||||
else if (localRatio <= 1.0001 && info.numSamples > 0)
|
||||
{
|
||||
// if the filter's not currently being applied, keep it stoked with the last couple of samples to avoid discontinuities
|
||||
for (int i = channelsToProcess; --i >= 0;)
|
||||
{
|
||||
const float* const endOfBuffer = info.buffer->getReadPointer (i, info.startSample + info.numSamples - 1);
|
||||
FilterState& fs = filterStates[i];
|
||||
|
||||
if (info.numSamples > 1)
|
||||
{
|
||||
fs.y2 = fs.x2 = *(endOfBuffer - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
fs.y2 = fs.y1;
|
||||
fs.x2 = fs.x1;
|
||||
}
|
||||
|
||||
fs.y1 = fs.x1 = *endOfBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
jassert (sampsInBuffer >= 0);
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::createLowPass (const double frequencyRatio)
|
||||
{
|
||||
const double proportionalRate = (frequencyRatio > 1.0) ? 0.5 / frequencyRatio
|
||||
: 0.5 * frequencyRatio;
|
||||
|
||||
const double n = 1.0 / std::tan (MathConstants<double>::pi * jmax (0.001, proportionalRate));
|
||||
const double nSquared = n * n;
|
||||
const double c1 = 1.0 / (1.0 + MathConstants<double>::sqrt2 * n + nSquared);
|
||||
|
||||
setFilterCoefficients (c1,
|
||||
c1 * 2.0f,
|
||||
c1,
|
||||
1.0,
|
||||
c1 * 2.0 * (1.0 - nSquared),
|
||||
c1 * (1.0 - MathConstants<double>::sqrt2 * n + nSquared));
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::setFilterCoefficients (double c1, double c2, double c3, double c4, double c5, double c6)
|
||||
{
|
||||
const double a = 1.0 / c4;
|
||||
|
||||
c1 *= a;
|
||||
c2 *= a;
|
||||
c3 *= a;
|
||||
c5 *= a;
|
||||
c6 *= a;
|
||||
|
||||
coefficients[0] = c1;
|
||||
coefficients[1] = c2;
|
||||
coefficients[2] = c3;
|
||||
coefficients[3] = c4;
|
||||
coefficients[4] = c5;
|
||||
coefficients[5] = c6;
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::resetFilters()
|
||||
{
|
||||
if (filterStates != nullptr)
|
||||
filterStates.clear ((size_t) numChannels);
|
||||
}
|
||||
|
||||
void ResamplingAudioSource::applyFilter (float* samples, int num, FilterState& fs)
|
||||
{
|
||||
while (--num >= 0)
|
||||
{
|
||||
const double in = *samples;
|
||||
|
||||
double out = coefficients[0] * in
|
||||
+ coefficients[1] * fs.x1
|
||||
+ coefficients[2] * fs.x2
|
||||
- coefficients[4] * fs.y1
|
||||
- coefficients[5] * fs.y2;
|
||||
|
||||
#if JUCE_INTEL
|
||||
if (! (out < -1.0e-8 || out > 1.0e-8))
|
||||
out = 0;
|
||||
#endif
|
||||
|
||||
fs.x2 = fs.x1;
|
||||
fs.x1 = in;
|
||||
fs.y2 = fs.y1;
|
||||
fs.y1 = out;
|
||||
|
||||
*samples++ = (float) out;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
105
modules/juce_audio_basics/sources/juce_ResamplingAudioSource.h
Normal file
105
modules/juce_audio_basics/sources/juce_ResamplingAudioSource.h
Normal file
@ -0,0 +1,105 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
A type of AudioSource that takes an input source and changes its sample rate.
|
||||
|
||||
@see AudioSource, LagrangeInterpolator, CatmullRomInterpolator
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API ResamplingAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a ResamplingAudioSource for a given input source.
|
||||
|
||||
@param inputSource the input source to read from
|
||||
@param deleteInputWhenDeleted if true, the input source will be deleted when
|
||||
this object is deleted
|
||||
@param numChannels the number of channels to process
|
||||
*/
|
||||
ResamplingAudioSource (AudioSource* inputSource,
|
||||
bool deleteInputWhenDeleted,
|
||||
int numChannels = 2);
|
||||
|
||||
/** Destructor. */
|
||||
~ResamplingAudioSource();
|
||||
|
||||
/** Changes the resampling ratio.
|
||||
|
||||
(This value can be changed at any time, even while the source is running).
|
||||
|
||||
@param samplesInPerOutputSample if set to 1.0, the input is passed through; higher
|
||||
values will speed it up; lower values will slow it
|
||||
down. The ratio must be greater than 0
|
||||
*/
|
||||
void setResamplingRatio (double samplesInPerOutputSample);
|
||||
|
||||
/** Returns the current resampling ratio.
|
||||
|
||||
This is the value that was set by setResamplingRatio().
|
||||
*/
|
||||
double getResamplingRatio() const noexcept { return ratio; }
|
||||
|
||||
/** Clears any buffers and filters that the resampler is using. */
|
||||
void flushBuffers();
|
||||
|
||||
//==============================================================================
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
void releaseResources() override;
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
OptionalScopedPointer<AudioSource> input;
|
||||
double ratio, lastRatio;
|
||||
AudioBuffer<float> buffer;
|
||||
int bufferPos, sampsInBuffer;
|
||||
double subSampleOffset;
|
||||
double coefficients[6];
|
||||
SpinLock ratioLock;
|
||||
const int numChannels;
|
||||
HeapBlock<float*> destBuffers;
|
||||
HeapBlock<const float*> srcBuffers;
|
||||
|
||||
void setFilterCoefficients (double c1, double c2, double c3, double c4, double c5, double c6);
|
||||
void createLowPass (double proportionalRate);
|
||||
|
||||
struct FilterState
|
||||
{
|
||||
double x1, x2, y1, y2;
|
||||
};
|
||||
|
||||
HeapBlock<FilterState> filterStates;
|
||||
void resetFilters();
|
||||
|
||||
void applyFilter (float* samples, int num, FilterState& fs);
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ResamplingAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
83
modules/juce_audio_basics/sources/juce_ReverbAudioSource.cpp
Normal file
83
modules/juce_audio_basics/sources/juce_ReverbAudioSource.cpp
Normal file
@ -0,0 +1,83 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
ReverbAudioSource::ReverbAudioSource (AudioSource* const inputSource, const bool deleteInputWhenDeleted)
|
||||
: input (inputSource, deleteInputWhenDeleted),
|
||||
bypass (false)
|
||||
{
|
||||
jassert (inputSource != nullptr);
|
||||
}
|
||||
|
||||
ReverbAudioSource::~ReverbAudioSource() {}
|
||||
|
||||
void ReverbAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
input->prepareToPlay (samplesPerBlockExpected, sampleRate);
|
||||
reverb.setSampleRate (sampleRate);
|
||||
}
|
||||
|
||||
void ReverbAudioSource::releaseResources() {}
|
||||
|
||||
void ReverbAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
|
||||
input->getNextAudioBlock (bufferToFill);
|
||||
|
||||
if (! bypass)
|
||||
{
|
||||
float* const firstChannel = bufferToFill.buffer->getWritePointer (0, bufferToFill.startSample);
|
||||
|
||||
if (bufferToFill.buffer->getNumChannels() > 1)
|
||||
{
|
||||
reverb.processStereo (firstChannel,
|
||||
bufferToFill.buffer->getWritePointer (1, bufferToFill.startSample),
|
||||
bufferToFill.numSamples);
|
||||
}
|
||||
else
|
||||
{
|
||||
reverb.processMono (firstChannel, bufferToFill.numSamples);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ReverbAudioSource::setParameters (const Reverb::Parameters& newParams)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
reverb.setParameters (newParams);
|
||||
}
|
||||
|
||||
void ReverbAudioSource::setBypassed (bool b) noexcept
|
||||
{
|
||||
if (bypass != b)
|
||||
{
|
||||
const ScopedLock sl (lock);
|
||||
bypass = b;
|
||||
reverb.reset();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
74
modules/juce_audio_basics/sources/juce_ReverbAudioSource.h
Normal file
74
modules/juce_audio_basics/sources/juce_ReverbAudioSource.h
Normal file
@ -0,0 +1,74 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
An AudioSource that uses the Reverb class to apply a reverb to another AudioSource.
|
||||
|
||||
@see Reverb
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API ReverbAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
/** Creates a ReverbAudioSource to process a given input source.
|
||||
|
||||
@param inputSource the input source to read from - this must not be null
|
||||
@param deleteInputWhenDeleted if true, the input source will be deleted when
|
||||
this object is deleted
|
||||
*/
|
||||
ReverbAudioSource (AudioSource* inputSource,
|
||||
bool deleteInputWhenDeleted);
|
||||
|
||||
/** Destructor. */
|
||||
~ReverbAudioSource();
|
||||
|
||||
//==============================================================================
|
||||
/** Returns the parameters from the reverb. */
|
||||
const Reverb::Parameters& getParameters() const noexcept { return reverb.getParameters(); }
|
||||
|
||||
/** Changes the reverb's parameters. */
|
||||
void setParameters (const Reverb::Parameters& newParams);
|
||||
|
||||
void setBypassed (bool isBypassed) noexcept;
|
||||
bool isBypassed() const noexcept { return bypass; }
|
||||
|
||||
//==============================================================================
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
void releaseResources() override;
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
CriticalSection lock;
|
||||
OptionalScopedPointer<AudioSource> input;
|
||||
Reverb reverb;
|
||||
std::atomic<bool> bypass;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ReverbAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,78 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
ToneGeneratorAudioSource::ToneGeneratorAudioSource()
|
||||
: frequency (1000.0),
|
||||
sampleRate (44100.0),
|
||||
currentPhase (0.0),
|
||||
phasePerSample (0.0),
|
||||
amplitude (0.5f)
|
||||
{
|
||||
}
|
||||
|
||||
ToneGeneratorAudioSource::~ToneGeneratorAudioSource()
|
||||
{
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void ToneGeneratorAudioSource::setAmplitude (const float newAmplitude)
|
||||
{
|
||||
amplitude = newAmplitude;
|
||||
}
|
||||
|
||||
void ToneGeneratorAudioSource::setFrequency (const double newFrequencyHz)
|
||||
{
|
||||
frequency = newFrequencyHz;
|
||||
phasePerSample = 0.0;
|
||||
}
|
||||
|
||||
//==============================================================================
|
||||
void ToneGeneratorAudioSource::prepareToPlay (int /*samplesPerBlockExpected*/, double rate)
|
||||
{
|
||||
currentPhase = 0.0;
|
||||
phasePerSample = 0.0;
|
||||
sampleRate = rate;
|
||||
}
|
||||
|
||||
void ToneGeneratorAudioSource::releaseResources()
|
||||
{
|
||||
}
|
||||
|
||||
void ToneGeneratorAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
|
||||
{
|
||||
if (phasePerSample == 0.0)
|
||||
phasePerSample = MathConstants<double>::twoPi / (sampleRate / frequency);
|
||||
|
||||
for (int i = 0; i < info.numSamples; ++i)
|
||||
{
|
||||
const float sample = amplitude * (float) std::sin (currentPhase);
|
||||
currentPhase += phasePerSample;
|
||||
|
||||
for (int j = info.buffer->getNumChannels(); --j >= 0;)
|
||||
info.buffer->setSample (j, info.startSample + i, sample);
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace juce
|
||||
@ -0,0 +1,71 @@
|
||||
/*
|
||||
==============================================================================
|
||||
|
||||
This file is part of the JUCE library.
|
||||
Copyright (c) 2017 - ROLI Ltd.
|
||||
|
||||
JUCE is an open source library subject to commercial or open-source
|
||||
licensing.
|
||||
|
||||
The code included in this file is provided under the terms of the ISC license
|
||||
http://www.isc.org/downloads/software-support-policy/isc-license. Permission
|
||||
To use, copy, modify, and/or distribute this software for any purpose with or
|
||||
without fee is hereby granted provided that the above copyright notice and
|
||||
this permission notice appear in all copies.
|
||||
|
||||
JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
|
||||
EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
|
||||
DISCLAIMED.
|
||||
|
||||
==============================================================================
|
||||
*/
|
||||
|
||||
namespace juce
|
||||
{
|
||||
|
||||
//==============================================================================
|
||||
/**
|
||||
A simple AudioSource that generates a sine wave.
|
||||
|
||||
|
||||
@tags{Audio}
|
||||
*/
|
||||
class JUCE_API ToneGeneratorAudioSource : public AudioSource
|
||||
{
|
||||
public:
|
||||
//==============================================================================
|
||||
/** Creates a ToneGeneratorAudioSource. */
|
||||
ToneGeneratorAudioSource();
|
||||
|
||||
/** Destructor. */
|
||||
~ToneGeneratorAudioSource();
|
||||
|
||||
//==============================================================================
|
||||
/** Sets the signal's amplitude. */
|
||||
void setAmplitude (float newAmplitude);
|
||||
|
||||
/** Sets the signal's frequency. */
|
||||
void setFrequency (double newFrequencyHz);
|
||||
|
||||
|
||||
//==============================================================================
|
||||
/** Implementation of the AudioSource method. */
|
||||
void prepareToPlay (int samplesPerBlockExpected, double sampleRate) override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void releaseResources() override;
|
||||
|
||||
/** Implementation of the AudioSource method. */
|
||||
void getNextAudioBlock (const AudioSourceChannelInfo&) override;
|
||||
|
||||
|
||||
private:
|
||||
//==============================================================================
|
||||
double frequency, sampleRate;
|
||||
double currentPhase, phasePerSample;
|
||||
float amplitude;
|
||||
|
||||
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ToneGeneratorAudioSource)
|
||||
};
|
||||
|
||||
} // namespace juce
|
||||
Reference in New Issue
Block a user