plonk_AudioFileReader.h

/*
 -------------------------------------------------------------------------------
 This file is part of the Plink, Plonk, Plank libraries
  by Martin Robinson
 
 http://code.google.com/p/pl-nk/
 
 Copyright University of the West of England, Bristol 2011-14
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
 * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
 * Neither the name of University of the West of England, Bristol nor 
   the names of its contributors may be used to endorse or promote products
   derived from this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 DISCLAIMED. IN NO EVENT SHALL UNIVERSITY OF THE WEST OF ENGLAND, BRISTOL BE 
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
 This software makes use of third party libraries. For more information see:
 doc/license.txt included in the distribution.
 -------------------------------------------------------------------------------
 */

#ifndef PLONK_AUDIOFILEREADER_H
#define PLONK_AUDIOFILEREADER_H

#include "../../core/plonk_CoreForwardDeclarations.h"
#include "../../core/plonk_SmartPointer.h"
#include "../../core/plonk_WeakPointer.h"
#include "../../core/plonk_SenderContainer.h"
#include "../../core/plonk_SmartPointerContainer.h"
#include "../../containers/plonk_Text.h"
#include "../../core/plonk_Sender.h"
#include "plonk_AudioFile.h"
#include "plonk_AudioFileMetaData.h"


class AudioFileReaderInternal : public SmartPointer
{
public:
    typedef AudioFileReader Container;

    AudioFileReaderInternal() throw();
    AudioFileReaderInternal (const char* path, const int bufferSize, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw();
    AudioFileReaderInternal (ByteArray const& bytes, const int bufferSize, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw();
    AudioFileReaderInternal (FilePathArray const& paths, const AudioFile::MultiFileTypes multiMode, const int bufferSize) throw();
    AudioFileReaderInternal (FilePathArray const& paths, IntVariable const& indexRef, const int bufferSize) throw();
    AudioFileReaderInternal (AudioFileReaderArray const& audioFiles, const AudioFile::MultiFileTypes multiMode, const int bufferSize, IntVariable* indexRef = 0) throw();
    AudioFileReaderInternal (FilePathQueue const& paths, const int bufferSize) throw();
    AudioFileReaderInternal (AudioFileReaderQueue const& audioFiles, const int bufferSize) throw();
//    AudioFileReaderInternal (AudioFileReader const& original, const LongLong start, const LongLong end, const int bufferSize) throw();
    AudioFileReaderInternal (AudioFileReader const& original, AudioFileRegion const& region, const int bufferSize) throw();

    ~AudioFileReaderInternal();
    
    ResultCode open (const char* path, const int bufferSize, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw();
    
    AudioFile::Format getFormat() const throw();
    AudioFile::Encoding getEncoding() const throw();
    AudioFile::SampleType getSampleType() const throw();
    
    int getBitsPerSample() const throw();
    int getBytesPerFrame() const throw();
    int getBytesPerSample() const throw();
    int getNumChannels() const throw();
    int getDefaultNumChannels() throw();
    void setDefaultNumChannels (const int numChannels) throw();
    void setDefaultSampleRate (const double sampleRate) throw();
    double getDefaultSampleRate() const throw();
    double getSampleRate() const throw();
    
    ChannelLayout getChannelLayout() const throw();
    ChannelIdentifier getChannelIdentifier (const int channel) const throw();
    
    LongLong getNumFrames() const throw();
    LongLong getFramePosition() const throw();
    
    bool isPositionable() const throw();
    void setFramePosition (const LongLong position) throw();
    void resetFramePosition() throw();
    void setFramePositionOnNextRead (const LongLong position) throw();
    
    template<class SampleType>
    void readFrames (NumericalArray<SampleType>& data, const bool applyScaling, const bool deinterleave, IntVariable& numLoops) throw();
    
    template<class SampleType>
    inline void initSignal (SignalBase<SampleType>& signal, const int numFrames) const throw()
    {
        const int numChannels = getNumChannels();
        const int length = (numFrames > 0) ? numFrames * numChannels : (int)getNumFrames() * numChannels;
        NumericalArray<SampleType> buffer = NumericalArray<SampleType>::withSize (length);
        signal = SignalBase<SampleType> (buffer, getSampleRate(), numChannels);
    }
    
    template<class SampleType>
    inline void readSignal (SignalBase<SampleType>& signal, const bool applyScaling) throw()
    {
        // would need to decide in here to deinterleave..
        
        signal.getSampleRate().setValue (getSampleRate());
        IntVariable oneLoop (1);
        readFrames (signal.getBuffers().first(), applyScaling, false, oneLoop);
    }
    
    void setOwner (void* owner) throw();
    void* getOwner() const throw();
    bool isOwned() const throw();
    bool isReady() const throw();
    
    void disownPeer (PlankAudioFileReaderRef otherReader) throw();
    
    bool didHitEOF() const throw() { return hitEndOfFile; }
    bool didNumChannelsChange() const throw() { return numChannelsChanged; }
    bool didAudioFileChange() const throw() { return audioFileChanged; }
    
    void setName (Text const& name) throw();
    Text getName() const throw();
    
    bool hasMetaData() const throw();
    AudioFileMetaData getMetaData() const throw();
//    int getNumCuePoints() const throw();
//    bool getCuePointAtIndex (const int index, UnsignedInt& cueID, Text& label, LongLong& position) const throw();
    
    inline PlankAudioFileReaderRef getPeerRef() { return static_cast<PlankAudioFileReaderRef> (&peer); }
    inline const PlankAudioFileReaderRef getPeerRef() const { return const_cast<const PlankAudioFileReaderRef> (&peer); }

private:
    ResultCode init (const char* path, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw();
    ResultCode init (ByteArray const& bytes, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw();

    template<class Type>
    static inline void swapEndianIfNotNative (Type* data, const int numItems, const bool dataIsBigEndian) throw()
    {
#if PLONK_BIGENDIAN
        if (! dataIsBigEndian) Endian::swap (data, numItems);
#endif
#if PLONK_LITTLEENDIAN
        if (dataIsBigEndian) Endian::swap (data, numItems);
#endif
    }

    PlankAudioFileReader peer;
    Chars readBuffer;
    int numFramesPerBuffer;
    AtomicLongLong newPositionOnNextRead;
    AtomicValue<void*> owner;
    bool hitEndOfFile;
    bool numChannelsChanged;
    bool audioFileChanged;
    IntVariable nextMultiIndexRef;
    int defaultNumChannels;
    double defaultSampleRate;
};

//------------------------------------------------------------------------------

template<class SampleType>
void AudioFileReaderInternal::readFrames (NumericalArray<SampleType>& data,
                                          const bool applyScaling, 
                                          const bool deinterleave,
                                          IntVariable& numLoops) throw()
{        
    typedef NumericalArray<SampleType> Buffer;
    
    this->hitEndOfFile = false;
    this->numChannelsChanged = false;
    this->audioFileChanged = false;
    
    ResultCode result = PlankResult_OK;
    
    const int dataLength = data.length();
    int dataRemaining = dataLength;
    
    SampleType* dataArray = data.getArray();
    void* const readBufferArray = readBuffer.getArray();
    
    int encoding = getEncoding();
    int channels = getNumChannels();
    int bytesPerSample = getBytesPerSample();
    
    plonk_assert ((encoding >= AudioFile::EncodingMin) && (encoding <= AudioFile::EncodingMax));
    plonk_assert (getBitsPerSample() > 0);
    plonk_assert (channels > 0);
    plonk_assert (getBytesPerFrame() > 0);
    
    bool isPCM = encoding & AudioFile::EncodingFlagPCM;
    bool isFloat = encoding & AudioFile::EncodingFlagFloat;
    bool isBigEndian = encoding & AudioFile::EncodingFlagBigEndian;
    bool isInterleaved = !(encoding & AudioFile::EncodingFlagNonIntervleaved);
        
    int dataIndex = 0;
    const int numFailsAllowed = 3;
    int numFails = 0;
    
    if (!numFramesPerBuffer)
    {
        if (!getBytesPerFrame())
            goto exit;
        
        numFramesPerBuffer = readBuffer.length() / getBytesPerFrame();
    }
        
    while ((dataRemaining > 0) && 
           (result != PlankResult_FileEOF) &&
           (result != PlankResult_AudioFileFrameFormatChanged) &&
           (result != PlankResult_AudioFileChanged) &&
           (numFails < numFailsAllowed))
    {
        AtomicLongLong newPosition (-1);
        newPositionOnNextRead.swapWith (newPosition);
        
        if (newPosition.getValueUnchecked() >= 0)
        {
            result = pl_AudioFileReader_SetFramePosition (getPeerRef(), newPosition.getValueUnchecked());
            plonk_assert (result == PlankResult_OK); // just continue though in release
        }
        
        const int framesToRead = plonk::min (dataRemaining / channels, numFramesPerBuffer);
        
        if (framesToRead == 0)
            break; // not enough data left for one frame

        int framesRead;
        result = pl_AudioFileReader_ReadFrames (getPeerRef(), PLANK_FALSE, framesToRead, readBufferArray, &framesRead);
        plonk_assert ((result == PlankResult_OK) ||
                      (result == PlankResult_FileEOF) ||
                      (result == PlankResult_AudioFileFrameFormatChanged) ||
                      (result == PlankResult_AudioFileChanged));
        
        if (framesRead > 0)
        {
            const int samplesRead = framesRead * channels;
            plonk_assert (samplesRead <= dataRemaining);
            
            if (isPCM)
            {            
                if (bytesPerSample == 2)
                {
                    Short* const convertBuffer = static_cast<Short*> (readBufferArray); 
                    swapEndianIfNotNative (convertBuffer, samplesRead, isBigEndian);
                    Buffer::convert (dataArray, convertBuffer, samplesRead, applyScaling);
                }
                else if (bytesPerSample == 3)
                {
                    Int24* const convertBuffer = static_cast<Int24*> (readBufferArray); 
                    swapEndianIfNotNative (convertBuffer, samplesRead, isBigEndian);
                    Buffer::convert (dataArray, convertBuffer, samplesRead, applyScaling);
                }
                else if (bytesPerSample == 4)
                {
                    Int* const convertBuffer = static_cast<Int*> (readBufferArray); 
                    swapEndianIfNotNative (convertBuffer, samplesRead, isBigEndian);
                    Buffer::convert (dataArray, convertBuffer, samplesRead, applyScaling);
                }
                else if (bytesPerSample == 1)
                {
                    Char* const convertBuffer = static_cast<Char*> (readBufferArray); 
                    Buffer::convert (dataArray, convertBuffer, samplesRead, applyScaling);
                }
                else
                {
                    plonk_assertfalse;
                    return;
                }
            }
            else if (isFloat)
            {
                if (bytesPerSample == 4)
                {
                    Float* const convertBuffer = static_cast<Float*> (readBufferArray); 
                    swapEndianIfNotNative (convertBuffer, samplesRead, isBigEndian);
                    Buffer::convert (dataArray, convertBuffer, samplesRead, applyScaling);
                }
                else if (bytesPerSample == 8)
                {
                    Double* const convertBuffer = static_cast<Double*> (readBufferArray); 
                    swapEndianIfNotNative (convertBuffer, samplesRead, isBigEndian);
                    Buffer::convert (dataArray, convertBuffer, samplesRead, applyScaling);
                }
                else
                {
                    plonk_assertfalse;
                    return;
                }
            }
            
            if (deinterleave && isInterleaved)
            {
                plonk_assertfalse; // haven't tested this yet...
                SampleType* const deinterleaveBuffer = static_cast<SampleType*> (readBufferArray); 
                Buffer::deinterleave (deinterleaveBuffer, dataArray, samplesRead, channels);
                Buffer::copyData (dataArray, deinterleaveBuffer, samplesRead);
            }
            else if (!deinterleave && !isInterleaved)
            {
                plonk_assertfalse; // haven't tested this yet...
                SampleType* const interleaveBuffer = static_cast<SampleType*> (readBufferArray); 
                Buffer::interleave (interleaveBuffer, dataArray, samplesRead / channels, channels);
                Buffer::copyData (dataArray, interleaveBuffer, samplesRead);
            }
            
            dataArray += samplesRead;
            dataIndex += samplesRead;
            dataRemaining -= samplesRead;
        }
        else
        {
            numFails++;
        }
            
        if ((result == PlankResult_FileEOF) && ((numLoops.getValue() == 0) || (numLoops.getValue() > 1)))
        {
            result = pl_AudioFileReader_ResetFramePosition (getPeerRef());              
            plonk_assert (result == PlankResult_OK);
            
            if (numLoops.getValue() > 1)
                numLoops.setValue (numLoops.getValue() - 1);
        }
        else if (result == PlankResult_AudioFileFrameFormatChanged)
        {
            encoding = getEncoding();
            
            const int newNumChannels = getNumChannels();
            
            if (newNumChannels == channels)
            {
                result = PlankResult_AudioFileChanged;
            }
            else
            {
                channels = getNumChannels();
            }
            
            bytesPerSample = getBytesPerSample();
            
            plonk_assert ((encoding >= AudioFile::EncodingMin) && (encoding <= AudioFile::EncodingMax));
            plonk_assert (getBitsPerSample() > 0);
            plonk_assert (channels > 0);
            plonk_assert (getBytesPerFrame() > 0);
            
            isPCM = encoding & AudioFile::EncodingFlagPCM;
            isFloat = encoding & AudioFile::EncodingFlagFloat;
            isBigEndian = encoding & AudioFile::EncodingFlagBigEndian;
            isInterleaved = !(encoding & AudioFile::EncodingFlagNonIntervleaved);
            
            if (!getBytesPerFrame())
                goto exit;
            
            numFramesPerBuffer = readBuffer.length() / getBytesPerFrame();
        }
    }
    
exit:
    if (dataIndex < dataLength)
        data.setSize (dataIndex, true);
    
    this->hitEndOfFile       = (result == PlankResult_FileEOF);
    this->numChannelsChanged = (result == PlankResult_AudioFileFrameFormatChanged);
    this->audioFileChanged   = (result == PlankResult_AudioFileChanged);
}


//------------------------------------------------------------------------------

class AudioFileReader : public SmartPointerContainer<AudioFileReaderInternal>
{
public:
    typedef AudioFileReaderInternal                 Internal;
    typedef SmartPointerContainer<Internal>         Base;
    typedef WeakPointerContainer<AudioFileReader>   Weak;

    
    static const AudioFileReader& getNull() throw()
    {
        static AudioFileReader null;        
        return null;
    }
    
    AudioFileReader() throw()
    :   Base (new Internal())
    {
    }
    
        AudioFileReader (Text const& path) throw()
        :       Base (new Internal (path.getArray(), 0, AudioFileMetaDataIOFlags((UnsignedInt)AudioFile::MetaDataIOFlagsNone)))
        {
        }
        
        AudioFileReader (const char* path) throw()
        :       Base (new Internal (path, 0, AudioFileMetaDataIOFlags((UnsignedInt)AudioFile::MetaDataIOFlagsNone)))
        {
        }
    
        AudioFileReader (FilePath const& path) throw()
        :       Base (new Internal (path.fullpath().getArray(), 0, AudioFileMetaDataIOFlags((UnsignedInt)AudioFile::MetaDataIOFlagsNone)))
        {
        }
    
    AudioFileReader (FilePath const& path, const int bufferSize, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw()
        :       Base (new Internal (path.fullpath().getArray(), bufferSize, metaDataIOFlags))
        {
        }
    
        AudioFileReader (const char* path, const int bufferSize, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw()
        :       Base (new Internal (path, bufferSize, metaDataIOFlags))
        {
        }

    AudioFileReader (FilePath const& path, const int bufferSize, UnsignedInt const& metaDataIOFlags) throw()
        :       Base (new Internal (path.fullpath().getArray(), bufferSize, AudioFileMetaDataIOFlags (metaDataIOFlags)))
        {
        }
    
        AudioFileReader (const char* path, const int bufferSize, UnsignedInt const& metaDataIOFlags) throw()
        :       Base (new Internal (path, bufferSize, AudioFileMetaDataIOFlags (metaDataIOFlags)))
        {
        }

        AudioFileReader (FilePathArray const& paths, const AudioFile::MultiFileTypes multiMode = AudioFile::MultiFileArraySequenceLoop, const int bufferSize = 0) throw()
        :       Base (new Internal (paths, multiMode, bufferSize))
        {
        }
    
        AudioFileReader (FilePathArray const& paths, IntVariable const& nextIndex, const int bufferSize = 0) throw()
        :       Base (new Internal (paths, nextIndex, bufferSize))
        {
        }
    
    AudioFileReader (AudioFileReaderArray const& audioFiles, const AudioFile::MultiFileTypes multiMode, const int bufferSize = 0, IntVariable* indexRef = 0) throw()
        :       Base (new Internal (audioFiles, multiMode, bufferSize, indexRef))
    {
    }

    AudioFileReader (FilePathQueue const& paths, const int bufferSize = 0) throw()
    :   Base (new Internal (paths, bufferSize))
    {
    }
    
    AudioFileReader (AudioFileReaderQueue const& audioFiles, const int bufferSize = 0) throw()
    :   Base (new Internal (audioFiles, bufferSize))
    {
    }
    
    AudioFileReader (AudioFileReader const& original, AudioFileRegion const region, const int bufferSize = 0) throw()
    :   Base (new Internal (original, region, bufferSize))
    {
    }
    
//    AudioFileReader (AudioFileReader const& original, const LongLong start, const LongLong end, const int bufferSize = 0) throw()
//    : Base (new Internal (original, start, end, bufferSize))
//    {
//    }
//    
//    AudioFileReader (AudioFileReader const& original, const int start, const int end, const int bufferSize = 0) throw()
//    : Base (new Internal (original, start, end, bufferSize))
//    {
//    }
//    
//    AudioFileReader (AudioFileReader const& original, const long start, const long end, const int bufferSize = 0) throw()
//    : Base (new Internal (original, start, end, bufferSize))
//    {
//    }
//
    AudioFileReader (AudioFileReader const& original, const double start, const double end, const int bufferSize = 0) throw()
    :   Base (new Internal (original,
                            AudioFileRegion (0, start, end, -1.0),
                            bufferSize))
    {
    }
//
//    AudioFileReader (AudioFileReader const& original, const float start, const float end, const int bufferSize = 0) throw()
//    : Base (new Internal (original,
//                            LongLong (start * original.getSampleRate()),
//                            LongLong (end * original.getSampleRate()),
//                            bufferSize))
//    {
//    }

    explicit AudioFileReader (Internal* internalToUse) throw() 
        :       Base (internalToUse)
        {
        }    
    
    AudioFileReader (AudioFileReader const& copy) throw()
    :   Base (static_cast<Base const&> (copy))
    {
    }
    
    AudioFileReader (ByteArray const& bytes, const int bufferSize = 0, AudioFileMetaDataIOFlags const& metaDataIOFlags = AudioFileMetaDataIOFlags ((UnsignedInt)AudioFile::MetaDataIOFlagsNone)) throw()
        :       Base (new Internal (bytes, bufferSize, metaDataIOFlags))
        {
        }
    
    AudioFileReader (ByteArray const& bytes, const int bufferSize = 0, UnsignedInt const& metaDataIOFlags = AudioFile::MetaDataIOFlagsNone) throw()
        :       Base (new Internal (bytes, bufferSize, AudioFileMetaDataIOFlags (metaDataIOFlags)))
        {
        }
    
    AudioFileReader& operator= (AudioFileReader const& other) throw()
        {
                if (this != &other)
            this->setInternal (other.getInternal());
        
        return *this;
        }
    
    static AudioFileReader fromWeak (Weak const& weak) throw()
    {
        return weak.fromWeak();
    }    
    
    inline AudioFile::Format getFormat() const throw()
    {
        return getInternal()->getFormat();
    }
    
    inline AudioFile::Encoding getEncoding() const throw()
    {
        return getInternal()->getEncoding();
    }
    
    inline AudioFile::SampleType getSampleType() const throw()
    {
        return getInternal()->getSampleType();   
    }
    
    inline int getBitsPerSample() const throw()
    {
        return getInternal()->getBitsPerSample();
    }
    
    inline int getBytesPerFrame() const throw()
    {
        return getInternal()->getBytesPerFrame();
    }
    
    inline int getBytesPerSample() const throw()
    {
        return getInternal()->getBytesPerSample();
    }
    
    inline int getNumChannels() const throw()
    {
        return getInternal()->getNumChannels();
    }
    
    inline void setDefaultNumChannels (const int numChannels) throw()
    {
        getInternal()->setDefaultNumChannels (numChannels);
    }

    inline int getDefaultNumChannels() const throw()
    {
        return getInternal()->getDefaultNumChannels();
    }
    
    inline void setDefaultSampleRate (const double sampleRate) throw()
    {
        getInternal()->setDefaultSampleRate (sampleRate);
    }

    inline double getDefaultSampleRate() const throw()
    {
        return getInternal()->getDefaultSampleRate();
    }

    inline double getSampleRate() const throw()
    {
        return getInternal()->getSampleRate();
    }
    
    inline LongLong getNumFrames() const throw()
    {
        return getInternal()->getNumFrames();
    }
    
    inline bool isPositionable() const throw()
    {
        return getInternal()->isPositionable();
    }
    
    inline LongLong getFramePosition() const throw()
    {
        return getInternal()->getFramePosition();
    }
    
    inline void setFramePosition (const LongLong position) throw()
    {
        getInternal()->setFramePosition (position);
    }
    
    inline void setFramePositionOnNextRead (const LongLong position) throw()
    {
        getInternal()->setFramePositionOnNextRead (position);
    }
    
    inline void resetFramePosition() throw()
    {
        getInternal()->resetFramePosition();
    }
    
    inline double getDuration() const throw()
    {
        return getInternal()->getNumFrames() / getInternal()->getSampleRate();
    }
        
    inline double getTime() const throw()
    {
        return getInternal()->getFramePosition() / getInternal()->getSampleRate();
    }
    
    inline void setTime (const double time) throw()
    {
        getInternal()->setFramePosition (LongLong (time * getInternal()->getSampleRate()));
    }
    
    inline void setTimeOnNextRead (const double time) throw()
    {
        getInternal()->setFramePositionOnNextRead (LongLong (time * getInternal()->getSampleRate()));
    }
    
    template<class SampleType>
    inline void readFrames (NumericalArray<SampleType>& data, IntVariable& numLoops) throw()
    {
        getInternal()->readFrames (data, true, false, numLoops);
    }
    
    template<class SampleType>
    inline void readFrames (NumericalArray<SampleType>& data) throw()
    {
        IntVariable numLoops (1);
        getInternal()->readFrames (data, true, false, numLoops);
    }
    
    template<class SampleType>
    inline void readFramesDirect (NumericalArray<SampleType>& data, IntVariable& numLoops) throw()
    {
        getInternal()->readFrames (data, false, false, numLoops);
    }
    
    template<class SampleType>
    inline void readFramesDirect (NumericalArray<SampleType>& data) throw()
    {
        IntVariable numLoops (1);
        getInternal()->readFrames (data, false, false, numLoops);
    }
    
    template<class SampleType>
    void initSignal (SignalBase<SampleType>& signal, const int numFrames = 0) const throw()
    {
        getInternal()->initSignal (signal, numFrames);
    }
    
    template<class SampleType>
    inline void readSignal (SignalBase<SampleType>& signal) throw()
    {
        plonk_assert (signal.isInterleaved());
        getInternal()->readSignal (signal, true);
    }
    
    template<class SampleType>
    inline void readSignalDirect (SignalBase<SampleType>& signal) throw()
    {
        plonk_assert (signal.isInterleaved());
        getInternal()->readSignal (signal, false);
    }
    
    template<class SampleType>
    inline NumericalArray<SampleType> readAllFrames (const bool applyScaling) throw()
    {
        typedef NumericalArray<SampleType> SampleArray;
        SampleArray data = SampleArray::withSize ((int)getNumFrames() * getNumChannels());
        resetFramePosition();
        IntVariable oneLoop (1);
        getInternal()->readFrames (data, applyScaling, false, oneLoop);
        return data;
    }

    template<class SampleType>
    inline operator NumericalArray<SampleType> () throw()
    {
        return readAllFrames<SampleType> (true);
    }
    
    template<class SampleType>
    inline operator SignalBase<SampleType> () throw()
    {
        NumericalArray<SampleType> data = readAllFrames<SampleType> (true);
        return SignalBase<SampleType> (data, getSampleRate(), getNumChannels());
    }
    
    template<class SampleType>
    inline SignalBase<SampleType> getOtherSignal() throw()
    {
        NumericalArray<SampleType> data = readAllFrames<SampleType> (true);
        return SignalBase<SampleType> (data, getSampleRate(), getNumChannels());
    }
    
    inline SignalBase<PLONK_TYPE_DEFAULT> getSignal() throw()
    {
        return getOtherSignal<PLONK_TYPE_DEFAULT>();
    }    
    
    void setOwner (void* owner) throw()
    {
        getInternal()->setOwner (owner);
    }
    
    void* getOwner() const throw()
    {
        return getInternal()->getOwner();
    }
    
    bool isOwned() const throw()
    {
        return getInternal()->isOwned();
    }
    
    bool isReady() const throw()
    {
        return getInternal()->isReady();
    }
    
    void disownPeer (PlankAudioFileReaderRef otherReader) throw()
    {
        getInternal()->disownPeer (otherReader);
    }
    
    bool didHitEOF() const throw()
    {
        return getInternal()->didHitEOF();
    }
    
    bool didNumChannelsChange() const throw()
    {
        return getInternal()->didNumChannelsChange();
    }
    
    bool didAudioFileChange() const throw()
    {
        return getInternal()->didAudioFileChange();
    }
    
    AudioFileReaderArray regionsFromMetaData (const int metaDataOption, const int bufferSize = 0) throw();
    
    void setName (Text const& name) throw()
    {
        getInternal()->setName (name);
    }
    
    Text getName() const throw()
    {
        return getInternal()->getName();
    }

    bool hasMetaData() const throw()
    {
        return this->getInternal()->hasMetaData();
    }
    
    AudioFileMetaData getMetaData() const throw()
    {
        return this->getInternal()->getMetaData();
    }
    
    inline ChannelLayout getChannelLayout() const throw()
    {
        return this->getInternal()->getChannelLayout();
    }
    
    inline ChannelIdentifier getChannelIdentifier (const int channel) const throw()
    {
        return this->getInternal()->getChannelIdentifier (channel);
    }


private:
    // these could be currently dangerous across threads, need to look at a safer way to open
    // a new file once one is already running...
    
    ResultCode open (const char* path, const int bufferSize, AudioFileMetaDataIOFlags const& metaDataIOFlags) throw()
    {
        return getInternal()->open (path, bufferSize, metaDataIOFlags);
    }
    
    ResultCode open (Text const& path) throw()
    {
        return getInternal()->open (path.getArray(), 0, AudioFileMetaDataIOFlags((UnsignedInt)AudioFile::MetaDataIOFlagsNone));
    }    
};



#endif // PLONK_AUDIOFILEREADER_H