/***************************************************************************
* Copyright (C) 1994 Charles P. Peterson *
* 4007 Enchanted Sun, San Antonio, Texas 78244-1254 *
* Email: Charles_P_Peterson@fcircus.sat.tx.us *
* *
* This is free software with NO WARRANTY. *
* See gfft.c, or run program itself, for details. *
* Support is available for a fee. *
***************************************************************************
*
* Program: gfft--General FFT analysis
* File: format.c
* Purpose: parse formatted files
* Author: Charles Peterson (CPP)
* History: 18-October-1993 CPP; Created.
* Comment: Thanks to Guido van Rossum for SOX and David Champion
* for OmniPlay, from which much was learned.
* Thanks to Malcolm Slaney and Ken Turkowski for
* ConvertFromIeeeExtended, from which much was learned.
* However, this is an original implementation, containing
* no previously copyrighted code.
*/
#include <math.h>
#include <stdio.h>
#include "gfft.h"
#include "settings.h"
#include "format.h"
#define NO_ERROR FALSE
#define CORRUPT TRUE
#define UNAVAIL_COMPRESSION 2
static unsigned long offset = 0; /* Running offset pointer used here */
/*
* Static function declarations
*/
static void read_form_format (void); /* Includes 8SVX, AIFF, AIFC types */
static void read_8svx_format (long form_cksize);
static int read_vhdr (ULONG form_cksize, struct ChunkHeader chunk_h);
static void read_aiff_format (long form_cksize);
static int read_comm_aiff (ULONG form_cksize, struct ChunkHeader chunk_h);
static void read_aifc_format (long form_cksize);
static int read_comm_aifc (ULONG form_cksize, struct ChunkHeader chunk_h);
static double double_from_extended (UBYTE *extended);
static void read_avr_format (void);
void reset_format (void)
{
/*
* Reset Global Format Info
*/
FileFormat = UNFORMATTED;
FileFormatOK = FALSE;
FileRate = AUTO_RATE;
FileDataOffset = 0;
FileFrames = 0;
FileVolume = 1.0L;
FileOctaves = 1;
FileChannels = 1;
FileOneShotHiFrames = 0;
FileRepeatHiFrames = 0;
}
void read_format (void)
{
ID format_id;
int format = UNFORMATTED;
reset_format();
if (fread (&format_id, sizeof format_id, 1, ReadPtr))
{
offset = sizeof format_id; /* This is where offset count begins */
switch (format_id)
{
case ID_FORM: /* IFF 8SVX, AIFF, and AIFC */
format = ID_FORM; /* Clarified later */
break;
case ID_RIFF:
format = ID_RIFF;
break;
case ID_VOCH:
format = ID_VOCH;
break;
case ID_AVR:
format = ID_AVR;
break;
}
}
if (format != UNFORMATTED)
{
if (IgnoreFormat)
{
error_message (FILE_FORMAT_IGNORED);
return;
}
Rate = AUTO_RATE; /* override must be forced afterwards */
}
FileFormat = format;
switch (format)
{
case ID_FORM:
read_form_format ();
break;
case ID_AVR:
read_avr_format ();
break;
case UNFORMATTED:
break;
default:
error_message (UNSUPPORTED_FORMAT);
FileFormatOK = FALSE;
}
}
static void read_form_format (void) /* Includes 8SVX, AIFF, AIFC types */
{
ULONG form_cksize;
ID form_type;
if (fread (&form_cksize, sizeof form_cksize, 1, ReadPtr) &&
fread (&form_type, sizeof form_type, 1, ReadPtr))
{
offset += sizeof form_cksize + sizeof form_type;
switch (form_type)
{
case ID_8SVX:
FileFormat = ID_8SVX;
read_8svx_format (form_cksize);
break;
case ID_AIFF:
FileFormat = ID_AIFF;
read_aiff_format (form_cksize);
break;
case ID_AIFC:
FileFormat = ID_AIFC;
read_aifc_format (form_cksize);
break;
default:
error_message (UNSUPPORTED_FORMAT);
break;
}
}
else
{
error_message (CORRUPT_IFF); /* Missing cksize and/or type! */
}
}
static void read_8svx_format (long form_cksize)
/*
* Chunks are allowed to be in any order.
* But, a fast and lazy approach is taken to validation:
* Chunks looked for: VHDR and BODY
* (Once those two have been found, and VHDR read, I exit.)
* BODY chunk isn't read (so premature file end must be detected later)
* BODY chunk is fseek'd over only if VHDR hasn't been found yet.
* form_cksize isn't actually checked
*/
{
int error = NO_ERROR;
struct ChunkHeader chunk_h;
ULONG skip_bytes;
BOOLEAN vhdr_found = FALSE;
BOOLEAN body_found = FALSE;
InputFormat.bits = 8; /* True of all 8SVX */
InputFormat.zero = 0; /* Ditto */
while (fread (&chunk_h, sizeof chunk_h, 1, ReadPtr))
{
offset += sizeof chunk_h;
switch (chunk_h.ckID)
{
case ID_VHDR:
vhdr_found = TRUE;
error = read_vhdr (form_cksize, chunk_h);
offset += WordAlign (chunk_h.ckSize);
break;
case ID_BODY:
body_found = TRUE;
FileDataOffset = offset;
if (!vhdr_found && !error) /* If still looking for VHDR */
{
skip_bytes = WordAlign (chunk_h.ckSize);
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
}
break;
default:
skip_bytes = WordAlign (chunk_h.ckSize);
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
break;
}
if (error || (vhdr_found && body_found))
{
break;
}
}
if (!vhdr_found || !body_found || error)
{
if (error <= CORRUPT) /* Higher errors reported elsewhere */
{
error_message (CORRUPT_IFF);
}
}
else
{
FileFormatOK = TRUE;
}
}
static int read_vhdr (ULONG form_cksize, struct ChunkHeader chunk_h)
{
int error = CORRUPT; /* defaulted if chunk not completely read */
struct VHDR vhdr;
ULONG skip_bytes;
if (chunk_h.ckSize < sizeof vhdr)
{
return CORRUPT; /* Error! Pre '85 or corrupt! */
}
if (fread (&vhdr, sizeof vhdr, 1, ReadPtr))
{
FileRate = vhdr.samplesPerSec;
if (vhdr.sCompression)
{
error_message (COMPRESSION_NOT_SUPPORTED);
return UNAVAIL_COMPRESSION;
}
FileVolume = vhdr.volume / 65536.0L;
FileOctaves = vhdr.ctOctave;
FileOneShotHiFrames = vhdr.oneShotHiSamples;
FileRepeatHiFrames = vhdr.repeatHiSamples;
FileFrames = FileOneShotHiFrames + FileRepeatHiFrames;
error = NO_ERROR;
if (skip_bytes = WordAlign (chunk_h.ckSize - sizeof vhdr)) /* = */
{
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
}
}
return error;
}
static void read_aiff_format (long form_cksize)
/*
* Chunks are allowed to be in any order.
* But, a fast and lazy approach is taken to validation:
* Chunks looked for: Common (COMM) and Sound Data (SSND)
* (Note: COMM here is different from the AIFC version.)
* (Once those two have been found, and COMM read, I exit.)
* SSND chunk isn't read (so premature file end must be detected later)
* SSND chunk is fseek'd over only if VHDR hasn't been found yet.
* form_cksize isn't actually checked
*/
{
ULONG skip_bytes;
int error = NO_ERROR;
struct ChunkHeader chunk_h;
struct SoundDataChunkInfo sdci;
BOOLEAN ssnd_found = FALSE;
BOOLEAN comm_found = FALSE;
while (fread (&chunk_h, sizeof chunk_h, 1, ReadPtr))
{
offset += sizeof chunk_h;
switch (chunk_h.ckID)
{
case ID_COMM:
comm_found = TRUE;
error = read_comm_aiff (form_cksize, chunk_h);
offset += WordAlign (chunk_h.ckSize);
break;
case ID_SSND:
ssnd_found = TRUE;
error = !fread (&sdci, sizeof sdci, 1, ReadPtr);
offset += sizeof sdci;
FileDataOffset = offset + sdci.offset;
if (!comm_found && !error)
{
skip_bytes = WordAlign (chunk_h.ckSize - sizeof sdci);
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
}
break;
default:
skip_bytes = WordAlign (chunk_h.ckSize);
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
break;
}
if (error || (comm_found && ssnd_found))
{
break;
}
}
if (!comm_found || !ssnd_found || error)
{
if (error <= CORRUPT) /* Higher errors reported elsewhere */
{
error_message (CORRUPT_AIFF);
}
}
else
{
FileFormatOK = TRUE;
}
}
static int read_comm_aiff (ULONG form_cksize, struct ChunkHeader chunk_h)
{
int error = CORRUPT; /* defaulted if chunk not completely read */
int skip_bytes;
struct CommAiff comm;
if (chunk_h.ckSize < sizeof comm)
{
return CORRUPT; /* Error...corrupt or unsupported AIFF format */
}
if (fread (&comm, sizeof comm, 1, ReadPtr))
{
FileChannels = comm.numChannels;
FileFrames = comm.numSampleFrames;
InputFormat.bits = comm.sampleSize;
InputFormat.zero = 0;
FileRate = double_from_extended (comm.sampleRate);
error = NO_ERROR;
if (skip_bytes = WordAlign (chunk_h.ckSize - sizeof comm)) /* = */
{
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
}
}
return error;
}
static void read_aifc_format (long form_cksize)
/*
* Chunks are allowed to be in any order.
* But, a fast and lazy approach is taken to validation:
* Chunks looked for: COMM and SSND
* (Once those two have been found, and COMM read, I exit.)
* SSND chunk isn't read (so premature file end must be detected later)
* SSND chunk is fseek'd over only if VHDR hasn't been found yet.
* form_cksize isn't actually checked
*/
{
ULONG skip_bytes;
int error = NO_ERROR;
struct ChunkHeader chunk_h;
struct SoundDataChunkInfo sdci;
BOOLEAN ssnd_found = FALSE;
BOOLEAN comm_found = FALSE;
while (fread (&chunk_h, sizeof chunk_h, 1, ReadPtr))
{
offset += sizeof chunk_h;
switch (chunk_h.ckID)
{
case ID_COMM:
comm_found = TRUE;
error = read_comm_aifc (form_cksize, chunk_h);
offset += WordAlign (chunk_h.ckSize);
break;
case ID_SSND:
ssnd_found = TRUE;
error = !fread (&sdci, sizeof sdci, 1, ReadPtr);
offset += sizeof sdci;
FileDataOffset = offset + sdci.offset;
if (!comm_found && !error)
{
skip_bytes = WordAlign (chunk_h.ckSize - sizeof sdci);
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
}
break;
default:
skip_bytes = WordAlign (chunk_h.ckSize);
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
break;
}
if (error || (comm_found && ssnd_found))
{
break;
}
}
if (!comm_found || !ssnd_found || error)
{
if (error <= CORRUPT)
{
error_message (CORRUPT_AIFC);
}
}
else
{
FileFormatOK = TRUE;
}
}
static int read_comm_aifc (ULONG form_cksize, struct ChunkHeader chunk_h)
{
int error = CORRUPT; /* Defaulted if chunk not read */
int skip_bytes;
struct CommAifc comm;
if (chunk_h.ckSize < sizeof comm)
{
return CORRUPT; /* Error...corrupt or unsupported AIFF format */
}
if (fread (&comm, sizeof comm, 1, ReadPtr))
{
FileChannels = comm.numChannels;
FileFrames = comm.numSampleFrames;
InputFormat.bits = comm.sampleSize;
InputFormat.zero = 0;
FileRate = double_from_extended (comm.sampleRate);
if (comm.compressionType != ID_NONE)
{
error_message (COMPRESSION_NOT_SUPPORTED);
return UNAVAIL_COMPRESSION;
}
error = NO_ERROR;
if (skip_bytes = WordAlign (chunk_h.ckSize - sizeof comm)) /* = */
{
error = !!fseek (ReadPtr, skip_bytes, SEEK_CUR);
offset += skip_bytes;
}
}
return error;
}
/*
* The following is based on ideas from ConvertFromIeeeExtended
* by Malcolm Slaney and Ken Turkowski. However, since that was
* copyright by Apple Computer, Inc., I have prepared an original
* implementation here.
*
* Note: NaN's and infinities are converted to HUGE_VAL. This is
* not very nice for NaN's.
*
* WARNING! THIS HASN'T BEEN WELL TESTED, SO I WOULDN'T USE THIS FOR
* OTHER OR SERIOUS PURPOSES OR ON OTHER ARCHITECTURES.
*/
#define UPPER_EXP_MASK 0x7F
#define SIGN_MASK 0x80
#define INFINITE_EXPONENT 0x7FFF
#define HI_E_OFF 16414 /* (16383 + 31) */
#define LO_E_OFF 16446 /* (16383 + 31 + 32) */
#define U_TO_F(u) (((double) ((long) ((u)-2147483647L-1))) + 2147483648.0)
static double double_from_extended (UBYTE *extended)
{
double dval;
ULONG high_mantissa;
ULONG low_mantissa;
int exponent;
exponent = ((extended[0] & UPPER_EXP_MASK) << 8) | extended[1];
high_mantissa = ((ULONG) (extended[2] << 24)) |
((ULONG) (extended[3] << 16)) |
((ULONG) (extended[4] << 8)) |
(ULONG) extended[5];
low_mantissa = ((ULONG) (extended[6] << 24)) |
((ULONG) (extended[7] << 16)) |
((ULONG) (extended[8] << 8)) |
(ULONG) extended[9];
if (exponent == 0 && high_mantissa == 0 && low_mantissa == 0)
{
dval = 0;
}
else
{
if (exponent == INFINITE_EXPONENT) /* Infinity or NaN */
{
dval = HUGE_VAL; /* from ANSI C math.h */
}
else
{
dval = ldexp ( U_TO_F (high_mantissa), exponent - HI_E_OFF) +
ldexp ( U_TO_F (low_mantissa), exponent - LO_E_OFF);
}
if (extended[0] & SIGN_MASK)
{
dval = (-dval);
}
}
return dval;
}
static void read_avr_format (void)
{
struct AVRH avrh;
if (!fread (&avrh, sizeof avrh, 1, ReadPtr))
{
error_message (CORRUPT_AVR);
}
else
{
FileFormatOK = TRUE;
FileDataOffset = sizeof (ID) + sizeof (struct AVRH);
if (avrh.mono == 0)
{
FileChannels = 1;
}
else if (avrh.mono == -1)
{
FileChannels = 2;
}
else
{
error_message (CORRUPT_AVR);
FileFormatOK = FALSE;
}
InputFormat.bits = avrh.rez;
if (InputFormat.bits > 16 || InputFormat.bits < 0)
{
error_message (CORRUPT_AVR);
FileFormatOK = FALSE;
}
if (avrh.sign == -1)
{
InputFormat.zero = 0;
}
else if (avrh.sign == 0)
{
int sample_width = (InputFormat.bits > 8) ? 16 : 8;
InputFormat.zero = ((unsigned long) 0xffffffff >>
(33 - sample_width)) + (unsigned long) 1;
}
else
{
error_message (CORRUPT_AVR);
FileFormatOK = FALSE;
}
FileRate = avrh.rate & 0xFFFFFF; /* I don't understand why */
/*
* Maybe FF in upper bits MEANS number is an integer, no FF means float
* But, my docs didn't say this
*/
FileFrames = avrh.size;
if (FileFrames < 0)
{
error_message (CORRUPT_AVR);
FileFormatOK = FALSE;
}
if (avrh.res2)
{
error_message (COMPRESSION_NOT_SUPPORTED);
FileFormatOK = FALSE;
}
}
}
