juce_AudioFormatReader.h

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   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
{
 
class AudioFormat;
 
 
//==============================================================================
class JUCE_API  AudioFormatReader
{
protected:
    //==============================================================================
    AudioFormatReader (InputStream* sourceStream,
                       const String& formatName);
 
public:
    virtual ~AudioFormatReader();
 
    //==============================================================================
    const String& getFormatName() const noexcept    { return formatName; }
 
    //==============================================================================
    bool read (float* const* destChannels, int numDestChannels,
               int64 startSampleInSource, int numSamplesToRead);
 
    bool read (int* const* destChannels,
               int numDestChannels,
               int64 startSampleInSource,
               int numSamplesToRead,
               bool fillLeftoverChannelsWithCopies);
 
    bool read (AudioBuffer<float>* buffer,
               int startSampleInDestBuffer,
               int numSamples,
               int64 readerStartSample,
               bool useReaderLeftChan,
               bool useReaderRightChan);
 
    virtual void readMaxLevels (int64 startSample, int64 numSamples,
                                Range<float>* results, int numChannelsToRead);
 
    virtual void readMaxLevels (int64 startSample, int64 numSamples,
                                float& lowestLeft,  float& highestLeft,
                                float& lowestRight, float& highestRight);
 
    int64 searchForLevel (int64 startSample,
                          int64 numSamplesToSearch,
                          double magnitudeRangeMinimum,
                          double magnitudeRangeMaximum,
                          int minimumConsecutiveSamples);
 
 
    //==============================================================================
    double sampleRate = 0;
 
    unsigned int bitsPerSample = 0;
 
    int64 lengthInSamples = 0;
 
    unsigned int numChannels = 0;
 
    bool usesFloatingPointData = false;
 
    StringPairArray metadataValues;
 
    InputStream* input;
 
    //==============================================================================
    virtual AudioChannelSet getChannelLayout();
 
    //==============================================================================
    virtual bool readSamples (int* const* destChannels,
                              int numDestChannels,
                              int startOffsetInDestBuffer,
                              int64 startSampleInFile,
                              int numSamples) = 0;
 
 
protected:
    //==============================================================================
    template <class DestSampleType, class SourceSampleType, class SourceEndianness>
    struct ReadHelper
    {
        using DestType   = AudioData::Pointer<DestSampleType,   AudioData::NativeEndian, AudioData::NonInterleaved, AudioData::NonConst>;
        using SourceType = AudioData::Pointer<SourceSampleType, SourceEndianness, AudioData::Interleaved, AudioData::Const>;
 
        template <typename TargetType>
        static void read (TargetType* const* destData, int destOffset, int numDestChannels,
                          const void* sourceData, int numSourceChannels, int numSamples) noexcept
        {
            for (int i = 0; i < numDestChannels; ++i)
            {
                if (void* targetChan = destData[i])
                {
                    DestType dest (targetChan);
                    dest += destOffset;
 
                    if (i < numSourceChannels)
                        dest.convertSamples (SourceType (addBytesToPointer (sourceData, i * SourceType::getBytesPerSample()), numSourceChannels), numSamples);
                    else
                        dest.clearSamples (numSamples);
                }
            }
        }
    };
 
    static void clearSamplesBeyondAvailableLength (int* const* destChannels, int numDestChannels,
                                                   int startOffsetInDestBuffer, int64 startSampleInFile,
                                                   int& numSamples, int64 fileLengthInSamples)
    {
        if (destChannels == nullptr)
        {
            jassertfalse;
            return;
        }
 
        const int64 samplesAvailable = fileLengthInSamples - startSampleInFile;
 
        if (samplesAvailable < numSamples)
        {
            for (int i = numDestChannels; --i >= 0;)
                if (destChannels[i] != nullptr)
                    zeromem (destChannels[i] + startOffsetInDestBuffer, (size_t) numSamples * sizeof (int));
 
            numSamples = (int) samplesAvailable;
        }
    }
 
private:
    String formatName;
 
    JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioFormatReader)
};
 
} // namespace juce