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; }
/** * starts the render thread * NOTE: the render thread is always active, even when the * sequencer is paused */ void start() { OPENSL_STREAM *p; p = android_OpenAudioDevice( AudioEngineProps::SAMPLE_RATE, AudioEngineProps::INPUT_CHANNELS, AudioEngineProps::OUTPUT_CHANNELS, AudioEngineProps::BUFFER_SIZE ); // hardware unavailable ? halt thread, trigger JNI callback for error handler if ( p == NULL ) { Observer::handleHardwareUnavailable(); return; } // audio hardware available, start render thread int buffer_size, i, c, ci; buffer_size = AudioEngineProps::BUFFER_SIZE; int outputChannels = AudioEngineProps::OUTPUT_CHANNELS; bool isMono = outputChannels == 1; std::vector<AudioChannel*> channels; std::vector<AudioChannel*> channels2; // used when loop starts for gathering events at the start range bool loopStarted = false; // whether the current buffer will exceed the end offset of the loop (read remaining samples from the start) int loopOffset = 0; // the offset within the current buffer where we start reading from the current loops start offset int loopAmount = 0; // amount of samples we must read from the current loops start offset float recbufferIn [ buffer_size ]; // used for recording from device input float outbuffer [ buffer_size * outputChannels ]; // the output buffer rendered by the hardware // generate buffers for temporary channel buffer writes AudioBuffer* channelBuffer = new AudioBuffer( outputChannels, buffer_size ); AudioBuffer* inbuffer = new AudioBuffer( outputChannels, buffer_size ); // accumulates all channels ("master strip") AudioBuffer* recbuffer = new AudioBuffer( AudioEngineProps::INPUT_CHANNELS, buffer_size ); thread = 1; // signal processors Finalizer* limiter = new Finalizer ( 2, 500, AudioEngineProps::SAMPLE_RATE, outputChannels ); LPFHPFilter* hpf = new LPFHPFilter(( float ) AudioEngineProps::SAMPLE_RATE, 55, outputChannels ); while ( thread ) { // erase previous buffer contents inbuffer->silenceBuffers(); // gather the audio events by the buffer range currently being processed int endPosition = bufferPosition + buffer_size; channels = sequencer::getAudioEvents( channels, bufferPosition, endPosition, true ); // read pointer exceeds maximum allowed offset ? => sequencer has started its loop // we must now also gather extra events at the start position of the seq. range loopStarted = endPosition > max_buffer_position; loopOffset = (( max_buffer_position + 1 ) - bufferPosition ); loopAmount = buffer_size - loopOffset; if ( loopStarted ) { // were we bouncing the audio ? save file and stop rendering if ( bouncing ) { DiskWriter::writeBufferToFile( AudioEngineProps::SAMPLE_RATE, AudioEngineProps::OUTPUT_CHANNELS, false ); // broadcast update via JNI, pass buffer identifier name to identify last recording Observer::handleBounceComplete( 1 ); thread = 0; // stop thread, halts rendering break; } else { endPosition -= max_buffer_position; channels2 = sequencer::getAudioEvents( channels2, min_buffer_position, min_buffer_position + buffer_size, false ); // er? the channels are magically merged by above invocation..., performing the insert below adds the same events TWICE*POP*!?!? //channels.insert( channels.end(), channels2.begin(), channels2.end() ); // merge the channels into one channels2.clear(); // would clear on next "getAudioEvents"-query... but why wait ? } } // record audio from Android device ? if ( recordFromDevice && AudioEngineProps::INPUT_CHANNELS > 0 ) { int recSamps = android_AudioIn( p, recbufferIn, AudioEngineProps::BUFFER_SIZE ); SAMPLE_TYPE* recBufferChannel = recbuffer->getBufferForChannel( 0 ); for ( int j = 0; j < recSamps; ++j ) { recBufferChannel[ j ] = recbufferIn[ j ];//static_cast<float>( recbufferIn[ j ] ); // merge recording into current input buffer for instant monitoring if ( monitorRecording ) { for ( int k = 0; k < outputChannels; ++k ) inbuffer->getBufferForChannel( k )[ j ] = recBufferChannel[ j ]; } } } // channel loop int j = 0; int channelAmount = channels.size(); for ( j; j < channelAmount; ++j ) { AudioChannel* channel = channels[ j ]; bool isCached = channel->hasCache; // whether this channel has a fully cached buffer bool mustCache = AudioEngineProps::CHANNEL_CACHING && channel->canCache() && !isCached; // whether to cache this channels output bool gotBuffer = false; int cacheReadPos = 0; // the offset we start ready from the channel buffer (when writing to cache) SAMPLE_TYPE channelVolume = ( SAMPLE_TYPE ) channel->mixVolume; std::vector<BaseAudioEvent*> audioEvents = channel->audioEvents; int amount = audioEvents.size(); // clear previous channel buffer content channelBuffer->silenceBuffers(); bool useChannelRange = channel->maxBufferPosition != 0; // channel has its own buffer range (i.e. drummachine) int maxBufferPosition = useChannelRange ? channel->maxBufferPosition : max_buffer_position; // we make a copy of the current buffer position indicator int bufferPos = bufferPosition; // ...in case the AudioChannels maxBufferPosition differs from the sequencer loop range // note that these buffer positions are always a full bar in length (as we loop measures) while ( bufferPos > maxBufferPosition ) bufferPos -= bytes_per_bar; // only render sequenced events when the sequencer isn't in the paused state // and the channel volume is actually at an audible level! ( > 0 ) if ( playing && amount > 0 && channelVolume > 0.0 ) { if ( !isCached ) { // write the audioEvent buffers into the main output buffer for ( int k = 0; k < amount; ++k ) { BaseAudioEvent* audioEvent = audioEvents[ k ]; if ( !audioEvent->isLocked()) // make sure we are allowed to query the contents { audioEvent->lock(); // prevent buffer mutations during this read cycle audioEvent->mixBuffer( channelBuffer, bufferPos, min_buffer_position, maxBufferPosition, loopStarted, loopOffset, useChannelRange ); audioEvent->unlock(); // release lock } } } else { channel->readCachedBuffer( channelBuffer, bufferPos ); } } // perform live rendering for this instrument if ( channel->hasLiveEvents ) { int lAmount = channel->liveEvents.size(); // the volume of the live events is divided by the channel mix as a live event // is played on the same instrument, but just as a different voice (note the // events can have their own mix level) float lAmp = channel->mixVolume > 0.0 ? MAX_PHASE / channel->mixVolume : MAX_PHASE; for ( int k = 0; k < lAmount; ++k ) { BaseAudioEvent* vo = channel->liveEvents[ k ]; channelBuffer->mergeBuffers( vo->synthesize( buffer_size ), 0, 0, lAmp ); } } // apply the processing chains processors / modulators ProcessingChain* chain = channel->processingChain; std::vector<BaseProcessor*> processors = chain->getActiveProcessors(); for ( int k = 0; k < processors.size(); k++ ) { BaseProcessor* processor = processors[ k ]; bool canCacheProcessor = processor->isCacheable(); // only apply processor when we're not caching or cannot cache its output if ( !isCached || !canCacheProcessor ) { // cannot cache this processor and we're caching ? write all contents // of the channelBuffer into the channels cache if ( mustCache && !canCacheProcessor ) mustCache = !writeChannelCache( channel, channelBuffer, cacheReadPos ); processors[ k ]->process( channelBuffer, channel->isMono ); } } // write cache if it didn't happen yet ;) (bus processors are (currently) non-cacheable) if ( mustCache ) mustCache = !writeChannelCache( channel, channelBuffer, cacheReadPos ); // write the channel buffer into the combined output buffer, apply channel volume // note live events are always audible as their volume is relative to the instrument if ( channel->hasLiveEvents && channelVolume == 0.0 ) channelVolume = MAX_PHASE; inbuffer->mergeBuffers( channelBuffer, 0, 0, channelVolume ); } // TODO: create bus processors for these ? // apply high pass filtering to prevent extreme low rumbling and nasty filter offsets hpf->process( inbuffer, buffer_size ); // limit the audio to prevent clipping limiter->process( inbuffer, isMono ); // write the accumulated buffers into the output buffer for ( i = 0, c = 0; i < buffer_size; i++, c += outputChannels ) { for ( ci = 0; ci < outputChannels; ci++ ) { float sample = ( float ) inbuffer->getBufferForChannel( ci )[ i ] * volume; // apply master volume // extreme limiting (still above the thresholds?) if ( sample < -MAX_PHASE ) sample = -MAX_PHASE; else if ( sample > +MAX_PHASE ) sample = +MAX_PHASE; outbuffer[ c + ci ] = sample; } // update the buffer pointers and sequencer position if ( playing ) { if ( ++bufferPosition % bytes_per_tick == 0 ) handleSequencerPositionUpdate( android_GetTimestamp( p )); if ( bufferPosition > max_buffer_position ) bufferPosition = min_buffer_position; } } // render the buffer in the audio hardware (unless we're bouncing as writing the output // makes it both unnecessarily audible and stalls this thread's execution if ( !bouncing ) android_AudioOut( p, outbuffer, buffer_size * AudioEngineProps::OUTPUT_CHANNELS ); // record the output if recording state is active if ( playing && ( recordOutput || recordFromDevice )) { if ( recordFromDevice ) // recording from device input ? > write the record buffer DiskWriter::appendBuffer( recbuffer ); else // recording global output ? > write the combined buffer DiskWriter::appendBuffer( inbuffer ); // exceeded maximum recording buffer amount ? > write current recording if ( DiskWriter::bufferFull() || haltRecording ) { int amountOfChannels = recordFromDevice ? AudioEngineProps::INPUT_CHANNELS : outputChannels; DiskWriter::writeBufferToFile( AudioEngineProps::SAMPLE_RATE, amountOfChannels, true ); if ( !haltRecording ) { DiskWriter::generateOutputBuffer(); // allocate new buffer for next iteration ++recordingFileId; } else { haltRecording = false; } } } // tempo update queued ? if ( queuedTempo != tempo ) handleTempoUpdate( queuedTempo, true ); } android_CloseAudioDevice( p ); // clear heap memory allocated before thread loop delete inbuffer; delete channelBuffer; delete limiter; delete hpf; }
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; }