Datasets:
shibing624
/
source_code

Dataset card Data Studio Files Community
2
text
stringlengths
0
2.2M
private:
const bool littleEndian;
template <typename SampleType>
void scanMinAndMax (int64 startSampleInFile, int64 numSamples, Range<float>* results, int numChannelsToRead) const noexcept
{
for (int i = 0; i < numChannelsToRead; ++i)
results[i] = scanMinAndMaxForChannel<SampleType> (i, startSampleInFile, numSamples);
}
template <typename SampleType>
Range<float> scanMinAndMaxForChannel (int channel, int64 startSampleInFile, int64 numSamples) const noexcept
{
return littleEndian ? scanMinAndMaxInterleaved<SampleType, AudioData::LittleEndian> (channel, startSampleInFile, numSamples)
: scanMinAndMaxInterleaved<SampleType, AudioData::BigEndian> (channel, startSampleInFile, numSamples);
}
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (MemoryMappedAiffReader)
};
//==============================================================================
AiffAudioFormat::AiffAudioFormat() : AudioFormat (aiffFormatName, ".aiff .aif") {}
AiffAudioFormat::~AiffAudioFormat() {}
Array<int> AiffAudioFormat::getPossibleSampleRates()
{
return { 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000 };
}
Array<int> AiffAudioFormat::getPossibleBitDepths()
{
return { 8, 16, 24 };
}
bool AiffAudioFormat::canDoStereo() { return true; }
bool AiffAudioFormat::canDoMono() { return true; }
#if JUCE_MAC
bool AiffAudioFormat::canHandleFile (const File& f)
{
if (AudioFormat::canHandleFile (f))
return true;
auto type = f.getMacOSType();
// (NB: written as hex to avoid four-char-constant warnings)
return type == 0x41494646 /* AIFF */ || type == 0x41494643 /* AIFC */
|| type == 0x61696666 /* aiff */ || type == 0x61696663 /* aifc */;
}
#endif
AudioFormatReader* AiffAudioFormat::createReaderFor (InputStream* sourceStream, bool deleteStreamIfOpeningFails)
{
std::unique_ptr<AiffAudioFormatReader> w (new AiffAudioFormatReader (sourceStream));
if (w->sampleRate > 0 && w->numChannels > 0)
return w.release();
if (! deleteStreamIfOpeningFails)
w->input = nullptr;
return nullptr;
}
MemoryMappedAudioFormatReader* AiffAudioFormat::createMemoryMappedReader (const File& file)
{
return createMemoryMappedReader (file.createInputStream().release());
}
MemoryMappedAudioFormatReader* AiffAudioFormat::createMemoryMappedReader (FileInputStream* fin)
{
if (fin != nullptr)
{
AiffAudioFormatReader reader (fin);
if (reader.lengthInSamples > 0)
return new MemoryMappedAiffReader (fin->getFile(), reader);
}
return nullptr;
}
AudioFormatWriter* AiffAudioFormat::createWriterFor (OutputStream* out,
double sampleRate,
unsigned int numberOfChannels,
int bitsPerSample,
const StringPairArray& metadataValues,
int /*qualityOptionIndex*/)
{
if (out != nullptr && getPossibleBitDepths().contains (bitsPerSample))
return new AiffAudioFormatWriter (out, sampleRate, numberOfChannels,
(unsigned int) bitsPerSample, metadataValues);
return nullptr;
}
} // namespace juce