/*************************************************************************//*                                                                       *//*                  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;}