ref: 9e0d2d23d3e0819d6192347fa80d473b83a74ff8
dir: /src/speech/cst_wave_io.c/
/*************************************************************************/
/* */
/* Language Technologies Institute */
/* Carnegie Mellon University */
/* Copyright (c) 2000 */
/* All Rights Reserved. */
/* */
/* Permission is hereby granted, free of charge, to use and distribute */
/* this software and its documentation without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of this work, and to */
/* permit persons to whom this work is furnished to do so, subject to */
/* the following conditions: */
/* 1. The code must retain the above copyright notice, this list of */
/* conditions and the following disclaimer. */
/* 2. Any modifications must be clearly marked as such. */
/* 3. Original authors' names are not deleted. */
/* 4. The authors' names are not used to endorse or promote products */
/* derived from this software without specific prior written */
/* permission. */
/* */
/* CARNEGIE MELLON UNIVERSITY AND THE CONTRIBUTORS TO THIS WORK */
/* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */
/* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */
/* SHALL CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE */
/* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */
/* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */
/* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */
/* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */
/* THIS SOFTWARE. */
/* */
/*************************************************************************/
/* Author: Alan W Black (awb@cs.cmu.edu) */
/* Date: August 2000 */
/*************************************************************************/
/* */
/* Waveforms */
/* */
/*************************************************************************/
#include "cst_string.h"
#include "cst_wave.h"
#include "cst_file.h"
void cst_wave_resample(cst_wave *w, int sample_rate)
{
/* This is here so that it won't necessarily be linked in tight-space */
/* platforms like PalmOS */
cst_rateconv *filt;
int up, down;
short *in;
const short *inptr;
short *outptr;
int n, insize, outsize;
/* Sure, we could take the GCD. In practice, though, this
gives us what we want and makes things go faster. */
down = w->sample_rate / 1000;
up = sample_rate / 1000;
if (up < 1 || down < 1) {
cst_errmsg("cst_wave_resample: invalid input/output sample rates (%d, %d)\n",
up * 1000, down * 1000);
cst_error();
}
filt = new_rateconv(up, down, w->num_channels);
inptr = in = w->samples;
insize = w->num_samples;
w->num_samples = w->num_samples * up / down + 2048;
w->samples = cst_alloc(short, w->num_samples * w->num_channels);
w->sample_rate = sample_rate;
outptr = w->samples;
outsize = w->num_samples;
while ((n = cst_rateconv_in(filt, inptr, insize)) > 0) {
inptr += n;
insize -= n;
while ((n = cst_rateconv_out(filt, outptr, outsize)) > 0) {
outptr += n;
outsize -= n;
}
}
cst_rateconv_leadout(filt);
while ((n = cst_rateconv_out(filt, outptr, outsize)) > 0) {
outptr += n;
outsize -= n;
}
cst_free(in);
delete_rateconv(filt);
}
int cst_wave_save(cst_wave *w,const char *filename,const char *type)
{
if (cst_streq(type,"riff"))
return cst_wave_save_riff(w,filename);
/* else if (cst_streq(type,"aiff"))
return cst_wave_save_aiff(w,filename);
else if (cst_streq(type,"snd"))
return cst_wave_save_snd(w,filename); */
else if (cst_streq(type,"raw"))
return cst_wave_save_raw(w,filename);
else
{
cst_errmsg("cst_wave_save: unsupported wavetype \"%s\"\n",
type);
return -1;
}
}
int cst_wave_save_raw(cst_wave *w, const char *filename)
{
cst_file fd;
int rv;
if ((fd = cst_fopen(filename,CST_OPEN_WRITE|CST_OPEN_BINARY)) == NULL)
{
cst_errmsg("cst_wave_save: can't open file \"%s\"\n",
filename);
return -1;
}
rv = cst_wave_save_raw_fd(w, fd);
cst_fclose(fd);
return rv;
}
int cst_wave_save_raw_fd(cst_wave *w, cst_file fd)
{
if (cst_fwrite(fd, cst_wave_samples(w),
sizeof(short), cst_wave_num_samples(w)) == cst_wave_num_samples(w))
return 0;
else
return -1;
}
int cst_wave_append_riff(cst_wave *w,const char *filename)
{
/* Appends to wave in file if it already exists */
cst_file fd;
cst_wave_header hdr;
char info[4];
int d_int;
int rv, num_bytes, n, sample_rate;
if ((fd = cst_fopen(filename,CST_OPEN_WRITE|CST_OPEN_READ|CST_OPEN_BINARY)) == NULL)
{
cst_errmsg("cst_wave_append: can't open file \"%s\"\n",
filename);
return -1;
}
rv = cst_wave_load_riff_header(&hdr,fd);
if (rv != CST_OK_FORMAT)
{
cst_fclose(fd);
return rv;
}
/* We will assume this is one of my riff files so it has *ONE* data part */
cst_fread(fd,info,1,4);
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
hdr.num_samples = d_int/sizeof(short);
cst_fseek(fd,
cst_ftell(fd)+(hdr.hsize-16)+
(hdr.num_samples*hdr.num_channels*sizeof(short)),
CST_SEEK_ABSOLUTE);
if (CST_BIG_ENDIAN)
{
short *xdata = cst_alloc(short,cst_wave_num_channels(w)*
cst_wave_num_samples(w));
memmove(xdata,cst_wave_samples(w),
sizeof(short)*cst_wave_num_channels(w)*
cst_wave_num_samples(w));
swap_bytes_short(xdata,
cst_wave_num_channels(w)*
cst_wave_num_samples(w));
n = cst_fwrite(fd,xdata,sizeof(short),
cst_wave_num_channels(w)*cst_wave_num_samples(w));
cst_free(xdata);
}
else
{
n = cst_fwrite(fd,cst_wave_samples(w),sizeof(short),
cst_wave_num_channels(w)*cst_wave_num_samples(w));
}
cst_fseek(fd,4,CST_SEEK_ABSOLUTE);
num_bytes = hdr.num_bytes + (n*sizeof(short));
if (CST_BIG_ENDIAN) num_bytes = SWAPINT(num_bytes);
cst_fwrite(fd,&num_bytes,4,1); /* num bytes in whole file */
cst_fseek(fd,4+4+4+4 +4+2+2 ,CST_SEEK_ABSOLUTE);
sample_rate = w->sample_rate;
if (CST_BIG_ENDIAN) sample_rate = SWAPINT(sample_rate);
cst_fwrite(fd,&sample_rate,4,1); /* sample rate */
cst_fseek(fd,4+4+4+4+4+2+2+4+4+2+2+4,CST_SEEK_ABSOLUTE);
num_bytes =
(sizeof(short) * cst_wave_num_channels(w) * cst_wave_num_samples(w)) +
(sizeof(short) * hdr.num_channels * hdr.num_samples);
if (CST_BIG_ENDIAN) num_bytes = SWAPINT(num_bytes);
cst_fwrite(fd,&num_bytes,4,1); /* num bytes in data */
cst_fclose(fd);
return rv;
}
int cst_wave_save_riff(cst_wave *w,const char *filename)
{
cst_file fd;
int rv;
if ((fd = cst_fopen(filename,CST_OPEN_WRITE|CST_OPEN_BINARY)) == NULL)
{
cst_errmsg("cst_wave_save: can't open file \"%s\"\n",
filename);
return -1;
}
rv = cst_wave_save_riff_fd(w, fd);
cst_fclose(fd);
return rv;
}
int cst_wave_save_riff_fd(cst_wave *w, cst_file fd)
{
const char *info;
short d_short;
int d_int, n;
int num_bytes;
info = "RIFF";
cst_fwrite(fd,info,4,1);
num_bytes = (cst_wave_num_samples(w)
* cst_wave_num_channels(w)
* sizeof(short)) + 8 + 16 + 12;
if (CST_BIG_ENDIAN) num_bytes = SWAPINT(num_bytes);
cst_fwrite(fd,&num_bytes,4,1); /* num bytes in whole file */
info = "WAVE";
cst_fwrite(fd,info,1,4);
info = "fmt ";
cst_fwrite(fd,info,1,4);
num_bytes = 16; /* size of header */
if (CST_BIG_ENDIAN) num_bytes = SWAPINT(num_bytes);
cst_fwrite(fd,&num_bytes,4,1);
d_short = RIFF_FORMAT_PCM; /* sample type */
if (CST_BIG_ENDIAN) d_short = SWAPSHORT(d_short);
cst_fwrite(fd,&d_short,2,1);
d_short = cst_wave_num_channels(w); /* number of channels */
if (CST_BIG_ENDIAN) d_short = SWAPSHORT(d_short);
cst_fwrite(fd,&d_short,2,1);
d_int = cst_wave_sample_rate(w); /* sample rate */
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
cst_fwrite(fd,&d_int,4,1);
d_int = (cst_wave_sample_rate(w)
* cst_wave_num_channels(w)
* sizeof(short)); /* average bytes per second */
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
cst_fwrite(fd,&d_int,4,1);
d_short = (cst_wave_num_channels(w)
* sizeof(short)); /* block align */
if (CST_BIG_ENDIAN) d_short = SWAPSHORT(d_short);
cst_fwrite(fd,&d_short,2,1);
d_short = 2 * 8; /* bits per sample */
if (CST_BIG_ENDIAN) d_short = SWAPSHORT(d_short);
cst_fwrite(fd,&d_short,2,1);
info = "data";
cst_fwrite(fd,info,1,4);
d_int = (cst_wave_num_channels(w)
* cst_wave_num_samples(w)
* sizeof(short)); /* bytes in data */
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
cst_fwrite(fd,&d_int,4,1);
if (CST_BIG_ENDIAN)
{
short *xdata = cst_alloc(short,cst_wave_num_channels(w)*
cst_wave_num_samples(w));
memmove(xdata,cst_wave_samples(w),
sizeof(short)*cst_wave_num_channels(w)*
cst_wave_num_samples(w));
swap_bytes_short(xdata,
cst_wave_num_channels(w)*
cst_wave_num_samples(w));
n = cst_fwrite(fd,xdata,sizeof(short),
cst_wave_num_channels(w)*cst_wave_num_samples(w));
cst_free(xdata);
}
else
{
n = cst_fwrite(fd,cst_wave_samples(w),sizeof(short),
cst_wave_num_channels(w)*cst_wave_num_samples(w));
}
if (n != cst_wave_num_channels(w)*cst_wave_num_samples(w))
return -1;
else
return 0;
}
int cst_wave_load_raw(cst_wave *w,const char *filename,
const char *bo, int sample_rate)
{
cst_file fd;
int r;
if ((fd = cst_fopen(filename,CST_OPEN_READ|CST_OPEN_BINARY)) == NULL)
{
cst_errmsg("cst_wave_load: can't open file \"%s\"\n",
filename);
return -1;
}
r = cst_wave_load_raw_fd(w, fd, bo, sample_rate);
cst_fclose(fd);
return r;
}
int cst_wave_load_raw_fd(cst_wave *w, cst_file fd,
const char *bo, int sample_rate)
{
long size;
/* Won't work on pipes, tough luck... */
size = cst_filesize(fd) / sizeof(short);
cst_wave_resize(w, size, 1);
if (cst_fread(fd, w->samples, sizeof(short), size) != size)
return -1;
w->sample_rate = sample_rate;
if (bo) /* if it's NULL we don't care */
if ((CST_LITTLE_ENDIAN && cst_streq(bo, BYTE_ORDER_BIG))
|| (CST_BIG_ENDIAN && cst_streq(bo, BYTE_ORDER_LITTLE)))
swap_bytes_short(w->samples,w->num_samples);
return 0;
}
int cst_wave_load_riff(cst_wave *w,const char *filename)
{
cst_file fd;
int r;
if ((fd = cst_fopen(filename,CST_OPEN_READ|CST_OPEN_BINARY)) == NULL)
{
cst_errmsg("cst_wave_load: can't open file \"%s\"\n",
filename);
return -1;
}
r = cst_wave_load_riff_fd(w,fd);
cst_fclose(fd);
return r;
}
int cst_wave_load_riff_header(cst_wave_header *header,cst_file fd)
{
char info[4];
short d_short;
int d_int;
if (cst_fread(fd,info,1,4) != 4)
return CST_WRONG_FORMAT;
else if (strncmp(info,"RIFF",4) != 0)
return CST_WRONG_FORMAT;
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
header->num_bytes = d_int;
if ((cst_fread(fd,info,1,4) != 4) ||
(strncmp(info,"WAVE",4) != 0))
return CST_ERROR_FORMAT;
if ((cst_fread(fd,info,1,4) != 4) ||
(strncmp(info,"fmt ",4) != 0))
return CST_ERROR_FORMAT;
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
header->hsize = d_int;
cst_fread(fd,&d_short,2,1);
if (CST_BIG_ENDIAN) d_short = SWAPSHORT(d_short);
if (d_short != RIFF_FORMAT_PCM)
{
cst_errmsg("cst_load_wave_riff: unsupported sample format\n");
return CST_ERROR_FORMAT;
}
cst_fread(fd,&d_short,2,1);
if (CST_BIG_ENDIAN) d_short = SWAPSHORT(d_short);
header->num_channels = d_short;
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
header->sample_rate = d_int;
cst_fread(fd,&d_int,4,1); /* avg bytes per second */
cst_fread(fd,&d_short,2,1); /* block align */
cst_fread(fd,&d_short,2,1); /* bits per sample */
return CST_OK_FORMAT;
}
int cst_wave_load_riff_fd(cst_wave *w,cst_file fd)
{
cst_wave_header hdr;
int rv;
char info[4];
int d_int, d;
int data_length;
int samples;
rv = cst_wave_load_riff_header(&hdr,fd);
if (rv != CST_OK_FORMAT)
return rv;
cst_fseek(fd,cst_ftell(fd)+(hdr.hsize-16),CST_SEEK_ABSOLUTE); /* skip rest of header */
/* Note there's a bunch of potential random headers */
while (1)
{
if (cst_fread(fd,info,1,4) != 4)
return CST_ERROR_FORMAT;
if (strncmp(info,"data",4) == 0)
{
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
samples = d_int/sizeof(short);
break;
}
else if (strncmp(info,"fact",4) == 0)
{
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
cst_fseek(fd,cst_ftell(fd)+d_int,CST_SEEK_ABSOLUTE);
}
else if (strncmp(info,"clm ",4) == 0)
{ /* another random chunk type -- resample puts this one in */
cst_fread(fd,&d_int,4,1);
if (CST_BIG_ENDIAN) d_int = SWAPINT(d_int);
cst_fseek(fd,cst_ftell(fd)+d_int,CST_SEEK_ABSOLUTE);
}
else
{
cst_errmsg("cst_wave_load_riff: unsupported chunk type \"%*s\"\n",
4,info);
return CST_ERROR_FORMAT;
}
}
/* Now read the data itself */
cst_wave_set_sample_rate(w,hdr.sample_rate); /* sample rate */
data_length = samples;
cst_wave_resize(w,samples/hdr.num_channels,hdr.num_channels);
if ((d = cst_fread(fd,w->samples,sizeof(short),data_length)) != data_length)
{
cst_errmsg("cst_wave_load_riff: %d missing samples, resized accordingly\n",
data_length-d);
w->num_samples = d;
}
if (CST_BIG_ENDIAN)
swap_bytes_short(w->samples,w->num_samples);
return CST_OK_FORMAT;
}