f@0: /***************************************************/
f@0: /*! \class RtWvOut
f@0:     \brief STK realtime audio (blocking) output class.
f@0: 
f@0:     This class provides a simplified interface to RtAudio for realtime
f@0:     audio output.  It is a subclass of WvOut.  This class makes use of
f@0:     RtAudio's callback functionality by creating a large ring-buffer
f@0:     into which data is written.  This class should not be used when
f@0:     low-latency is desired.
f@0: 
f@0:     RtWvOut supports multi-channel data in interleaved format.  It is
f@0:     important to distinguish the tick() method that outputs a single
f@0:     sample to all channels in a sample frame from the overloaded one
f@0:     that takes a reference to an StkFrames object for multi-channel
f@0:     and/or multi-frame data.
f@0: 
f@0:     by Perry R. Cook and Gary P. Scavone, 1995--2014.
f@0: */
f@0: /***************************************************/
f@0: #pragma once
f@0: 
f@0: #include "../include/RtWvOut.h"
f@0: #include <cstring>
f@0: 
f@0: namespace stk {
f@0: 
f@0: // Streaming status states.
f@0: enum { RUNNING, EMPTYING, FINISHED };
f@0: 
f@0: // This function is automatically called by RtAudio to get audio data for output.
f@0: int write( void *outputBuffer, void *inputBuffer, unsigned int nBufferFrames,
f@0:            double streamTime, RtAudioStreamStatus status, void *dataPointer )
f@0: {
f@0:   return ( (RtWvOut *) dataPointer )->readBuffer( outputBuffer, nBufferFrames );
f@0: }
f@0: 
f@0: // This function does not block.  If the user does not write output
f@0: // data to the buffer fast enough, previous data will be re-output
f@0: // (data underrun).
f@0: int RtWvOut :: readBuffer( void *buffer, unsigned int frameCount )
f@0: {
f@0:   unsigned int nSamples, nChannels = data_.channels();
f@0:   unsigned int nFrames = frameCount;
f@0:   StkFloat *input = (StkFloat *) &data_[ readIndex_ * nChannels ];
f@0:   StkFloat *output = (StkFloat *) buffer;
f@0:   long counter;
f@0: 
f@0:   while ( nFrames > 0 ) {
f@0: 
f@0:     // I'm assuming that both the RtAudio and StkFrames buffers
f@0:     // contain interleaved data.
f@0:     counter = nFrames;
f@0: 
f@0:     // Pre-increment read pointer and check bounds.
f@0:     readIndex_ += nFrames;
f@0:     if ( readIndex_ >= data_.frames() ) {
f@0:       counter -= readIndex_ - data_.frames();
f@0:       readIndex_ = 0;
f@0:     }
f@0: 
f@0:     // Copy data from the StkFrames container.
f@0:     if ( status_ == EMPTYING && framesFilled_ <= counter ) {
f@0:       nSamples = framesFilled_ * nChannels;
f@0:       unsigned int i;
f@0:       for ( i=0; i<nSamples; i++ ) *output++ = *input++;
f@0:       nSamples = (counter - framesFilled_) * nChannels;
f@0:       for ( i=0; i<nSamples; i++ ) *output++ = 0.0;
f@0:       status_ = FINISHED;
f@0:       return 1;
f@0:     }
f@0:     else {
f@0:       nSamples = counter * nChannels;
f@0:       for ( unsigned int i=0; i<nSamples; i++ )
f@0:         *output++ = *input++;
f@0:     }
f@0: 
f@0:     nFrames -= counter;
f@0:   }
f@0: 
f@0:   mutex_.lock();
f@0:   framesFilled_ -= frameCount;
f@0:   mutex_.unlock();
f@0:   if ( framesFilled_ < 0 ) {
f@0:     framesFilled_ = 0;
f@0:     //    writeIndex_ = readIndex_;
f@0:     oStream_ << "RtWvOut: audio buffer underrun!";
f@0:     handleError( StkError::WARNING );
f@0:   }
f@0: 
f@0:   return 0;
f@0: }
f@0: 
f@0: 
f@0: RtWvOut :: RtWvOut( unsigned int nChannels, StkFloat sampleRate, int device, int bufferFrames, int nBuffers )
f@0:   : stopped_( true ), readIndex_( 0 ), writeIndex_( 0 ), framesFilled_( 0 ), status_(0)
f@0: {
f@0:   // We'll let RtAudio deal with channel and sample rate limitations.
f@0:   RtAudio::StreamParameters parameters;
f@0:   if ( device == 0 )
f@0:     parameters.deviceId = dac_.getDefaultOutputDevice();
f@0:   else
f@0:     parameters.deviceId = device - 1;
f@0:   parameters.nChannels = nChannels;
f@0:   unsigned int size = bufferFrames;
f@0:   RtAudioFormat format = ( sizeof(StkFloat) == 8 ) ? RTAUDIO_FLOAT64 : RTAUDIO_FLOAT32;
f@0: 
f@0:   // Open a stream and set the callback function.
f@0:   try {
f@0:     dac_.openStream( &parameters, NULL, format, (unsigned int)Stk::sampleRate(), &size, &write, (void *)this );
f@0:   }
f@0:   catch ( RtAudioError &error ) {
f@0:     handleError( error.what(), StkError::AUDIO_SYSTEM );
f@0:   }
f@0: 
f@0:   data_.resize( size * nBuffers, nChannels );
f@0: 
f@0:   // Start writing half-way into buffer.
f@0:   writeIndex_ = (unsigned int ) (data_.frames() / 2.0);
f@0:   framesFilled_ = writeIndex_;
f@0: }
f@0: 
f@0: RtWvOut :: ~RtWvOut( void )
f@0: {
f@0:   // Change status flag to signal callback to clear the buffer and close.
f@0:   status_ = EMPTYING;
f@0:   while ( status_ != FINISHED || dac_.isStreamRunning() == true ) Stk::sleep( 100 );
f@0:   dac_.closeStream();
f@0: }
f@0: 
f@0: void RtWvOut :: start( void )
f@0: {
f@0:   if ( stopped_ ) {
f@0:     dac_.startStream();
f@0:     stopped_ = false;
f@0:   }
f@0: }
f@0: 
f@0: void RtWvOut :: stop( void )
f@0: {
f@0:   if ( !stopped_ ) {
f@0:     dac_.stopStream();
f@0:     stopped_ = true;
f@0:   }
f@0: }
f@0: 
f@0: void RtWvOut :: tick( const StkFloat sample )
f@0: {
f@0:   if ( stopped_ ) this->start();
f@0: 
f@0:   // Block until we have room for at least one frame of output data.
f@0:   while ( framesFilled_ == (long) data_.frames() ) Stk::sleep( 1 );
f@0: 
f@0:   unsigned int nChannels = data_.channels();
f@0:   StkFloat input = sample;
f@0:   clipTest( input );
f@0:   unsigned long index = writeIndex_ * nChannels;
f@0:   for ( unsigned int j=0; j<nChannels; j++ )
f@0:     data_[index++] = input;
f@0: 
f@0:   mutex_.lock();
f@0:   framesFilled_++;
f@0:   mutex_.unlock();
f@0:   frameCounter_++;
f@0:   writeIndex_++;
f@0:   if ( writeIndex_ == data_.frames() )
f@0:     writeIndex_ = 0;
f@0: }
f@0: 
f@0: void RtWvOut :: tick( const StkFrames& frames )
f@0: {
f@0: #if defined(_STK_DEBUG_)
f@0:   if ( data_.channels() != frames.channels() ) {
f@0:     oStream_ << "RtWvOut::tick(): incompatible channel value in StkFrames argument!";
f@0:     handleError( StkError::FUNCTION_ARGUMENT );
f@0:   }
f@0: #endif
f@0: 
f@0:   if ( stopped_ ) this->start();
f@0: 
f@0:   // See how much space we have and fill as much as we can ... if we
f@0:   // still have samples left in the frames object, then wait and
f@0:   // repeat.
f@0:   unsigned int framesEmpty, nFrames, bytes, framesWritten = 0;
f@0:   unsigned int nChannels = data_.channels();
f@0:   while ( framesWritten < frames.frames() ) {
f@0: 
f@0:     // Block until we have some room for output data.
f@0:     while ( framesFilled_ == (long) data_.frames() ) Stk::sleep( 1 );
f@0:     framesEmpty = data_.frames() - framesFilled_;
f@0: 
f@0:     // Copy data in one chunk up to the end of the data buffer.
f@0:     nFrames = framesEmpty;
f@0:     if ( writeIndex_ + nFrames > data_.frames() )
f@0:       nFrames = data_.frames() - writeIndex_;
f@0:     if ( nFrames > frames.frames() - framesWritten )
f@0:       nFrames = frames.frames() - framesWritten;
f@0:     bytes = nFrames * nChannels * sizeof( StkFloat );
f@0:     StkFloat *samples = &data_[writeIndex_ * nChannels];
f@0:     StkFrames *ins = (StkFrames *) &frames;
f@0:     memcpy( samples, &(*ins)[framesWritten * nChannels], bytes );
f@0:     for ( unsigned int i=0; i<nFrames * nChannels; i++ ) clipTest( *samples++ );
f@0: 
f@0:     writeIndex_ += nFrames;
f@0:     if ( writeIndex_ == data_.frames() ) writeIndex_ = 0;
f@0: 
f@0:     framesWritten += nFrames;
f@0:     mutex_.lock();
f@0:     framesFilled_ += nFrames;
f@0:     mutex_.unlock();
f@0:     frameCounter_ += nFrames;
f@0:   }
f@0: }
f@0: 
f@0: } // stk namespace