int main() {
int n = 0x01234567;
show_bytes((char *)&n, sizeof(n));
endianess(n);
printf("\n");
int x = rev_endianness(n);
printf("%d\n", x);
show_bytes((char *)&x, sizeof(x));
return 0;
}
static BufferData *
loadWavFile (InputStream *stream)
{
ALboolean found_header = AL_FALSE;
UInt32LittleEndian chunkLength;
Int32BigEndian magic;
UInt16LittleEndian audioFormat;
UInt16LittleEndian numChannels;
UInt32LittleEndian sampleFrequency;
UInt32LittleEndian byteRate;
UInt16LittleEndian blockAlign;
UInt16LittleEndian bitsPerSample;
Codec *codec = _alutCodecLinear;
if (!_alutInputStreamReadUInt32LE (stream, &chunkLength) ||
!_alutInputStreamReadInt32BE (stream, &magic))
{
return NULL;
}
if (magic != 0x57415645) /* "WAVE" */
{
_alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE);
return NULL;
}
while (1)
{
if (!_alutInputStreamReadInt32BE (stream, &magic) ||
!_alutInputStreamReadUInt32LE (stream, &chunkLength))
{
return NULL;
}
if (magic == 0x666d7420) /* "fmt " */
{
found_header = AL_TRUE;
if (chunkLength < 16)
{
_alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA);
return NULL;
}
if (!_alutInputStreamReadUInt16LE (stream, &audioFormat) ||
!_alutInputStreamReadUInt16LE (stream, &numChannels) ||
!_alutInputStreamReadUInt32LE (stream, &sampleFrequency) ||
!_alutInputStreamReadUInt32LE (stream, &byteRate) ||
!_alutInputStreamReadUInt16LE (stream, &blockAlign) ||
!_alutInputStreamReadUInt16LE (stream, &bitsPerSample))
{
return NULL;
}
if (!_alutInputStreamSkip (stream, chunkLength - 16))
{
return NULL;
}
switch (audioFormat)
{
case 1: /* PCM */
codec = (bitsPerSample == 8
|| endianess () ==
LittleEndian) ? _alutCodecLinear : _alutCodecPCM16;
break;
case 7: /* uLaw */
bitsPerSample *= 2; /* ToDo: ??? */
codec = _alutCodecULaw;
break;
default:
_alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE);
return NULL;
}
}
else if (magic == 0x64617461) /* "data" */
{
ALvoid *data;
if (!found_header)
{
/* ToDo: A bit wrong to check here, fmt chunk could come later... */
_alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA);
return NULL;
}
data = _alutInputStreamRead (stream, chunkLength);
if (data == NULL)
{
return NULL;
}
return codec (data, chunkLength, numChannels, bitsPerSample,
(ALfloat) sampleFrequency);
}
else
{
if (!_alutInputStreamSkip (stream, chunkLength))
{
return NULL;
}
}
if ((chunkLength & 1) && !_alutInputStreamEOF (stream)
&& !_alutInputStreamSkip (stream, 1))
{
return NULL;
}
}
}
static BufferData *
loadAUFile (InputStream *stream)
{
Int32BigEndian dataOffset; /* byte offset to data part, minimum 24 */
Int32BigEndian len; /* number of bytes in the data part, -1 = not known */
Int32BigEndian encoding; /* encoding of the data part, see AUEncoding */
Int32BigEndian sampleFrequency; /* number of samples per second */
Int32BigEndian numChannels; /* number of interleaved channels */
size_t length;
Codec *codec;
char *data;
ALint bitsPerSample;
if (!_alutInputStreamReadInt32BE (stream, &dataOffset) ||
!_alutInputStreamReadInt32BE (stream, &len) ||
!_alutInputStreamReadInt32BE (stream, &encoding) ||
!_alutInputStreamReadInt32BE (stream, &sampleFrequency) ||
!_alutInputStreamReadInt32BE (stream, &numChannels))
{
return AL_FALSE;
}
length = (len == -1) ?
(_alutInputStreamGetRemainingLength (stream) - AU_HEADER_SIZE -
dataOffset) : (size_t) len;
if (!
(dataOffset >= AU_HEADER_SIZE && length > 0 && sampleFrequency >= 1
&& numChannels >= 1))
{
_alutSetError (ALUT_ERROR_CORRUPT_OR_TRUNCATED_DATA);
return AL_FALSE;
}
if (!_alutInputStreamSkip (stream, dataOffset - AU_HEADER_SIZE))
{
return AL_FALSE;
}
switch (encoding)
{
case AU_ULAW_8:
bitsPerSample = 16;
codec = _alutCodecULaw;
break;
case AU_PCM_8:
bitsPerSample = 8;
codec = _alutCodecPCM8s;
break;
case AU_PCM_16:
bitsPerSample = 16;
codec =
(endianess () == BigEndian) ? _alutCodecLinear : _alutCodecPCM16;
break;
case AU_ALAW_8:
bitsPerSample = 16;
codec = _alutCodecALaw;
break;
default:
_alutSetError (ALUT_ERROR_UNSUPPORTED_FILE_SUBTYPE);
return AL_FALSE;
}
data = _alutInputStreamRead (stream, length);
if (data == NULL)
{
return NULL;
}
return codec (data, length, numChannels, bitsPerSample,
(ALfloat) sampleFrequency);
}
