void create_aiff(struct parameters *p, PSF_PROPS *inProps, PSF_PROPS *outProps, int infile, int outfile)
{
long framesread;
unsigned long nframes = NFRAMES;
float* inframe = NULL;
float* outframe = NULL;
double timeincr;
double sampletime;
inframe = (float*) malloc(nframes * inProps->chans * sizeof(float));
outframe = (float *) malloc(nframes * outProps->chans * sizeof(float));
timeincr = 1.0 / inProps->srate;
sampletime = 0.0;
// --------------------------------------------------
while ((framesread = psf_sndReadFloatFrames(infile, inframe, nframes)) > 0)
{
int i, out_i;
for (i = 0, out_i = 0; i < framesread; i++)
{
outframe[out_i++] = (float)(inframe[i]);
sampletime += timeincr;
}
if (psf_sndWriteFloatFrames(outfile, outframe, framesread) != framesread)
{
printf("Error writing to outfile\n");
break;
}
}
free(inframe);
free(outframe);
}
int main(int argc, char *argv[])
{
long outframesize,thissize;
int i,ofd;
int ifdlist[MAX_INFILES];
//int force_stype = -1,out_stype;
int force_wave = 0;
int infilearg,inchans;
int num_infiles = 0;
int halfsec;
MYLONG peaktime;
float *outframe = NULL,*inframe = NULL;
PSF_PROPS firstinprops,inprops;
PSF_CHPEAK *fpeaks = NULL;
int wave_type = -1;
char *create_msg = NULL;
psf_format informat = PSF_STDWAVE;
char* p_dot = NULL; /* to find extension of outfile */
for(i=0;i < MAX_INFILES;i++)
ifdlist[i] = -1;
/* CDP version number */
if(argc==2 && (stricmp(argv[1],"--version")==0)){
printf("2.0.1.\n");
return 0;
}
if(argc < 4) {
fprintf(stderr,"interlx: insufficient arguments\n");
usage();
exit(1);
}
while(argv[1][0] =='-'){
switch(argv[1][1]){
case('t'):
if(argv[1][2]=='\0'){
fprintf(stderr,"-t flag requires parameter\n");
usage();
exit(1);
}
wave_type = atoi(&(argv[1][2]));
if((wave_type < 0) || wave_type >= OPT_MAXOPTS){
fprintf(stderr,"wave type out of range\n");
usage();
exit(1);
}
force_wave = 1;
break;
default:
fprintf(stderr,"\nabfpan: error: illegal flag option %s",argv[1]);
exit(1);
}
argc--; argv++;
}
if(argc < 4){
fprintf(stderr,"interlx error: at least two infiles required!\n");
usage();
exit(1);
}
if(psf_init()){
printf("Startup failure.\n");
return 1;
}
//open first infile and get properties
ifdlist[0] = psf_sndOpen(argv[2],&firstinprops,0);
if(ifdlist[0] < 0){
fprintf(stderr,"unable to open infile %s\n",argv[2]);
cleanup(ifdlist);
return 1;
}
/* we don't know how to deal with speaker positions yet, so disregard these
if(firstinprops.chformat > MC_STD){
printf(stderr,"Warning,interlx: ignoring source file speaker positions\n");
}
*/
outframesize = psf_sndSize(ifdlist[0]);
if(outframesize < 0){
fprintf(stderr,"unable to read size of infile %s\n",argv[2]);
cleanup(ifdlist);
return 1;
}
inchans = firstinprops.chans;
/*we can always allow more channels if someone really needs it! */
if(!(inchans==1 || inchans==2)){
fprintf(stderr,"interlx: error: infile %s has %d channels\n"
"\t(only mono and stereo files can be used)\n",argv[2],inchans);
cleanup(ifdlist);
return 1;
}
num_infiles = 1;
printf("interleaving %d-channel files,sample rate = %d\n",inchans,firstinprops.srate);
infilearg = 3;
while(argv[infilearg] != NULL){
if(strcmp(argv[infilearg],"0")==0){
ifdlist[num_infiles] = -1; // mark silent channel
}
else{
if((ifdlist[num_infiles] = psf_sndOpen(argv[infilearg],&inprops,0)) < 0){
fprintf(stderr,"cannot open infile %s\n",argv[infilearg]);
cleanup(ifdlist);
return 1;
}
if(inprops.chans != firstinprops.chans){
fprintf(stderr,"interlx: error: channel mismatch from infile %s\n",argv[infilearg]);
cleanup(ifdlist);
return 1;
}
if(inprops.srate != firstinprops.srate){
fprintf(stderr,"interlx: error: sample rate mismatch from infile %s\n",argv[infilearg]);
cleanup(ifdlist);
return 1;
}
thissize = psf_sndSize(ifdlist[num_infiles]);
if(thissize < 0){
fprintf(stderr,"unable to read size of infile %s\n",argv[infilearg]);
cleanup(ifdlist);
return 1;
}
outframesize = max(outframesize,thissize);
}
infilearg++;
num_infiles++;
if(num_infiles > MAX_INFILES){
fprintf(stderr,"Sorry! too many infiles. Maximum accepted is %d.\n",MAX_INFILES);
cleanup(ifdlist);
exit(1);
}
}
inframe = malloc(inchans * sizeof(float));
if(inframe==NULL){
puts("interlx: error: no memory for input buffer!\n");
cleanup(ifdlist);
return 1;
}
firstinprops.chans *= num_infiles;
outframe = (float *) malloc(firstinprops.chans * sizeof(float));
if(outframe==NULL){
puts("\ninterlx: error: no memory for output buffer!\n");
cleanup(ifdlist);
return 1;
}
fpeaks = (PSF_CHPEAK *) calloc(firstinprops.chans,sizeof(PSF_CHPEAK));
if(fpeaks==NULL){
puts("interlx: error: no memory for internal PEAK buffer\n");
cleanup(ifdlist);
return 1;
}
if(force_wave){
int i,matched;
switch(wave_type){
case(OPT_WAVEX_GENERIC):
inprops.chformat = MC_STD;
informat = PSF_WAVE_EX;
create_msg = "creating STD WAVE_EX file";
break;
case(OPT_WAVEX):
switch(firstinprops.chans){
case(1):
firstinprops.chformat = MC_MONO;
informat = PSF_WAVE_EX;
create_msg = "creating MONO WAVE_EX file";
break;
case(2):
firstinprops.chformat = MC_STEREO;
informat = PSF_WAVE_EX;
create_msg = "creating STEREO WAVE_EX file";
break;
case(4):
firstinprops.chformat = MC_QUAD;
informat = PSF_WAVE_EX;
create_msg = "creating QUAD WAVE_EX file";
break;
default:
fprintf(stderr,"infile nchans incompatible with requested WAVE-EX format\n");
usage();
cleanup(ifdlist);
return 1;
}
break;
case(OPT_WAVEX_LCRS):
if(firstinprops.chans != 4){
fprintf(stderr,"result must have four channels\n");
usage();
cleanup(ifdlist);
return 1;
}
firstinprops.chformat = MC_LCRS;
informat = PSF_WAVE_EX;
create_msg = "creating LCRS-surround WAVE_EX file";
break;
case(OPT_WAVEX_SURROUND):
if(firstinprops.chans != 6){
fprintf(stderr,"result must have six channels\n");
usage();
cleanup(ifdlist);
exit(1);
}
firstinprops.chformat = MC_DOLBY_5_1;
informat = PSF_WAVE_EX;
create_msg = "creating 5.1 surround WAVE_EX file";
break;
case(OPT_SURR_5_0):
if(firstinprops.chans != 5){
fprintf(stderr,"result must have five channels.\n");
usage();
cleanup(ifdlist);
return 1;
}
firstinprops.chformat = MC_SURR_5_0;
informat = PSF_WAVE_EX;
create_msg = "creating 5.0 surround WAVE_EX file";
break;
case(OPT_WAVEX_BFORMAT):
matched = 0;
for(i=0;i < N_BFORMATS;i++) {
if(firstinprops.chans == bformats[i]){
matched = 1;
break;
}
}
if(!matched){
printf("WARNING: No Bformat definition for %d-channel file.\n",inprops.chans);
}
firstinprops.chformat = MC_BFMT;
informat = PSF_WAVE_EX;
create_msg = "creating AMBISONIC B-FORMAT WAVE_EX file";
break;
case OPT_WAVEX_7_1:
if(firstinprops.chans != 8){
fprintf(stderr,"result must have channels\n");
usage();
cleanup(ifdlist);
return 1;
}
firstinprops.chformat = MC_SURR_7_1;
informat = PSF_WAVE_EX;
create_msg = "creating 7.1 surround WAVE_EX file";
break;
case OPT_WAVEX_CUBE:
if(firstinprops.chans != 8){
fprintf(stderr,"result must have channels\n");
usage();
cleanup(ifdlist);
return 1;
}
firstinprops.chformat = MC_CUBE;
informat = PSF_WAVE_EX;
create_msg = "creating cube surround WAVE_EX file";
break;
case OPT_WAVEX_6_1:
if(firstinprops.chans != 7){
fprintf(stderr,"result must have channels\n");
usage();
cleanup(ifdlist);
return 1;
}
firstinprops.chformat = MC_SURR_6_1;
informat = PSF_WAVE_EX;
create_msg = "creating 6.1 surround WAVE_EX file";
break;
default:
inprops.chformat = STDWAVE;
informat = PSF_STDWAVE;
create_msg = "creating plain sound file";
break;
}
}
/* want to avoid WAVE_EX if just plain WAVE possible */
firstinprops.format = informat;
/*firstinprops.chformat = MC_STD;*/ /* RWD April 2006 do this here? */
p_dot = strrchr(argv[1],'.');
if(stricmp(++p_dot,"amb")==0) {
int i;
int matched = 0;
firstinprops.chformat = MC_BFMT;
for(i=0;i < N_BFORMATS;i++) {
if(firstinprops.chans == bformats[i]){
matched = 1;
break;
}
}
if(!matched)
printf("\nWARNING: channel count %d unknown for BFormat.\n",firstinprops.chans);
}
if(!is_legalsize(outframesize,&firstinprops)){
fprintf(stderr,"error: outfile size %ld exceeds capacity of format.\n",outframesize);
return 1;
}
printf("\n%s: %d channels, %ld frames.\n",create_msg,firstinprops.chans,outframesize);
ofd = psf_sndCreate(argv[1],&firstinprops,0,0,PSF_CREATE_RDWR);
if(ofd < 0){
fprintf(stderr,"interlx: error: unable to create outfile %s.\n",argv[1]);
cleanup(ifdlist);
return 1;
}
halfsec = firstinprops.srate / 2;
for(i=0;i < outframesize; i++){ // frame loop
float *p_framesamp,*p_filesamp;
int j;
p_framesamp = outframe;
memset((char *)outframe,0,firstinprops.chans * sizeof(float));
for(j=0;j < num_infiles;j++) { //file loop
int k,got;
memset((char *)inframe,0,inchans * sizeof(float));
if(ifdlist[j] < 0){
got = inchans; // placeholder - write silent channel
}
else{
if((got = psf_sndReadFloatFrames(ifdlist[j],inframe,1)) < 0){
fprintf(stderr,"interlx: error reading from infile %s\n",argv[2+j]);
psf_sndClose(ofd);
cleanup(ifdlist);
return 1;
}
}
if(got==1){
p_filesamp = inframe;
for(k=0;k < inchans;k++) //channel loop
*p_framesamp++ = *p_filesamp++;
}
else
p_framesamp += inchans;
}
if(psf_sndWriteFloatFrames(ofd,outframe,1) < 0){
fprintf(stderr,"interlx: error writing to outfile\n");
psf_sndClose(ofd);
cleanup(ifdlist);
return 1;
}
if(i % halfsec==0) {
printf("%.2lf secs\r",(double)i / (double) firstinprops.srate);
fflush(stdout);
}
}
printf("%.4lf secs\nWritten %ld sample frames to %s\n",(double)outframesize / (double)firstinprops.srate,outframesize,argv[1]);
if(psf_sndReadPeaks( ofd,fpeaks,&peaktime)){
printf("PEAK data:\n");
for(i = 0; i < firstinprops.chans; i++) {
double val, dbval;
val = (double) fpeaks[i].val;
dbval = 20.0 * log10(val);
printf("CH %d: %.6f (%.2lfdB) at frame %u:\t%.4f secs\n",i,
val,dbval,(unsigned int) fpeaks[i].pos,(double)fpeaks[i].pos / (double) firstinprops.srate);
}
}
printf("\n");
psf_sndClose(ofd);
free(inframe);
free(outframe);
if(fpeaks)
free(fpeaks);
cleanup(ifdlist);
return 0;
}
int main(int argc, char* argv[])
{
int i;
PSF_PROPS props;
long framesread;
long totalread;
/* init all dynamic resources to default states */
int ifd = -1,ofd = -1;
int error = 0;
PSF_CHPEAK* peaks = NULL;
float* frame = NULL;
psf_format outformat = PSF_FMT_UNKNOWN;
printf("SF2FLOAT: convert soundfile to 32bit floats format\n");
if(argc < 4){
printf("insufficient arguments.\n"
"usage:\n\t"
"sf2float option infile outfile\n");
return 1;
}
/* be good, and startup portsf */
if(psf_init()){
printf("unable to start portsf\n");
return 1;
}
ifd = psf_sndOpen(argv[2],&props,0);
if(ifd < 0 && atoi(argv[1])!=5){
printf("Error: unable to open infile %s\n",argv[2]);
return 1;
}
if(props.samptype == PSF_SAMP_16){
printf("Info: infile is in 16 bit format.\n");
}
if(props.samptype == PSF_SAMP_24){
printf("Info: infile is in 24 bit format.\n");
}
if(props.samptype == PSF_SAMP_32){
printf("Info: infile is in 32 bit format.\n");
}
/* we now have a resource, so we use goto hereafter on hitting any error */
/* tell user if source file is already floats */
if(props.samptype == PSF_SAMP_IEEE_FLOAT){
printf("Info: infile is already in floats format.\n");
}
props.samptype = PSF_SAMP_IEEE_FLOAT;
/* check file extension of outfile name, so we use correct output file format*/
// TODO: needs to be changed because output is not always the same format
if (atoi(argv[1])<3 || atoi(argv[1])==5) {
outformat = psf_getFormatExt(argv[3]);
printf("output file format: %d", outformat);
if(outformat == PSF_FMT_UNKNOWN){
printf("outfile name %s has unknown format.\n"
"Use any of .wav, .aiff, .aif, .afc, .aifc\n",argv[3]);
error++;
goto exit;
}
}
else if (atoi(argv[1])==4) {
outformat = psf_getFormatExt(argv[4]);
printf("output file format: %d", outformat);
if(outformat == PSF_FMT_UNKNOWN){
printf("outfile name %s has unknown format.\n"
"Use any of .wav, .aiff, .aif, .afc, .aifc\n",argv[4]);
error++;
goto exit;
}
}
props.format = outformat;
if(atoi(argv[1])<3 || atoi(argv[1])==5) {
props.srate = 44100;
props.chans = 2;
props.samptype = PSF_SAMP_IEEE_FLOAT;
props.format = PSF_STDWAVE;
props.chformat = STDWAVE;
ofd = psf_sndCreate(argv[3],&props,0,0,PSF_CREATE_RDWR);
if(ofd < 0){
printf("Error: unable to create outfile %s\n",argv[3]);
error++;
goto exit;
}
}
else if (atoi(argv[1])==4) {
ofd = psf_sndCreate(argv[4],&props,0,0,PSF_CREATE_RDWR);
if(ofd < 0){
printf("Error: unable to create outfile %s\n",argv[4]);
error++;
goto exit;
}
}
/* allocate space for one sample frame */
frame = (float*) malloc(props.chans * sizeof(float));
if(frame==NULL){
puts("No memory!\n");
error++;
goto exit;
}
/* and allocate space for PEAK info */
peaks = (PSF_CHPEAK*) malloc(props.chans * sizeof(PSF_CHPEAK));
if(peaks == NULL){
puts("No memory!\n");
error++;
goto exit;
}
// if(atoi(argv[1])!=5) {
//printf("copying....\n");
/* single-frame loop to do copy: report any read/write errors */
// framesread = psf_sndReadFloatFrames(ifd,frame,1);
// totalread = 0; /* count sample frames as they are copied */
// }
int part = atoi(argv[1]);
/*
* Switch depending on the part of the assignment
*/
switch(part) {
/*
* Part 0: Output the file as is.
*/
case 0:
while (framesread == 1){
totalread++;
if(psf_sndWriteFloatFrames(ofd,frame,1) != 1){
printf("Error writing to outfile\n");
error++;
break;
}
framesread = psf_sndReadFloatFrames(ifd,frame,1);
}
break;
/*
* Part 1: Divide the value of each sample by 2.
*/
case 1: {
while (framesread == 1){
frame[0] = frame[0]/2;
frame[1] = frame[1]/2;
totalread++;
if(psf_sndWriteFloatFrames(ofd,frame,1) != 1){
printf("Error writing to outfile\n");
error++;
break;
}
framesread = psf_sndReadFloatFrames(ifd,frame,1);
}
break;
}
/*
* Part 2: Pan the output from left to right, with an interval of 5 seconds.
*/
case 2: {
double cycle = 5; // cycle of 5 seconds
double period = 4 * cycle; // sine or cosine period
double sampleLimit = period * 44100;
while (framesread == 1){
frame[0] = frame[0]*sin(2*M_PI*totalread/sampleLimit);
frame[1] = frame[1]*cos(2*M_PI*totalread/sampleLimit);
totalread++;
if(psf_sndWriteFloatFrames(ofd,frame,1) != 1){
printf("Error writing to outfile\n");
error++;
break;
}
framesread = psf_sndReadFloatFrames(ifd,frame,1);
}
break;
}
/*
* Part 3: Create envelope file.
*/
case 3:
{
double max = 0; // to keep track of the max in the interval
int currentSample = 0;
double intervalTime = 0.05;
double sampleLimit = 44100*intervalTime;
int interval = 1;
FILE *file;
file = fopen(argv[3], "w+");
printf("sampleLimit %f\n", sampleLimit);
while (framesread == 1){
if (currentSample < sampleLimit) {
if (max < frame[0]) {
max = frame[0];
}
if (max < -1*frame[0]) {
max = -1*frame[0];
}
if (max < frame[1]) {
max = frame[1];
}
if (max < -1*frame[1]) {
max = -1*frame[1];
}
currentSample++;
}
else {
fprintf(file, "%f %f\n", (double)(interval*intervalTime), max);
max = 0;
currentSample = 0;
interval++;
}
totalread++;
framesread = psf_sndReadFloatFrames(ifd,frame,1);
}
fclose(file);
break;
}
/*
* apply envelope on file
*/
case 4:
{
// open up file, put the reading index on the first line
FILE *file;
file = fopen(argv[3], "r");
double intervalTime = 0.05;
char intervalLimitString[20], valueString[20], space[1];
double intervalLimit=-1, value=0;
// to do the linear regression and get the factor
double prevValue = 0;
double slope = 0;
double intercept = 0;
double factor = 1;
double current=0;
while (framesread == 1) {
if (!feof(file)) {
if(current/44100 >= intervalLimit ) {
if(fgets(intervalLimitString, 10, file) != NULL) {
intervalLimit = strtod(intervalLimitString, NULL);
}
if(fgets(space, 1, file) != NULL) {}
if(fgets(valueString, 12, file) != NULL) {
prevValue = value;
value = strtod(valueString, NULL);
slope = (value-prevValue)/intervalTime;
intercept = prevValue;
}
}
factor = ((double)(totalread%((int)(44100*intervalTime)))/44100)*slope + intercept;
frame[0] = frame[0]*factor;
frame[1] = frame[1]*factor;
int tt = totalread%2205;
// printf("time: %d \t value: %f \t slope %f \t intercep %f \t will multiply by: %f\n", tt, value, slope, intercept, factor);
}
current++;
totalread++;
if(psf_sndWriteFloatFrames(ofd,frame,1) != 1){
printf("Error writing to outfile\n");
error++;
break;
}
framesread = psf_sndReadFloatFrames(ifd,frame,1);
}
break;
}
/*
* add up sine waves
*/
case 5: {
FILE *file;
file = fopen(argv[2], "r");
char sineAmplitudeString[20], sineFrequencyString[20], space[1];
double sineAmplitude, sineFrequency;
double sineAmplitudes[20], sineFrequencies[20];
int currentIndex = 0;
int arraySize=0;
while (!feof(file)) {
if(fgets(sineFrequencyString, 5, file) != NULL) {
sineFrequency = strtod(sineFrequencyString, NULL);
if(sineFrequency==-1)
break;
else {
sineFrequencies[currentIndex] = sineFrequency;
if(fgets(space, 1, file) != NULL) {}
if(fgets(sineAmplitudeString, 20, file) != NULL) {
sineAmplitude = strtod(sineAmplitudeString, NULL);
sineAmplitudes[currentIndex] = sineAmplitude;
currentIndex++;
}
}
}
}
arraySize = currentIndex;
currentIndex = 0;
int i;
for(i=0; i<arraySize; i++) {
printf(" %f %f \n", sineAmplitudes[i], sineFrequencies[i]);
}
// do i assume it is 0.05?
double intervalTime = 0.05;
char intervalLimitString[20], valueString[20];
double intervalLimit=-1, value=0;
// to do the linear regression and get the factor
double prevValue = 0;
double slope = 0;
double intercept = 0;
double factor = 1;
double current=0;
while(!feof(file)){
if(current/44100 >= intervalLimit ) {
if(fgets(intervalLimitString, 10, file) != NULL) {
intervalLimit = strtod(intervalLimitString, NULL);
}
if(fgets(space, 1, file) != NULL) {}
if(fgets(valueString, 12, file) != NULL) {
prevValue = value;
value = strtod(valueString, NULL);
slope = (value-prevValue)/intervalTime;
intercept = prevValue;
}
}
factor = ((double)((int)current%((int)(44100*intervalTime)))/44100)*slope + intercept;
printf("%f\n", factor);
// compute frame[1] and frame[2]
frame[0] = 0;
int i;
for(i=0; i<arraySize; i++) {
frame[0] += sineAmplitudes[i]*sin(2*M_PI*current*sineFrequencies[i]/44100);
}
frame[0] = frame[0]*factor;
frame[1] = frame[0];
if(psf_sndWriteFloatFrames(ofd,frame,1) != 1){
printf("Error writing to outfile\n");
error++;
break;
}
current++;
}
break;
}
default:
printf("default case");
break;
}
if(framesread < 0) {
printf("Error reading infile. Outfile is incomplete.\n");
error++;
}
else {
if (atoi(argv[1])<3) {
printf("Done. %ld sample frames copied to %s\n",totalread,argv[3]);
}
else if (atoi(argv[1])==4) {
printf("Done. %ld sample frames copied to %s\n",totalread,argv[4]);
}
}
/* report PEAK values to user */
if(psf_sndReadPeaks(ofd,peaks,NULL) > 0){
long i;
double peaktime;
printf("PEAK information:\n");
for(i=0;i < props.chans;i++){
peaktime = (double) peaks[i].pos / (double) props.srate;
printf("CH %ld:\t%.4f at %.4f secs\n", i+1, peaks[i].val, peaktime);
}
}
/* do all cleanup */
exit: if(ifd >= 0)
psf_sndClose(ifd);
if(ofd >= 0)
psf_sndClose(ofd);
if(frame)
free(frame);
if(peaks)
free(peaks);
psf_finish();
return error;
}
int main(int argc, char**argv)
{
PSF_PROPS props;
long framesread, totalread;
DWORD nFrames;
int size;
int limit;
int N; // copy infile N times
/* init all resource vals to default states */
int ifd=-1, ofd=-1;
int error=0;
psf_format outformat = PSF_FMT_UNKNOWN;
PSF_CHPEAK* peaks = NULL;
float* buffer = NULL;
printf ("SF2FLOAT: convert soundfile to floats format.\n");
if (argc!=ARG_NARGS)
{
printf("insufficient arguments.\n"
"USAGE:\tsf2float infile outfile buffer limit N\n");
return 1;
}
/* startup portsf */
if(psf_init())
{
printf("ERROR: unable to start portsf\n");
return 1;
}
/* initialize buffer */
nFrames = (DWORD)atoi(argv[ARG_BUFF]);
if (nFrames < 1)
{
printf("ERROR: buffer size must be at least 1\n");
return 1;
}
/* initialize limit */
limit = atoi(argv[ARG_LIMIT]);
if (limit<1)
{
printf("ERROR: size limit must be positive.\n");
return 1;
}
/* initialize N */
N = atoi(argv[ARG_N]);
if (N<1)
{
printf("ERROR: N must be at least one.\n");
return 1;
}
/* open infile */
ifd = psf_sndOpen(argv[ARG_INFILE], &props, 0);
if (ifd<0)
{
printf("ERROR: unable to open infile \"%s\"\n",argv[ARG_INFILE]);
return 1;
}
/* we now have a resource, so we use goto hereafter
on hitting any error */
/* get number of frames from infile */
size = psf_sndSize(ifd);
if(size<0)
{
printf("ERROR: unable to obtain the size of \"%s\"\n",argv[ARG_INFILE]);
error++;
goto exit;
}
/* check if copy limit is less than size */
if(size<limit)
{
printf("ERROR: infile size is less than the copy limit.\n"
"infile:\t%s\n"
"infile size:\t%d frames\n"
"copy limit:\t%d frames\n",
argv[ARG_INFILE], size, limit);
error++;
goto exit;
}
/* tell user if source file is already floats */
if (props.samptype==PSF_SAMP_IEEE_FLOAT)
printf("Info: infile is already in floats format.\n");
/* check if infile uses 8-bit samples*/
if (props.samptype==PSF_SAMP_8)
{
printf("ERROR: sf2float does not support 8-bit format.\n");
error++;
goto exit;
}
if(!psf_sndInfileProperties(argv[ARG_INFILE],ifd,&props))
{
error++;
goto exit;
}
props.samptype=PSF_SAMP_IEEE_FLOAT;
/* check if outfile extension is one we know about */
outformat = psf_getFormatExt(argv[ARG_OUTFILE]);
if (outformat == PSF_FMT_UNKNOWN)
{
printf("Outfile name \"%s\" has unknown format.\n"
"Use any of .wav .aiff .aif .afc .aifc\n",
argv[ARG_OUTFILE]);
error++;
goto exit;
}
props.format = outformat;
/* create outfile */
ofd = psf_sndCreate(argv[ARG_OUTFILE], &props, 0, 0, PSF_CREATE_RDWR);
if (ofd<0)
{
printf("ERROR: unable to create outfile \"%s\"\n",argv[ARG_OUTFILE]);
error++;
goto exit;
}
/* allocate space for sample frames */
if (limit<nFrames)
nFrames = (DWORD)limit;
buffer= (float*)malloc(props.chans*sizeof(float)*nFrames);
if (buffer==NULL)
{
puts("No memory!\n");
error++;
goto exit;
}
/* and allocate space for PEAK info */
peaks = (PSF_CHPEAK*)malloc(props.chans*sizeof(PSF_CHPEAK));
if (peaks==NULL)
{
puts("No memory!\n");
error++;
goto exit;
}
printf("copying...\n");
int i=0;
int j;
/* copy the infile N times */
for (j=0; j<N; j++)
{
/* make sure to set nFrames to the correct value
every time you pass through the for loop */
if (limit < atoi(argv[ARG_BUFF]))
nFrames = (DWORD)limit;
else
nFrames = (DWORD)atoi(argv[ARG_BUFF]);
totalread = 0; /* running count of sample frames */
if(psf_sndSeek(ifd,0,PSF_SEEK_SET))
{
printf("ERROR: cannot reset infile\n");
error++;
goto exit;
}
/* nFrames loop to do copy, report any errors */
framesread = psf_sndReadFloatFrames(ifd,buffer,nFrames);
while (framesread>0&&totalread<limit)
{
i++;
/* update copy status after refreshing the buffer every 100 times */
if (i%100==0)
printf("%ld samples copied... %ld%%\r",totalread,100*totalread/size);
totalread+=framesread;
if(psf_sndWriteFloatFrames(ofd,buffer,nFrames)<0)
{
printf("Error writing to outfile.\n");
error++;
break;
}
/* make sure not to copy frames past the limit */
if (nFrames+totalread > limit)
nFrames = (DWORD)(limit-totalread);
framesread = psf_sndReadFloatFrames(ifd,buffer,nFrames);
}
}
totalread *= N; /* total number of frames copied */
if(framesread<0)
{
printf("Error reading infile. Outfile is incomplete.\n");
error++;
}
else
printf("Done. %ld sample frames copied to %s\n",
totalread, argv[ARG_OUTFILE]);
/* report PEAKS to user */
if (psf_sndReadPeaks(ofd,peaks,NULL)>0)
{
long i;
double peaktime;
double peakDB;
printf("Peak information:\n");
for (i=0; i<props.chans; i++)
{
peaktime = (double)peaks[i].pos/props.srate;
if (peaks[i].val == 0.0)
peaks[i].val = 1.0e-4;
peakDB = log10(peaks[i].val);
printf("CH %ld:\t%.4f\t(%.4f dB) at %.4f secs\n",
i+1, peaks[i].val, peakDB, peaktime);
}
}
/* do all the cleanup */
exit:
if (ifd>=0)
psf_sndClose(ifd);
if (ofd>=0)
psf_sndClose(ofd);
if (buffer)
free(buffer);
if (peaks)
free(peaks);
psf_finish();
return error;
}
int main(int argc, char**argv)
{
PSF_PROPS props;
long framesread, totalread;
DWORD nFrames;
int size;
int limit;
int N; // copy infile N times
float ampfac;
float dbval;
/* init all resource vals to default states */
int ifd=-1, ofd=-1;
int error=0;
psf_format outformat = PSF_FMT_UNKNOWN;
PSF_CHPEAK* peaks = NULL;
float* buffer = NULL;
/* init flags for command-line options */
int isamp=0; // default scale factor is in dBs
printf ("SFGAIN: change level of soundfile.\n");
if ((argc<ARG_NOPS)||(argc>ARG_OPS))
{
printf("insufficient arguments.\n"
"USAGE:\tsfgain infile outfile buffer limit N [dBval | -a ampfac]\n"
"dBval must be <= 0 or ampfac must be > 0\n");
return 1;
}
/* check for command-line options */
if (argc==ARG_OPS)
{
if (argv[ARG_OP][0]=='-')
{
if (argv[ARG_OP][1]=='a')
isamp=1;
else
{
printf("ERROR: %s is not a valid command-line option.\n"
"USAGE:\tsfgain infile outfile buffer limit N [dBval | -a ampfac]\n"
"dBval must be <= 0 or ampfac must be > 0\n", argv[ARG_OP]);
return 1;
}
}
}
/* startup portsf */
if(psf_init())
{
printf("ERROR: unable to start portsf\n");
return 1;
}
/* initialize buffer */
nFrames = (DWORD)atoi(argv[ARG_BUFF]);
if (nFrames < 1)
{
printf("ERROR: buffer size must be at least 1\n");
return 1;
}
/* initialize limit */
limit = atoi(argv[ARG_LIMIT]);
if (limit<1)
{
printf("ERROR: size limit must be positive.\n");
return 1;
}
/* initialize N */
N = atoi(argv[ARG_N]);
if (N<1)
{
printf("ERROR: N must be at least one.\n");
return 1;
}
/* initialize dBval or ampfac */
if (isamp)
{
ampfac = atof(argv[ARG_AMP]);
if (ampfac <= 0.0)
{
printf("ERROR: ampfac must be positive.\n");
return 1;
}
if (ampfac == 1.0)
{
printf("ERROR: an ampfac of 1 creates an outfile "
" identicle to the infile\n");
return 1;
}
}
else
{
dbval = atof(argv[ARG_DB]);
if (dbval > 0.0)
{
printf("ERROR: dBval cannot be positive.\n");
return 1;
}
if (dbval==0.0)
{
printf("ERROR: dBval of 0 creates an outfile "
"identicle to the infile\n");
return 1;
}
/* convert dB to amps */
ampfac = pow(10.0, dbval/20.0);
}
/* open infile */
ifd = psf_sndOpen(argv[ARG_INFILE], &props, 0);
if (ifd<0)
{
printf("ERROR: unable to open infile \"%s\"\n",argv[ARG_INFILE]);
return 1;
}
/* we now have a resource, so we use goto hereafter
on hitting any error */
/* get number of frames from infile */
size = psf_sndSize(ifd);
if(size<0)
{
printf("ERROR: unable to obtain the size of \"%s\"\n",argv[ARG_INFILE]);
error++;
goto exit;
}
/* check if copy limit is less than size */
if(size<limit)
{
printf("ERROR: infile size is less than the copy limit.\n"
"infile:\t%s\n"
"infile size:\t%d frames\n"
"copy limit:\t%d frames\n",
argv[ARG_INFILE], size, limit);
error++;
goto exit;
}
/* check if infile uses 8-bit samples*/
if (props.samptype==PSF_SAMP_8)
{
printf("ERROR: sfgain does not support 8-bit format.\n");
error++;
goto exit;
}
/* display infile properties */
if(!psf_sndInfileProperties(argv[ARG_INFILE],ifd,&props))
{
error++;
goto exit;
}
/* check if outfile extension is one we know about */
outformat = psf_getFormatExt(argv[ARG_OUTFILE]);
if (outformat == PSF_FMT_UNKNOWN)
{
printf("Outfile name \"%s\" has unknown format.\n"
"Use any of .wav .aiff .aif .afc .aifc\n",
argv[ARG_OUTFILE]);
error++;
goto exit;
}
props.format = outformat;
/* create outfile */
ofd = psf_sndCreate(argv[ARG_OUTFILE], &props, 0, 0, PSF_CREATE_RDWR);
if (ofd<0)
{
printf("ERROR: unable to create outfile \"%s\"\n",argv[ARG_OUTFILE]);
error++;
goto exit;
}
/* allocate space for sample frames */
if (limit<nFrames)
nFrames = (DWORD)limit;
buffer= (float*)malloc(props.chans*sizeof(float)*nFrames);
if (buffer==NULL)
{
puts("No memory!\n");
error++;
goto exit;
}
/* and allocate space for PEAK info */
peaks = (PSF_CHPEAK*)malloc(props.chans*sizeof(PSF_CHPEAK));
if (peaks==NULL)
{
puts("No memory!\n");
error++;
goto exit;
}
printf("copying...\n");
int update=0;
int loop;
int i;
int j;
/* copy the infile N times */
for (loop=0; loop<N; loop++)
{
/* make sure to set nFrames to the correct value
every time you pass through the for loop */
if (limit < atoi(argv[ARG_BUFF]))
nFrames = (DWORD)limit;
else
nFrames = (DWORD)atoi(argv[ARG_BUFF]);
totalread = 0; /* running count of sample frames */
if(psf_sndSeek(ifd,0,PSF_SEEK_SET))
{
printf("ERROR: cannot reset infile\n");
error++;
goto exit;
}
/* nFrames loop to do copy, report any errors */
framesread = psf_sndReadFloatFrames(ifd,buffer,nFrames);
while (framesread>0&&totalread<limit)
{
update++;
/* update copy status after refreshing the buffer every 100 times */
if (update%100==0)
printf("%ld samples copied... %ld%%\r",totalread,100*totalread/size);
totalread+=framesread;
/* change sample values by amp factor */
for (j=0; j<nFrames; j++)
for (i=0; i<props.chans; i++)
buffer[props.chans*j+i] *= ampfac;
if(psf_sndWriteFloatFrames(ofd,buffer,nFrames)<0)
{
printf("Error writing to outfile.\n");
error++;
break;
}
/* make sure not to copy frames past the limit */
if (nFrames+totalread > limit)
nFrames = (DWORD)(limit-totalread);
framesread = psf_sndReadFloatFrames(ifd,buffer,nFrames);
}
}
totalread *= N; /* total number of frames copied */
if(framesread<0)
{
printf("Error reading infile. Outfile is incomplete.\n");
error++;
}
else
printf("Done. %ld sample frames copied to %s\n",
totalread, argv[ARG_OUTFILE]);
/* report PEAKS to user */
if (psf_sndReadPeaks(ofd,peaks,NULL)>0)
{
long i;
double peaktime;
double peakDB;
printf("Peak information:\n");
for (i=0; i<props.chans; i++)
{
peaktime = (double)peaks[i].pos/props.srate;
if (peaks[i].val == 0.0)
peaks[i].val = 1.0e-4;
peakDB = log10(peaks[i].val);
printf("CH %ld:\t%.4f\t(%.4f dB) at %.4f secs\n",
i+1, peaks[i].val, peakDB, peaktime);
}
}
/* do all the cleanup */
exit:
if (ifd>=0)
psf_sndClose(ifd);
if (ofd>=0)
psf_sndClose(ofd);
if (buffer)
free(buffer);
if (peaks)
free(peaks);
psf_finish();
return error;
}
void sf2float(int argc, char *argv[])
{
//This function will sound portsf to convert a soundfile to float format
/*=========================USAGE=========================
sf2float infile outfile
======================================================*/
if(argc!=NUMARGS)
{
fprintf(stderr, "USAGE: sf2float infile outfile\n");
exit(1);
}
PSF_PROPS props; //structure containing sample rate, channels, sample type, format, channel format...
long framesread,totalread;
int infd =-1 , outfd = -1;
psf_format outformat = PSF_FMT_UNKNOWN; //initially make the outformat unknown until properly defined by create function
PSF_CHPEAK* peaks = NULL; //in waveform and aiff, peaks holds the channel peak values accordingly
float* frame = NULL; //a frame is a set of n datatypes (16-bit --> short; 24 bit --> long; 32 bit --> float) where n is determined by number of channels
//initialize portsf
int psfd = psf_init();
if(psfd<0)
{
fprintf(stderr, "Unable to initialize portsf\n");
exit(1);
}
//function to open exsiting soudfile protoype--> psf_sndOpen(const char *path, PSF_PROPS *props, int rescale)
//PSF_PROPS <-- refer to note above on definition line of props
//rescale --> normally set to 0 for samples to be read unaltered; otherwise, rescale normalizes sound between -1 and 1 to preven clipping
infd = psf_sndOpen(argv[IN_FILE], &props, 0);
if(infd<0)
{
fprintf(stderr, "Unable to open soundfile\n");
goto exit; //Works like a JAL command; exit block must be within same function block; used for cleanup purposes. ALL SUBSEQUENT ERROR HANDLING MUST USE GOTO
}
//tell user if in_file is already floats (i.e 32-bit)
if(props.samptype == PSF_SAMP_IEEE_FLOAT)
{
fprintf(stderr, "Infile already of type float\t Nothing to do...\n");
goto exit;
}
else props.samptype = PSF_SAMP_IEEE_FLOAT; //if not already of type float --> then set the samptype parameter of props strcuture to type float
//Check to see that outfile extension is applicable --> noncompressed, lossless --> wav, aiff, aif, afc, aifc
outformat = psf_getFormatExt(argv[OUTFILE]);
if(outformat==PSF_FMT_UNKNOWN)
{
fprintf(stderr, "Improper outfile format\nAccepted Formats: .wav, .aiff, .aif, .afc, .aifc\n");
goto exit;
}
else props.format=outformat; //if format applicable --> set the format paramter of props structure to the outformat as discovered by portfs on outfile extension provided
//Opening a sound file for writing prototype --> psf_sndCreate(const char *path, const PSF_PROPS *props, int clip_floats, int minheader, int mode)
//clip_floats --> set the way the floats are written <-- used in conjunction with rescale value being nonzero in psf_sndOpen
//minheader --> normally set to 0; set to 1 for legacy compatibility
//mode --> control of read-write access to the file {PSF_CREATE_RDWR, PSF_CREATE_TEMPORARY, PSF_CREATE_WRONLY}
outfd = psf_sndCreate(argv[OUTFILE], &props, 0, 0, PSF_CREATE_RDWR);
if(outfd<0)
{
fprintf(stderr, "Unable to create soundfile\n");
goto exit;
}
//Allocate space for one sample frame
frame = (float*)malloc(props.chans * sizeof(float));
if(frame==NULL) goto no_memory;
//Allocate space for PEAK info
peaks = (PSF_CHPEAK*)malloc(props.chans * sizeof(PSF_CHPEAK));
if(peaks==NULL) goto no_memory;
//single-frame loop --> copying as floats (conversion process)
framesread = psf_sndReadFloatFrames(infd, frame, 1);
totalread = 0;
while(framesread==1)
{
totalread++;
if(psf_sndWriteFloatFrames(outfd,frame,1) != 1)
{
fprintf(stderr, "Error writing to file\n");
break;
}
/* ===============DO ANY PROCESSING HERE; CORE OF AUDIO PROCESSING===============*/
framesread = psf_sndReadFloatFrames(infd,frame,1);
}
if(framesread<0)
{
fprintf(stderr, "Error handling infile; outfile is incomplete\n");
goto exit;
}
else fprintf(stdout, "Task Finished %d sample frames copied to %s\n", (int)totalread, argv[OUTFILE]);
//report PEAK values to user
if(psf_sndReadPeaks(outfd, peaks, NULL) >0)
{
long i;
double peakTime;
fprintf(stdout, "PEAK Information:\n");
for(i=0; i<props.chans; i++)
{
peakTime = (double) peaks[i].pos / props.srate;
fprintf(stdout, "CH %d:\t%.4f at %.4f secs\n", (int)(i+1), peaks[i].val, peakTime);
}
}
exit:
if(infd>=0) psf_sndClose(infd);
if(outfd>=0) psf_sndClose(outfd);
if(frame) free(frame);
if(peaks) free(peaks);
psf_finish(); // close portfs
fprintf(stderr, "Program Terminated\n");
exit(1);
no_memory:
fprintf(stderr, "No Memory!\n");
goto exit;
}
