|
|
@@ -0,0 +1,1490 @@
|
|
|
+/*
|
|
|
+ * Copyright (c) 1983-2013 Trevor Wishart and Composers Desktop Project Ltd
|
|
|
+ * http://www.trevorwishart.co.uk
|
|
|
+ * http://www.composersdesktop.com
|
|
|
+ *
|
|
|
+ This file is part of the CDP System.
|
|
|
+
|
|
|
+ The CDP System is free software; you can redistribute it
|
|
|
+ and/or modify it under the terms of the GNU Lesser General Public
|
|
|
+ License as published by the Free Software Foundation; either
|
|
|
+ version 2.1 of the License, or (at your option) any later version.
|
|
|
+
|
|
|
+ The CDP System is distributed in the hope that it will be useful,
|
|
|
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
+ GNU Lesser General Public License for more details.
|
|
|
+
|
|
|
+ You should have received a copy of the GNU Lesser General Public
|
|
|
+ License along with the CDP System; if not, write to the Free Software
|
|
|
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
|
|
|
+ 02111-1307 USA
|
|
|
+ *
|
|
|
+ */
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+#include <stdio.h>
|
|
|
+#include <stdlib.h>
|
|
|
+#include <structures.h>
|
|
|
+#include <tkglobals.h>
|
|
|
+#include <globcon.h>
|
|
|
+#include <cdpmain.h>
|
|
|
+#include <sndinfo.h>
|
|
|
+#include <processno.h>
|
|
|
+#include <modeno.h>
|
|
|
+#include <pnames.h>
|
|
|
+#include <filetype.h>
|
|
|
+#include <flags.h>
|
|
|
+#include <float.h>
|
|
|
+#include <time.h>
|
|
|
+#include <sfsys.h>
|
|
|
+#include <string.h>
|
|
|
+#include <math.h>
|
|
|
+
|
|
|
+#define SPACECNT (32)
|
|
|
+
|
|
|
+static int try_header(int chans,double inverse_sr,dataptr dz);
|
|
|
+static void make_time_display(char temp[],char timestr[],double secs);
|
|
|
+static int get_and_set_float_maxmina(float *flbuf,dataptr dz);
|
|
|
+static int get_and_set_float_maxmin(float *buf,int chans, double inverse_sr,dataptr dz);
|
|
|
+
|
|
|
+static int compare_sndfile_properties(char temp[],dataptr dz);
|
|
|
+static int compare_analfile_properties(dataptr dz);
|
|
|
+static int read_both_the_files(int samesize,dataptr dz);
|
|
|
+static int read_samps_for_cdiff(dataptr dz);
|
|
|
+static void compare_samps(char temp[],int *badmatch,int *limitcnt,double threshold,dataptr dz);
|
|
|
+static void anal_file_time(char temp[],int n,dataptr dz);
|
|
|
+static void snd_file_time(char temp[],int n,dataptr dz);
|
|
|
+static int sfdiff_process(char temp[],int samesize,dataptr dz);
|
|
|
+static int compare_infile_sizes(int *same_size,dataptr dz);
|
|
|
+
|
|
|
+static int do_sfdiff(char temp[],dataptr dz);
|
|
|
+static int prntprops(SFPROPS *prop, dataptr dz);
|
|
|
+static int get_float_maxmin(float *buf,int chans, double inverse_sr,dataptr dz);
|
|
|
+/*RWD 6:2001 */
|
|
|
+static int getpeakdata(int ifd, float *peakval,SFPROPS *props);
|
|
|
+
|
|
|
+static int do_zcross_ratio(dataptr dz);
|
|
|
+
|
|
|
+/****************************** DO_SNDINFO ******************************/
|
|
|
+
|
|
|
+int do_sndinfo(dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ float *flbuf;
|
|
|
+ float *buf;
|
|
|
+ double sr = (double)dz->infile->srate;
|
|
|
+ int chans = dz->infile->channels, maxpos;
|
|
|
+ double other_sr = (double)dz->otherfile->srate;
|
|
|
+ int other_chans = dz->otherfile->channels;
|
|
|
+ double inverse_sr = 1.0, secs;
|
|
|
+ int thisspace, m;
|
|
|
+ float *chanmax;
|
|
|
+ int ftype = dz->infile->filetype;
|
|
|
+ int is_a_text_file = FALSE;
|
|
|
+ int n, k, j;
|
|
|
+ fileptr fptr = dz->infile;
|
|
|
+ char timestr[64];
|
|
|
+ char temp[200];
|
|
|
+ int holesize = 0, holesamp = 0;
|
|
|
+ int maxholesize = 0;
|
|
|
+ int maxholesamp = 0;
|
|
|
+ double maxholelen, maxholetime;
|
|
|
+ double threshold, level = 0.0;
|
|
|
+ int orig_ifd0;
|
|
|
+ SFPROPS props = {0};
|
|
|
+ infileptr ifp;
|
|
|
+ double maxamp, maxloc;
|
|
|
+ int maxrep;
|
|
|
+ int getmax = 0, getmaxinfo = 0;
|
|
|
+
|
|
|
+ if(sr > 0.0)
|
|
|
+ inverse_sr = 1.0/sr;
|
|
|
+ switch(dz->process) {
|
|
|
+
|
|
|
+ case(INFO_TIMESUM):
|
|
|
+ secs = 0.0;
|
|
|
+ for(n=0;n<dz->infilecnt;n++) {
|
|
|
+ secs += (double)(dz->insams[n]/chans) * inverse_sr;
|
|
|
+ secs -= dz->param[TIMESUM_SPLEN] * MS_TO_SECS;
|
|
|
+ }
|
|
|
+ sprintf(errstr,"TOTAL TIME ");
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_TIMELIST):
|
|
|
+ if((ifp = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
|
|
|
+ sprintf(errstr,"INSUFFICIENT MEMORY to store data on file.\n");
|
|
|
+ return(MEMORY_ERROR);
|
|
|
+ }
|
|
|
+ secs = (double)(dz->insams[0]/chans) * inverse_sr;
|
|
|
+ sprintf(errstr,"%s",dz->wordstor[0]);
|
|
|
+ thisspace = SPACECNT - strlen(dz->wordstor[0]);
|
|
|
+ thisspace = max(thisspace,2);
|
|
|
+ for(m=0;m<thisspace;m++)
|
|
|
+ strcat(errstr,".");
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+//TW UPDATE
|
|
|
+ if(sloom) {
|
|
|
+ sprintf(errstr,"%lf\n",secs);
|
|
|
+ if(fputs(errstr,dz->fp)<0) {
|
|
|
+ sprintf(errstr,"Cannot output data to file\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ for(n=1;n<dz->infilecnt;n++) {
|
|
|
+ if((exit_status = readhead(ifp,dz->ifd[n],dz->wordstor[n],&maxamp,&maxloc,&maxrep,getmax,getmaxinfo))<0) {
|
|
|
+ sprintf(errstr,"Cannot re-read file %d header.\n",n+1);
|
|
|
+ return(PROGRAM_ERROR);
|
|
|
+ }
|
|
|
+ copy_to_fileptr(ifp,dz->infile);
|
|
|
+ secs = (double)(dz->insams[n]/dz->infile->channels)/(double)dz->infile->srate;
|
|
|
+ sprintf(errstr,"%s",dz->wordstor[n]);
|
|
|
+ thisspace = SPACECNT - strlen(dz->wordstor[n]);
|
|
|
+ thisspace = max(thisspace,2);
|
|
|
+ for(m=0;m<thisspace;m++)
|
|
|
+ strcat(errstr,".");
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+//TW UPDATE
|
|
|
+ if(sloom) {
|
|
|
+ sprintf(errstr,"%lf\n",secs);
|
|
|
+ if(fputs(errstr,dz->fp)<0) {
|
|
|
+ sprintf(errstr,"Cannot output data to file\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(INFO_LOUDLIST):
|
|
|
+ orig_ifd0 = dz->ifd[0];
|
|
|
+ for(m=0;m<dz->infilecnt;m++) {
|
|
|
+ float fmaxamp = 0.0f; /*RWD 6:2001 */
|
|
|
+ int gotpeak = 0;
|
|
|
+ /*RWD 6:2001 try to read PEAK chunk too! */
|
|
|
+ if(getpeakdata(dz->ifd[m],&fmaxamp,&props)){
|
|
|
+ level = fmaxamp;
|
|
|
+ gotpeak = 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ else {
|
|
|
+ /* RWD impossible to report int values without lot of hoohaa */
|
|
|
+ /* just look as if its floatsam file, for now */
|
|
|
+ if(sndgetprop(dz->ifd[m],"fmaxamp",(char *)&fmaxamp,sizeof(float)) < 0 ) {
|
|
|
+ dz->samps_left = dz->insams[m];
|
|
|
+ dz->ifd[0] = dz->ifd[m];
|
|
|
+ while(dz->samps_left) {
|
|
|
+ if((exit_status = read_samps(dz->bigbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ for(n=0;n<dz->ssampsread;n++)
|
|
|
+ fmaxamp = (float)max(fmaxamp,fabs(dz->bigbuf[n]));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(!gotpeak) /*RWD 6:2001 */
|
|
|
+ level = (double)fmaxamp/F_MAXSAMP;
|
|
|
+
|
|
|
+ sprintf(errstr,"%s\t",dz->wordstor[m]);
|
|
|
+ sprintf(timestr,"%lf\n",level);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(fputs(timestr,dz->fp)<0) {
|
|
|
+ sprintf(errstr,"Cannot output data to file\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ dz->ifd[0] = orig_ifd0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+
|
|
|
+
|
|
|
+ case(INFO_TIMEDIFF):
|
|
|
+ sprintf(errstr,"DIFFERENCE IS ");
|
|
|
+ secs = (dz->insams[0]/chans) * inverse_sr;
|
|
|
+ secs -= (dz->insams[1]/other_chans)/other_sr;
|
|
|
+ secs = fabs(secs);
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_SFLEN):
|
|
|
+ switch(dz->infile->filetype) {
|
|
|
+ case(SNDFILE):
|
|
|
+ print_outmessage("A soundfile\n");
|
|
|
+ sprintf(errstr,"DURATION: ");
|
|
|
+ secs = (double)(dz->insams[0]/dz->infile->channels) * inverse_sr;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ sprintf(temp,"samples %d\n",dz->insams[0]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ break;
|
|
|
+ case(ANALFILE):
|
|
|
+ print_outmessage("An analysis data file\n");
|
|
|
+ sprintf(errstr,"DURATION: ");
|
|
|
+ secs = (double)dz->wlength * dz->frametime;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ sprintf(temp,"windows %d : floats %d\n",dz->wlength,dz->insams[0]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ break;
|
|
|
+ case(PITCHFILE):
|
|
|
+ print_outmessage("A binary pitch data file\n");
|
|
|
+ sprintf(errstr,"DURATION: ");
|
|
|
+ secs = (double)dz->insams[0] * dz->frametime;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ sprintf(temp,"windows %d : floats %d\n",dz->insams[0],dz->insams[0]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ break;
|
|
|
+ case(TRANSPOSFILE):
|
|
|
+ print_outmessage("A binary transposition data file\n");
|
|
|
+ sprintf(errstr,"DURATION: ");
|
|
|
+ secs = (double)dz->insams[0] * dz->frametime;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ sprintf(temp,"windows %d : floats %d\n",dz->insams[0],dz->insams[0]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ break;
|
|
|
+ case(ENVFILE):
|
|
|
+ print_outmessage("A binary envelope file\n");
|
|
|
+ sprintf(errstr,"DURATION: ");
|
|
|
+ secs = (double)dz->insams[0] * dz->infile->window_size * MS_TO_SECS;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ sprintf(temp,"windows %d : floats %d\n",dz->wlength,dz->insams[0]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ break;
|
|
|
+ case(FORMANTFILE):
|
|
|
+ print_outmessage("A formant data file\n");
|
|
|
+ sprintf(errstr,"DURATION: ");
|
|
|
+ dz->wlength = (dz->insams[0]/dz->specenvcnt) - DESCRIPTOR_DATA_BLOKS;
|
|
|
+ secs = (double)dz->wlength * dz->frametime;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ strcat(errstr,timestr);
|
|
|
+ n = dz->insams[0] - (dz->specenvcnt * DESCRIPTOR_DATA_BLOKS);
|
|
|
+ sprintf(temp,"windows %d : floats %d\n",dz->wlength,n);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ sprintf(errstr,"This process only works with soundfiling-system files.\n");
|
|
|
+ return(DATA_ERROR);
|
|
|
+ }
|
|
|
+ print_outmessage(errstr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_LOUDCHAN):
|
|
|
+ if(dz->infile->channels==MONO) {
|
|
|
+ sprintf(errstr,"This program does not works with MONO files.\n");
|
|
|
+ return(GOAL_FAILED);
|
|
|
+ }
|
|
|
+ if((chanmax = (float *)malloc(chans *sizeof(float)))==NULL) {
|
|
|
+ sprintf(errstr,"INSUFFICIENT MEMORY to store channel maximi.\n");
|
|
|
+ return(MEMORY_ERROR);
|
|
|
+ }
|
|
|
+ for(m=0;m<chans;m++)
|
|
|
+ chanmax[m] = 0;
|
|
|
+ while(dz->samps_left) {
|
|
|
+ if((exit_status = read_samps(dz->bigbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ for(n=0;n<dz->ssampsread;n+=chans) {
|
|
|
+ for(m=0;m<chans;m++)
|
|
|
+ chanmax[m] = (float)max(chanmax[m],(float) fabs(dz->bigbuf[n+m]));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ maxpos = 0;
|
|
|
+ for(m=1;m<chans;m++) {
|
|
|
+ if(chanmax[m] > chanmax[maxpos])
|
|
|
+ maxpos = m;
|
|
|
+ }
|
|
|
+ sprintf(errstr,"LOUDEST CHANNEL is %d\n",maxpos+1);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ free(chanmax);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_SAMPTOTIME):
|
|
|
+ if(!dz->vflag[CHAN_GROUPED])
|
|
|
+ dz->iparam[INFO_SAMPS] /= chans;
|
|
|
+ secs = dz->iparam[INFO_SAMPS] * inverse_sr;
|
|
|
+ make_time_display(temp,timestr,secs);
|
|
|
+ sprintf(errstr,"TIME %s",timestr);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_TIMETOSAMP):
|
|
|
+ n = round(dz->param[INFO_TIME] * sr);
|
|
|
+ if(!dz->vflag[CHAN_GROUPED])
|
|
|
+ n *= chans;
|
|
|
+ sprintf(errstr,"SAMPLE %d\n",n);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_PROPS):
|
|
|
+ errstr[0] = ENDOFSTR;
|
|
|
+ switch(ftype) {
|
|
|
+ case(SNDFILE):
|
|
|
+ sprintf(errstr,"A SOUND file.\n"); break;
|
|
|
+ case(ANALFILE):
|
|
|
+ sprintf(errstr,"An ANALYSIS file.\n"); break;
|
|
|
+ case(PITCHFILE):
|
|
|
+ sprintf(errstr,"A binary PITCH file.\n"); break;
|
|
|
+ case(TRANSPOSFILE):
|
|
|
+ sprintf(errstr,"A binary TRANSPOSITION file.\n"); break;
|
|
|
+ case(FORMANTFILE):
|
|
|
+ sprintf(errstr,"A FORMANT data file.\n"); break;
|
|
|
+ case(ENVFILE):
|
|
|
+ sprintf(errstr,"A binary ENVELOPE file.\n"); break;
|
|
|
+ default:
|
|
|
+ if(is_a_textfile_type(ftype)) {
|
|
|
+ sprintf(errstr,"A TEXT data file.\n");
|
|
|
+ is_a_text_file = TRUE;
|
|
|
+ } else {
|
|
|
+ print_outmessage("UNKNOWN input file type.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(is_a_text_file) {
|
|
|
+ sprintf(errstr,"Contains %d LINES\n",dz->linecnt);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"Contains %d WORDS\n",dz->all_words);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(ftype==MIXFILE) {
|
|
|
+ sprintf(errstr,"Could be a MIXFILE with output channel cnt %d\n",dz->out_chans);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ } else if(ftype==SYNCLIST) {
|
|
|
+ sprintf(errstr,"Could be a LIST OF SOUNDFILES TO SYNCHRONISE.\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ } else if(ftype==SNDLIST) {
|
|
|
+ sprintf(errstr,"Could be a LIST OF SOUNDFILES.\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ if(dz->tempsize >0 || (dz->extrabrkno >= 0 && dz->brksize[dz->extrabrkno] > 0)) {
|
|
|
+ sprintf(errstr,"Could be a BREAKPOINT FILE:\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"length %d minval %lf maxval %lf duration %lf\n",
|
|
|
+ dz->numsize/2,dz->minbrk,dz->maxbrk,dz->duration);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ if(dz->numsize > 0) {
|
|
|
+ sprintf(errstr,"Could be a NUMBER LIST:\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"length %d minval %lf maxval %lf\n",dz->numsize,dz->minnum,dz->maxnum);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ sprintf(errstr,"samples: ............ %d\n",dz->insams[0]);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(ftype!=SNDFILE) {
|
|
|
+ switch(ftype) {
|
|
|
+ case(ANALFILE):
|
|
|
+ sprintf(errstr,"file type: .......... ANALYSIS DATA\n"); break;
|
|
|
+ case(PITCHFILE):
|
|
|
+ sprintf(errstr,"file type: .......... PITCH DATA (binary)\n"); break;
|
|
|
+ case(TRANSPOSFILE):
|
|
|
+ sprintf(errstr,"file type: .......... TRANSPOSITION DATA (binary)\n"); break;
|
|
|
+ case(FORMANTFILE):
|
|
|
+ sprintf(errstr,"file type: .......... FORMANT DATA (binary)\n"); break;
|
|
|
+ case(ENVFILE):
|
|
|
+ sprintf(errstr,"file type: .......... ENVELOPE DATA (binary)\n"); break;
|
|
|
+ }
|
|
|
+ print_outmessage(errstr);
|
|
|
+//TW UPDATE: moved srate & chans, as ENVFILES have srate and channels
|
|
|
+ sprintf(errstr,"sample rate: ........ %d\n",fptr->srate);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"channels: ........... %d\n",fptr->channels);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(fptr->filetype==ENVFILE) {
|
|
|
+ sprintf(errstr,"window size: ........ %f ms\n",fptr->window_size);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(fptr->filetype==FORMANTFILE) {
|
|
|
+ sprintf(errstr,"formant envelope cnt: %d\n",fptr->specenvcnt);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ /*RWD*/
|
|
|
+//TW NOW REDUNDANT: flagging changed
|
|
|
+// if(fptr->filetype!=SNDFILE){
|
|
|
+ sprintf(errstr,"original sampsize: .. %d\n",fptr->origstype);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"original sample rate: %d\n",fptr->origrate);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"analysis rate: ...... %f\n",fptr->arate);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"analysis window len: %d\n",fptr->Mlen);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"decimation factor: .. %d\n",fptr->Dfac);
|
|
|
+ print_outmessage(errstr);
|
|
|
+// }
|
|
|
+ if(fptr->filetype==PITCHFILE || fptr->filetype==TRANSPOSFILE) {
|
|
|
+ sprintf(errstr,"original channels: .. %d\n",fptr->origchans);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ sprintf(errstr,"file type: ........... SOUND\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"sample rate: ........ %d\n",fptr->srate);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"channels: ........... %d\n",fptr->channels);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ if((exit_status = prntprops(&props,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(INFO_MAXSAMP):
|
|
|
+ if(is_a_text_input_filetype(dz->infile->filetype)) {
|
|
|
+ sprintf(errstr,"This is a text file.\n");
|
|
|
+ return(GOAL_FAILED);
|
|
|
+ }
|
|
|
+ /* RWD 2022 this hangs if user supplies anal file */
|
|
|
+ if(dz->infile->filetype == ANALFILE){
|
|
|
+ sprintf(errstr,"This is an anlysis file.\n");
|
|
|
+ return(GOAL_FAILED);
|
|
|
+ }
|
|
|
+ flbuf = (float *)dz->bigbuf;
|
|
|
+ buf = dz->bigbuf;
|
|
|
+ if(!dz->vflag[FORCE_SCAN] && try_header(chans,inverse_sr,dz)==FINISHED)
|
|
|
+ break;
|
|
|
+ else {
|
|
|
+ if(dz->infile->filetype != SNDFILE) {
|
|
|
+ if((exit_status = get_and_set_float_maxmina(flbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ } else {
|
|
|
+ if((exit_status = get_and_set_float_maxmin(buf,chans,inverse_sr,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(INFO_MAXSAMP2):
|
|
|
+ buf = dz->bigbuf;
|
|
|
+ if((exit_status = get_float_maxmin(buf,chans,inverse_sr,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ break;
|
|
|
+
|
|
|
+ case(INFO_PRNTSND):
|
|
|
+ dz->ssampsread = 0;
|
|
|
+ dz->iparam[PRNT_START] = round(dz->param[PRNT_START] * sr) * chans;
|
|
|
+ dz->iparam[PRNT_END] = round(dz->param[PRNT_END] * sr) * chans;
|
|
|
+ if(dz->iparam[PRNT_START] >= dz->iparam[PRNT_END]) {
|
|
|
+ sprintf(errstr,"Incompatible start and end times.\n");
|
|
|
+ return(DATA_ERROR);
|
|
|
+ }
|
|
|
+ if(dz->iparam[PRNT_START] >= dz->insams[0]) {
|
|
|
+ sprintf(errstr,"Start time is at end of file: can't proceed.\n");
|
|
|
+ return(DATA_ERROR);
|
|
|
+ }
|
|
|
+
|
|
|
+ dz->total_samps_read = 0;
|
|
|
+ for(;;) {
|
|
|
+ if((exit_status = read_samps(dz->bigbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ if(dz->iparam[PRNT_START] > dz->ssampsread) {
|
|
|
+ dz->iparam[PRNT_START] -= dz->ssampsread;
|
|
|
+ dz->iparam[PRNT_END] -= dz->ssampsread;
|
|
|
+ } else
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ k = 0;
|
|
|
+ j = (dz->total_samps_read - dz->ssampsread + dz->iparam[PRNT_START])/chans;
|
|
|
+ display_virtual_time(0L,dz);
|
|
|
+ for(n=dz->iparam[PRNT_START];n<dz->iparam[PRNT_END];n+=chans,k+=chans,j++) {
|
|
|
+ fprintf(dz->fp,"[%d]\t",j);
|
|
|
+ for(m=0;m<chans;m++)
|
|
|
+ fprintf(dz->fp,"%.6f\t",(float) dz->bigbuf[n+m]); /*RWD 12:2003 was %d */
|
|
|
+ fprintf(dz->fp,"\n");
|
|
|
+ if(n >= dz->ssampsread) {
|
|
|
+ if((exit_status = read_samps(dz->bigbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+//TW CHANGED to samps
|
|
|
+ display_virtual_time(k,dz);
|
|
|
+ dz->iparam[PRNT_END] -= dz->ssampsread;
|
|
|
+ n = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+//TW CHANGED to samps
|
|
|
+ display_virtual_time(k,dz);
|
|
|
+ break;
|
|
|
+ case(INFO_FINDHOLE):
|
|
|
+ threshold = dz->param[HOLE_THRESH] * (double)F_MAXSAMP;
|
|
|
+ while(dz->samps_left) {
|
|
|
+ if((exit_status = read_samps(dz->bigbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ for(n = 0; n < dz->ssampsread; n++) {
|
|
|
+ if(holesize==0) {
|
|
|
+ if(fabs(dz->bigbuf[n])<threshold) {
|
|
|
+ holesize = 1;
|
|
|
+ holesamp = dz->total_samps_read - dz->ssampsread + n;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if(fabs(dz->bigbuf[n])<threshold)
|
|
|
+ holesize++;
|
|
|
+ else {
|
|
|
+ if(holesize > maxholesize) {
|
|
|
+ maxholesize = holesize;
|
|
|
+ maxholesamp = holesamp;
|
|
|
+ }
|
|
|
+ holesize = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ maxholelen = (double)(maxholesize/chans) * inverse_sr;
|
|
|
+ maxholetime = (double)(maxholesamp/chans) * inverse_sr;
|
|
|
+ sprintf(errstr,"Maximum holesize is %.6lf at time %.6lf\n",maxholelen,maxholetime);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ break;
|
|
|
+ case(INFO_CDIFF):
|
|
|
+ case(INFO_DIFF):
|
|
|
+ if((exit_status = do_sfdiff(temp,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ break;
|
|
|
+ case(ZCROSS_RATIO):
|
|
|
+ if((exit_status = do_zcross_ratio(dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ sprintf(errstr,"Unknown process in do_sndinfo()\n");
|
|
|
+ return(PROGRAM_ERROR);
|
|
|
+ }
|
|
|
+ fflush(stdout);
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************** TRY_HEADER ************************/
|
|
|
+
|
|
|
+int try_header(int chans,double inverse_sr,dataptr dz)
|
|
|
+{
|
|
|
+ int pos_repeats, neg_repeats, repeats, maxloc, maxamp = -1;
|
|
|
+ float maxpfamp, maxnfamp;
|
|
|
+ double gain, dbgain;
|
|
|
+ float newmaxamp = 0.0f;
|
|
|
+ if(dz->infile->filetype != SNDFILE) {
|
|
|
+//TW SUBSTITUTED SNDgetprop
|
|
|
+ if( sndgetprop(dz->ifd[0],"maxpfamp",(char *)&maxpfamp,sizeof(float)) < 0 )
|
|
|
+ return(CONTINUE);
|
|
|
+ if( sndgetprop(dz->ifd[0],"maxnfamp",(char *)&maxnfamp,sizeof(float)) < 0 )
|
|
|
+ return(CONTINUE);
|
|
|
+ if(sndgetprop(dz->ifd[0],"maxprep",(char *)&pos_repeats,sizeof(float)) < 0 )
|
|
|
+ return(CONTINUE);
|
|
|
+ if(sndgetprop(dz->ifd[0],"maxnrep",(char *)&neg_repeats,sizeof(int)) < 0 )
|
|
|
+ return(CONTINUE);
|
|
|
+ sprintf(errstr,"maximum float value: %f\n",maxpfamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"occurs: ............ %d times\n",pos_repeats);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"minimum float value: %f\n",maxnfamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"occurs: ............ %d times\n",neg_repeats);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ } else {
|
|
|
+ if( sndgetprop(dz->ifd[0],"maxamp",(char *)&maxamp,sizeof(int)) < 0 /* old files */
|
|
|
+ && sndgetprop(dz->ifd[0],"maxpfamp",(char *)&newmaxamp,sizeof(float)) < 0) /* new files */
|
|
|
+ return(CONTINUE);
|
|
|
+ if( sndgetprop(dz->ifd[0],"maxloc",(char *)&maxloc,sizeof(int)) < 0 )
|
|
|
+ return(CONTINUE);
|
|
|
+ if( sndgetprop(dz->ifd[0],"maxrep",(char *)&repeats,sizeof(int)) < 0 )
|
|
|
+ return(CONTINUE);
|
|
|
+ if(maxamp>=0)
|
|
|
+ newmaxamp = (float)(maxamp/(double)MAXSAMP);
|
|
|
+ sprintf(errstr,"maximum abs value:.. %f\n",newmaxamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"at: ................ %d samples\n",maxloc);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"time: .............. %.4lf secs\n",(double)(maxloc/chans) *inverse_sr);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"repeated: .......... %d times\n",repeats);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(newmaxamp>=0.0) {
|
|
|
+ gain = 1.0/(double)maxamp;
|
|
|
+ dbgain = log10(gain) * 20.0;
|
|
|
+ sprintf(errstr,"max possible gain:.. %.4lf\n",gain);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"max dB gain:........ %.4lf\n",dbgain);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************** MAKE_TIME_DISPLAY ************************/
|
|
|
+
|
|
|
+void make_time_display(char temp[],char timestr[],double secs)
|
|
|
+{
|
|
|
+ int mins = 0, hrs = 0;
|
|
|
+ if(secs > 60.0) {
|
|
|
+ mins = round(floor(secs/60.0));
|
|
|
+ secs -= (double)(mins * 60);
|
|
|
+ }
|
|
|
+ if(mins > 60) {
|
|
|
+ hrs = round(floor((double)mins/60.0));
|
|
|
+ mins -= hrs * 60;
|
|
|
+ }
|
|
|
+ timestr[0] = ENDOFSTR;
|
|
|
+ if(hrs) {
|
|
|
+ sprintf(temp,"%d hrs ",hrs);
|
|
|
+ strcat(timestr,temp);
|
|
|
+ }
|
|
|
+ if(mins) {
|
|
|
+ sprintf(temp,"%d mins ",mins);
|
|
|
+ strcat(timestr,temp);
|
|
|
+ }
|
|
|
+ sprintf(temp,"%.6lf secs ",secs);
|
|
|
+ strcat(timestr,temp);
|
|
|
+}
|
|
|
+
|
|
|
+/************************** GET_AND_SET_FLOAT_MAXMIN ************************/
|
|
|
+/* RWD assumes analysis ?*/
|
|
|
+int get_and_set_float_maxmina(float *flbuf,dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ double maxpdamp = DBL_MIN;
|
|
|
+ double maxndamp = DBL_MAX;
|
|
|
+ float maxpfamp, maxnfamp;
|
|
|
+ int maxprep = 1, maxnrep = 1;
|
|
|
+ int n;
|
|
|
+ dz->samps_left = dz->insams[0];
|
|
|
+ if(sndseekEx(dz->ifd[0],0,0)<0) {
|
|
|
+ sprintf(errstr,"sndseek() failed. get_and_set_float_maxmin()\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ while(dz->samps_left > 0) {
|
|
|
+ if((exit_status = read_samps(flbuf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ for(n=0;n<dz->ssampsread;n++) {
|
|
|
+ if(flbuf[n] < maxpdamp) /* IF < max, ignore */
|
|
|
+ ;
|
|
|
+ else if(flbuf[n] > maxpdamp) {
|
|
|
+ maxpdamp = flbuf[n]; /* IF > max, reset max and count */
|
|
|
+ maxprep = 1;
|
|
|
+ } else /* else must be EQUAL to max; incr counter */
|
|
|
+ maxprep++;
|
|
|
+
|
|
|
+ if(flbuf[n] > maxndamp)
|
|
|
+ ;
|
|
|
+ else if(flbuf[n] < maxndamp) {
|
|
|
+ maxndamp = flbuf[n];
|
|
|
+ maxnrep = 1;
|
|
|
+ } else
|
|
|
+ maxnrep++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ maxpfamp = (float)maxpdamp;
|
|
|
+ maxnfamp = (float)maxndamp;
|
|
|
+//TW cannot reset header of a read-in file
|
|
|
+// if( sndputprop(dz->ifd[0],"maxpfamp",(char *)&maxpfamp,sizeof(float)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write maximum float value to header\n");
|
|
|
+// if(sndputprop(dz->ifd[0],"maxprep",(char *)&maxprep,sizeof(long)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write maxfloat repeats-count to header\n");
|
|
|
+// if( sndputprop(dz->ifd[0],"maxnfamp",(char *)&maxnfamp,sizeof(float)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write mimimum float value to header\n");
|
|
|
+// if(sndputprop(dz->ifd[0],"maxnrep",(char *)&maxnrep,sizeof(long)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write minfloat repeats-count to header\n");
|
|
|
+
|
|
|
+ sprintf(errstr,"maximum float value: %f\n",maxpfamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"occurs: ........... %d times\n",maxprep);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"minimum float value: %f\n",maxnfamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"occurs: ........... %d times\n",maxnrep);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************** GET_AND_SET_SHORT_MAXMIN ************************/
|
|
|
+
|
|
|
+int get_and_set_float_maxmin(float *buf,int chans, double inverse_sr,dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ /*int maxamp = MINSAMP, mag;*/
|
|
|
+ float maxamp = F_MINSAMP, mag;
|
|
|
+ int maxloc = 0;
|
|
|
+ int maxrep = 1;
|
|
|
+ int n;
|
|
|
+ double gain = 0.0, dbgain = 0.0;
|
|
|
+ while(dz->samps_left) {
|
|
|
+ if((exit_status = read_samps(buf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ for(n=0;n<dz->ssampsread;n++) {
|
|
|
+ mag = (float) fabs(buf[n]);
|
|
|
+ if(mag > maxamp) {
|
|
|
+ maxloc = dz->total_samps_read - dz->ssampsread + n;
|
|
|
+ maxamp = mag;
|
|
|
+ maxrep = 1;
|
|
|
+ } else if(mag==maxamp)
|
|
|
+ maxrep++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+//TW Cannot alter heqader of an input file
|
|
|
+// if(sndputprop(dz->ifd[0],"maxamp",(char *)&maxamp,sizeof(float)) < 0 )
|
|
|
+// if(sndputprop(dz->ifd[0],"maxpfamp",(char *)&maxamp,sizeof(float)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write maximum value to header.\n");
|
|
|
+// if(sndputprop(dz->ifd[0],"maxloc",(char *)&maxloc,sizeof(long)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write location of maximum value to header.\n");
|
|
|
+// if(sndputprop(dz->ifd[0],"maxrep",(char *)&maxrep,sizeof(long)) < 0 )
|
|
|
+// fprintf(stdout,"WARNING: Cannot write maximum repeats to header.\n");
|
|
|
+
|
|
|
+ if(maxamp>0.0f) {
|
|
|
+ gain = F_MAXSAMP/(double)maxamp;
|
|
|
+ dbgain = log10(gain) * 20.0;
|
|
|
+ }
|
|
|
+ sprintf(errstr,"maximum abs value:.. %f\n",maxamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"at: ................ %d samples\n",maxloc);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"time: .............. %.4lf secs\n",(double)(maxloc/chans) *inverse_sr);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"repeated: .......... %d times\n",maxrep);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(maxamp>0.0f) {
|
|
|
+ sprintf(errstr,"max possible gain:.. %.4lf\n",gain);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"max dB gain:........ %.4lf\n",dbgain);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************ COMPARE_INFILE_SIZES ***********************/
|
|
|
+
|
|
|
+int compare_infile_sizes(int *samesize,dataptr dz)
|
|
|
+{
|
|
|
+ if(dz->insams[0] != dz->insams[1]) {
|
|
|
+ print_outmessage_flush("Files are not same size.\n");
|
|
|
+ if(!dz->vflag[IGNORE_LENDIFF])
|
|
|
+ return(FINISHED);
|
|
|
+ else {
|
|
|
+ dz->insams[0] = min(dz->insams[0],dz->insams[1]);
|
|
|
+ *samesize = FALSE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ dz->samps_left = dz->insams[0];
|
|
|
+ return(CONTINUE);
|
|
|
+}
|
|
|
+
|
|
|
+/************************** COMPARE_SNDFILE_PROPERTIES *********************/
|
|
|
+
|
|
|
+int compare_sndfile_properties(char temp[],dataptr dz)
|
|
|
+{
|
|
|
+ errstr[0] = ENDOFSTR;
|
|
|
+ if(dz->infile->srate != dz->otherfile->srate) {
|
|
|
+ sprintf(errstr,"Files don't have same sample rate.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->channels != dz->otherfile->channels) {
|
|
|
+ sprintf(errstr,"Files don't have same number of channels. ");
|
|
|
+ if(dz->vflag[IGNORE_CHANDIFF]) {
|
|
|
+ sprintf(temp,"1st has %d : 2nd has %d\n",dz->infile->channels,dz->otherfile->channels);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ } else {
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ return(CONTINUE);
|
|
|
+}
|
|
|
+
|
|
|
+/*************************** SFDIFF_PROCESS **************************/
|
|
|
+
|
|
|
+int sfdiff_process(char temp[],int samesize,dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ int limitcnt = 0, badmatch = 0;
|
|
|
+ double threshold = dz->param[SFDIFF_THRESH] /* * (double)MAXSAMP*/;
|
|
|
+
|
|
|
+ display_virtual_time(0L,dz);
|
|
|
+ if(sndseekEx(dz->ifd[0],0,0)<0) {
|
|
|
+ sprintf(errstr,"sndseekEx() problem in sfdiff_process()\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ if(dz->process==INFO_DIFF && sndseekEx(dz->ifd[1],0,0)<0) {
|
|
|
+ sprintf(errstr,"sndseekEx() problem 2 in sfdiff_process()\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ while(dz->samps_left > 0) {
|
|
|
+ if(dz->process==INFO_CDIFF) {
|
|
|
+ if((exit_status = read_samps_for_cdiff(dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ } else {
|
|
|
+ if((exit_status = read_both_the_files(samesize,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ }
|
|
|
+ compare_samps(temp,&badmatch,&limitcnt,threshold,dz);
|
|
|
+ display_virtual_time(dz->total_samps_read,dz);
|
|
|
+ fflush(stdout);
|
|
|
+ }
|
|
|
+ if(limitcnt == 0) {
|
|
|
+ if(dz->process==INFO_CDIFF)
|
|
|
+ sprintf(errstr,"Channels are IDENTICAL");
|
|
|
+ else {
|
|
|
+ if(samesize)
|
|
|
+ sprintf(errstr,"Files are IDENTICAL");
|
|
|
+ else
|
|
|
+ sprintf(errstr,"Files are otherwise IDENTICAL");
|
|
|
+ }
|
|
|
+ if(dz->process==INFO_CDIFF) {
|
|
|
+ if(dz->param[SFDIFF_THRESH] > 0) {
|
|
|
+ sprintf(temp," to within %lf\n",dz->param[SFDIFF_THRESH]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ }else
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ } else {
|
|
|
+ switch(dz->infile->filetype) {
|
|
|
+ case(SNDFILE):
|
|
|
+ if(dz->param[SFDIFF_THRESH] > 0) {
|
|
|
+ sprintf(temp," to within %lf\n",dz->param[SFDIFF_THRESH]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ } else
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ if(dz->param[SFDIFF_THRESH] > 0.0) {
|
|
|
+ sprintf(temp," to within %lf\n",dz->param[SFDIFF_THRESH]);
|
|
|
+ strcat(errstr,temp);
|
|
|
+ } else
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ } else if(badmatch) {
|
|
|
+ if(limitcnt < dz->iparam[SFDIFF_CNT])
|
|
|
+ strcat(errstr," : as far as end of file.\n");
|
|
|
+ else
|
|
|
+ strcat(errstr," : comparison stopped here.\n");
|
|
|
+ }
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************ READ_BOTH_THE_FILES *******************************/
|
|
|
+
|
|
|
+int read_both_the_files(int samesize,dataptr dz)
|
|
|
+{
|
|
|
+ int samps_read2;
|
|
|
+ if((dz->ssampsread = fgetfbufEx(dz->sampbuf[0], /*dz->bigbufsize*/dz->buflen,dz->ifd[0],0)) < 0) {
|
|
|
+ sprintf(errstr, "Can't read samps from 1st soundfile\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ if((samps_read2 = fgetfbufEx(dz->sampbuf[1], dz->buflen,dz->ifd[1],0)) < 0) {
|
|
|
+ sprintf(errstr, "Can't read samps from 2nd soundfile\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+ if((dz->ssampsread != samps_read2)) {
|
|
|
+ if(samesize) {
|
|
|
+ sprintf(errstr, "Anomaly in soundfile read.\n");
|
|
|
+ return(PROGRAM_ERROR);
|
|
|
+ } else
|
|
|
+ dz->ssampsread = min(dz->ssampsread,samps_read2);
|
|
|
+ }
|
|
|
+ dz->total_samps_read += dz->ssampsread;
|
|
|
+ dz->samps_left -= dz->ssampsread;
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************ READ_SAMPS_FOR_CDIFF *******************************/
|
|
|
+
|
|
|
+int read_samps_for_cdiff(dataptr dz)
|
|
|
+{
|
|
|
+ int n, m;
|
|
|
+ if((dz->ssampsread = fgetfbufEx(dz->sampbuf[2], dz->buflen * 2,dz->ifd[0],0)) < 0) {
|
|
|
+ sprintf(errstr, "Can't read samples from soundfile\n");
|
|
|
+ return(SYSTEM_ERROR);
|
|
|
+ }
|
|
|
+
|
|
|
+ for(n=0,m=0;m<dz->ssampsread;n++,m+=2) {
|
|
|
+ dz->sampbuf[0][n] = dz->sampbuf[2][m];
|
|
|
+ dz->sampbuf[1][n] = dz->sampbuf[2][m+1];
|
|
|
+ }
|
|
|
+ dz->total_samps_read += dz->ssampsread;
|
|
|
+ dz->samps_left -= dz->ssampsread;
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/**************************** COMPARE_SAMPS ***************************/
|
|
|
+
|
|
|
+void compare_samps(char temp[],int *badmatch,int *limitcnt,double threshold,dataptr dz)
|
|
|
+{
|
|
|
+ int n;
|
|
|
+ int sampsread = dz->ssampsread;
|
|
|
+ switch(dz->infile->filetype) {
|
|
|
+ case(SNDFILE):
|
|
|
+ if(dz->process==INFO_CDIFF)
|
|
|
+ sampsread /= STEREO;
|
|
|
+ for(n=0;n<sampsread;n++) {
|
|
|
+ if(fabs(dz->sampbuf[0][n]-dz->sampbuf[1][n]) > threshold) {
|
|
|
+ if(*badmatch==0) {
|
|
|
+ sprintf(errstr,"Badmatch from ");
|
|
|
+ snd_file_time(temp,n,dz);
|
|
|
+ *badmatch = 1;
|
|
|
+ if(++(*limitcnt) >= dz->iparam[SFDIFF_CNT]) {
|
|
|
+ dz->samps_left = 0; /* force calling loop to end */
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if(*badmatch) {
|
|
|
+ strcat(errstr," as far as ");
|
|
|
+ snd_file_time(temp,n,dz);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ *badmatch = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(ANALFILE):
|
|
|
+ dz->ssampsread = sampsread;
|
|
|
+ for(n=0;n<dz->ssampsread;n+=2) {
|
|
|
+ if(fabs(dz->flbufptr[0][n]-dz->flbufptr[1][n]) > threshold) {
|
|
|
+ if(*badmatch==0) {
|
|
|
+ sprintf(errstr,"Bad frq match from ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ *badmatch = 1;
|
|
|
+ if(++(*limitcnt) >= dz->iparam[SFDIFF_CNT]) {
|
|
|
+ dz->samps_left = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if(*badmatch) {
|
|
|
+ strcat(errstr," as far as ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ *badmatch = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(*badmatch) {
|
|
|
+ strcat(errstr," as far as ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ *badmatch = 0;
|
|
|
+ }
|
|
|
+ for(n=1;n<dz->ssampsread;n+=2) {
|
|
|
+ if(fabs(dz->flbufptr[0][n]-dz->flbufptr[1][n]) > threshold) {
|
|
|
+ if(*badmatch==0) {
|
|
|
+ sprintf(errstr,"Bad amp match from ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ *badmatch = 1;
|
|
|
+ if(++(*limitcnt) >= dz->iparam[SFDIFF_CNT]) {
|
|
|
+ dz->samps_left = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if(*badmatch) {
|
|
|
+ strcat(errstr," as far as ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ *badmatch = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(*badmatch) {
|
|
|
+ strcat(errstr," to buffer end ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ *badmatch = 0;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default: /* float files */
|
|
|
+ dz->ssampsread = sampsread;
|
|
|
+ for(n=0;n<dz->ssampsread;n++) {
|
|
|
+ if(fabs(dz->flbufptr[0][n]-dz->flbufptr[1][n]) > threshold) {
|
|
|
+ if(*badmatch==0) {
|
|
|
+ sprintf(errstr,"Badmatch from ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ *badmatch = 1;
|
|
|
+ if(++(*limitcnt) >= dz->iparam[SFDIFF_CNT]) {
|
|
|
+ dz->samps_left = 0;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if(*badmatch) {
|
|
|
+ strcat(errstr," as far as ");
|
|
|
+ anal_file_time(temp,n,dz);
|
|
|
+ strcat(errstr,"\n");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ *badmatch = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/***************************** ANAL_FILE_TIME *************************/
|
|
|
+
|
|
|
+void anal_file_time(char temp[],int n,dataptr dz)
|
|
|
+{
|
|
|
+ int this_channel;
|
|
|
+ double this_time;
|
|
|
+ int wanted;
|
|
|
+ int this_sample = (dz->total_samps_read - dz->ssampsread) + n;
|
|
|
+ int this_window;
|
|
|
+ switch(dz->infile->filetype) {
|
|
|
+ case(ANALFILE):
|
|
|
+ wanted = dz->infile->Mlen + 2;
|
|
|
+ this_window = this_sample/wanted; /* TRUNCATE */
|
|
|
+ this_sample = this_sample%wanted; /* sample count from window base */
|
|
|
+ this_channel = this_sample/2;
|
|
|
+ this_time = (double)this_window/(double)dz->infile->arate;
|
|
|
+ sprintf(temp," channel %d: window %d: time %.4lf ",this_channel,this_window,this_time);
|
|
|
+ break;
|
|
|
+ case(PITCHFILE):
|
|
|
+ case(TRANSPOSFILE):
|
|
|
+ this_window = this_sample;
|
|
|
+ this_time = (double)this_window/(double)dz->infile->arate;
|
|
|
+ sprintf(temp," window %d: time %.4lf ",this_window,this_time);
|
|
|
+ break;
|
|
|
+ case(ENVFILE):
|
|
|
+ this_window = this_sample;
|
|
|
+ this_time = (double)this_window * dz->infile->window_size * MS_TO_SECS;
|
|
|
+ sprintf(temp," window %d: time %.4lf ",this_window,this_time);
|
|
|
+ break;
|
|
|
+ case(FORMANTFILE):
|
|
|
+ this_sample -= dz->specenvcnt * DESCRIPTOR_DATA_BLOKS;
|
|
|
+ this_window = this_sample/dz->specenvcnt; /* TRUNCATE */
|
|
|
+ this_channel = this_sample%dz->specenvcnt;
|
|
|
+ this_time = (double)this_window/(double)dz->infile->arate;
|
|
|
+ sprintf(temp," channel %d: window %d: time %.4lf ",this_channel,this_window,this_time);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ strcat(errstr,temp);
|
|
|
+}
|
|
|
+
|
|
|
+/**************************** SND_FILE_TIME ***************************/
|
|
|
+
|
|
|
+void snd_file_time(char temp [],int n,dataptr dz)
|
|
|
+{
|
|
|
+ int this_sample;
|
|
|
+ double this_time, sr = (double)dz->infile->srate;
|
|
|
+ if(dz->process==INFO_CDIFF) {
|
|
|
+ this_sample = ((dz->total_samps_read - dz->ssampsread)/STEREO) + n;
|
|
|
+ this_time = (double)this_sample/sr;
|
|
|
+ } else {
|
|
|
+ this_sample = (dz->total_samps_read - dz->ssampsread) + n;
|
|
|
+ this_time = (double)this_sample/(sr * (double)dz->infile->channels);
|
|
|
+ }
|
|
|
+ sprintf(temp,"sample %d: time %.4lf ",this_sample,this_time);
|
|
|
+ strcat(errstr,temp);
|
|
|
+}
|
|
|
+
|
|
|
+/**************************** COMPARE_ANALFILE_PROPERTIES ***************************/
|
|
|
+
|
|
|
+int compare_analfile_properties(dataptr dz)
|
|
|
+{
|
|
|
+ errstr[0] = ENDOFSTR;
|
|
|
+ switch(dz->infile->filetype) {
|
|
|
+ case(ENVFILE):
|
|
|
+ if(dz->infile->window_size != dz->otherfile->window_size) {
|
|
|
+ sprintf(errstr,"Files do not have same WINDOW_SIZE.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(FORMANTFILE):
|
|
|
+ if(dz->infile->specenvcnt != dz->otherfile->specenvcnt) {
|
|
|
+ sprintf(errstr,"Files do not have same FORMANT WINDOW CNT.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(PITCHFILE):
|
|
|
+ case(TRANSPOSFILE):
|
|
|
+ if(dz->infile->origchans != dz->otherfile->origchans) {
|
|
|
+ sprintf(errstr,"Files do not have same ORIGINAL NO. OF CHANNELS.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if(dz->infile->stype != dz->otherfile->stype) {
|
|
|
+ sprintf(errstr,"Files do not have same SAMPLE TYPE.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->srate != dz->otherfile->srate) {
|
|
|
+ sprintf(errstr,"Files do not have same SAMPLING RATE.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->channels != dz->otherfile->channels) {
|
|
|
+ sprintf(errstr,"Files do not have same NO. OF CHANNELS.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->filetype!=ENVFILE) {
|
|
|
+ if(dz->infile->origstype != dz->otherfile->origstype) {
|
|
|
+ sprintf(errstr,"Files do not have same ORIGINAL SAMPLE TYPE.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->origrate != dz->otherfile->origrate) {
|
|
|
+ sprintf(errstr,"Files do not have same ORIGINAL SAMPLING RATE.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->arate != dz->otherfile->arate) {
|
|
|
+ sprintf(errstr,"Files do not have same ANALYSIS RATE.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->Mlen != dz->otherfile->Mlen) {
|
|
|
+ sprintf(errstr,"Files do not have same ANALYSIS WINDOW LENGTH.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(dz->infile->Dfac != dz->otherfile->Dfac) {
|
|
|
+ sprintf(errstr,"Files do not have same DECIMATION FACTOR.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return(CONTINUE);
|
|
|
+}
|
|
|
+
|
|
|
+/********************************* DO_SFDIFF ***********************************/
|
|
|
+
|
|
|
+int do_sfdiff(char temp[],dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ int samesize = TRUE;
|
|
|
+
|
|
|
+ switch(dz->process) {
|
|
|
+ case(INFO_CDIFF):
|
|
|
+ if(dz->infile->channels!=2) {
|
|
|
+ sprintf(errstr,"Process only works with STEREO files.\n");
|
|
|
+ return(DATA_ERROR);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ if(is_a_text_input_filetype(dz->infile->filetype)
|
|
|
+ || is_a_text_input_filetype(dz->otherfile->filetype)) {
|
|
|
+ sprintf(errstr,"Program only works with soundfiling system files.\n");
|
|
|
+ return(DATA_ERROR);
|
|
|
+ }
|
|
|
+ if(dz->infile->filetype != dz->otherfile->filetype) {
|
|
|
+ print_outmessage_flush("Files are not of the same type.\n");
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ if(compare_infile_sizes(&samesize,dz)!=CONTINUE)
|
|
|
+ return(FINISHED);
|
|
|
+
|
|
|
+ switch(dz->infile->filetype) {
|
|
|
+ case(SNDFILE):
|
|
|
+ if(compare_sndfile_properties(temp,dz)!=CONTINUE) {
|
|
|
+ print_outmessage_flush(errstr);
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ if(compare_analfile_properties(dz)!=CONTINUE) {
|
|
|
+ print_outmessage_flush(errstr);
|
|
|
+ return(FINISHED);
|
|
|
+ }
|
|
|
+ dz->flbufptr[0] = dz->sampbuf[0];
|
|
|
+ dz->flbufptr[1] = dz->sampbuf[1];
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ if((exit_status = sfdiff_process(temp,samesize,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+
|
|
|
+ print_outmessage_flush(errstr);
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/********************************* PRNTPROPS ***********************************/
|
|
|
+/* RWD much adapted to report PEAK data if available */
|
|
|
+int prntprops(SFPROPS *props,dataptr dz)
|
|
|
+{
|
|
|
+ char *prop;
|
|
|
+ time_t thistime;
|
|
|
+ char *p;
|
|
|
+ CHPEAK peaks[2000];
|
|
|
+ int chans, peaktime;
|
|
|
+
|
|
|
+ if((prop = (char *)malloc(max(sizeof(unsigned int),sizeof(double))))==NULL) {
|
|
|
+ sprintf(errstr,"INSUFFICIENT MEMORY to get properties.\n");
|
|
|
+ return(MEMORY_ERROR);
|
|
|
+ }
|
|
|
+
|
|
|
+ /*RWD find PEAK chunk as priority */
|
|
|
+
|
|
|
+ if(snd_headread(dz->ifd[0],props)){
|
|
|
+ if((*props).type == wt_wave) {
|
|
|
+ switch(props->samptype){ /*RWD Nov 2003 show sample type now we have so many possibilities! */
|
|
|
+ case(SHORT16):
|
|
|
+ sprintf(errstr,"sample type: 16bit\n");
|
|
|
+ break;
|
|
|
+ case(FLOAT32):
|
|
|
+ sprintf(errstr,"sample type: 32bit floats\n");
|
|
|
+ break;
|
|
|
+ case(INT2424):
|
|
|
+ sprintf(errstr,"sample type: 24bit packed\n");
|
|
|
+ break;
|
|
|
+ case(SHORT8):
|
|
|
+ sprintf(errstr,"sample type: 8bit\n");
|
|
|
+ break;
|
|
|
+ case(INT2432):
|
|
|
+ sprintf(errstr,"sample type: 24bit in 32bit frames\n");
|
|
|
+ break;
|
|
|
+ case(INT_32):
|
|
|
+ sprintf(errstr,"sample type: 32bit integer\n");
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ sprintf(errstr,"sample type unknown (custom format)\n");
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ print_outmessage(errstr);
|
|
|
+ chans = (*props).chans;
|
|
|
+ if(sndreadpeaks(dz->ifd[0],chans,peaks,&peaktime)>0){
|
|
|
+ int i;
|
|
|
+ thistime = (time_t) peaktime;
|
|
|
+ sprintf(errstr,"PEAK data at: %s\n",ctime(&thistime));
|
|
|
+ print_outmessage(errstr);
|
|
|
+ for(i=0;i < chans;i++){
|
|
|
+ sprintf(errstr,"CH %d:\tamp = %.4f (%.2f dB)\tFrame %u\n",
|
|
|
+ i+1,peaks[i].value,20 * log10(peaks[i].value),peaks[i].position);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ sprintf(errstr,"No PEAK chunk in this file");
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(sndgetprop(dz->ifd[0], "date", prop, sizeof(unsigned int))>=0
|
|
|
+ || sndgetprop(dz->ifd[0], "DATE", prop, sizeof(unsigned int))>=0) {
|
|
|
+ thistime = (time_t) *(int*)prop;
|
|
|
+ p = ctime(&thistime);
|
|
|
+
|
|
|
+ sprintf(errstr,"Date: %s\n",p);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ fflush(stdout);
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/************************** GET_SHORT_MAXMIN ************************/
|
|
|
+
|
|
|
+int get_float_maxmin(float *buf,int chans, double inverse_sr,dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ /*int maxamp = MINSAMP;*/
|
|
|
+ float maxamp = F_MINSAMP,mag;
|
|
|
+ int maxloc = 0;
|
|
|
+ int maxrep = 1;
|
|
|
+ int n;
|
|
|
+ double gain = 0.0, dbgain = 0.0;
|
|
|
+ double convertor = (double)(chans * dz->infile->srate);
|
|
|
+ int startsamp = round(dz->param[MAX_STIME] * convertor);
|
|
|
+ int endsamp = round(dz->param[MAX_ETIME] * convertor);
|
|
|
+ int last_total_samps_read;
|
|
|
+ int startsrch, endsrch;
|
|
|
+ dz->total_samps_read = 0; /* REDUNDANT ? */
|
|
|
+ while(dz->samps_left) {
|
|
|
+ last_total_samps_read = dz->total_samps_read;
|
|
|
+ if((exit_status = read_samps(buf,dz))<0)
|
|
|
+ return(exit_status);
|
|
|
+ if(dz->total_samps_read <= startsamp)
|
|
|
+ continue;
|
|
|
+ else
|
|
|
+ startsrch = max(0,startsamp - last_total_samps_read);
|
|
|
+ if(dz->total_samps_read > endsamp) {
|
|
|
+ if((endsrch = endsamp - last_total_samps_read) < 0)
|
|
|
+ break;
|
|
|
+ } else
|
|
|
+ endsrch = dz->ssampsread;
|
|
|
+ for(n=startsrch;n<endsrch;n++) {
|
|
|
+ mag = (float) fabs(buf[n]);
|
|
|
+ if(mag > maxamp) {
|
|
|
+ maxloc = last_total_samps_read + n;
|
|
|
+ maxamp = mag;
|
|
|
+ maxrep = 1;
|
|
|
+ } else if(mag==maxamp)
|
|
|
+ maxrep++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(maxamp>0.0f) {
|
|
|
+ gain = (double)F_MAXSAMP/(double)maxamp;
|
|
|
+ dbgain = log10(gain) * 20.0;
|
|
|
+ }
|
|
|
+ sprintf(errstr,"maximum abs value:.. %f\n",maxamp);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"at: ................ %d samples\n",maxloc);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"time: .............. %.4lf secs\n",(double)(maxloc/chans) *inverse_sr);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"repeated: .......... %d times\n",maxrep);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ if(maxamp>0.0f) {
|
|
|
+ sprintf(errstr,"max possible gain:.. %.4lf\n",gain);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ sprintf(errstr,"max dB gain:........ %.4lf\n",dbgain);
|
|
|
+ print_outmessage(errstr);
|
|
|
+ }
|
|
|
+ return(FINISHED);
|
|
|
+}
|
|
|
+
|
|
|
+/*RWD 6:2001 read PEAK chunk */
|
|
|
+int getpeakdata(int ifd, float *peakval,SFPROPS *props)
|
|
|
+{
|
|
|
+ CHPEAK peaks[16];
|
|
|
+ int chans, peaktime;
|
|
|
+ float maxamp = 0.0f;
|
|
|
+
|
|
|
+ if(snd_headread(ifd,props)){
|
|
|
+ chans = (*props).chans;
|
|
|
+ if(sndreadpeaks(ifd,chans,peaks,&peaktime)){
|
|
|
+ int i;
|
|
|
+ for(i=0;i < chans;i++)
|
|
|
+ maxamp = max(maxamp,peaks[i].value);
|
|
|
+ *peakval = maxamp;
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* sf_headread error; but can't do much about it */
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+/************************** DO_ZCROSS_RATIO ************************/
|
|
|
+
|
|
|
+int do_zcross_ratio(dataptr dz)
|
|
|
+{
|
|
|
+ int exit_status;
|
|
|
+ int chans = dz->infile->channels, *phase, k, m;
|
|
|
+ int n, *cnt, cntsum = 0, zc0, zc1, lastzc0, lastzc1, bufstart, bufend, bufskip, skipsamps, totsams, total_samps_processed;
|
|
|
+ double zc_ratio;
|
|
|
+ float *buf = dz->sampbuf[0];
|
|
|
+ double srate = dz->infile->srate;
|
|
|
+ if((cnt = (int *)malloc(chans * sizeof(int)))==NULL) {
|
|
|
+ sprintf(errstr,"NO MEMORY TO STORE ZERO-CROSSING COUNTERS.\n");
|
|
|
+ return(MEMORY_ERROR);
|
|
|
+ }
|
|
|
+ if((phase = (int *)malloc(chans * sizeof(int)))==NULL) {
|
|
|
+ sprintf(errstr,"NO MEMORY TO STORE PHASE MARKERS.\n");
|
|
|
+ return(MEMORY_ERROR);
|
|
|
+ }
|
|
|
+ dz->iparam[ZC_START] = (int)round(dz->param[ZC_START] * srate) * chans;
|
|
|
+ bufend = (int)round(dz->param[ZC_END] * srate) * chans;
|
|
|
+ totsams = bufend - dz->iparam[ZC_START];
|
|
|
+ dz->tempsize = totsams;
|
|
|
+ bufstart = dz->iparam[ZC_START] % dz->buflen;
|
|
|
+ if((bufskip = dz->iparam[ZC_START] / dz->buflen) > 0) {
|
|
|
+ skipsamps = bufskip * dz->buflen;
|
|
|
+ sndseekEx(dz->ifd[0],skipsamps,0);
|
|
|
+ bufend -= skipsamps;
|
|
|
+ }
|
|
|
+ if((exit_status = read_samps(buf,dz)) < 0)
|
|
|
+ return(exit_status);
|
|
|
+ if(dz->ssampsread < chans * 2) {
|
|
|
+ sprintf(errstr,"INSUFFICIENT DATA TO COUNT ZERO-CROSSINGS.\n");
|
|
|
+ return(DATA_ERROR);
|
|
|
+ }
|
|
|
+ total_samps_processed = 0;
|
|
|
+ for(m=0,n = bufstart;m<chans;m++,n++) {
|
|
|
+ if(buf[n] > 0)
|
|
|
+ phase[m] = 1;
|
|
|
+ else if(buf[n] < 0)
|
|
|
+ phase[m] = -1;
|
|
|
+ else
|
|
|
+ phase[m] = 0;
|
|
|
+ cnt[m] = 0;
|
|
|
+ }
|
|
|
+ k = bufstart + chans;
|
|
|
+ while(bufend > dz->buflen) {
|
|
|
+ for(n = k; n < dz->ssampsread;n+=chans) {
|
|
|
+ for(m=0;m<chans;m++) {
|
|
|
+ switch(phase[m]) {
|
|
|
+ case(0):
|
|
|
+ if(buf[n+m] > 0)
|
|
|
+ phase[m] = 1;
|
|
|
+ else if(buf[n+m] < 0)
|
|
|
+ phase[m] = -1;
|
|
|
+ break;
|
|
|
+ case(1):
|
|
|
+ if(buf[n+m] < 0) {
|
|
|
+ cnt[m]++;
|
|
|
+ phase[m] = -1;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(-1):
|
|
|
+ if(buf[n+m] > 0) {
|
|
|
+ cnt[m]++;
|
|
|
+ phase[m] = 1;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ total_samps_processed += (dz->ssampsread - k);
|
|
|
+ display_virtual_time(total_samps_processed,dz);
|
|
|
+ if((exit_status = read_samps(buf,dz)) < 0)
|
|
|
+ return(exit_status);
|
|
|
+ bufend -= dz->buflen;
|
|
|
+ k = 0;
|
|
|
+ }
|
|
|
+ if(bufend > 0) {
|
|
|
+ for(n = k; n < bufend;n+=chans) {
|
|
|
+ for(m=0;m<chans;m++) {
|
|
|
+ switch(phase[m]) {
|
|
|
+ case(0):
|
|
|
+ if(buf[n+m] > 0)
|
|
|
+ phase[m] = 1;
|
|
|
+ else if(buf[n+m] < 0)
|
|
|
+ phase[m] = -1;
|
|
|
+ break;
|
|
|
+ case(1):
|
|
|
+ if(buf[n+m] < 0) {
|
|
|
+ cnt[m]++;
|
|
|
+ phase[m] = -1;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case(-1):
|
|
|
+ if(buf[n+m] > 0) {
|
|
|
+ cnt[m]++;
|
|
|
+ phase[m] = 1;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ total_samps_processed += (bufend - k);
|
|
|
+ display_virtual_time(total_samps_processed,dz);
|
|
|
+ }
|
|
|
+ for(m=0;m<chans;m++)
|
|
|
+ cntsum += cnt[m];
|
|
|
+ zc_ratio = (double)cntsum/(double)totsams;
|
|
|
+ zc1 = 32768;
|
|
|
+ zc0 = (int)round(zc_ratio * zc1);
|
|
|
+ do {
|
|
|
+ lastzc0 = zc0;
|
|
|
+ lastzc1 = zc1;
|
|
|
+ zc1 /= 2;
|
|
|
+ zc0 = (int)round(zc_ratio * zc1);
|
|
|
+ } while(zc0 > 0 && zc1 >= 64);
|
|
|
+ zc0 = lastzc0;
|
|
|
+ zc1 = lastzc1;
|
|
|
+ while(EVEN(zc0)) {
|
|
|
+ zc0 /= 2;
|
|
|
+ zc1 /= 2;
|
|
|
+ }
|
|
|
+ fprintf(stdout,"INFO: Proportion of zero-crossings = %lf or approx %d:%d\n",zc_ratio,zc0,zc1);
|
|
|
+ fflush(stdout);
|
|
|
+ return FINISHED;
|
|
|
+}
|
richarddobson