Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
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;
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
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;
}
Ejemplo n.º 5
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
	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;
}
Ejemplo n.º 6
0
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);
}
Ejemplo n.º 7
0
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);
}
Ejemplo n.º 8
0
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;
}