TEST( BaseAudioEvent, PositionInSamples )
{
BaseAudioEvent* audioEvent = new BaseAudioEvent();
int sampleLength = randomInt( 512, 8192 );
int sampleStart = randomInt( 0, sampleLength / 2 );
int expectedEnd = sampleStart + ( sampleLength - 1 );
audioEvent->setSampleStart ( sampleStart );
audioEvent->setSampleLength( sampleLength );
EXPECT_EQ( sampleStart, audioEvent->getSampleStart() );
EXPECT_EQ( expectedEnd, audioEvent->getSampleEnd() );
EXPECT_EQ( sampleLength, audioEvent->getSampleLength() );
// test whether values in seconds have updated accordingly
int SAMPLE_RATE = 44100;
float expectedStartPosition = BufferUtility::bufferToSeconds( sampleStart, SAMPLE_RATE );
float expectedEndPosition = BufferUtility::bufferToSeconds( expectedEnd, SAMPLE_RATE );
float expectedDuration = expectedEndPosition - expectedStartPosition;
EXPECT_FLOAT_EQ( expectedStartPosition, audioEvent->getStartPosition() );
EXPECT_FLOAT_EQ( expectedEndPosition, audioEvent->getEndPosition() );
EXPECT_FLOAT_EQ( expectedDuration, audioEvent->getDuration() );
// test auto sanitation of properties
audioEvent->setSampleEnd( expectedEnd * 2 );
EXPECT_EQ( expectedEnd, audioEvent->getSampleEnd() )
<< "expected sample end not to exceed the range set by the sample start and length properties";
sampleLength /= 2;
audioEvent->setSampleLength( sampleLength );
expectedEnd = sampleStart + ( sampleLength - 1 );
EXPECT_EQ( expectedEnd, audioEvent->getSampleEnd() )
<< "expected sample end not to exceed the range set by the sample start and updated length properties";
// test non sanitation of properties for loopeable events
audioEvent->setLoopeable( true );
expectedEnd *= 2;
audioEvent->setSampleEnd( expectedEnd );
EXPECT_EQ( expectedEnd, audioEvent->getSampleEnd() )
<< "expected sample end to exceed the range set by the sample start and length properties for loopeable event";
sampleLength /= 2;
audioEvent->setSampleLength( sampleLength );
EXPECT_EQ( expectedEnd, audioEvent->getSampleEnd() )
<< "expected sample end to exceed the range set by the sample start and updated length properties for loopeable event";
deleteAudioEvent( audioEvent );
}
/**
* used by the cacheAudioEventsForMeasure-method, this collects
* all AudioEvents in the requested measure for entry into the BulkCacher
*
* @param bufferPosition {int} the desired measures buffers start pointer
* @param bufferEnd {int} the desired measures buffers end pointer
*
* @return {std::vector<BaseCacheableAudioEvent*>}
*/
std::vector<BaseCacheableAudioEvent*>* collectCacheableSequencerEvents( int bufferPosition, int bufferEnd )
{
std::vector<BaseCacheableAudioEvent*>* events = new std::vector<BaseCacheableAudioEvent*>();
for ( int i = 0, l = instruments.size(); i < l; ++i )
{
std::vector<BaseAudioEvent*>* audioEvents = instruments.at( i )->getEvents();
int amount = audioEvents->size();
for ( int j = 0; j < amount; j++ )
{
BaseAudioEvent* audioEvent = audioEvents->at( j );
// if event is an instance of BaseCacheableAudioEvent add it to the list
if ( dynamic_cast<BaseCacheableAudioEvent*>( audioEvent ) != NULL )
{
int sampleStart = audioEvent->getSampleStart();
int sampleEnd = audioEvent->getSampleEnd();
if (( sampleStart >= bufferPosition && sampleStart <= bufferEnd ) ||
( sampleStart < bufferPosition && sampleEnd >= bufferPosition ))
{
if ( !audioEvent->isDeletable())
events->push_back(( BaseCacheableAudioEvent* ) audioEvent );
}
}
}
}
return events;
}
/**
* used by the getAudioEvents-method of the sequencer, this validates
* the present AudioEvents against the requested position
* and updates and flushes the removal queue
*
* @param instrument {BaseInstrument*} instrument to gather events from
* @param bufferPosition {int} the current buffers start pointer
* @param bufferEnd {int} the current buffers end pointer
*/
void collectSequencedEvents( BaseInstrument* instrument, int bufferPosition, int bufferEnd )
{
if ( !instrument->hasEvents() )
return;
AudioChannel* channel = instrument->audioChannel;
std::vector<BaseAudioEvent*>* audioEvents = instrument->getEvents();
// removal queue
std::vector<BaseAudioEvent*> removes;
// channel has an internal loop (e.g. drum machine) ? recalculate requested
// buffer position by subtracting all measures above the first
if ( channel->maxBufferPosition > 0 )
{
int samplesPerBar = AudioEngine::samples_per_bar;
while ( bufferPosition >= channel->maxBufferPosition )
{
bufferPosition -= samplesPerBar;
bufferEnd -= samplesPerBar;
}
}
int i = 0, amount = audioEvents->size();
for ( i; i < amount; i++ )
{
BaseAudioEvent* audioEvent = audioEvents->at( i );
if ( audioEvent->isEnabled() )
{
int sampleStart = audioEvent->getSampleStart();
int sampleEnd = audioEvent->getSampleEnd();
if ( audioEvent->isLoopeable() ||
( sampleStart >= bufferPosition && sampleStart <= bufferEnd ) ||
( sampleStart < bufferPosition && sampleEnd >= bufferPosition ))
{
if ( !audioEvent->isDeletable())
channel->addEvent( audioEvent );
else
removes.push_back( audioEvent );
}
}
}
// removal queue filled ? process it so we can safely
// remove "deleted" AudioEvents without errors occurring
if ( removes.size() > 0 )
{
int i = 0;
for ( i; i < removes.size(); i++ )
{
BaseAudioEvent* audioEvent = removes[ i ];
instrument->removeEvent( audioEvent, false );
}
}
}
TEST( BaseAudioEvent, MixBufferLoopeableEvent )
{
BaseAudioEvent* audioEvent = new BaseAudioEvent();
int sourceSize = 16;
AudioBuffer* sourceBuffer = new AudioBuffer( 1, sourceSize );
SAMPLE_TYPE* rawBuffer = sourceBuffer->getBufferForChannel( 0 );
fillAudioBuffer( sourceBuffer );
audioEvent->setBuffer( sourceBuffer, false );
audioEvent->setLoopeable( true );
audioEvent->setSampleLength( 16 * 4 ); // thus will loop 4 times
audioEvent->positionEvent ( 0, 16, 0 );
// create an output buffer at a size smaller than the source buffer length
int outputSize = ( int )(( double ) sourceSize * .4 );
AudioBuffer* targetBuffer = new AudioBuffer( sourceBuffer->amountOfChannels, outputSize );
int minBufferPos = audioEvent->getSampleStart();
int bufferPos = minBufferPos;
int maxBufferPos = audioEvent->getSampleEnd();
// test the seamless mixing over multiple iterations
for ( ; bufferPos < maxBufferPos; bufferPos += outputSize )
{
// mix buffer contents
targetBuffer->silenceBuffers();
bool loopStarted = bufferPos + ( outputSize - 1 ) > maxBufferPos;
int loopOffset = ( maxBufferPos - bufferPos ) + 1;
audioEvent->mixBuffer( targetBuffer, bufferPos, minBufferPos, maxBufferPos, loopStarted, loopOffset, false );
// assert results
SAMPLE_TYPE* mixedBuffer = targetBuffer->getBufferForChannel( 0 );
for ( int i = 0; i < outputSize; ++i )
{
int compareOffset = ( bufferPos + i ) % sourceSize;
EXPECT_EQ( rawBuffer[ compareOffset ], mixedBuffer[ i ] )
<< "expected mixed buffer contents to equal the source contents at mixed offset " << i << " for source offset " << compareOffset;
}
}
delete targetBuffer;
delete sourceBuffer;
delete audioEvent;
}
TEST( BaseAudioEvent, PositionInSeconds )
{
BaseAudioEvent* audioEvent = new BaseAudioEvent();
float startPosition = randomFloat( 0, 10 );
float endPosition = startPosition + randomFloat( 0, 10 );
int SAMPLE_RATE = 44100;
float expectedDuration = endPosition - startPosition;
int expectedSampleStart = BufferUtility::secondsToBuffer( startPosition, SAMPLE_RATE );
int expectedSampleEnd = BufferUtility::secondsToBuffer( endPosition, SAMPLE_RATE );
int expectedSampleLength = ( expectedSampleEnd - expectedSampleStart ) - 1;
audioEvent->setStartPosition( startPosition );
EXPECT_FLOAT_EQ( startPosition, audioEvent->getStartPosition() );
EXPECT_FLOAT_EQ( startPosition, audioEvent->getEndPosition() )
<< "expected end position to equal start position (hasn't been explicitly set yet)";
EXPECT_FLOAT_EQ( 0, audioEvent->getDuration())
<< "expected zero duration (duration nor end haven't been explicitly set yet)";
EXPECT_EQ( 0, audioEvent->getSampleLength())
<< "expected zero sample length (duration nor end haven't been explicitly set yet)";
EXPECT_EQ( expectedSampleStart, audioEvent->getSampleStart() )
<< "expected sample start to have been updated after setting start position";
audioEvent->setEndPosition( endPosition );
EXPECT_FLOAT_EQ( startPosition, audioEvent->getStartPosition() );
EXPECT_FLOAT_EQ( endPosition, audioEvent->getEndPosition() );
EXPECT_FLOAT_EQ( expectedDuration, audioEvent->getDuration() );
EXPECT_EQ( expectedSampleEnd, audioEvent->getSampleEnd())
<< "expected sample end to have been updated after setting end position";
EXPECT_EQ( expectedSampleLength, audioEvent->getSampleLength())
<< "expected sample length to have been updated after setting end position";
expectedDuration /= 2;
float expectedEndPosition = startPosition + expectedDuration;
audioEvent->setDuration( expectedDuration );
EXPECT_FLOAT_EQ( expectedDuration, audioEvent->getDuration() );
EXPECT_FLOAT_EQ( expectedEndPosition, audioEvent->getEndPosition())
<< "expected end position to have corrected after updating of duration";
deleteAudioEvent( audioEvent );
}
TEST( BaseAudioEvent, PositionEvent )
{
BaseAudioEvent* audioEvent = new BaseAudioEvent();
AudioEngine::samples_per_bar = randomInt( 11025, 88200 );
int sampleLength = randomInt( 24, 8192 );
audioEvent->setSampleLength( sampleLength );
int startMeasure = randomInt( 0, 15 );
int subdivisions = randomInt( 4, 128 );
int offset = randomInt( 0, 64 );
audioEvent->positionEvent( startMeasure, subdivisions, offset );
int expectedSampleStart = ( startMeasure * AudioEngine::samples_per_bar ) +
( offset * AudioEngine::samples_per_bar / subdivisions );
int expectedSampleEnd = expectedSampleStart + sampleLength - 1;
EXPECT_EQ( expectedSampleStart, audioEvent->getSampleStart() );
EXPECT_EQ( expectedSampleEnd, audioEvent->getSampleEnd() );
deleteAudioEvent( audioEvent );
}
TEST( BaseAudioEvent, MixBuffer )
{
BaseAudioEvent* audioEvent = new BaseAudioEvent();
int sampleLength = randomInt( 8, 24 );
int sampleStart = randomInt( 0, ( int )( sampleLength / 2 ));
audioEvent->setSampleStart ( sampleStart );
audioEvent->setSampleLength( sampleLength );
int sampleEnd = audioEvent->getSampleEnd();
AudioBuffer* buffer = fillAudioBuffer( new AudioBuffer( randomInt( 1, 4 ), sampleLength ));
audioEvent->setBuffer( buffer, true );
float volume = randomFloat();
audioEvent->setVolume( volume );
//std::cout << " ss: " << sampleStart << " se: " << sampleEnd << " sl: " << sampleLength << " ch: " << buffer->amountOfChannels;
// create a temporary buffer to write output in, ensure it is smaller than the event buffer
AudioBuffer* targetBuffer = new AudioBuffer( buffer->amountOfChannels, randomInt( 2, 4 ));
int buffersToWrite = targetBuffer->bufferSize;
ASSERT_FALSE( bufferHasContent( targetBuffer ))
<< "expected target buffer to be silent after creation, but it has content";
// test 1. mix without loopable range
int maxBufferPos = sampleLength * 2; // use a "loop range" larger than the size of the events length
int minBufferPos = randomInt( 0, maxBufferPos / 2 );
int bufferPos = randomInt( minBufferPos, maxBufferPos - 1 );
bool loopStarted = false;
int loopOffset = 0;
// if the random bufferPosition wasn't within the events sampleStart and sampleEnd range, we expect no content
bool expectContent = ( bufferPos >= sampleStart && bufferPos <= sampleEnd ) ||
(( bufferPos + buffersToWrite ) >= sampleStart && ( bufferPos + buffersToWrite ) <= sampleEnd );
//std::cout << " expected content: " << expectContent << " for buffer size: " << buffersToWrite;
//std::cout << " min: " << minBufferPos << " max: " << maxBufferPos << " cur: " << bufferPos;
audioEvent->mixBuffer( targetBuffer, bufferPos, minBufferPos, maxBufferPos, loopStarted, loopOffset, false );
// validate buffer contents after mixing
if ( expectContent )
{
for ( int c = 0, ca = targetBuffer->amountOfChannels; c < ca; ++c )
{
SAMPLE_TYPE* buffer = targetBuffer->getBufferForChannel( c );
SAMPLE_TYPE* sourceBuffer = audioEvent->getBuffer()->getBufferForChannel( c );
SAMPLE_TYPE expectedSample;
for ( int i = 0; i < buffersToWrite; ++i )
{
int r = i + bufferPos; // read pointer for the source buffer
if ( r >= maxBufferPos && !loopStarted )
r -= ( maxBufferPos - minBufferPos );
if ( r >= sampleStart && r <= sampleEnd )
{
r -= sampleStart; // substract audioEvent start position
expectedSample = sourceBuffer[ r ] * volume;
}
else {
expectedSample = 0.0;
}
SAMPLE_TYPE sample = buffer[ i ];
EXPECT_EQ( expectedSample, sample )
<< "expected mixed sample at " << i << " to be equal to the calculated expected sample at read offset " << r;
}
}
}
else {
ASSERT_FALSE( bufferHasContent( targetBuffer ))
<< "expected target buffer to contain no content after mixing for an out-of-range buffer position";
}
// test 2. mixing within a loopable range (implying sequencer is starting a loop)
targetBuffer->silenceBuffers();
ASSERT_FALSE( bufferHasContent( targetBuffer ))
<< "expected target buffer to be silent after silencing, but it still has content";
bufferPos = randomInt( minBufferPos, maxBufferPos - 1 );
loopStarted = true;
loopOffset = ( maxBufferPos - bufferPos ) + 1;
// pre calculate at which buffer iterator the looping will commence
// loopStartIteratorPosition describes at which sequencer position the loop starts
// loopStartWritePointer describes at which position in the targetBuffer the loop is written to
// amountOfLoopedWrites is the amount of samples written in the loop
// loopStartReadPointer describes at which position the samples from the source audioEvent will be read when loop starts
// loopStartReadPointerEnd describes the last position the samples from the source audioEvent will be read for the amount of loop writes
int loopStartIteratorPosition = maxBufferPos + 1;
int loopStartWritePointer = loopOffset;
int loopStartReadPointer = minBufferPos;
int amountOfLoopedWrites = ( bufferPos + buffersToWrite ) - loopStartIteratorPosition;
int loopStartReadPointerEnd = ( loopStartReadPointer + amountOfLoopedWrites ) - 1;
expectContent = ( bufferPos >= sampleStart && bufferPos <= sampleEnd ) ||
(( bufferPos + buffersToWrite ) >= sampleStart && ( bufferPos + buffersToWrite ) <= sampleEnd ) ||
( loopStartIteratorPosition > maxBufferPos && (
( loopStartReadPointer >= sampleStart && loopStartReadPointer <= sampleEnd ) ||
( loopStartReadPointerEnd >= sampleStart && loopStartReadPointerEnd <= sampleEnd )));
audioEvent->mixBuffer( targetBuffer, bufferPos, minBufferPos, maxBufferPos, loopStarted, loopOffset, false );
//std::cout << " expected content: " << expectContent << " for buffer size: " << buffersToWrite;
//std::cout << " min: " << minBufferPos << " max: " << maxBufferPos << " cur: " << bufferPos << " loop offset: " << loopOffset;
if ( expectContent )
{
for ( int c = 0, ca = targetBuffer->amountOfChannels; c < ca; ++c )
{
SAMPLE_TYPE* buffer = targetBuffer->getBufferForChannel( c );
SAMPLE_TYPE* sourceBuffer = audioEvent->getBuffer()->getBufferForChannel( c );
for ( int i = 0; i < buffersToWrite; ++i )
{
SAMPLE_TYPE expectedSample = 0.0;
int r = i + bufferPos; // read pointer for the source buffer
if ( i >= loopOffset )
r = minBufferPos + ( i - loopOffset );
if ( r >= sampleStart && r <= sampleEnd )
{
r -= sampleStart; // substract audioEvent start position
expectedSample = sourceBuffer[ r ] * volume;
}
SAMPLE_TYPE sample = buffer[ i ];
EXPECT_EQ( expectedSample, sample )
<< "expected mixed sample at " << i << " to be equal to the calculated expected sample at read "
<< "offset " << r << " ( sanitized from " << ( i + bufferPos ) << " )";
}
}
}
else {
ASSERT_FALSE( bufferHasContent( targetBuffer ))
<< "expected output buffer to contain no content after mixing for an out-of-range buffer position";
}
delete audioEvent;
delete targetBuffer;
delete buffer;
}