/*
* SampleIO.h
* ----------
* Purpose: Central code for reading and writing samples. Create your SampleIO object and have a go at the ReadSample and WriteSample functions!
* Notes : Not all combinations of possible sample format combinations are implemented, especially for WriteSample.
* Using the existing generic sample conversion functors in SampleFormatConverters.h, it should be quite easy to extend the code, though.
* Authors: Olivier Lapicque
* OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#pragma once
#include "BuildSettings.h"
#include "../common/FileReaderFwd.h"
OPENMPT_NAMESPACE_BEGIN
struct ModSample;
// Sample import / export formats
class SampleIO
{
public:
// Bits per sample
enum Bitdepth : uint8
{
_8bit = 8,
_16bit = 16,
_24bit = 24,
_32bit = 32,
_64bit = 64,
};
// Number of channels + channel format
enum Channels : uint8
{
mono = 1,
stereoInterleaved, // LRLRLR...
stereoSplit, // LLL...RRR...
};
// Sample byte order
enum Endianness : uint8
{
littleEndian = 0,
bigEndian = 1,
};
// Sample encoding
enum Encoding : uint8
{
signedPCM = 0, // Integer PCM, signed
unsignedPCM, // Integer PCM, unsigned
deltaPCM, // Integer PCM, delta-encoded
floatPCM, // Floating point PCM
IT214, // Impulse Tracker 2.14 compressed
IT215, // Impulse Tracker 2.15 compressed
AMS, // AMS / Velvet Studio packed
DMF, // DMF Huffman compression
MDL, // MDL Huffman compression
PTM8Dto16, // PTM 8-Bit delta value -> 16-Bit sample
PCM7to8, // 8-Bit sample data with unused high bit
ADPCM, // 4-Bit ADPCM-packed
MT2, // MadTracker 2 stereo delta encoding
floatPCM15, // Floating point PCM with 2^15 full scale
floatPCM23, // Floating point PCM with 2^23 full scale
floatPCMnormalize, // Floating point PCM and data will be normalized while reading
signedPCMnormalize, // Integer PCM and data will be normalized while reading
uLaw, // 8-to-16 bit G.711 u-law compression
aLaw, // 8-to-16 bit G.711 a-law compression
};
protected:
Bitdepth m_bitdepth;
Channels m_channels;
Endianness m_endianness;
Encoding m_encoding;
public:
constexpr SampleIO(Bitdepth bits = _8bit, Channels channels = mono, Endianness endianness = littleEndian, Encoding encoding = signedPCM)
: m_bitdepth(bits), m_channels(channels), m_endianness(endianness), m_encoding(encoding)
{ }
bool operator== (const SampleIO &other) const
{
return memcmp(this, &other, sizeof(*this)) == 0;
}
bool operator!= (const SampleIO &other) const
{
return memcmp(this, &other, sizeof(*this)) != 0;
}
void operator|= (Bitdepth bits)
{
m_bitdepth = bits;
}
void operator|= (Channels channels)
{
m_channels = channels;
}
void operator|= (Endianness endianness)
{
m_endianness = endianness;
}
void operator|= (Encoding encoding)
{
m_encoding = encoding;
}
void MayNormalize()
{
if(GetBitDepth() >= 24)
{
if(GetEncoding() == SampleIO::signedPCM)
{
m_encoding = SampleIO::signedPCMnormalize;
} else if(GetEncoding() == SampleIO::floatPCM)
{
m_encoding = SampleIO::floatPCMnormalize;
}
}
}
// Return 0 in case of variable-length encoded samples.
MPT_CONSTEXPR14_FUN uint8 GetEncodedBitsPerSample() const
{
switch(GetEncoding())
{
case signedPCM: // Integer PCM, signed
case unsignedPCM: //Integer PCM, unsigned
case deltaPCM: // Integer PCM, delta-encoded
case floatPCM: // Floating point PCM
case MT2: // MadTracker 2 stereo delta encoding
case floatPCM15: // Floating point PCM with 2^15 full scale
case floatPCM23: // Floating point PCM with 2^23 full scale
case floatPCMnormalize: // Floating point PCM and data will be normalized while reading
case signedPCMnormalize: // Integer PCM and data will be normalized while reading
return GetBitDepth();
case IT214: // Impulse Tracker 2.14 compressed
case IT215: // Impulse Tracker 2.15 compressed
case AMS: // AMS / Velvet Studio packed
case DMF: // DMF Huffman compression
case MDL: // MDL Huffman compression
return 0; // variable-length compressed
case PTM8Dto16: // PTM 8-Bit delta value -> 16-Bit sample
return 16;
case PCM7to8: // 8-Bit sample data with unused high bit
return 8;
case ADPCM: // 4-Bit ADPCM-packed
return 4;
case uLaw: // G.711 u-law
return 8;
case aLaw: // G.711 a-law
return 8;
default:
return 0;
}
}
// Return the static header size additional to the raw encoded sample data.
MPT_CONSTEXPR14_FUN std::size_t GetEncodedHeaderSize() const
{
switch(GetEncoding())
{
case ADPCM:
return 16;
default:
return 0;
}
}
// Returns true if the encoded size cannot be calculated apriori from the encoding format and the sample length.
MPT_CONSTEXPR14_FUN bool IsVariableLengthEncoded() const
{
return GetEncodedBitsPerSample() == 0;
}
// Returns true if the decoder for a given format uses FileReader interface and thus do not need to call GetPinnedRawDataView()
MPT_CONSTEXPR14_FUN bool UsesFileReaderForDecoding() const
{
switch(GetEncoding())
{
case IT214:
case IT215:
case AMS:
case DMF:
case MDL:
return true;
default:
return false;
}
}
// Get bits per sample
constexpr uint8 GetBitDepth() const
{
return static_cast<uint8>(m_bitdepth);
}
// Get channel layout
constexpr Channels GetChannelFormat() const
{
return m_channels;
}
// Get number of channels
constexpr uint8 GetNumChannels() const
{
return GetChannelFormat() == mono ? 1u : 2u;
}
// Get sample byte order
constexpr Endianness GetEndianness() const
{
return m_endianness;
}
// Get sample format / encoding
constexpr Encoding GetEncoding() const
{
return m_encoding;
}
// Returns the encoded size of the sample. In case of variable-length encoding returns 0.
std::size_t CalculateEncodedSize(SmpLength length) const
{
if(IsVariableLengthEncoded())
{
return 0;
}
uint8 bps = GetEncodedBitsPerSample();
if(bps % 8u != 0)
{
MPT_ASSERT(GetEncoding() == ADPCM && bps == 4);
return GetEncodedHeaderSize() + (((length + 1) / 2) * GetNumChannels()); // round up
}
return GetEncodedHeaderSize() + (length * (bps / 8) * GetNumChannels());
}
// Read a sample from memory
size_t ReadSample(ModSample &sample, FileReader &file) const;
#ifndef MODPLUG_NO_FILESAVE
// Write a sample to file
size_t WriteSample(std::ostream &f, const ModSample &sample, SmpLength maxSamples = 0) const;
#endif // MODPLUG_NO_FILESAVE
};
OPENMPT_NAMESPACE_END