Azahar-Mirror/soundtouch
1
0
Fork 0
mirror of https://github.com/azahar-emu/soundtouch synced 2025-11-08 16:10:10 +01:00
Code Issues Packages Projects Releases Wiki Activity

Added wav file support for 24/32 bit samples, as far as data is read into floating point variables.

Browse Source
This commit is contained in:
oparviai 2012-08-22 20:33:50 +00:00
parent 657d07b5e6
commit f7ad193e4d
2 changed files with 254 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

294
source/SoundStretch/WavFile.cpp
View File

@ -84,29 +84,31 @@ static const char dataStr[] = "data";
// big-endian CPU, swap bytes in 16 & 32 bit words // big-endian CPU, swap bytes in 16 & 32 bit words
// helper-function to swap byte-order of 32bit integer // helper-function to swap byte-order of 32bit integer
static inline void _swap32(unsigned int &dwData) static inline long _swap32(long &dwData)
{ {
dwData = ((dwData >> 24) & 0x000000FF) | dwData = ((dwData >> 24) & 0x000000FF) |
((dwData >> 8) & 0x0000FF00) | ((dwData >> 8) & 0x0000FF00) |
((dwData << 8) & 0x00FF0000) | ((dwData << 8) & 0x00FF0000) |
((dwData << 24) & 0xFF000000); ((dwData << 24) & 0xFF000000);
return dwData;
} }
// helper-function to swap byte-order of 16bit integer // helper-function to swap byte-order of 16bit integer
static inline void _swap16(unsigned short &wData) static inline short _swap16(short &wData)
{ {
wData = ((wData >> 8) & 0x00FF) | wData = ((wData >> 8) & 0x00FF) |
((wData << 8) & 0xFF00); ((wData << 8) & 0xFF00);
return wData;
} }
// helper-function to swap byte-order of buffer of 16bit integers // helper-function to swap byte-order of buffer of 16bit integers
static inline void _swap16Buffer(unsigned short *pData, unsigned int dwNumWords) static inline void _swap16Buffer(short *pData, int numWords)
{ {
unsigned long i; int i;
for (i = 0; i < dwNumWords; i ++) for (i = 0; i < numWords; i ++)
{ {
_swap16(pData[i]); pData[i] = _swap16(pData[i]);
} }
} }
@ -114,19 +116,21 @@ static const char dataStr[] = "data";
// little-endian CPU, WAV file is ok as such // little-endian CPU, WAV file is ok as such
// dummy helper-function // dummy helper-function
static inline void _swap32(unsigned int &dwData) static inline long _swap32(long &dwData)
{ {
// do nothing // do nothing
return dwData;
} }
// dummy helper-function // dummy helper-function
static inline void _swap16(unsigned short &wData) static inline short _swap16(short &wData)
{ {
// do nothing // do nothing
return wData;
} }
// dummy helper-function // dummy helper-function
static inline void _swap16Buffer(unsigned short *pData, unsigned int dwNumBytes) static inline void _swap16Buffer(short *pData, int numBytes)
{ {
// do nothing // do nothing
} }
@ -134,6 +138,39 @@ static const char dataStr[] = "data";
#endif // BIG_ENDIAN #endif // BIG_ENDIAN
//////////////////////////////////////////////////////////////////////////////
//
// Class WavFileBase
//
WavFileBase::WavFileBase()
{
convBuff = NULL;
convBuffSize = 0;
}
WavFileBase::~WavFileBase()
{
delete[] convBuff;
convBuffSize = 0;
}
/// Get pointer to conversion buffer of at min. given size
void *WavFileBase::getConvBuffer(int sizeBytes)
{
if (convBuffSize < sizeBytes)
{
delete[] convBuff;
convBuffSize = (sizeBytes + 15) & -8;
convBuff = new char[convBuffSize];
}
return convBuff;
}
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
// //
// Class WavInFile // Class WavInFile
@ -188,11 +225,13 @@ void WavInFile::init()
ST_THROW_RT_ERROR(msg.c_str()); ST_THROW_RT_ERROR(msg.c_str());
} }
/* Ignore 'fixed' field value as 32bit signed linear data can have other value than 1.
if (header.format.fixed != 1) if (header.format.fixed != 1)
{ {
string msg = "Input file uses unsupported encoding."; string msg = "Input file uses unsupported encoding.";
ST_THROW_RT_ERROR(msg.c_str()); ST_THROW_RT_ERROR(msg.c_str());
} }
*/
dataRead = 0; dataRead = 0;
} }
@ -268,7 +307,7 @@ int WavInFile::read(short *buffer, int maxElems)
if (header.format.bits_per_sample == 8) if (header.format.bits_per_sample == 8)
{ {
// 8 bit format // 8 bit format
char *temp = new char[maxElems]; char *temp = (char*)getConvBuffer(maxElems);
int i; int i;
numElems = read(temp, maxElems); numElems = read(temp, maxElems);
@ -277,7 +316,6 @@ int WavInFile::read(short *buffer, int maxElems)
{ {
buffer[i] = temp[i] << 8; buffer[i] = temp[i] << 8;
} }
delete[] temp;
} }
else else
{ {
@ -307,33 +345,106 @@ int WavInFile::read(short *buffer, int maxElems)
numElems = numBytes / 2; numElems = numBytes / 2;
// 16bit samples, swap byte order if necessary // 16bit samples, swap byte order if necessary
_swap16Buffer((unsigned short *)buffer, numElems); _swap16Buffer((short *)buffer, numElems);
} }
return numElems; return numElems;
} }
/// Read data in float format. Notice that when reading in float format
/// 8/16/24/32 bit sample formats are supported
int WavInFile::read(float *buffer, int maxElems) int WavInFile::read(float *buffer, int maxElems)
{ {
short *temp = new short[maxElems]; unsigned int afterDataRead;
int num; int numBytes;
int i; int numElems;
double fscale; int bytesPerSample;
num = read(temp, maxElems); assert(buffer);
fscale = 1.0 / 32768.0; bytesPerSample = header.format.bits_per_sample / 8;
// convert to floats, scale to range [-1..+1[ if ((bytesPerSample < 1) || (bytesPerSample > 4))
for (i = 0; i < num; i ++)
{ {
buffer[i] = (float)(fscale * (double)temp[i]); stringstream ss;
ss << "\nOnly 8/16/24/32 bit sample WAV files supported. Can't open WAV file with ";
ss << (int)header.format.bits_per_sample;
ss << " bit sample format. ";
ST_THROW_RT_ERROR(ss.str().c_str());
} }
delete[] temp; numBytes = maxElems * bytesPerSample;
afterDataRead = dataRead + numBytes;
if (afterDataRead > header.data.data_len)
{
// Don't read more samples than are marked available in header
numBytes = (int)header.data.data_len - (int)dataRead;
assert(numBytes >= 0);
}
return num; // read raw data into temporary buffer
char *temp = (char*)getConvBuffer(numBytes);
numBytes = fread(temp, 1, numBytes, fptr);
dataRead += numBytes;
numElems = numBytes / bytesPerSample;
// swap byte ordert & convert to float, depending on sample format
switch (bytesPerSample)
{
case 1:
{
char *temp2 = temp;
double conv = 1.0 / 128;
for (int i = 0; i < numElems; i ++)
{
buffer[i] = (float)(temp2[i] * conv);
}
break;
}
case 2:
{
short *temp2 = (short*)temp;
double conv = 1.0 / 32768;
for (int i = 0; i < numElems; i ++)
{
short value = temp2[i];
buffer[i] = (float)(_swap16(value) * conv);
}
break;
}
case 3:
{
char *temp2 = (char *)temp;
double conv = 1.0 / 8388608;
for (int i = 0; i < numElems; i ++)
{
long value = *((long*)temp2);
value = _swap32(value) & 0x00ffffff; // take 24 bits
value |= (value & 0x00800000) ? 0xff000000 : 0; // extend minus sign bits
buffer[i] = (float)(value * conv);
temp2 += 3;
}
break;
}
case 4:
{
long *temp2 = (long *)temp;
double conv = 1.0 / 2147483648;
assert(sizeof(long) == 4);
for (int i = 0; i < numElems; i ++)
{
long value = temp2[i];
buffer[i] = (float)(_swap32(value) * conv);
}
break;
}
}
return numElems;
} }
@ -374,7 +485,7 @@ int WavInFile::readRIFFBlock()
if (fread(&(header.riff), sizeof(WavRiff), 1, fptr) != 1) return -1; if (fread(&(header.riff), sizeof(WavRiff), 1, fptr) != 1) return -1;
// swap 32bit data byte order if necessary // swap 32bit data byte order if necessary
_swap32((unsigned int &)header.riff.package_len); _swap32((long &)header.riff.package_len);
// header.riff.riff_char should equal to 'RIFF'); // header.riff.riff_char should equal to 'RIFF');
if (memcmp(riffStr, header.riff.riff_char, 4) != 0) return -1; if (memcmp(riffStr, header.riff.riff_char, 4) != 0) return -1;
@ -401,7 +512,7 @@ int WavInFile::readHeaderBlock()
// Decode blocks according to their label // Decode blocks according to their label
if (strcmp(label, fmtStr) == 0) if (strcmp(label, fmtStr) == 0)
{ {
int nLen, nDump; long nLen, nDump;
// 'fmt ' block // 'fmt ' block
memcpy(header.format.fmt, fmtStr, 4); memcpy(header.format.fmt, fmtStr, 4);
@ -409,7 +520,7 @@ int WavInFile::readHeaderBlock()
// read length of the format field // read length of the format field
if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1; if (fread(&nLen, sizeof(int), 1, fptr) != 1) return -1;
// swap byte order if necessary // swap byte order if necessary
_swap32((unsigned int &)nLen); // int format_len; _swap32(nLen); // int format_len;
header.format.format_len = nLen; header.format.format_len = nLen;
// calculate how much length differs from expected // calculate how much length differs from expected
@ -425,12 +536,12 @@ int WavInFile::readHeaderBlock()
if (fread(&(header.format.fixed), nLen, 1, fptr) != 1) return -1; if (fread(&(header.format.fixed), nLen, 1, fptr) != 1) return -1;
// swap byte order if necessary // swap byte order if necessary
_swap16((unsigned short &)header.format.fixed); // short int fixed; _swap16(header.format.fixed); // short int fixed;
_swap16((unsigned short &)header.format.channel_number); // short int channel_number; _swap16(header.format.channel_number); // short int channel_number;
_swap32((unsigned int &)header.format.sample_rate); // int sample_rate; _swap32((long &)header.format.sample_rate); // int sample_rate;
_swap32((unsigned int &)header.format.byte_rate); // int byte_rate; _swap32((long &)header.format.byte_rate); // int byte_rate;
_swap16((unsigned short &)header.format.byte_per_sample); // short int byte_per_sample; _swap16(header.format.byte_per_sample); // short int byte_per_sample;
_swap16((unsigned short &)header.format.bits_per_sample); // short int bits_per_sample; _swap16(header.format.bits_per_sample); // short int bits_per_sample;
// if format_len is larger than expected, skip the extra data // if format_len is larger than expected, skip the extra data
if (nDump > 0) if (nDump > 0)
@ -447,7 +558,7 @@ int WavInFile::readHeaderBlock()
if (fread(&(header.data.data_len), sizeof(uint), 1, fptr) != 1) return -1; if (fread(&(header.data.data_len), sizeof(uint), 1, fptr) != 1) return -1;
// swap byte order if necessary // swap byte order if necessary
_swap32((unsigned int &)header.data.data_len); _swap32((long &)header.data.data_len);
return 1; return 1;
} }
@ -641,15 +752,15 @@ void WavOutFile::writeHeader()
// swap byte order if necessary // swap byte order if necessary
hdrTemp = header; hdrTemp = header;
_swap32((unsigned int &)hdrTemp.riff.package_len); _swap32((long &)hdrTemp.riff.package_len);
_swap32((unsigned int &)hdrTemp.format.format_len); _swap32((long &)hdrTemp.format.format_len);
_swap16((unsigned short &)hdrTemp.format.fixed); _swap16((short &)hdrTemp.format.fixed);
_swap16((unsigned short &)hdrTemp.format.channel_number); _swap16((short &)hdrTemp.format.channel_number);
_swap32((unsigned int &)hdrTemp.format.sample_rate); _swap32((long &)hdrTemp.format.sample_rate);
_swap32((unsigned int &)hdrTemp.format.byte_rate); _swap32((long &)hdrTemp.format.byte_rate);
_swap16((unsigned short &)hdrTemp.format.byte_per_sample); _swap16((short &)hdrTemp.format.byte_per_sample);
_swap16((unsigned short &)hdrTemp.format.bits_per_sample); _swap16((short &)hdrTemp.format.bits_per_sample);
_swap32((unsigned int &)hdrTemp.data.data_len); _swap32((long &)hdrTemp.data.data_len);
// write the supplemented header in the beginning of the file // write the supplemented header in the beginning of the file
fseek(fptr, 0, SEEK_SET); fseek(fptr, 0, SEEK_SET);
@ -685,6 +796,7 @@ void WavOutFile::write(const char *buffer, int numElems)
} }
void WavOutFile::write(const short *buffer, int numElems) void WavOutFile::write(const short *buffer, int numElems)
{ {
int res; int res;
@ -708,7 +820,7 @@ void WavOutFile::write(const short *buffer, int numElems)
else else
{ {
// 16bit format // 16bit format
unsigned short *pTemp = new unsigned short[numElems]; short *pTemp = new short[numElems];
if (header.format.bits_per_sample != 16) if (header.format.bits_per_sample != 16)
{ {
@ -736,25 +848,87 @@ void WavOutFile::write(const short *buffer, int numElems)
} }
/// Convert from float to integer and saturate
inline long saturate(float fvalue, float minval, float maxval)
{
if (fvalue > maxval)
{
fvalue = maxval;
}
else if (fvalue < minval)
{
fvalue = minval;
}
return (long)fvalue;
}
void WavOutFile::write(const float *buffer, int numElems) void WavOutFile::write(const float *buffer, int numElems)
{ {
int i; int numBytes;
short *temp = new short[numElems]; int bytesPerSample;
int iTemp;
// convert to 16 bit integer if (numElems == 0) return;
for (i = 0; i < numElems; i ++)
bytesPerSample = header.format.bits_per_sample / 8;
numBytes = numElems * bytesPerSample;
short *temp = (short*)getConvBuffer(numBytes);
switch (bytesPerSample)
{ {
// convert to integer case 1:
iTemp = (int)(32768.0f * buffer[i]); {
char *temp2 = (char *)temp;
for (int i = 0; i < numElems; i ++)
{
temp2[i] = (char)saturate(buffer[i] * 128.0f, -128.0f, 127.0f);
}
break;
}
// saturate case 2:
if (iTemp < -32768) iTemp = -32768; {
if (iTemp > 32767) iTemp = 32767; short *temp2 = (short *)temp;
temp[i] = (short)iTemp; for (int i = 0; i < numElems; i ++)
{
short value = (short)saturate(buffer[i] * 32768.0f, -32768.0f, 32767.0f);
temp2[i] = _swap16(value);
}
break;
}
case 3:
{
char *temp2 = (char *)temp;
for (int i = 0; i < numElems; i ++)
{
long value = saturate(buffer[i] * 8388608.0f, -8388608.0f, 8388607.0f);
*((long*)temp2) = _swap32(value);
temp2 += 3;
}
break;
}
case 4:
{
long *temp2 = (long *)temp;
for (int i = 0; i < numElems; i ++)
{
long value = saturate(buffer[i] * 2147483648.0f, -2147483648.0f, 2147483647.0f);
temp2[i] = _swap32(value);
}
break;
}
default:
assert(false);
} }
write(temp, numElems); int res = fwrite(temp, 1, numBytes, fptr);
delete[] temp; if (res != numBytes)
{
ST_THROW_RT_ERROR("Error while writing to a wav file.");
}
bytesWritten += numBytes;
} }

22
source/SoundStretch/WavFile.h
View File

@ -92,8 +92,25 @@ typedef struct
} WavHeader; } WavHeader;
/// Base class for processing WAV audio files.
class WavFileBase
{
private:
/// Conversion working buffer;
void *convBuff;
int convBuffSize;
protected:
WavFileBase();
virtual ~WavFileBase();
/// Get pointer to conversion buffer of at min. given size
void *getConvBuffer(int sizeByte);
};
/// Class for reading WAV audio files. /// Class for reading WAV audio files.
class WavInFile class WavInFile : protected WavFileBase
{ {
private: private:
/// File pointer. /// File pointer.
@ -177,6 +194,7 @@ public:
/// Reads audio samples from the WAV file to floating point format, converting /// Reads audio samples from the WAV file to floating point format, converting
/// sample values to range [-1,1[. Reads given number of elements from the file /// sample values to range [-1,1[. Reads given number of elements from the file
/// or if end-of-file reached, as many elements as are left in the file. /// or if end-of-file reached, as many elements as are left in the file.
/// Notice that reading in float format supports 8/16/24/32bit sample formats.
/// ///
/// \return Number of elements read from the file. /// \return Number of elements read from the file.
int read(float *buffer, ///< Pointer to buffer where to read data. int read(float *buffer, ///< Pointer to buffer where to read data.
@ -192,7 +210,7 @@ public:
/// Class for writing WAV audio files. /// Class for writing WAV audio files.
class WavOutFile class WavOutFile : protected WavFileBase
{ {
private: private:
/// Pointer to the WAV file /// Pointer to the WAV file