ref: a9fddb06a4e0fba4ef9fd585626bd674b959934b
dir: /src/maud.c/
/*
* July 5, 1991
* Copyright 1991 Lance Norskog And Sundry Contributors
* This source code is freely redistributable and may be used for
* any purpose. This copyright notice must be maintained.
* Lance Norskog And Sundry Contributors are not responsible for
* the consequences of using this software.
*/
/*
* Sound Tools MAUD file format driver, by Lutz Vieweg 1993
*
* supports: mono and stereo, linear, a-lawa and u-law reading and writing
*
*/
#include "st.h"
#include "libst.h"
#include <string.h>
#include <stdlib.h>
#define SEEK_CUR 1 /* nasty nasty */
/* Private data for MAUD file */
struct maudstuff { /* max. 100 bytes!!!! */
ULONG nsamples;
};
void maudwriteheader(P1(ft_t));
void rawwrite(P3(ft_t, LONG *, LONG));
/*
* Do anything required before you start reading samples.
* Read file header.
* Find out sampling rate,
* size and style of samples,
* mono/stereo/quad.
*/
void maudstartread(ft)
ft_t ft;
{
struct maudstuff * p = (struct maudstuff *) ft->priv;
char buf[12];
char *endptr;
char *chunk_buf;
unsigned short bitpersam;
ULONG nom;
unsigned short denom;
unsigned short chaninf;
ULONG chunksize;
int littlendian = 0;
/* read FORM chunk */
if (fread(buf, 1, 4, ft->fp) != 4 || strncmp(buf, "FORM", 4) != 0)
fail("MAUD: header does not begin with magic word 'FORM'");
rblong(ft); /* totalsize */
if (fread(buf, 1, 4, ft->fp) != 4 || strncmp(buf, "MAUD", 4) != 0)
fail("MAUD: 'FORM' chunk does not specify 'MAUD' as type");
/* read chunks until 'BODY' (or end) */
while (fread(buf,1,4,ft->fp) == 4 && strncmp(buf,"MDAT",4) != 0) {
/*
buf[4] = 0;
report("chunk %s",buf);
*/
if (strncmp(buf,"MHDR",4) == 0) {
chunksize = rblong(ft);
if (chunksize != 8*4) fail ("MAUD: MHDR chunk has bad size");
/* fseek(ft->fp,12,SEEK_CUR); */
p->nsamples = rblong(ft); /* number of samples stored in MDAT */
bitpersam = rbshort(ft); /* number of bits per sample as stored in MDAT */
rbshort(ft); /* number of bits per sample after decompression */
nom = rblong(ft); /* clock source frequency */
denom = rbshort(ft); /* clock devide */
if (denom == 0) fail("MAUD: frequency denominator == 0, failed");
ft->info.rate = nom / denom;
chaninf = rbshort(ft); /* channel information */
switch (chaninf) {
case 0:
ft->info.channels = 1;
break;
case 1:
ft->info.channels = 2;
break;
default:
fail("MAUD: unsupported number of channels in file");
break;
}
chaninf = rbshort(ft); /* number of channels (mono: 1, stereo: 2, ...) */
if (chaninf != ft->info.channels) fail("MAUD: unsupported number of channels in file");
chaninf = rbshort(ft); /* compression type */
rblong(ft); /* rest of chunk, unused yet */
rblong(ft);
rblong(ft);
if (bitpersam == 8 && chaninf == 0) {
ft->info.size = BYTE;
ft->info.style = UNSIGNED;
}
else if (bitpersam == 8 && chaninf == 2) {
ft->info.size = BYTE;
ft->info.style = ALAW;
}
else if (bitpersam == 8 && chaninf == 3) {
ft->info.size = BYTE;
ft->info.style = ULAW;
}
else if (bitpersam == 16 && chaninf == 0) {
ft->info.size = WORD;
ft->info.style = SIGN2;
}
else fail("MAUD: unsupported compression type detected");
ft->comment = 0;
continue;
}
if (strncmp(buf,"ANNO",4) == 0) {
chunksize = rblong(ft);
if (chunksize & 1)
chunksize++;
chunk_buf = (char *) malloc(chunksize + 1);
if (fread(chunk_buf,1,(int)chunksize,ft->fp)
!= chunksize)
fail("MAUD: Unexpected EOF in ANNO header");
chunk_buf[chunksize] = '\0';
report ("%s",chunk_buf);
free(chunk_buf);
continue;
}
/* some other kind of chunk */
chunksize = rblong(ft);
if (chunksize & 1)
chunksize++;
fseek(ft->fp,chunksize,SEEK_CUR);
continue;
}
if (strncmp(buf,"MDAT",4) != 0) fail("MAUD: MDAT chunk not found");
p->nsamples = rblong(ft);
endptr = (char *) &littlendian;
*endptr = 1;
if (littlendian == 1) ft->swap = 1;
}
/*
* Read up to len samples from file.
* Convert to signed longs.
* Place in buf[].
* Return number of samples read.
*/
LONG maudread(ft, buf, len)
ft_t ft;
LONG *buf, len;
{
register int datum;
int done = 0;
if (ft->info.channels == 1) {
if (ft->info.size == BYTE) {
switch(ft->info.style) {
case UNSIGNED:
while(done < len) {
datum = getc(ft->fp);
if (feof(ft->fp)) return done;
/* Convert to signed */
datum ^= 128;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 24);
done++;
}
break;
case ULAW:
/* grab table from Posk stuff */
while(done < len) {
datum = getc(ft->fp);
if (feof(ft->fp)) return done;
datum = st_ulaw_to_linear(datum);
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
done++;
}
break;
case ALAW:
while(done < len) {
datum = st_Alaw_to_linear((unsigned char) getc(ft->fp));
if (feof(ft->fp)) return done;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
done++;
}
break;
}
}
else {
while(done < len) {
datum = rbshort(ft);
if (feof(ft->fp)) return done;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
done++;
}
}
}
else { /* stereo */
if (ft->info.size == BYTE) {
switch(ft->info.style) {
case UNSIGNED:
while(done < len) {
datum = getc(ft->fp);
if (feof(ft->fp)) return done;
/* Convert to signed */
datum ^= 128;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 24);
datum = getc(ft->fp);
if (feof(ft->fp)) return done;
/* Convert to signed */
datum ^= 128;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 24);
done += 2;
}
break;
case ULAW:
/* grab table from Posk stuff */
while(done < len) {
datum = getc(ft->fp);
if (feof(ft->fp)) return done;
datum = st_ulaw_to_linear(datum);
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
datum = getc(ft->fp);
if (feof(ft->fp)) return done;
datum = st_ulaw_to_linear(datum);
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
done += 2;
}
break;
case ALAW:
while(done < len) {
datum = st_Alaw_to_linear((unsigned char) getc(ft->fp));
if (feof(ft->fp)) return done;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
datum = st_Alaw_to_linear((unsigned char) getc(ft->fp));
if (feof(ft->fp)) return done;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
done += 2;
}
break;
}
}
else {
while(done < len) {
datum = rbshort(ft);
if (feof(ft->fp)) return done;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
datum = rbshort(ft);
if (feof(ft->fp)) return done;
/* scale signed up to long's range */
*buf++ = LEFT(datum, 16);
done += 2;
}
}
}
return done;
}
/*
* Do anything required when you stop reading samples.
* Don't close input file!
*/
void maudstopread(ft)
ft_t ft;
{
}
void maudstartwrite(ft)
ft_t ft;
{
struct maudstuff * p = (struct maudstuff *) ft->priv;
int littlendian = 0;
char *endptr;
/* If you have to seek around the output file */
if (! ft->seekable) fail("Output .maud file must be a file, not a pipe");
if (ft->info.channels != 1 && ft->info.channels != 2) {
fail("MAUD: unsupported number of channels, unable to store");
}
if (ft->info.size == WORD) ft->info.style = SIGN2;
if (ft->info.style == ULAW || ft->info.style == ALAW) ft->info.size = BYTE;
if (ft->info.size == BYTE && ft->info.style == SIGN2) ft->info.style = UNSIGNED;
p->nsamples = 0x7f000000L;
maudwriteheader(ft);
p->nsamples = 0;
endptr = (char *) &littlendian;
*endptr = 1;
if (littlendian == 1) ft->swap = 1;
}
void maudwrite(ft, buf, len)
ft_t ft;
LONG *buf, len;
{
struct maudstuff * p = (struct maudstuff *) ft->priv;
p->nsamples += len;
rawwrite(ft, buf, len);
}
void maudstopwrite(ft)
ft_t ft;
{
/* All samples are already written out. */
if (fseek(ft->fp, 0L, 0) != 0) fail("can't rewind output file to rewrite MAUD header");
maudwriteheader(ft);
}
#define MAUDHEADERSIZE (4+(4+4+32)+(4+4+32)+(4+4))
void maudwriteheader(ft)
ft_t ft;
{
struct maudstuff * p = (struct maudstuff *) ft->priv;
fputs ("FORM", ft->fp);
wblong(ft, (p->nsamples*ft->info.size) + MAUDHEADERSIZE); /* size of file */
fputs("MAUD", ft->fp); /* File type */
fputs ("MHDR", ft->fp);
wblong(ft, (LONG) 8*4); /* number of bytes to follow */
wblong(ft, (LONG) (p->nsamples )); /* number of samples stored in MDAT */
switch (ft->info.style) {
case UNSIGNED:
wbshort(ft, (int) 8); /* number of bits per sample as stored in MDAT */
wbshort(ft, (int) 8); /* number of bits per sample after decompression */
break;
case SIGN2:
wbshort(ft, (int) 16); /* number of bits per sample as stored in MDAT */
wbshort(ft, (int) 16); /* number of bits per sample after decompression */
break;
case ALAW:
case ULAW:
wbshort(ft, (int) 8); /* number of bits per sample as stored in MDAT */
wbshort(ft, (int) 16); /* number of bits per sample after decompression */
break;
}
wblong(ft, (LONG) ft->info.rate); /* clock source frequency */
wbshort(ft, (int) 1); /* clock devide */
if (ft->info.channels == 1) {
wbshort(ft, (int) 0); /* channel information */
wbshort(ft, (int) 1); /* number of channels (mono: 1, stereo: 2, ...) */
}
else {
wbshort(ft, (int) 1);
wbshort(ft, (int) 2);
}
switch (ft->info.style) {
case UNSIGNED:
case SIGN2:
wbshort(ft, (int) 0); /* no compression */
break;
case ULAW:
wbshort(ft, (int) 3);
break;
case ALAW:
wbshort(ft, (int) 2);
break;
}
wblong(ft, (LONG) 0); /* reserved */
wblong(ft, (LONG) 0); /* reserved */
wblong(ft, (LONG) 0); /* reserved */
fputs ("ANNO", ft->fp);
wblong(ft, (LONG) 32); /* length of block */
fputs ("file written by SOX MAUD-export ", ft->fp);
fputs ("MDAT", ft->fp);
wblong(ft, p->nsamples * ft->info.size ); /* samples in file */
}