int main(int argc, char* argv[]) { PSF_PROPS props; long framesread; long totalread; /* init all dynamic resources to default states */ int ifd = -1,ofd = -1; int i,error = 0; double gain = 1.0; PSF_CHPEAK* peaks = NULL; psf_format outformat = PSF_FMT_UNKNOWN; FILE* fin = NULL; float* frame; printf("TEXT2SF: convert text audio data to soundfile\n"); if(argc < ARG_NARGS) { printf("insufficient arguments.\n" "usage:\n\t" "text2sf infile outfile srate chans gain\n"); return 1; } /* be good, and startup portsf */ if(psf_init()) { printf("unable to start portsf\n"); return 1; } fin = fopen(argv[ARG_INFILE],"r"); /* we now have a resource, so we use goto hereafter on hitting any error */ /* tell user if source file is already floats */ if(fin==NULL) { printf("cannot open infile %s\n",argv[ARG_INFILE]); return 1; } props.chans = atoi(argv[ARG_CHANS]); if(props.chans <=0) { printf("chans must be positive!\n"); fclose(fin); return 1; } props.srate = atoi(argv[ARG_SR]); if(props.srate <=0) { printf("srate must be positive!\n"); fclose(fin); return 1; } gain = atof(argv[ARG_GAIN]); if(gain <= 0.0) { printf("gain value must be positive!\n"); fclose(fin); return 1; } frame = malloc(props.chans * sizeof(float)); if(frame==NULL) { puts("No memoery!\n"); fclose(fin); return 1; } /* fixed output to 16bit file; one alternative would be PSF_SAM_IEEE_FLOAT for 32bit float format */ props.samptype = PSF_SAMP_16; props.format = PSF_STDWAVE; props.chformat = STDWAVE; /* check file extension of outfile name, so we use correct output file format*/ 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; 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; } /* 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"); /* single-frame loop to do copy: report any read/write errors */ framesread = readframe(fin,frame,props.chans); totalread = 0; /* count sample frames as they are copied */ /* note: readframe retval of -1 signifies EOF */ while (framesread == 1) { totalread++; /* <--- do any processing here! ---------->*/ for(i=0; i < props.chans; i++) frame[i] *= gain; if(psf_sndWriteFloatFrames(ofd,frame,1) != 1) { printf("Error writing to outfile\n"); error++; break; } framesread = readframe(fin,frame,props.chans); } if(framesread == 0) { printf("Error reading infile at line %ld. Outfile may be incomplete.\n",totalread); error++; } else printf("Done. %ld sample frames copied to %s\n",totalread,argv[ARG_OUTFILE]); /* 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(fin != NULL) fclose(fin); if(ofd >= 0) psf_sndClose(ofd); if(frame) free(frame); if(peaks) free(peaks); psf_finish(); /* return error status to caller: may be useful in a script etc */ return error; }
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[]) { 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) { 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 osc_gen(int argc, char *argv[]) { //This function serves as an Osccilator bank (an arrary of oscillators) for additive synthesis //It produces more natural sounding waves confined in the spectrum of the availabke ranges of the sampling rate at or above the Nyquist limit //Structurally, this program is very similar to sig_gen, except that we will only be calling upon sine_wave_node and implement additive synthesis //to achieve the other waveforms. If osc_gen_num_oscs == 1 (meaning only 1 oscillator) a normal sine wave will be produced. //This function makes use of wave_generator.c/.h objects and functions /***************USAGE*************** oscgen outfile dur srate num_chans, amp, freq, wavetype, num_oscs **********************************/ if(argc < OSC_GEN_NARGS) { fprintf(stderr, "insufficient arguments.\n" "usage: oscgen outfile dur srate num_chans amp freq wavetype num_oscs\n" "where wavetype =:\n" " 0 = square\n" " 1 = triangle\n" " 2 = sawtooth up\n" " 3 = sawtooth down\n" " 4 = pulse\n" "dur = duration of outfile (seconds)\n" "srate = required sample rate of outfile\n" "amp = amplitude value or breakpoint file (0 < amp <= 1.0)\n" "freq = frequency value (freq > 0) or breakpoint file.\n" "num_oscs = number of oscillators (where 1 is normal sine wave)\n" ); exit(1); } /********* initialize all dynamic resources to default states **********/ PSF_PROPS outprops; int ofd = -1; int error = 0; PSF_CHPEAK* peaks = NULL; psf_format outformat = PSF_FMT_UNKNOWN; long nframes = NFRAMES; float* outframe = NULL; double amp,freq,dur; long outframes,nbufs = 0,num_oscs,i; //num_oscs holds number of oscillators for additive synthesis long remainder; int samptype = PSF_SAMP_16; OSCIL** oscs = NULL; //an array of oscil pointers (because additive synthesis requires more than one oscillators) double* oscamps = NULL; //for oscillator bank amplitudes and frequencies double* oscfreqs = NULL; double phase = 0.0; double ampfac,freqfac,ampadjust; //Because we cannot know the number of oscillators before hand, we need to calculate it cumulatively //Recall that adding sine waves amplitude is as simple as numerically adding the amplitude values. So 1 + 3 + 5 + 7 will yield an amp //value of 16. However, we want amp to be between -1 and 1 --> therefore total amp is 1/(1^2) + 1/(3^2) + 1/(5^2) + 1/(7^2) = 1 + 1/9 + 1/25 + 1/49 = 1.172 //General Rule : totalamp = Sum (from n = 0 to N) 1/(2n-1)^2 where N = number of oscillators FILE* fpfreq = NULL; BRKSTREAM *freqstream = NULL, *ampstream = NULL; unsigned long brkfreqSize = 0; double minval = 0.0,maxval= 0.0; FILE* fpamp = NULL; unsigned long brkampSize = 0; double amp_minval = 0.0,amp_maxval= 0.0; clock_t starttime, endtime; int wavetype; oscs = NULL; /********** error checking on wave type **********/ wavetype = atoi(argv[OSC_GEN_WAVETYPE]); if(wavetype < OSC_GEN_SQUARE || wavetype > OSC_GEN_PULSE) { fprintf(stderr, "Error: wavetype not defined\n"); goto exit; } /********** error checking on number of oscillators **********/ num_oscs = atoi(argv[OSC_GEN_NUM_OSCS]); if(num_oscs <= 0) { fprintf(stderr, "Error: number of oscillators must be positive\n"); goto exit; } /********** define outfile format (with embedded error checking) **********/ outprops.srate = atoi(argv[OSC_GEN_SRATE]); if(outprops.srate <= 0) { fprintf(stderr, "Error: srate must be positive\n"); goto exit; } outprops.chans = atoi(argv[OSC_GEN_NUM_CHANS]); if(outprops.chans <= 0) { fprintf(stderr, "Error: number of channels must be positive\n"); goto exit; } outprops.samptype = (psf_stype) samptype; outprops.chformat = STDWAVE; dur = atof(argv[OSC_GEN_DUR]); if(dur <= 0.0) { fprintf(stderr, "Error: duration must be positive (>=0)\n"); goto exit; } outframes = (unsigned long) (dur * outprops.srate + 0.5); nbufs = outframes / nframes; remainder = outframes - nbufs * nframes; if(remainder > 0) nbufs++; /********** open breakpoint files, or set constants if no breakpoint file is defined **********/ /***** amp (amplitude) breakpoints file *****/ fpamp = fopen(argv[OSC_GEN_AMP], "r"); //try opening specified argument if(fpamp == NULL) { //meaning that either argument OSC_GEN_AMP is not a breakpoint file or error opening amp = atof(argv[OSC_GEN_AMP]); if(amp <= 0.0 || amp > 1) { fprintf(stderr, "Error: amplitude must be between 0 and 1 (0 <= amp <= 1)\n"); goto exit; } } else { //meaning that argument OSC_GEN_AMP is indeed a breakpoint file ampstream = bps_newstream(fpamp,outprops.srate,&brkampSize); if(ampstream == NULL) { fprintf(stderr, "Error reading amplitude breakpoint file: %s\n", argv[OSC_GEN_AMP]); goto exit; } if(bps_getminmax(ampstream, &minval, &maxval)) { //meaning we called upon said function that will put into minval and maxval appropriate values //if said function returns 1 --> we have error fprintf(stderr, "Error reading range breakpoint file: %s\n", argv[OSC_GEN_AMP]); goto exit; } if(minval < 0.0 || minval > 1.0 || maxval < 0.0 || maxval > 1.0) { fprintf(stderr, "Error: amplitude values out of range in breakpoint file\n"); goto exit; } } /***** freq (frequency) breakpoints file *****/ fpfreq = fopen(argv[OSC_GEN_FREQ], "r"); if(fpfreq == NULL) { //meaning that either argument OSC_GEN_FREQ is not a breakpoint file or error opening freq = atof(argv[OSC_GEN_FREQ]); if(freq <= 0.0) { fprintf(stderr, "Error: frequency must be positive\n"); goto exit; } } else { //meaning that argument OSC_GEN_FREQ is indeed a breakpoint file freqstream = bps_newstream(fpfreq, outprops.srate, &brkfreqSize); if(freqstream == NULL) { fprintf(stderr, "Error reading frequncy from breakpoint file: %s\n", argv[OSC_GEN_FREQ]); goto exit; } if(bps_getminmax(freqstream, &minval, &maxval)) { fprintf(stderr, "Error reading range from breakpoint file: %s\n", argv[OSC_GEN_FREQ]); goto exit; } if(minval <= 0.0) { fprintf(stderr, "Error in breakpoing file; Frequency values must be positive\n"); goto exit; } } /********** Initialize portsf **********/ if(psf_init()) { fprintf(stderr, "Error: Unable to initialize portsf\n"); goto exit; } /********** Sample Frame Buffer Memory Aloocation **********/ outframe = (float*)malloc(nframes * outprops.chans * sizeof(float)); if(outframe == NULL) { fprintf(stderr, "Error: No memory for outframe buffer\n"); goto exit; } /********** Check for correct output extension **********/ outformat = psf_getFormatExt(argv[OSC_GEN_OUTFILE]); if(outformat == PSF_FMT_UNKNOWN) { fprintf(stderr, "Error: invalid extension\n" "Possible extensions:\t *.wav\t *.aiff\t *.aif\t *.afc\t *.aifc\n"); goto exit; } //reach here meaning outformat is viable extension outprops.format = outformat; /********** create oscillator amp and oscillator freq arrays **********/ oscamps = (double*)malloc(num_oscs * sizeof(double)); oscfreqs = (double*)malloc(num_oscs * sizeof(double)); if(!oscamps || !oscfreqs) { fprintf(stderr, "Error: Failed memory allocation for oscillator amp/freq arrays\n"); goto exit; } /********** create amp/freq data for requested waveshape, normalized to 1 **********/ ampfac = 1.0; freqfac = 1.0; ampadjust = 0.0; switch(wavetype) { case(OSC_GEN_SQUARE): for(i=0; i<num_oscs; i++) { oscamps[i] = ampfac; oscfreqs[i] = freqfac; freqfac += 2.0; ampadjust += ampfac; ampfac = 1.0 / freqfac; } //normalize for(i=0; i<num_oscs; i++) oscamps[i] /= ampadjust; break; case(OSC_GEN_TRIANGLE): for(i=0; i<num_oscs; i++) { oscamps[i] = ampfac; oscfreqs[i] = freqfac; freqfac += 2.0; ampadjust += ampfac; ampfac = 1.0 / (freqfac * freqfac); } //normalize for(i=0; i<num_oscs; i++) oscamps[i] /= ampadjust; phase = 0.25; break; case(OSC_GEN_SAW_UP): case(OSC_GEN_SAW_DOWN): for(i=0; i<num_oscs; i++) { oscamps[i] = ampfac; oscfreqs[i] = freqfac; freqfac += 1.0; ampadjust += ampfac; ampfac = 1.0 / freqfac; } if(wavetype == OSC_GEN_SAW_UP) ampadjust = -ampadjust; //normalize for(i=0; i<num_oscs; i++) oscamps[i] /= ampadjust; break; case(OSC_GEN_PULSE): freqfac = 1.0; ampfac = 1.0 / num_oscs; ampadjust = 0.0; for(i=0; i<num_oscs; i++) { oscamps[i] = ampfac; oscfreqs[i] = freqfac; freqfac += 1.0; } break; } /********** Create Oscillator Bank **********/ oscs = (OSCIL**)malloc(num_oscs * sizeof(OSCIL*)); if(!oscs) { fprintf(stderr, "Error: Failed memory allocation on creation of oscillator bank\n"); goto exit; } for(i=0; i< num_oscs; i++) { oscs[i] = new_oscil_with_phase(outprops.srate, phase); if(!oscs[i]) { fprintf(stderr, "Error: Failed memory allocation on creation of oscillator object\n"); goto exit; } } /********** Initialize Peak nfo **********/ peaks = (PSF_CHPEAK*)malloc(outprops.chans * sizeof(PSF_CHPEAK)); if(peaks == NULL) { fprintf(stderr, "Error: No memory for peaks\n"); goto exit; } /********** Create and Handle outfile **********/ ofd = psf_sndCreate(argv[OSC_GEN_OUTFILE],&outprops, 0, 0, PSF_CREATE_RDWR); //refer to sf2float for documentation if(ofd < 0) { fprintf(stderr, "Error: Unable to create outfile\n"); goto exit; } /********** Audio Processing **********/ printf("Reached here\t\t numbufs: %lu; numframes: %lu\n", nbufs, nframes); starttime = clock(); for(i=0; i<nbufs; i++) { long j,k,l; double val; if(i == nbufs -1) nframes = remainder; for(j=0; j< nframes; j++) { if(freqstream) freq = bps_tick(freqstream); if(ampstream) amp = bps_tick(freqstream); val = 0.0; for(l=0; l<num_oscs; l++) { val += oscamps[l] * sine_wave_node(oscs[l], freq * oscfreqs[l]); } for(k=0; k<outprops.chans; k++) { outframe[j*outprops.chans +k] = (float)(val * amp); } } //end j for-loop if(psf_sndWriteFloatFrames(ofd, outframe, nframes) != nframes) { fprintf(stderr, "Error writing to outfile"); break; } }//end i for-loop endtime = clock(); exit: fprintf(stdout, "Task Finished \nElapsed Time: %f seconds\n", (endtime - starttime)/(double)CLOCKS_PER_SEC); /***** Report PEAK values to user *****/ if(psf_sndReadPeaks(ofd,peaks,NULL) > 0){ long i; double peaktime; printf("PEAK information:\n"); for(i=0;i < outprops.chans;i++){ peaktime = (double) peaks[i].pos / (double) outprops.srate; printf("CH %d:\t%.4f at %.4f secs\n", (int)(i+1), peaks[i].val, peaktime); } } if(ofd >= 0) psf_sndClose(ofd); if(outframe) free(outframe); if(peaks) free(peaks); if(oscs){ for(i=0;i < num_oscs;i++){ free(oscs[i]); } free(oscs); } if(oscamps) free(oscamps); if(oscfreqs) free(oscfreqs); psf_finish(); exit(1); }
void sig_gen(int argc, char *argv[]) { //This function will generate simple waveforms --> Sine, Triangle, Square, Sawtooth up, Sawtooth down //Showcases Pseudo-Object Oriented Programming, Function Pointers (functoids) /***************USAGE*************** siggen outfile wavetype dur srate amp freq **********************************/ if(argc < SIG_GEN_NARGS) { fprintf(stderr, "insufficient arguments.\n" "usage: siggen outfile wavetype dur srate amp freq\n" "where wavetype =:\n" " 0 = sine\n" " 1 = triangle\n" " 2 = square\n" " 3 = sawtooth up\n" " 4 = sawtooth down\n" "dur = duration of outfile (seconds)\n" "srate = required sample rate of outfile\n" "amp = amplitude value or breakpoint file (0 < amp <= 1.0)\n" "freq = frequency value (freq > 0) or breakpoint file.\n" ); exit(1); } /********* initialize all dynamic resources to default states **********/ PSF_PROPS outprops; int ofd = -1; PSF_CHPEAK* peaks = NULL; psf_format outformat = PSF_FMT_UNKNOWN; //all psf* defined in portsf sound library long nframes = NFRAMES; float* outframe = NULL; double amp,freq,dur; unsigned long outframes,nbufs,i; long remainder; int wavetype; OSCIL* osc = NULL; //OSCIL pseudo-object defined in wave_generator.h node_func_ptr node; //function pointer defined in wave_generator.h FILE* fpfreq = NULL; FILE* fpamp = NULL; BRKSTREAM* freqstream = NULL; //BRKSTREAM* defined in breakpoint.h BRKSTREAM* ampstream = NULL; unsigned long brkfreqSize = 0, brkampSize = 0; double minval, maxval; /********** error checking on wave type **********/ wavetype = atoi(argv[SIG_GEN_TYPE]); if(wavetype < SINE_WAVE || wavetype >= NUM_WAVE_TYPES) { fprintf(stderr, "Error: wavetype not defined\n"); goto exit; } /********** assigning function pointer accordingly **********/ switch(wavetype) { case(SINE_WAVE): node = sine_wave_node; //node is a function pointer (type: node_func_ptr); sine_wave_node is function break; case(SQAURE_WAVE): node = square_wave_node; break; case(TRIANGLE_WAVE): node = triangle_wave_node; break; case(SAW_UP_WAVE): node = sawtooth_up_wave_node; break; case(SAW_DOWN_WAVE): node = sawtooth_down_wave_node; break; } /********** define outfile format (with embedded error checking) **********/ outprops.srate = atoi(argv[SIG_GEN_SRATE]); if(outprops.srate <= 0) { fprintf(stderr, "Error: srate must by positive (>=0)\n"); goto exit; } outprops.chans = 1; //as of this sig_gen implementation --> mono outprops.samptype = (psf_stype) PSF_SAMP_16; //16-bit samples outprops.chformat = STDWAVE; //STDWAVE defined in portsf library dur = atof(argv[SIG_GEN_DUR]); if(dur <= 0.0) { fprintf(stderr, "Error: duration must be positive (>=0)\n"); goto exit; } outframes = (unsigned long) (dur * outprops.srate + 0.5); nbufs = outframes / nframes; remainder = outframes - nbufs * nframes; if(remainder) nbufs++; /********** open breakpoint files, or set constants if no breakpoint file is defined **********/ /***** amp (amplitude) breakpoints file *****/ fpamp = fopen(argv[SIG_GEN_AMP], "r"); //try opening specified argument if(fpamp == NULL) { //meaning that either argument SIG_GEN_AMP is not a breakpoint file or error opening amp = atof(argv[SIG_GEN_AMP]); if(amp <= 0.0 || amp > 1) { fprintf(stderr, "Error: amplitude must be between 0 and 1 (0 <= amp <= 1)\n"); goto exit; } } else { //meaning that argument SIG_GEN_AMP is indeed a breakpoint file ampstream = bps_newstream(fpamp,outprops.srate,&brkampSize); if(ampstream == NULL) { fprintf(stderr, "Error reading amplitude breakpoint file: %s\n", argv[SIG_GEN_AMP]); goto exit; } if(bps_getminmax(ampstream, &minval, &maxval)) { //meaning we called upon said function that will put into minval and maxval appropriate values //if said function returns 1 --> we have error fprintf(stderr, "Error reading range breakpoint file: %s\n", argv[SIG_GEN_AMP]); goto exit; } if(minval < 0.0 || minval > 1.0 || maxval < 0.0 || maxval > 1.0) { fprintf(stderr, "Error: amplitude values out of range in breakpoint file\n"); goto exit; } } /***** freq (frequency) breakpoints file *****/ fpfreq = fopen(argv[SIG_GEN_FREQ], "r"); if(fpfreq == NULL) { //meaning that either argument SIG_GEN_FREQ is not a breakpoint file or error opening freq = atof(argv[SIG_GEN_FREQ]); if(freq <= 0.0) { fprintf(stderr, "Error: frequency must be positive\n"); goto exit; } } else { //meaning that argument SIG_GEN_FREQ is indeed a breakpoint file freqstream = bps_newstream(fpfreq, outprops.srate, &brkfreqSize); if(freqstream == NULL) { fprintf(stderr, "Error reading frequncy from breakpoint file: %s\n", argv[SIG_GEN_FREQ]); goto exit; } if(bps_getminmax(freqstream, &minval, &maxval)) { fprintf(stderr, "Error reading range from breakpoint file: %s\n", argv[SIG_GEN_FREQ]); goto exit; } if(minval <= 0.0) { fprintf(stderr, "Error in breakpoing file; Frequency values must be positive\n"); goto exit; } } /********** Initialize OSCIL pseudo-object **********/ osc = new_oscil(outprops.srate); if(osc == NULL) { fprintf(stderr, "No memory for oscillator\n"); goto exit; } /********** Initialize portsf **********/ if(psf_init()) { fprintf(stderr, "Error: Unable to initialize portsf\n"); goto exit; } /********** Sample Frame Buffer Memory Aloocation **********/ outframe = (float*)malloc(nframes * outprops.chans * sizeof(float)); if(outframe == NULL) { fprintf(stderr, "Error: No memory for outframe buffer\n"); goto exit; } /********** Check for correct output extension **********/ outformat = psf_getFormatExt(argv[SIG_GEN_OUTFILE]); if(outformat == PSF_FMT_UNKNOWN) { fprintf(stderr, "Error: invalid extension\n" "Possible extensions:\t *.wav\t *.aiff\t *.aif\t *.afc\t *.aifc\n"); goto exit; } //reach here meaning outformat is viable extension outprops.format = outformat; /********** Initialize Peak nfo **********/ peaks = (PSF_CHPEAK*)malloc(outprops.chans * sizeof(PSF_CHPEAK)); if(peaks == NULL) { fprintf(stderr, "Error: No memory for peaks\n"); goto exit; } /********** Create and Handle outfile **********/ ofd = psf_sndCreate(argv[SIG_GEN_OUTFILE],&outprops, 0, 0, PSF_CREATE_RDWR); //refer to sf2float for documentation if(ofd < 0) { fprintf(stderr, "Error: Unable to create outfile\n"); goto exit; } /********** Audio Processing **********/ for(i=0; i<nbufs; i++) { long j; if(i == nbufs-1) nframes = remainder; for(j=0; j<nframes; j++) { if(freqstream) freq = bps_tick(freqstream); if(ampstream) amp = bps_tick(ampstream); outframe[j] = (float)(amp * node(osc,freq)); //call upon function via function pointer with OSCIL pseudo-object and freq; } if(psf_sndWriteFloatFrames(ofd, outframe, nframes) != nframes) { fprintf(stderr, "Error: unable to write to outfile\n"); goto exit; } } /********** Clean_up section **********/ exit: fprintf(stderr, "Task Finished\n"); /***** Report PEAK values to user *****/ if(psf_sndReadPeaks(ofd,peaks,NULL) > 0){ long i; double peaktime; printf("PEAK information:\n"); for(i=0;i < outprops.chans;i++){ peaktime = (double) peaks[i].pos / (double) outprops.srate; printf("CH %d:\t%.4f at %.4f secs\n", (int)(i+1), peaks[i].val, peaktime); } } if(ofd >= 0) if(psf_sndClose(ofd)) printf("Error closing outfile %s\n",argv[SIG_GEN_OUTFILE]); if(outframe) free(outframe); if(peaks) free(peaks); /*TODO: cleanup any other resources */ if(osc) free(osc); if(fpfreq) if(fclose(fpfreq)) printf("Error closing breakpoint file %s\n",argv[SIG_GEN_FREQ]); if(fpamp) if(fclose(fpamp)) printf("Error closing breakpoint file %s\n",argv[SIG_GEN_AMP]); if(freqstream){ bps_freepoints(freqstream); free(freqstream); } if(ampstream){ bps_freepoints(ampstream); free(ampstream); } psf_finish(); exit(1); }
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; }