initial commit

dev/misc/CMakeLists.txt

@@ -0,0 +1,100 @@
+if(APPLE)
+  set(CMAKE_C_FLAGS "-O2 -Wall -mmacosx-version-min=10.5 -Dunix")
+else()
+  if(MINGW)
+    set(CMAKE_C_FLAGS "-O2 -Wall -DWIN32")
+  else()
+    set(CMAKE_C_FLAGS "-O2 -Wall -Dlinux -Dunix")
+  endif()
+endif()
+
+link_directories(../cdp2k ../sfsys)
+
+include_directories(../../include)
+
+add_executable(brkdur brkdur.c)
+target_link_libraries(brkdur cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(brkdur)
+
+add_executable(diskspace diskspace.c )
+target_link_libraries(diskspace cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(diskspace)
+
+add_executable(fixgobo fixgobo.c)
+target_link_libraries(fixgobo cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(fixgobo)
+
+add_executable(gobo gobo.c)
+target_link_libraries(gobo cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(gobo)
+
+add_executable(gobosee gobosee.c)
+target_link_libraries(gobosee cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(gobosee)
+
+add_executable(histconv histconv.c)
+target_link_libraries(histconv cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(histconv)
+
+add_executable(listdate listdate.c)
+target_link_libraries(listdate cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(listdate)
+
+add_executable(logdate  logdate.c)
+target_link_libraries(logdate  cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(logdate )
+
+add_executable(maxsamp2 maxsamp2.c)
+target_link_libraries(maxsamp2 cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(maxsamp2)
+
+add_executable(paudition paudition.c mxfft.c)
+target_link_libraries(paudition cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(paudition)
+
+add_executable(pdisplay pdisplay.c)
+target_link_libraries(pdisplay cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(pdisplay)
+
+add_executable(pmodify pmodify.c)
+target_link_libraries(pmodify cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(pmodify)
+
+add_executable(progmach progmach.c)
+target_link_libraries(progmach cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(progmach)
+
+add_executable(stretcha stretcha.c)
+target_link_libraries(stretcha cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(stretcha)
+
+add_executable(tkusage tkusage.c)
+target_link_libraries(tkusage  cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(tkusage)
+
+add_executable(tkusage_other tkusage_other.c)
+target_link_libraries(tkusage_other cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(tkusage_other)
+
+add_executable(vuform vuform.c)
+target_link_libraries(vuform cdp2k sfsys ${EXTRA_LIBRARIES})
+
+my_install(vuform)
+
+

dev/misc/brkdur.c

@@ -0,0 +1,301 @@
+/*
+ * 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 <ctype.h>
+#include <math.h>
+#include <string.h>
+
+#define CALCLIM 		(0.00002)
+#define FLTERR	 		(0.00002)
+#define ONE_OVER_LN2	(1.442695)
+#define BIGARRAY		200
+#define ENDOFSTR		('\0')
+#define NEWLINE			('\n')
+
+int 	read_brkdata(double **bbrk,FILE *fp,int mode);
+void 	get_dur(double *bbrk,int bbrksize,double in_dur,int mode);
+double 	cntevents(double dur,double s0,double s1);
+int 	sizeq(double f1,double f2);
+int  	get_float_from_within_string(char **str,double *val);
+double 	round(double a);
+int 	flteq(double a,double b);
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char * argv [])
+{
+	double *bbrk, in_dur;
+	FILE *fp;
+	int bbrksize, mode;
+
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc!=4) {
+		fprintf(stdout,"ERROR: Bad function call.\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sscanf(argv[2],"%d",&mode)!=1) {
+		fprintf(stdout,"ERROR: Failed to read mode.\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sscanf(argv[3],"%lf",&in_dur)!=1) {
+		fprintf(stdout,"ERROR: Failed to read input file duration.\n");
+		fflush(stdout);
+		return(0);
+	}
+	if((fp = fopen(argv[1],"r"))==NULL) {
+		fprintf(stdout,"ERROR: Failed to open file %s\n",argv[1]);
+		fflush(stdout);
+		return(0);
+	}
+	if((bbrksize = read_brkdata(&bbrk,fp,mode))<=0)
+		return(0);
+	get_dur(bbrk,bbrksize,in_dur,mode);
+	return(1);
+}
+
+void get_dur(double *bbrk,int bbrksize,double in_dur,int mode)
+{
+	int n, m;
+	double lasttime, lastval, thistime, thisval, newtime = 0;
+	int done;
+	double tratio;
+	/*RWD need init */
+	thistime = 0;
+	lasttime = bbrk[0];
+	lastval  = bbrk[1];
+	if(mode == 1) {
+		for(n = 1; n <bbrksize * 2; n+=2)
+			bbrk[n] = pow(2.0,bbrk[n]/12.0);
+	}
+	done = 0;
+	for(m=2,n= 1;n<bbrksize;m+=2,n++) {
+		thistime = bbrk[m]; 
+		thisval  = bbrk[m+1]; 
+		if((in_dur > 0.0) && (thistime > in_dur)) {
+			done = 1;
+			tratio   = (in_dur - lasttime)/(thistime - lasttime);
+			if(!flteq(tratio,0.0)) {
+				thistime = in_dur;
+				thisval  = ((thisval - lastval) * tratio) + lastval;
+				newtime += cntevents(thistime - lasttime,lastval,thisval);
+			}
+		} else {
+			newtime += cntevents(thistime - lasttime,lastval,thisval);
+		}
+		if(done)
+			break;
+		lasttime = thistime;
+		lastval  = thisval;
+	}
+	if(!done && (thistime < in_dur)) {
+		thistime = in_dur;
+		thisval  = lastval;
+		newtime += cntevents(thistime - lasttime,lastval,thisval);
+	}
+	fprintf(stdout,"INFO: DURATION is %lf\n",newtime);
+	fflush(stdout);
+}
+
+/*************************** CNTEVENTS *****************************/
+
+double cntevents(double dur,double s0,double s1)
+{   
+	double f1 = dur,f2;
+	if(sizeq(s1,s0))
+		return((f1*2.0)/(s1+s0));
+	f2  = s1-s0;
+	f1 /= f2;
+	f2  = s1/s0;
+	f2  = log(f2);
+	f1 *= f2;
+	return(fabs(f1));
+}
+
+/**************************** SIZEQ *******************************/
+
+int sizeq(double f1,double f2)
+{   
+	double upperbnd, lowerbnd;
+	upperbnd = f2 + CALCLIM;
+	lowerbnd = f2 - CALCLIM;
+	if((f1>upperbnd) || (f1<lowerbnd))
+		return(0);
+	return(1);
+}
+
+
+/**************************** READ_BRKDATA *******************************/
+
+int read_brkdata(double **bbrk, FILE *fp,int mode)
+{
+	double *p, *w, zmax, zmin, lasttime = 0;	/*RWD added init */
+	char *q,  temp[400];
+	int is_time = 1, is_insert = 0,cnt = 0;
+	int arraysize = BIGARRAY;
+	if(mode == 1) {
+		zmax = 120.0;
+		zmin = -120.0;
+	} else {
+		zmax = 1000.0;
+		zmin = 0.001;
+	}
+	if((*bbrk = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+		fprintf(stdout,"ERROR: INSUFFICIENT MEMORY to store input brktable data.\n");
+		fflush(stdout);
+		return(0);
+	}
+	p = *bbrk;
+	cnt = 0;
+	while(fgets(temp,200,fp)==temp) {	 /* READ AND TEST BRKPNT VALS */
+		q = temp;
+		while(get_float_from_within_string(&q,p)) {
+			if(is_time) {
+				if(cnt==0) {
+					if(*p < 0.0) {
+						fprintf(stdout,"ERROR: First timeval (%lf) in brkpntfile is less than zero.\n",*p);
+						fflush(stdout);
+						return(0);
+					} else if (*p > 0.0) {
+						is_insert = 1;
+					}
+				} else {
+					if(is_insert) {	 		/*	Force val at time zero */
+						p   += 2;
+						cnt += 2;
+						w = p;
+						*p = *(p-2);
+						p--;
+						*p = *(p-2);
+						p--;
+						*p = *(p-2);
+						(*bbrk)[0] = 0.0;
+						p = w;
+						is_insert = 0;
+					}
+					if(*p <= lasttime) {
+						fprintf(stdout,"ERROR: Times (%lf & %lf) in brkpntfile are not in increasing order.\n",*p,lasttime);
+						fflush(stdout);
+						return(0);
+					}
+				}
+				lasttime = *p;
+			} else {
+				if(*p < zmin || *p > zmax) {
+					fprintf(stdout,"ERROR: Time stretch values are out of range (%lf to %lf)\n",zmin, zmax);
+					fflush(stdout);
+					return(0);
+				}
+			}
+			is_time = !is_time;
+			p++;
+			if(++cnt >= arraysize) {
+				arraysize += BIGARRAY;
+				if((*bbrk = (double *)realloc((char *)(*bbrk),arraysize * sizeof(double)))==NULL) {
+					fprintf(stdout,"ERROR: INSUFFICIENT MEMORY to reallocate input brktable data.\n");
+					fflush(stdout);
+					return(0);
+				}
+				p = (*bbrk) + cnt;		
+			}
+		}
+	}	    
+	if(cnt < 4) {
+		fprintf(stdout,"ERROR: Not enough data in brkpnt file.\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(cnt&1) {
+		fprintf(stdout,"ERROR: Data not paired correctly in brkpntfile.\n");
+		fflush(stdout);
+		return(0);
+	}
+	return cnt/2;
+}
+
+/************************** GET_FLOAT_FROM_WITHIN_STRING **************************/
+
+int  get_float_from_within_string(char **str,double *val)
+{
+	char   *p, *valstart;
+	int    decimal_point_cnt = 0, has_digits = 0;
+	p = *str;
+	while(isspace(*p))
+		p++;
+	valstart = p;	
+	switch(*p) {
+	case('-'):						break;
+	case('.'): decimal_point_cnt=1;	break;
+	default:
+		if(!isdigit(*p))
+			return(0);
+		has_digits = 1;
+		break;
+	}
+	p++;		
+	while(!isspace(*p) && *p!=NEWLINE && *p!=ENDOFSTR) {
+		if(isdigit(*p))
+			has_digits = 1;
+		else if(*p == '.') {
+			if(++decimal_point_cnt>1)
+				return(0);
+		} else
+			return(0);
+		p++;
+	}
+	if(!has_digits || sscanf(valstart,"%lf",val)!=1)
+		return(0);
+	*str = p;
+	return(1);
+}
+
+double round(double a)
+{
+	int b;
+	if(a >= 0.0)
+		b = (int)floor(a + 0.5);
+	else {
+		a = -a;
+		b = (int)floor(a + 0.5);
+		b = -b;
+	}
+	return b;
+}
+
+int flteq(double a,double b)
+{
+	double hibnd = a + FLTERR;	
+	double lobnd = a - FLTERR;
+	if(b >= lobnd && b <= hibnd)
+		return 1;
+	return 0;
+}

dev/misc/diskspace.c

@@ -0,0 +1,190 @@
+/*
+ * 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 <string.h>
+#include <sfsys.h>
+#include <math.h>
+#include <osbind.h>
+
+char errstr[2400];
+
+#define MONO        (1)
+#define STEREO      (2)
+#define ENDOFSTR    ('\0')
+
+#define LEAVESPACE  (10*1024)
+
+void splice_multiline_string(char *str,char *prefix);
+const char* cdp_version = "7.1.0";
+/*RWD Jan 2014 updated getdrivefreespace(), corrected INFO output format for unsigned long */
+/************************************ CHECK_AVAILABLE_DISKSPACE ********************************/
+
+int main(int argc,char *argv[])
+{
+    double srate, secs, mins, hrs;
+    unsigned int outsamps = 0, orig_outsamps;
+    int m, k, kk, spacecnt;
+    char temp[800];
+    unsigned int freespace = getdrivefreespace(/*"temp"*/".") - LEAVESPACE;
+    unsigned int start = hz1000();
+
+    if((argc==2) && strcmp(argv[1],"--version")==0) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+
+    //start = hz1000(); 
+    if(argc!=2)  {
+        fprintf(stdout,"ERROR: Cannot run this process.\n");
+        fflush(stdout);
+//TW UPDATE
+        while(!(hz1000() - start))
+            ;
+        return 1;
+    }
+    if(sscanf(argv[1],"%lf",&srate)!=1) {
+        fprintf(stdout,"ERROR: Cannot read sample rate.\n");
+        fflush(stdout);
+//TW UPDATE
+        while(!(hz1000() - start))
+            ;
+        return 1;
+    }
+
+    sprintf(errstr,"AVAILABLE DISK SPACE\n");
+    sprintf(temp,"%u",freespace);
+    strcat(errstr,temp);
+    spacecnt = 13 - strlen(temp);
+    for(k=0;k<spacecnt;k++)
+        strcat(errstr," ");
+    strcat(errstr,"bytes\n");
+    splice_multiline_string(errstr,"INFO:");
+    fflush(stdout);
+    kk = 0;
+    while (kk < 4) {
+        errstr[0] = ENDOFSTR;
+        switch(kk) {
+        case(0): outsamps = freespace/2;    break;
+        case(1): outsamps = freespace/3;    break;
+        case(2): outsamps = freespace/4;    break;
+        case(3): outsamps = freespace/sizeof(float);    break;
+        }
+        sprintf(temp,"%d",outsamps);
+        strcat(errstr,temp);
+        spacecnt = 13 - strlen(temp);
+        for(k=0;k<spacecnt;k++)
+            strcat(errstr," ");
+        switch(kk) {
+        case(0): strcat(errstr,"16-bit samples\n"); break;
+        case(1): strcat(errstr,"24-bit samples\n"); break;
+        case(2): strcat(errstr,"32-bit samples\n"); break;
+        case(3): strcat(errstr,"float  samples\n"); break;
+        }
+        orig_outsamps = outsamps;
+        for(m=MONO;m<=STEREO;m++) {
+            switch(m) {
+            case(MONO):
+                outsamps = orig_outsamps;
+                sprintf(temp,"IN MONO    : ");
+                strcat(errstr,temp);
+                break;
+            case(STEREO):
+                outsamps /= 2;
+                sprintf(temp,"IN STEREO : ");
+                strcat(errstr,temp);
+                break;
+            }
+            secs  = (double)outsamps/srate;
+            mins  = floor(secs/60.0);
+            secs -= mins * 60.0;
+            hrs   = floor(mins/60.0);
+            mins -= hrs * 60.0;
+            if(hrs > 0.0) {
+                sprintf(temp,"%.0lf",hrs);
+                strcat(errstr,temp);
+                spacecnt = 3 - strlen(temp);
+                for(k=0;k<spacecnt;k++)
+                    strcat(errstr," ");
+                strcat(errstr,"hours ");
+            } else {
+                for(k=0;k<4 + (int)strlen("hours");k++)
+                    strcat(errstr," ");
+            }
+            if(mins > 0.0) {
+                sprintf(temp,"%.0lf",mins);
+                strcat(errstr,temp);
+                spacecnt = 3 - strlen(temp);
+                for(k=0;k<spacecnt;k++)
+                    strcat(errstr," ");
+                strcat(errstr,"mins ");
+            } else {
+                for(k=0;k<4 + (int)strlen("mins");k++)
+                    strcat(errstr," ");
+            }
+            sprintf(temp,"%.3lf",secs);
+            strcat(errstr,temp);
+            spacecnt = 7 - strlen(temp);
+            for(k=0;k<spacecnt;k++)
+                strcat(errstr," ");
+            strcat(errstr,"secs\n");
+        }
+        splice_multiline_string(errstr,"INFO:");
+        fflush(stdout);
+        kk++;
+    }
+//TW UPDATE
+    while(!(hz1000() - start))
+        ;
+    return 0;
+}
+
+/****************************** SPLICE_MULTILINE_STRING ******************************/
+
+void splice_multiline_string(char *str,char *prefix)
+{
+    char *p, *q, c;
+    p = str;
+    q = str;
+    while(*q != ENDOFSTR) {
+        while(*p != '\n' && *p != ENDOFSTR)
+            p++;
+        c = *p;
+        *p = ENDOFSTR;
+        fprintf(stdout,"%s %s\n",prefix,q);
+        *p = c;
+        if(*p == '\n')
+             p++;
+        while(*p == '\n') {
+            fprintf(stdout,"%s \n",prefix);
+            p++;
+        }
+        q = p;
+        p++;
+    }
+}

dev/misc/fixgobo.c

@@ -0,0 +1,474 @@
+/*
+ * 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 <string.h>
+#include <ctype.h>
+#include <processno.h>
+#include <standalone.h>
+
+#define NUMBER_OF_GOBOS (41)
+#define ENDOFSTR    ('\0')
+
+#define MAX_TEMPROC_AREA    (288)
+#define MIN_TEMPROC_AREA    (287)
+
+static int check_flags(char *str,int **flags,int max_gobos);
+static int check_progno(int *progno, int system_update);
+static int make_next_gobo_name_and_number(int *gobo_number, int *goboname_len, char **comp, char *pretext, int max_gobos);
+static int count_gobo_array_elements_in_first_gobo(char *gobo_line, char *comp, int progno, int new_element_cnt);
+static int altergobo(char **gobo_line,int existing_element_cnt,int make_new_array_element,int gobo_array_element,
+            int gobo_element_mask,int substitute,int setval);
+static int count_gobo_array_elements(char *gobo_line);
+
+//TW UPDATE
+int deleter = 0;
+int substitute = 0;
+char pretext[] = "int ";    /* text occuring before goboname, on gobo defining lines in gobo.c */
+const char* cdp_version = "7.1.0";
+
+int main(int argc, char *argv[])
+{
+    FILE *fpi, *fpo;
+    char *gobo_line, *comp;
+//TW UPDATE
+    int gobo_number = 0, goboname_len = 10, setval = 0, *flags;
+    int max_gobos = NUMBER_OF_GOBOS + 2;
+    int finished_fixing_gobos = 0, progno;
+    int gobo_array_element, gobo_array_element_index, gobo_element_mask, first_gobostring = 1;
+    int existing_element_cnt = 0, new_element_cnt, make_new_array_element = 0;
+    int system_update = 0;
+        
+    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if(argc==4) {
+        if(strcmp(argv[3],"SYSTEM_UPDATE")) {
+            fprintf(stdout,"ERROR: Bad call to fixgobo.\n");
+            fflush(stdout);
+            exit(1);
+        } else {
+            system_update = 1;
+        }
+    } else if(argc!=3) {
+        fprintf(stdout,"ERROR: Bad call to fixgobo.\n");
+        fflush(stdout);
+        exit(1);
+    }
+    if(sscanf(argv[2],"%d",&progno)!=1) {
+        fprintf(stdout,"ERROR: Cannot read process number.\n");
+        fflush(stdout);
+        exit(1);
+    }
+    if((substitute = check_progno(&progno,system_update)) < 0)
+        exit(1);
+    if(check_flags(argv[1],&flags,max_gobos) < 0)
+        exit(1);
+    progno--;                   /* progs count from 1, gob flags indexed from 0 */
+    gobo_array_element       = progno/32;
+    gobo_array_element_index = progno%32;
+    progno++;
+    gobo_element_mask = 1 << gobo_array_element_index;
+    if((fpi = fopen("gobo.c","r"))==NULL) {
+        fprintf(stdout,"ERROR: Cannot open the existing gobo file, to update it.\n");
+        fflush(stdout);
+        exit(1);
+    }
+    if((fpo = fopen("temp.c","w"))==NULL) {
+        fprintf(stdout,"ERROR: Cannot open temporary file 'temp.c', to write revised gobo.\n");
+        fclose(fpi);
+        fflush(stdout);
+        exit(1);
+    }
+    if((gobo_line = malloc(512 * sizeof(char)))==NULL) {
+        fprintf(stdout,"ERROR: Out of memory to create gobo line store, in fixgobo.\n");
+        fflush(stdout);
+        exit(1);
+    }
+    if((comp = malloc(24 * sizeof(char)))==NULL) {
+        fprintf(stdout,"ERROR: Out of memory to create gobo name comaparator, in fixgobo.\n");
+        fflush(stdout);
+        exit(1);
+    }
+    new_element_cnt = ((MAX_PROCESS_NO - 1)/32) + 1;
+    make_next_gobo_name_and_number(&gobo_number,&goboname_len,&comp,pretext,max_gobos);
+    setval = flags[gobo_number];
+    while(fgets(gobo_line,200,fpi)!=NULL) {
+        if(!finished_fixing_gobos && !strncmp(gobo_line,comp,goboname_len)) {
+            if(first_gobostring) {
+                existing_element_cnt = count_gobo_array_elements_in_first_gobo(gobo_line,comp,progno,new_element_cnt);
+                if(existing_element_cnt <= 0)
+                    exit(1);
+                if(new_element_cnt > existing_element_cnt)
+                    make_new_array_element = 1;
+                first_gobostring = 0;
+            } else if(count_gobo_array_elements(gobo_line) != existing_element_cnt) {
+                fprintf(stdout, "ERROR: Anomalous count of array members in gobo %s.\n",comp);
+                fflush(stdout);
+                exit(1);
+            }
+            if(!altergobo
+            (&gobo_line,existing_element_cnt,make_new_array_element,gobo_array_element,gobo_element_mask,substitute,setval)) {
+                exit(1);
+            }
+            if(fputs(gobo_line,fpo)==EOF) {
+                fprintf(stdout,"ERROR: Failed to write new line of gobo data to the new temporary file.\n");
+                fflush(stdout);
+                exit(1);
+            }
+            finished_fixing_gobos = make_next_gobo_name_and_number(&gobo_number,&goboname_len,&comp,pretext,max_gobos);
+            setval = flags[gobo_number];
+        } else {
+            if(fputs(gobo_line,fpo)==EOF) {
+                fprintf(stdout,"ERROR: Failed to write original line of gobo data to the new temporary file.\n");
+                fflush(stdout);
+                exit(1);
+            }
+        }
+    }
+    fclose(fpi);
+    fclose(fpo);
+    fprintf(stdout,"END: \n");
+    fflush(stdout);
+    return 0;
+}
+
+/*********************************** COUNT_GOBO_ARRAY_ELEMENTS ******************************/
+
+int count_gobo_array_elements(char *gobo_line)
+{
+    char *p;
+    int existing_element_cnt = 0, OK = 0;   
+
+    p = gobo_line;
+    while(*p != '{') {              /* search for start of array */
+        p++;
+        if(*p==ENDOFSTR) {
+            fprintf(stdout,"ERROR: Failed to find gobo array in string.\n");
+            fflush(stdout);
+            return(0);
+        }
+    }       
+    p++;
+    while(isspace(*p))
+        p++;                        /* check for inappropriate end of array */
+    if(*p=='}') {
+        fprintf(stdout,"ERROR: First gobo array is empty.\n");
+        fflush(stdout);
+        return(0);
+    }
+    while(*p != '}') {              /* until array end is found */
+        if(isdigit(*p))
+            OK = 1;                 /* check that each array element contains numeric data */
+        if(*p == ',') {             /* count array elements, by counting separating commas */
+            existing_element_cnt++;
+            if(!OK) {
+                fprintf(stdout,"ERROR: First-gobo array-element %d is missing.\n",existing_element_cnt);
+                fflush(stdout);
+                return(0);
+            }
+            OK = 0;
+        }
+        p++;
+        if(*p==ENDOFSTR) {
+            fprintf(stdout,"ERROR: Failed to find gobo element in array, in string.\n");
+            fflush(stdout);
+            return(0);
+        }
+    }
+    existing_element_cnt++;         /* count last array elements */
+    if(!OK) {                       /* and check that it contains numeric data */
+        fprintf(stdout,"ERROR: First-gobo, last array-element is missing.\n");
+        fflush(stdout);
+        return(0);
+    }
+    return(existing_element_cnt);
+}
+
+/*********************************** ALTERGOBO ******************************/
+
+int altergobo
+(char **gobo_line,int existing_element_cnt,int make_new_array_element,
+int gobo_array_element,int gobo_element_mask,int substitute, int setval)
+{
+    char *p, *gobo_pointer, gobo_string[24], end_part[512];
+    int goboval, n, zero_mask;
+
+    p = *gobo_line;
+    while(*p != '{') {              /* search for start of array */
+        p++;
+        if(*p==ENDOFSTR) {
+            fprintf(stdout,"ERROR: Failed to find gobo array in string.\n");
+            fflush(stdout);
+            return(0);
+        }
+    }                               /* CREATING NEW ARRAY ELEMENT */
+    if(make_new_array_element) {
+        while(*p != '}') {          /* search for end of array */
+            p++;
+            if(*p==ENDOFSTR) {
+                fprintf(stdout,"ERROR: Failed to find gobo array in string.\n");
+                fflush(stdout);
+                return(0);
+            }
+        }
+        strcpy(end_part,p);         /* store characters at end of array */
+        *p++ = ',';                 /* enter new separating comma */
+        *p = ENDOFSTR;              /* cut array at this point */
+
+        goboval = 0;                /* PRESET NEW ARRAY ELEMENT TO 0 */
+//TW UPDATE
+        if(!deleter && (setval==1)) /* put in value 1, only if flag set */
+            goboval |= gobo_element_mask;       
+                                    /* & store the new value in a string */
+        sprintf(gobo_string,"%d",goboval);
+
+    } else {                        /* ELSE, SUBSTITUTING NEW VALUE IN EXISTING LOCATION */
+
+        if(gobo_array_element>0) {
+            for(n=0;n<gobo_array_element;n++) {
+                while(*p != ',') {      /* search for the array element by counting separating commas */
+                    p++;
+                    if(*p==ENDOFSTR || *p == '}') {
+                        fprintf(stdout,"ERROR: Failed to find gobo element in array, in string.\n");
+                        fflush(stdout);
+                        return(0);
+                    }
+                }
+                p++;
+            }
+        } else
+            p++;
+        gobo_pointer = p;           /* point to the start of the array element wanted */
+                                
+        if(gobo_array_element == existing_element_cnt-1) {
+            while(*p != '}') {      /* if we're working on the last element in the array */
+                p++;                /* look for the array end */
+                if(*p==ENDOFSTR) {
+                    fprintf(stdout,"ERROR: Failed to find last gobo element in array, in string.\n");
+                    fflush(stdout);
+                    return(0);
+                }
+            }
+        } else {                    /* else */
+            while(*p != ',') {      /* look for the next separating comma */
+                p++;
+                if(*p==ENDOFSTR || *p == '}') {
+                    fprintf(stdout,"ERROR: Failed to find gobo element in array, in string.\n");
+                    fflush(stdout);
+                    return(0);
+                }
+            }
+        }
+        strcpy(end_part,p);         /* keep the remaining characters of the array */
+        *p = ENDOFSTR;              /* cut the array at this point */
+                                    /* read the existing array element */
+        if(sscanf(gobo_pointer,"%d",&goboval)!=1) {
+            fprintf(stdout,"ERROR: Failed to read value of existing gobo element in array %s, in string.\n",gobo_pointer);
+            fflush(stdout);
+            return(0);
+        }
+        *gobo_pointer = ENDOFSTR;
+                                    /* If existing value to be changed */
+        if(substitute) {            /* zero the value at gobo_element_mask position */
+            zero_mask = ~gobo_element_mask;     
+            goboval &= zero_mask;   
+        }                           /* put in value 1, only if flag set */
+        if(!deleter && (setval==1)) /* & store the new value in a string */
+            goboval |= gobo_element_mask;
+        sprintf(gobo_string,"%d",goboval);
+    }
+    strcat(*gobo_line,gobo_string); /* put new value on end of (cut) original string */
+    strcat(*gobo_line,end_part);    /* replace end characters of array, at end of string */
+    return(1);
+}
+
+/******************************** COUNT_GOBO_ARRAY_ELEMENTS_IN_FIRST_GOBO ******************************/
+
+int count_gobo_array_elements_in_first_gobo(char *gobo_line, char *comp, int progno, int new_element_cnt)
+{
+    int existing_element_cnt, next_available_progno;
+
+    if((existing_element_cnt = count_gobo_array_elements(gobo_line))<=0)
+        return(0);
+    if(new_element_cnt > existing_element_cnt) {
+        if(new_element_cnt > existing_element_cnt + 1) {
+            fprintf(stdout,
+            "ERROR: MAX_PROCESS_NO is TOO HIGH to tally with the existing gobo count in gobo %s.\n",comp);
+            fflush(stdout);
+            return(0);
+        }
+        next_available_progno = ((new_element_cnt - 1) * 32) + 1;
+        if(progno < next_available_progno) {
+            fprintf(stdout,
+            "ERROR: MAX_PROCESS_NO is TOO HIGH to tally with the existing gobo count in gobo %s.\n",comp);
+            return(0);
+        }
+        if(progno > next_available_progno) {
+            fprintf(stdout,
+            "ERROR: The process-number being entered creates a gap in numbering of processes on the system.\n");
+            fflush(stdout);
+            return(0);
+        }
+    } else if(new_element_cnt < existing_element_cnt) {
+        fprintf(stdout, 
+        "ERROR: new_element_cnt %d existing_element_cnt %d\n",new_element_cnt,existing_element_cnt);
+        fprintf(stdout, 
+        "ERROR: MAX_PROCESS_NO is TOO LOW to tally with the existing gobo count in gobo %s.\n",comp);
+        fflush(stdout);
+        return(0);
+    }
+    return(existing_element_cnt);
+}
+
+/******************************** MAKE_NEXT_GOBO_NAME_AND_NUMBER ******************************/
+
+int make_next_gobo_name_and_number(int *gobo_number, int *goboname_len, char **comp, char *pretext, int max_gobos)
+{
+    int finished_fixing_gobos = 0;
+    char num[4];
+    (*gobo_number)++;
+    (*comp)[0] = ENDOFSTR;
+    strcat(*comp,pretext);
+    strcat(*comp,"gobo");
+    if(*gobo_number == max_gobos-1) {
+        *goboname_len +=2;
+        strcat(*comp,"_any");
+    } else if(*gobo_number == max_gobos) {
+        strcat(*comp,"zero");
+    } else if(*gobo_number > max_gobos) {
+        finished_fixing_gobos = 1;
+    } else {
+        if(*gobo_number == 10)
+            (*goboname_len)++;  
+        sprintf(num,"%d",*gobo_number);
+        strcat(*comp,num);
+    }
+    return finished_fixing_gobos;
+}
+
+/******************************** CHECK_PROGNO ******************************/
+
+int check_progno(int *progno, int system_update)
+{
+    int is_new = 0;
+    if(system_update) {
+
+/* TEST */
+        if(*progno == 0) {
+            *progno = MAX_PROCESS_NO;
+//TW UPDATES
+            fprintf(stdout,"INFO: using the value %d for the MAX_PROCESS_NO: If this is incorrect, recompile fixgobo, and start again.\n",MAX_PROCESS_NO);
+            fprintf(stdout,"INFO: If you do not do this, the gobo data for program %d will be overwritten!!\n",MAX_PROCESS_NO);
+            fflush(stdout);
+
+            is_new = 1;
+        }
+//      if((*progno >= MIN_TEMPROC_AREA) && (*progno <= MAX_TEMPROC_AREA)) {
+//          if(is_new)
+//              fprintf(stdout,"ERROR: Invalid MAX_PROCESS_NO for new system processes.\n");
+//          else
+//              fprintf(stdout,"ERROR: Invalid process number for new system processes.\n");
+//          fprintf(stdout,"Cannot be between %d  and %d inclusive\n",MIN_TEMPROC_AREA,MAX_TEMPROC_AREA);
+//          fprintf(stdout,"as these are reserved for private user processes.\n");
+//          fflush(stdout);
+//          return(-1);
+//      } else 
+        if(*progno > MAX_PROCESS_NO) {
+            fprintf(stdout,"ERROR: The process number entered is above MAX_PROCESS_NO\n");
+            fflush(stdout);
+            return(-1);
+//TW UPDATE
+        } else if(*progno <= MAX_PROCESS_NO) {
+            fprintf(stdout,"WARNING: REDEFINING THE GOBO FOR AN EXISTING PROCESS.\n");
+            fflush(stdout);
+            return(1);
+        }
+    } else {
+        if(*progno == 0) {
+            *progno = MAX_TEMP_PROCESS_NO;
+            is_new = 1;
+        }
+//      if((*progno > MAX_TEMPROC_AREA) || (*progno < MIN_TEMPROC_AREA)) {
+//          if(is_new)
+//              fprintf(stdout,"ERROR: Invalid MAX_TEMP_PROCESS_NO for new processes.\n");
+//          else
+//              fprintf(stdout,"ERROR: Invalid process number for new processes.\n");
+//          fprintf(stdout,"Private user processes must lie between %d and %d\n",MIN_TEMPROC_AREA,MAX_TEMPROC_AREA);
+//          fprintf(stdout,"If you have run out of space for new processes,\n");
+//          fprintf(stdout,"perhaps you should install some of them as common CDP system processes\n");
+//          fprintf(stdout,"by contacting the CDP.\n");
+//          fflush(stdout);
+//          return(-1);
+//      } else 
+        if(*progno < MAX_TEMP_PROCESS_NO) {
+            fprintf(stdout,"WARNING: OVERWRITING AN EXISTING PROCESS.\n");
+            fflush(stdout);
+            return(1);
+        }
+    }
+    return(0);
+}
+
+/******************************** CHECK_FLAGS ******************************/
+
+int check_flags(char *str,int **flags,int max_gobos)
+{
+    char *p;
+    int n;
+//TW UPDATE
+    if(!strcmp(str,"0")) {
+        deleter = 1;
+    } else if(strlen(str) != (unsigned int)max_gobos) {
+        fprintf(stdout,"ERROR: Bad data string sent to fixgobo.\n");
+        fflush(stdout);
+        return(-1);
+    }
+    if((*flags = malloc((max_gobos+2) * sizeof(int)))==NULL) {
+        fprintf(stdout,"ERROR: Out of memory to store flags, in fixgobo.\n");
+        fflush(stdout);
+        return(-1);
+    }
+    p = str;
+    for(n=1;n<=max_gobos;n++) {
+        switch(*p) {
+        case('0'):  (*flags)[n] = 0;    break;
+        case('1'):  (*flags)[n] = 1;    break;
+        default:
+            fprintf(stdout,"ERROR: Bad character (ascii %d) in gobo-flag string sent to fixgobo.\n",*p);
+            fflush(stdout);
+            return(-1);
+        }
+//TW UPDATE
+        if(!deleter)
+            p++;
+    }
+    return(1);
+}
+

dev/misc/gobo.c

@@ -0,0 +1,539 @@
+/*
+ * Copyright (c) 1983-2020 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 aint 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 <string.h>
+#include <osbind.h>
+#include <processno.h>
+/*
+#include <minmax.h>
+*/                      /*RWD not allowed: not portable. incloude sfsys.h instead */
+#include <sfsys.h>
+#include "filetype.h"
+#include <standalone.h>
+
+/******* masking GOBOs for the list of programs: each contains 'maskcnt' bitflags, each of 32 bits ********/
+
+#define NUMBER_OF_GOBOS (42)
+#define ORIG_MASK_ARRAY_ELEMENTS_CNT (17)   /* No of masks on original release + 2 for experimental progs */
+
+// ~~ ***** ADDING A NEW BLOCK OF 32 PROGRAMS : Need to INCREMENT "ORIG_MASK_ARRAY_ELEMENTS_CNT" *** ~~
+// ~~ ***** that would be AFTER PROCESS 544 as at June 17th :2020  **** ~~
+// ~~ ALSO FIX SPECIAL GOBO MASKS IN 
+// ~~   _bulk.tcl:
+// ~~   _progmask.tcl:
+// ~~   _standalone.tcl:
+
+#define INT_SIZE   (32)    /* Flags assumed to be in 32-bit ints : BUT DON'T CHANGE THIS EVEN IF ints ARE intER!! */
+#define CHARBITSIZE (8)     /* bits in a char */
+
+int gobo1[]  = {-1,-1,-1,-1,-1,-1,-16777217,-1,2147483647,-1,-1,-16778241,-1,-939532289,-164097,-19955569,15};         /* set to zero any process that changes srate */
+int gobo2[]  = {0,0,0,1,2097152,2097152,0,557873152,0,1048592,4194816,-2147483646,262147,132121664,1075838976,0,0};    /* set to 1 if process works with zero files */
+int gobo3[]  = {-1549,-402681857,-16779252,-1048580,-27787265,-14683905,-1310721,-558070023,1609791102,-340820177,-4444827,2063596061,-515137604,-1071658209,-1075876101,-20479857,14}; /* works with 1 files  1,1+  */
+int gobo4[]  = {1548,2013294592,1073743859,-133169150,25690623,4198144,169083268,196871,537692545,340394432,8638618,1412432352,112222288,1048749,134369284,268959744,1};          /* works with 2 files  2,1+,2+ */
+int gobo5[]  = {8,0,1073742208,-134217728,511,4195328,168821124,131075,1,273318336,8573064,1412431872,471883792,1052685,134365188,268435456,1};        /* works with 3 files  3,1+,2+ */
+int gobo6[]  = {0,0,1073742208,-134217728,511,4195328,168821124,131075,1,273285568,8573064,1412431872,471883792,1052685,134365188,268435456,1};        /* works with any number of files (not 0) 1+,2+  */
+int gobo7[]  = {-1,-536739841,134741995,1,2097152,2097152,-501218304,29391136,813695105,34750480,4194816,-2147479046,8654547,132302272,1084228099,2089680900,0};   /* File1 = ANAL: else 0  */
+int gobo8[]  = {0,536739840,16252944,1,2097152,2097152,-501219328,21002528,258,3390992,6291968,-2147483646,262147,132121664,1075838976,0,0};   /* File1 = PICH (binary): else 0  */
+int gobo9[]  = {0,402653184,2097152,1,2097152,2097152,-501219328,21002528,0,1179664,4194816,-2147483646,262147,132121664,1075838976,0,0};  /* File1 = TRNS (binary): else 0  */
+int gobo10[] = {0,0,4,1,2097152,2097152,-501219328,21002528,64,1179664,4194816,-2147483646,262147,132121664,1075838976,0,0};                   /* File1 = FMNT : else 0 */
+int gobo11[] = {0,0,-167772160,-1,-201326593,-10481917,-67113985,1564508159,1333788220,-35782152,-2154537,-16784889,-549457629,-939712897,-8422148,-2109636469,15};            /* File1 = SND : else 0 */
+int gobo12[] = {0,0,0,1,69206016,2097164,-501219328,21002528,0,1179664,4194816,-2147483646,262147,132121664,1075838976,0,0};                   /* File1 = ENV (binary) : else 0 */
+int gobo13[] = {0,0,0,1,2097152,2097152,606076928,4225024,0,1048592,4211200,-2147483646,262147,132121664,1075838976,0,0};          /* File1 = TextFile (NOT exclusively numbers): else 0 */
+int gobo14[] = {0,402653184,0,1,2097152,2097152,572526592,21002240,0,1048599,4203008,-2147483646,262159,132121664,1075838976,0,0};     /* File1 = pitch or transpos textfile: else 0 */
+int gobo15[] = {0,0,0,1,2097152,2097248,572526592,21002240,0,1048592,4194816,-2147483646,262147,132121664,1075838976,0,0};         /* File1 = dB-envelope textfile: else 0 */
+int gobo16[] = {0,0,0,1,136314880,2097296,572526592,21002240,0,1048599,4203008,-2147483646,262159,132121664,1075838976,0,0};           /* File1 = normalised-envelope textfile: else 0 */
+int gobo17[] = {0,0,0,1,2097152,2097152,572526592,21002240,0,1048599,4203008,-2147481598,262159,132121664,1075838976,0,0};         /* File1 = unranged brktable textfile: else 0 */
+int gobo18[] = {0,0,0,1,2097152,2359296,639635456,16807936,0,1048592,4194816,-2147483646,541327363,132121664,1075838976,0,0};          /* File1 = list of sndfiles in a textfile: else 0 */
+int gobo19[] = {0,0,0,1,2097152,2621440,35655680,21002240,0,1048592,4194816,-2147483646,262147,132121664,1075838976,0,0};          /* File1 = sndfile synchronisation list: else 0 */
+int gobo20[] = {0,0,0,1,2097152,4190208,572526592,-2126481408,0,1048592,4227624,-2147483646,262147,132121664,1075838976,0,0};          /* File1 = mixfile: else 0 */
+int gobo21[] = {0,0,0,1,2097152,2097152,572526592,58718208,0,1048599,4203008,-2147483646,262159,132121664,1075838976,0,0};         /* File1 = textfile of list-of-numbers: else 0 */
+int gobo22[] = {-1,-1,-16777217,-1,-1,-12582913,-1,-603979777,2147483647,-1,-1,-16778241,-1,-939532289,-33025,-19955569,15};           /* Always 1 / non-functional */
+int gobo23[] = {-1,-1,-16777217,-1,-1,-14675969,-1,-603979777,2147483647,-1,-1,-16778241,-541065217,-939532289,-33025,-19955569,15}; /* If file1=sndlist/synclist, if these must be same SR, set to 0*/
+int gobo24[] = {-1,-1,-16777217,-1,-1,-8388609,-1,-641695745,2147483647,-1,-1,-16778241,-1,-939532289,-33025,-19955569,15};            /* Always 1 / non-functional */
+int gobo25[] = {-1,-1,-1090519041,-1,-1,-8388609,-268435457,-536871489,2147483647,-1,-321,-16778241,-1,-939532289,-39169,-20021105,15};                            /* Reject progs not accepting mono sndsys files by setting to 0*/
+int gobo26[] = {-1,-536739841,1544028139,-4194297,-201326593,-8389646,-35329,1610612735,914362497,-1747041840,785784791,-50392065,-1064845613,-941432864,1593318019,-53542907,7};  /* Reject progs not accepting stereo sndsys files by setting to 0: pitch, formants, transpos, and envbin get 0 */
+int gobo27[] = {-1,-536739841,470286315,130023431,-201327104,-14677006,-402688569,1610612223,914362497,-1814674992,785784343,-52489734,-1064845613,-941432864,1593311875,-53608443,7};/* If process won't run with >2chas,sets to 0,all ANAL progs=1: sndprogs limited to stereo max get 0, pitch,formants,transpos,& envbin get 0 */
+int gobo28[] = {-1541,-2013265921,-1090519058,-1048579,-25690113,-12586753,-135528837,-637730824,2146662015,-340296129,-8638619,-1429210113,-506486785,-940585006,-134402309,-19955569,14}; /* >1 file: to reject all lastfiles except =ANAL set to 1*/
+int gobo29[] = {-1549,-2013294593,-1090521059,-1048579,-25690113,-12586753,-135528837,-637730824,1609791486,-340296129,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: to reject all lastfiles except =FMNT set to 1*/
+int gobo30[] = {-1549,-2013294593,-16779252,-1,-1,-8388609,-1,-637730817,1610612350,-67141633,-1,-16778721,-8388689,-939532417,-33025,-288915313,15};           /* >1 file: to reject all lastfiles except =SND   set to 1*/
+int gobo31[] = {-9,-28673,-1090521076,-1048579,-25690113,-12586753,-135528837,-637730824,1609791102,-340296129,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: to reject all lastfiles except =PCH or TRNSP binary   set to 1*/
+int gobo32[] = {-1549,-1610641409,-1090521076,-1048579,-524289,-12586753,-135528837,-603980040,1609791102,-273318337,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: to reject all lastfiles except =ENV(or dBENV) BRK  set to 1*/
+int gobo33[] = {-1549,-1610641409,-1090521076,-1048579,-25690113,-12586753,-135528837,-637731080,1609791102,-340427201,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* if lastfile = textfile: if you want to reject all lastfiles except number lists, set to 0 */
+int gobo34[] = {-9,-28673,-1090521059,133169151,-524800,-8391937,-135266693,-637730824,2147483646,-273154497,-8523905,-1429210113,-471883793,-940584961,-134398213,-288391025,14};         /* >1 file: if all files must be same type: set to 0 */
+int gobo35[] = {-1549,-1610641409,-1090521076,133169149,-512,-12586753,-135528837,-637730819,1609791102,-273154241,-8589459,-1429210593,-514875473,-940585134,-134402309,-288915313,14};   /* >1 file: if all files must be same srate: set to 0 */
+int gobo36[] = {-1549,-1610641409,-1090521076,133169151,-512,-8392193,-135528577,-637730819,1609791102,-272629953,-8589331,-1362101729,-514875473,-940585102,-134402309,-288915313,14};    /* >1 file: if all files must be same chancnt: set to 0 */
+int gobo37[] = {-1549,-1610641409,-16779252,-1048577,-1,-8391937,-1,-637730824,1610612350,-1,-1,-16778721,-8388689,-939532417,-33025,-20479857,15};    /* >1 file: if all files must be same other props: set to 0 : but 1 for all sndfile only processes */
+int gobo38[] = {-1,-134217729,-16777217,-1,-1,-8388609,-1,-603979777,2147483647,-1,-1,-16778241,-1,-939532289,-33025,-19955569,15};                    /* >1 file: if infiles are P and T, and output is binary, and hence 1 input must be binary: set to 0 */
+int gobo39[] = {-1549,-2013294593,-1090521076,-3,-524289,-12586753,-135528837,-637731080,1609791102,-340394433,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14};   /* >1 file: to reject all lastfiles except =ENV binary   set to 1*/
+int gobo40[] = {-1549,-1610641409,-1090521076,-1048579,-524289,-12586753,-135528837,-603980040,1609791102,-273318337,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: if it can't use textfile as lastfile, set to 0 */
+int gobo41[] = { -1,-1,-1,-1,-8388609,-1,-1,-1,2147483647,-67108865,-1,-16778241,-1,-939532289,-33025,-19955569,15};                                       /* always set to 1 for NEW progs */
+int gobo42[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                                         /* always set to 1 for NEW progs */
+int gobo_any[] = {0,0,0,0,0,0,33554432,0,0,0,0,0,0,0,0,0,0};   /* processes which work with absolutely ANY files (i.e. including non-CDP valid files): set to 1, else set to 0 */
+int gobozero[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};      /* set all gobos to 0 */
+
+void    usage(void);
+void    gobo_EQUALS(int** gobo_1,int gobo_2[]);
+void    gobo_AND(int** gobo_1,int* gobo_2);
+void    gobo_OR(int** gobo_1,int* gobo_2);
+void    gobo_ZEROED(int** gobo_1);
+
+/***** TESTING ONLY ******/
+int     show(char *str,int *gobo_out,int progno,int valid_multifile);
+
+#define FALSE   (0)
+#define TRUE    (1)
+
+#define ALL_INFILES_OF_SAME_TYPE    (16)
+#define ALL_INFILES_OF_SAME_SRATE   (8)
+#define ALL_INFILES_OF_SAME_CHANCNT (4)
+#define ALL_INFILES_OF_SAME_PROPS   (2)
+#define AT_LEAST_ONE_PFT_INFILE     (1)
+
+/***** DATA COMING FROM INPUT FILES *****
+
+[1] Count of input files
+[2] Filetype of 1st infile
+[3] Filetype of last infile
+[4] Cumulative filetypes (those types which all files share)
+[5] Bitflag re file compatibility etc. (16+8+4+2+1)
+    #           16  = all infiles of same type
+    #           8   = all infiles of same srate
+    #           4   = all infiles of same channel count
+    #           2   = all infiles have all other properties compatible
+    #           1   = At least 1 of infiles is a binary PFT file
+[6] Number of channels (of all files, if all have same channels: otherwise, of last file)
+
+****/
+
+int process_for_single_file = 0;
+int maskcnt;
+const char* cdp_version = "8.0.0";
+
+/*******************************************************************/
+
+int main(int argc, char *argv[])
+{
+    int     filecnt, n, m;
+    int    firstfile_type=0,lastfile_type=0,compatibility=0,chancnt=0, mask;
+    int     ismachine_create = 0, is_fixed_srate = 0;
+    unsigned int start = hz1000();
+
+    int pbrk            = FALSE;
+    int tbrk            = FALSE;
+    int tfile           = FALSE;
+    int mixlist         = FALSE;
+    int pfile2          = FALSE;
+    int pbrk2           = FALSE;
+    int tbrk2           = FALSE;
+    int nlist2          = TRUE;
+    int valid_multifile = TRUE;
+
+    int *gobo_out, *gobo_accumulate=NULL;
+    char *temp;
+    int progno = -1;
+    int cmdline_testing_mode = 0;
+    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    maskcnt = min(((MAX_PROCESS_NO - 1)/32) + 1,ORIG_MASK_ARRAY_ELEMENTS_CNT);
+    if(argc == 1) {
+        fprintf(stdout,"TO TEST THE GOBO SETTING FOR A NEW PROGRAM\n\n");
+        fprintf(stdout,"1) In the soundloom code, MAIN, set gobo_testing to 1\n");
+        fprintf(stdout,"2) restart the SOUND LOOM, choose zero or more files, & proceed to process.\n");
+        fprintf(stdout,"3) When the gobo cmdline is displayed, note it down.\n");
+        fprintf(stdout,"4) Now run gobo in command.tos, using the same cmdline PLUS\n");
+        fprintf(stdout,"   THE PROCESS NUMBER, placed at the end of the cmdline.\n");
+        fprintf(stdout,"   (The process number can be found in the file 'processno.h')\n\n");
+        fprintf(stdout,"   The GOBO program will report at what stage it decides that\n");
+        fprintf(stdout,"   the process will not run with the files entered.\n\n");
+        fprintf(stdout,"   If you are developing a new application, and the process SHOULD run\n");
+        fprintf(stdout,"   with the entered files, you need to correct the program's gobo settings.\n");
+        return(0);
+    }
+    if(argc==5 || argc == 9) {
+        if(sscanf(argv[argc-1],"%d",&progno)!=1) {
+            fprintf(stderr,"Invalid program number given.\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        } else if (progno < 1 || progno > MAX_PROCESS_NO) {
+            fprintf(stderr,"Program number %d does not exist.\n",progno);
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+        cmdline_testing_mode = 1;
+        argc--;
+    }
+    if(argc < 4) {
+        fprintf(stdout,"ERROR: Incorrect call to gobo program: not enough args\n");
+        while (!(hz1000() - start))
+            ;
+        return(-1);
+    }
+
+    if(sscanf(argv[1],"%d",&filecnt)!=1) {
+        fprintf(stdout,"ERROR: Cannot read filecnt argument to gobo program.\n");
+        while (!(hz1000() - start))
+            ;
+        return(-1);
+    }
+    if(sscanf(argv[2],"%d",&ismachine_create)!=1) {
+        fprintf(stdout,"ERROR: Cannot read machinecreate argument to gobo program.\n");
+        while (!(hz1000() - start))
+            ;
+        return(-1);
+    }
+    if(sscanf(argv[3],"%d",&is_fixed_srate)!=1) {
+        fprintf(stdout,"ERROR: Cannot read is_fixed_srate argument to gobo program.\n");
+        while (!(hz1000() - start))
+            ;
+        return(-1);
+    }
+    if(filecnt > 0) {                   /* if process has files, read the data on filetypes etc */
+        if(argc!=8) {
+            fprintf(stdout,"ERROR: Incorrect call to gobo program: too many args\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+        if(sscanf(argv[4],"%d",&firstfile_type)!=1) {
+            fprintf(stdout,"ERROR: Cannot read firstfile_type argument to [3] gobo program.\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+        if(sscanf(argv[5],"%d",&lastfile_type)!=1) {
+            fprintf(stdout,"ERROR: Cannot read lastfile_type argument to [4] gobo program.\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+        if(sscanf(argv[6],"%d",&compatibility)!=1) {
+            fprintf(stdout,"ERROR: Cannot read compatibility argument [5] to gobo program.\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+        if(sscanf(argv[7],"%d",&chancnt)!=1) {
+            fprintf(stdout,"ERROR: Cannot read channel count argument [6] to gobo program.\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+    }
+
+    if((gobo_out = malloc(maskcnt * sizeof(int)))==NULL) {
+        fprintf(stdout,"ERROR: Can't allocate memory space 1 for gobos.\n");
+        while (!(hz1000() - start))
+            ;
+        return(-1);
+    }
+
+    if(filecnt > 0) {
+        if((gobo_accumulate = malloc(maskcnt * sizeof(int)))==NULL) {
+            fprintf(stdout,"ERROR: Can't allocate memory space 2 for gobos.\n");
+            while (!(hz1000() - start))
+                ;
+            return(-1);
+        }
+        for(n=0;n<maskcnt;n++)
+            gobo_accumulate[n] = 0;
+    }
+
+                /* Initialise the process gobos for process or machine situations */
+
+    if(filecnt == 0) {
+        if(ismachine_create)
+            gobo_EQUALS(&gobo_out,gobozero);    /* initialise gobo to accept all machine-compatible 0 file procs */
+        else                                        
+            gobo_EQUALS(&gobo_out,gobo2);   /* initialise gobo to accept all progs requiring 0 files */
+    } else {
+            /*  If there are input files, adjust processes-gobo according to file props */
+        gobo_ZEROED(&gobo_out);             /* initialise gobo to accept nothing */
+
+        switch(filecnt) {                   /* accept programs on basis of input filecnt */
+        case(1): valid_multifile = FALSE;
+                 process_for_single_file = 1;
+                 gobo_OR(&gobo_out,gobo3);  /* all progs requiring 1 file, or 1-or-more files */                break;
+        case(2): gobo_OR(&gobo_out,gobo4);  /* all progs requiring 2 files,1-or-more files,2-or-more files  */  break;
+        case(3): gobo_OR(&gobo_out,gobo5);  /* all progs requiring 3 files,1-or-more files,2-or-more files  */  break;
+        default: gobo_OR(&gobo_out,gobo6);  /* all progs requiring 1-or-more files, 2-or-more files  */         break;
+        }
+        if(cmdline_testing_mode && !show("AFTER FILECNT TEST (gobo6)",gobo_out,progno,valid_multifile))
+            return(0);
+
+        if(is_fixed_srate) 
+            gobo_AND(&gobo_out,gobo1);          /* if interface uses fixed srate, disallow srate-changing progs */
+
+        if(cmdline_testing_mode && !show("AFTER TEST FOR SYSTEM AT FIXED SRATE (gobo1)",gobo_out,progno,valid_multifile))
+            return(0);
+        switch(firstfile_type) {
+        case(ANALFILE):     gobo_AND(&gobo_out,gobo7);  /* Accept only progs having ANALFILE as first file */       break;
+        case(PITCHFILE):    gobo_AND(&gobo_out,gobo8);  /* Accept only progs having PITCHFILE as first file */      break;
+        case(TRANSPOSFILE): tfile = TRUE;
+                            gobo_AND(&gobo_out,gobo9);  /* Accept only progs having TRANSPOSFILE as first file */   break;
+        case(FORMANTFILE):  gobo_AND(&gobo_out,gobo10); /* Accept only progs having FORMANTFILE as first file */    break;
+        case(SNDFILE):      gobo_AND(&gobo_out,gobo11); /* Accept only progs having SNDFILE as first file */        break;
+        case(ENVFILE):      gobo_AND(&gobo_out,gobo12); /* Accept only progs having ENVELOPE BINFILE as 1st file */ break;
+        case(LINELIST_OR_WORDLIST):             
+                            gobo_AND(&gobo_out,gobo13); /* Accept only progs of textlines(not just nos.) as file1*/ break;
+        case(WORDLIST):     gobo_AND(&gobo_out,gobo13); /* Accept only prgs havng unspecific words */
+                                                        /*(& not only numbers) as 1st file */                       break;
+
+        default:                                    /* DEAL WITH ALL OTHER TEXTFILE TYPES */
+            if(firstfile_type & IS_A_PITCH_BRKFILE)         pbrk = TRUE;
+            if(firstfile_type & IS_A_TRANSPOS_BRKFILE)      tbrk = TRUE;
+            if(pbrk || tbrk)            
+                gobo_OR(&gobo_accumulate,gobo14);   /* Accept progs having pitch or transpos textfile as first file */
+            if(firstfile_type & IS_A_DB_BRKFILE)
+                gobo_OR(&gobo_accumulate,gobo15);   /* Accept progs having dB-envelope textfile as first file */
+            if(firstfile_type & IS_A_NORMD_BRKFILE)
+                gobo_OR(&gobo_accumulate,gobo16);   /* Accept progs having normalised-envelope textfile as first file */
+            if(firstfile_type & IS_AN_UNRANGED_BRKFILE)
+                gobo_OR(&gobo_accumulate,gobo17);   /* Accept progs having unranged brktable textfile as first file */
+            if(firstfile_type & IS_A_SNDLIST)
+                gobo_OR(&gobo_accumulate,gobo18);   /* Accept progs having list of sndfiles in a textfile as first file */
+            if(firstfile_type & IS_A_SYNCLIST)
+                gobo_OR(&gobo_accumulate,gobo19);   /* Accept progs having sndfile synchronisation list as first file */
+            if((firstfile_type & IS_A_MIXFILE) && (firstfile_type != WORDLIST)) {
+                mixlist = TRUE;
+                gobo_OR(&gobo_accumulate,gobo20);   /* Accept progs having mixfile textfile as first file */
+            }
+            if(firstfile_type & IS_A_NUMLIST)
+                gobo_OR(&gobo_accumulate,gobo21);   /* Accept progs having list-of-numbers textfile as first file */
+            gobo_AND(&gobo_out,gobo_accumulate);    /* Accept all the accumulated progs (only) */
+            if((firstfile_type & IS_A_SNDLIST_FIXEDSR) != IS_A_SNDLIST_FIXEDSR) {
+                if(!mixlist)
+                    gobo_AND(&gobo_out,gobo23);
+            }
+        }
+
+        if(cmdline_testing_mode && !show("AFTER FILETYPE TESTS",gobo_out,progno,valid_multifile))
+            return(0);
+
+        switch(chancnt) {
+        case(0):
+            break;                          /* Ignore files with 0 chans (textfiles) */
+        case(1):
+            gobo_AND(&gobo_out,gobo25); /* Reject progs not accepting mono files */
+            break;
+        case(2):    
+            gobo_AND(&gobo_out,gobo26); /* Reject progs not accepting stereo files */
+            break;
+        default:
+            gobo_AND(&gobo_out,gobo27); /* Reject progs taking ONLY mono or stereo files */
+            break;
+        }
+
+        if(cmdline_testing_mode && !show("AFTER CHANNEL CNT TEST (gobo27)",gobo_out,progno,valid_multifile))
+            return(0);
+
+        if(valid_multifile) {   /* i.e. More than 1 input file */
+            if(cmdline_testing_mode && !show("AFTER VALID MULTIFILE TEST",gobo_out,progno,valid_multifile))
+                return(0);
+
+            switch(lastfile_type) {
+            case(ANALFILE):     gobo_AND(&gobo_out,gobo28); /* Accept only progs taking analfile as last file */    break;
+            case(FORMANTFILE):  gobo_AND(&gobo_out,gobo29); /* Accept only progs taking fmntfile as last file */    break;
+            case(SNDFILE):      gobo_AND(&gobo_out,gobo30); /* Accept only progs taking sndfile as last file  */    break;
+            case(PITCHFILE):    pfile2 = TRUE;
+            /* fall thro */
+            case(TRANSPOSFILE): gobo_AND(&gobo_out,gobo31); /* Accept only progs taking pitch */
+                                                             /* or transpos binfile as last file */
+                if(cmdline_testing_mode && !show("2nd FILE IS P or T BINARY",gobo_out,progno,valid_multifile))
+                    return(0);
+                break;
+            case(ENVFILE):      gobo_AND(&gobo_out,gobo39);/* progs taking only env-binfiles as last file  */       break;
+
+            default:                                /* DEAL WITH ALL TEXTFILE TYPES */
+                if(!(lastfile_type & IS_A_TEXTFILE)) {
+
+                    valid_multifile = FALSE;
+                    if(cmdline_testing_mode && !show("2nd FILE IS NOT A TEXTFILE",gobo_out,progno,valid_multifile))
+                        return(0);
+
+                    gobo_EQUALS(&gobo_out,gobo_any);    /* i.e. Nothing else works, except HOUSE-BUNDLE options */
+                } else {
+                    gobo_AND(&gobo_out,gobo40);         /* Drop all files that DON'T use textfile as last file */
+
+
+                    if(cmdline_testing_mode && !show("2nd FILE IS A TEXTFILE",gobo_out,progno,valid_multifile))
+                        return(0);
+
+                    if(lastfile_type & IS_A_PITCH_BRKFILE)      pbrk2 = TRUE;
+                    if(lastfile_type & IS_A_TRANSPOS_BRKFILE)   tbrk2 = TRUE;
+
+                    if(!((lastfile_type & IS_A_NORMD_BRKFILE) || (lastfile_type & IS_A_DB_BRKFILE)))
+                        gobo_AND(&gobo_out,gobo32); /* Accept only progs taking envelope type brkfiles */
+
+
+                    if(cmdline_testing_mode && !show("AFTER NORMD-BRKFILE TEST (gobo32)",gobo_out,progno,valid_multifile))
+                        return(0);
+
+                    if(!(lastfile_type & IS_A_DB_BRKFILE)
+                    && !(lastfile_type & IS_A_NORMD_BRKFILE)
+                    && !(lastfile_type & IS_A_TRANSPOS_BRKFILE)
+                    && !(lastfile_type & IS_A_POSITIVE_BRKFILE))
+                        gobo_AND(&gobo_out,gobo41); /* env-impose exception */
+
+
+                    if(cmdline_testing_mode && !show("UNRANGED BRKFILE TEST",gobo_out,progno,valid_multifile))
+                        return(0);
+
+                    if((lastfile_type & IS_A_NUMBER_LINELIST) != IS_A_NUMBER_LINELIST)  {
+                        nlist2 = FALSE;
+                        gobo_AND(&gobo_out,gobo33);     /* Reject progs not taking list of numbers as lastfile */
+                    }
+
+                    if(cmdline_testing_mode && !show("NUMBER LIST TEST (gobo33)",gobo_out,progno,valid_multifile))
+                        return(0);
+
+                    if(!(pbrk2 || tbrk2 || nlist2)) {   /* Nothing else works, except 0-FILE options */
+                        valid_multifile = FALSE;
+                        gobo_EQUALS(&gobo_out,gobo_any);
+                    }
+
+                    if(cmdline_testing_mode && !show("ALL OTHER TEXTFILES TEST",gobo_out,progno,valid_multifile))
+                        return(0);
+
+                }
+            }
+
+            if(cmdline_testing_mode && !show("LAST FILETYPE",gobo_out,progno,valid_multifile))
+                return(0);
+
+            if(valid_multifile) {
+                if((tfile||tbrk) && !pbrk && (pfile2||pbrk2) && !tbrk2) {
+                    valid_multifile = FALSE;            /* Can't have Tfile followed by Pfile */
+                    gobo_EQUALS(&gobo_out,gobo_any);
+                } else {
+                    if(!(compatibility & ALL_INFILES_OF_SAME_TYPE))     gobo_AND(&gobo_out,gobo34);
+                    if(!(compatibility & ALL_INFILES_OF_SAME_SRATE))    gobo_AND(&gobo_out,gobo35);
+                    if(!(compatibility & ALL_INFILES_OF_SAME_CHANCNT))  gobo_AND(&gobo_out,gobo36);
+                    if(!(compatibility & ALL_INFILES_OF_SAME_PROPS))    gobo_AND(&gobo_out,gobo37);
+                    if(!(compatibility & AT_LEAST_ONE_PFT_INFILE))      gobo_AND(&gobo_out,gobo38);
+                }
+            }
+
+            if(cmdline_testing_mode && !show("AFTER COMPATIBILITY TEST",gobo_out,progno,valid_multifile))
+                return(0);
+
+        }
+/* KLUJ for NEW MUTICHANNEL MIXFILES */
+        if(firstfile_type == MIX_MULTI) {
+            for(n=0;n<maskcnt;n++)
+                gobo_out[n] = 0;
+            gobo_out[7] = /* -2147483648 */ 0x80000000;  /* RWD: bypass gcc warning about signedness. NB: assumes 32bit int! */
+        }
+    }
+    if(cmdline_testing_mode && !show("AFTER ALL TESTS",gobo_out,progno,valid_multifile))
+        return(0);
+    if((temp = malloc((maskcnt * ((sizeof(int) * CHARBITSIZE)+1)) + 2))==NULL) {
+        fprintf(stdout,"ERROR: Can't allocate memory space 3 for gobos.\n");
+        while (!(hz1000() - start))
+            ;
+        return(-1);
+    }
+    temp[0] = '\0';
+    for(n=0;n<maskcnt;n++) {
+        mask = 1;
+        for(m=0;m<INT_SIZE;m++) {
+            if(gobo_out[n] & mask)
+                strcat(temp,"1");
+            else
+                strcat(temp,"0");
+            mask <<= 1;
+        }
+    }
+    strcat(temp,"\n");
+    fprintf(stdout,"%s\n",temp);
+    while (!(hz1000() - start))
+        ;
+    return(0);
+}
+
+/********************************* gobo_EQUALS *********************************/
+
+void gobo_EQUALS(int** gobo_1,int gobo_2[])
+{
+    int n;
+    for(n=0;n<maskcnt;n++)
+        (*gobo_1)[n] = gobo_2[n];
+}
+
+/********************************* gobo_ZEROED *********************************/
+
+void gobo_ZEROED(int** gobo_1)
+{
+    int n;
+    for(n=0;n<maskcnt;n++)
+        (*gobo_1)[n] = 0;
+}
+
+/********************************* gobo_AND *********************************/
+
+void gobo_AND(int** gobo_1,int* gobo_2)
+{
+    int n;
+    for(n=0;n<maskcnt;n++)
+        (*gobo_1)[n] &= gobo_2[n];
+}
+
+/********************************* gobo_OR **********************************/
+
+void gobo_OR(int** gobo_1,int* gobo_2)
+{
+    int n;
+    for(n=0;n<maskcnt;n++)
+        (*gobo_1)[n] |= gobo_2[n];
+}
+
+int show(char *str,int *gobo_out,int progno,int valid_multifile) {
+    int mask = 1;
+    int gobono, itemno, n = 0;
+    progno--;
+    gobono = progno/32;
+    itemno = progno%32;
+    if(itemno>0) {
+        for(n=0;n<itemno;n++) {
+            mask <<= 1;
+        }
+    }
+    if(gobo_out[gobono] & mask) {
+        if(process_for_single_file == 1)
+            fprintf(stdout,"%s: process OK\n",str);
+        else if(valid_multifile)
+            fprintf(stdout,"%s: process OK: with these files\n",str);
+        else
+            fprintf(stdout,"%s: process OK: but NOT with these files\n",str);
+        return(1);
+    } else {
+        fprintf(stdout,"%s: process NOT OK\n",str);
+        return(0);
+    }
+}

dev/misc/gobosee.c

@@ -0,0 +1,138 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <standalone.h>
+
+/******* masking GOBOs for the list of programs: each contains 'maskcnt' bitflags, each of 32 bits ********/
+
+#define ENDOFSTR '\0'
+#define NUMBER_OF_GOBOS (42)
+
+#define INT_SIZE   (32)    /* Flags assumed to be in 32-bit ints : BUT DON'T CHANGE THIS EVEN IF ints ARE intER!! */
+#define CHARBITSIZE (8)     /* bits in a char */
+
+int gobo1[]  = {-1,-1,-1,-1,-1,-1,-16777217,-1,2147483647,-1,-1,-16778241,-1,-939532289,-164097,-19955569,15};         /* set to zero any process that changes srate */
+int gobo2[]  = {0,0,0,1,2097152,2097152,0,557873152,0,1048592,4194816,-2147483646,262147,132121664,1075838976,0,0};    /* set to 1 if process works with zero files */
+int gobo3[]  = {-1549,-402681857,-16779252,-1048580,-27787265,-14683905,-1310721,-558070023,1609791102,-340820177,-4444827,2063596061,-515137604,-1071658209,-1075876101,-20479857,14}; /* works with 1 files  1,1+  */
+int gobo4[]  = {1548,2013294592,1073743859,-133169150,25690623,4198144,169083268,196871,537692545,340394432,8638618,1412432352,112222288,1048749,134369284,268959744,1};          /* works with 2 files  2,1+,2+ */
+int gobo5[]  = {8,0,1073742208,-134217728,511,4195328,168821124,131075,1,273318336,8573064,1412431872,471883792,1052685,134365188,268435456,1};        /* works with 3 files  3,1+,2+ */
+int gobo6[]  = {0,0,1073742208,-134217728,511,4195328,168821124,131075,1,273285568,8573064,1412431872,471883792,1052685,134365188,268435456,1};        /* works with any number of files (not 0) 1+,2+  */
+int gobo7[]  = {-1,-536739841,134741995,1,2097152,2097152,-501218304,29391136,813695105,34750480,4194816,-2147479046,8654547,132302272,1084228099,2089680900,0};   /* File1 = ANAL: else 0  */
+int gobo8[]  = {0,536739840,16252944,1,2097152,2097152,-501219328,21002528,258,3390992,6291968,-2147483646,262147,132121664,1075838976,0,0};   /* File1 = PICH (binary): else 0  */
+int gobo9[]  = {0,402653184,2097152,1,2097152,2097152,-501219328,21002528,0,1179664,4194816,-2147483646,262147,132121664,1075838976,0,0};  /* File1 = TRNS (binary): else 0  */
+int gobo10[] = {0,0,4,1,2097152,2097152,-501219328,21002528,64,1179664,4194816,-2147483646,262147,132121664,1075838976,0,0};                   /* File1 = FMNT : else 0 */
+int gobo11[] = {0,0,-167772160,-1,-201326593,-10481917,-67113985,1564508159,1333788220,-35782152,-2154537,-16784889,-549457629,-939712897,-8422148,-2109636469,15};            /* File1 = SND : else 0 */
+int gobo12[] = {0,0,0,1,69206016,2097164,-501219328,21002528,0,1179664,4194816,-2147483646,262147,132121664,1075838976,0,0};                   /* File1 = ENV (binary) : else 0 */
+int gobo13[] = {0,0,0,1,2097152,2097152,606076928,4225024,0,1048592,4211200,-2147483646,262147,132121664,1075838976,0,0};          /* File1 = TextFile (NOT exclusively numbers): else 0 */
+int gobo14[] = {0,402653184,0,1,2097152,2097152,572526592,21002240,0,1048599,4203008,-2147483646,262159,132121664,1075838976,0,0};     /* File1 = pitch or transpos textfile: else 0 */
+int gobo15[] = {0,0,0,1,2097152,2097248,572526592,21002240,0,1048592,4194816,-2147483646,262147,132121664,1075838976,0,0};         /* File1 = dB-envelope textfile: else 0 */
+int gobo16[] = {0,0,0,1,136314880,2097296,572526592,21002240,0,1048599,4203008,-2147483646,262159,132121664,1075838976,0,0};           /* File1 = normalised-envelope textfile: else 0 */
+int gobo17[] = {0,0,0,1,2097152,2097152,572526592,21002240,0,1048599,4203008,-2147481598,262159,132121664,1075838976,0,0};         /* File1 = unranged brktable textfile: else 0 */
+int gobo18[] = {0,0,0,1,2097152,2359296,639635456,16807936,0,1048592,4194816,-2147483646,541327363,132121664,1075838976,0,0};          /* File1 = list of sndfiles in a textfile: else 0 */
+int gobo19[] = {0,0,0,1,2097152,2621440,35655680,21002240,0,1048592,4194816,-2147483646,262147,132121664,1075838976,0,0};          /* File1 = sndfile synchronisation list: else 0 */
+int gobo20[] = {0,0,0,1,2097152,4190208,572526592,-2126481408,0,1048592,4227624,-2147483646,262147,132121664,1075838976,0,0};          /* File1 = mixfile: else 0 */
+int gobo21[] = {0,0,0,1,2097152,2097152,572526592,58718208,0,1048599,4203008,-2147483646,262159,132121664,1075838976,0,0};         /* File1 = textfile of list-of-numbers: else 0 */
+int gobo22[] = {-1,-1,-16777217,-1,-1,-12582913,-1,-603979777,2147483647,-1,-1,-16778241,-1,-939532289,-33025,-19955569,15};           /* Always 1 / non-functional */
+int gobo23[] = {-1,-1,-16777217,-1,-1,-14675969,-1,-603979777,2147483647,-1,-1,-16778241,-541065217,-939532289,-33025,-19955569,15}; /* If file1=sndlist/synclist, if these must be same SR, set to 0*/
+int gobo24[] = {-1,-1,-16777217,-1,-1,-8388609,-1,-641695745,2147483647,-1,-1,-16778241,-1,-939532289,-33025,-19955569,15};            /* Always 1 / non-functional */
+int gobo25[] = {-1,-1,-1090519041,-1,-1,-8388609,-268435457,-536871489,2147483647,-1,-321,-16778241,-1,-939532289,-39169,-20021105,15};                            /* Reject progs not accepting mono sndsys files by setting to 0*/
+int gobo26[] = {-1,-536739841,1544028139,-4194297,-201326593,-8389646,-35329,1610612735,914362497,-1747041840,785784791,-50392065,-1064845613,-941432864,1593318019,-53542907,7};  /* Reject progs not accepting stereo sndsys files by setting to 0: pitch, formants, transpos, and envbin get 0 */
+int gobo27[] = {-1,-536739841,470286315,130023431,-201327104,-14677006,-402688569,1610612223,914362497,-1814674992,785784343,-52489734,-1064845613,-941432864,1593311875,-53608443,7};/* If process won't run with >2chas,sets to 0,all ANAL progs=1: sndprogs limited to stereo max get 0, pitch,formants,transpos,& envbin get 0 */
+int gobo28[] = {-1541,-2013265921,-1090519058,-1048579,-25690113,-12586753,-135528837,-637730824,2146662015,-340296129,-8638619,-1429210113,-506486785,-940585006,-134402309,-19955569,14}; /* >1 file: to reject all lastfiles except =ANAL set to 1*/
+int gobo29[] = {-1549,-2013294593,-1090521059,-1048579,-25690113,-12586753,-135528837,-637730824,1609791486,-340296129,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: to reject all lastfiles except =FMNT set to 1*/
+int gobo30[] = {-1549,-2013294593,-16779252,-1,-1,-8388609,-1,-637730817,1610612350,-67141633,-1,-16778721,-8388689,-939532417,-33025,-288915313,15};           /* >1 file: to reject all lastfiles except =SND   set to 1*/
+int gobo31[] = {-9,-28673,-1090521076,-1048579,-25690113,-12586753,-135528837,-637730824,1609791102,-340296129,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: to reject all lastfiles except =PCH or TRNSP binary   set to 1*/
+int gobo32[] = {-1549,-1610641409,-1090521076,-1048579,-524289,-12586753,-135528837,-603980040,1609791102,-273318337,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: to reject all lastfiles except =ENV(or dBENV) BRK  set to 1*/
+int gobo33[] = {-1549,-1610641409,-1090521076,-1048579,-25690113,-12586753,-135528837,-637731080,1609791102,-340427201,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* if lastfile = textfile: if you want to reject all lastfiles except number lists, set to 0 */
+int gobo34[] = {-9,-28673,-1090521059,133169151,-524800,-8391937,-135266693,-637730824,2147483646,-273154497,-8523905,-1429210113,-471883793,-940584961,-134398213,-288391025,14};         /* >1 file: if all files must be same type: set to 0 */
+int gobo35[] = {-1549,-1610641409,-1090521076,133169149,-512,-12586753,-135528837,-637730819,1609791102,-273154241,-8589459,-1429210593,-514875473,-940585134,-134402309,-288915313,14};   /* >1 file: if all files must be same srate: set to 0 */
+int gobo36[] = {-1549,-1610641409,-1090521076,133169151,-512,-8392193,-135528577,-637730819,1609791102,-272629953,-8589331,-1362101729,-514875473,-940585102,-134402309,-288915313,14};    /* >1 file: if all files must be same chancnt: set to 0 */
+int gobo37[] = {-1549,-1610641409,-16779252,-1048577,-1,-8391937,-1,-637730824,1610612350,-1,-1,-16778721,-8388689,-939532417,-33025,-20479857,15};    /* >1 file: if all files must be same other props: set to 0 : but 1 for all sndfile only processes */
+int gobo38[] = {-1,-134217729,-16777217,-1,-1,-8388609,-1,-603979777,2147483647,-1,-1,-16778241,-1,-939532289,-33025,-19955569,15};                    /* >1 file: if infiles are P and T, and output is binary, and hence 1 input must be binary: set to 0 */
+int gobo39[] = {-1549,-2013294593,-1090521076,-3,-524289,-12586753,-135528837,-637731080,1609791102,-340394433,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14};   /* >1 file: to reject all lastfiles except =ENV binary   set to 1*/
+int gobo40[] = {-1549,-1610641409,-1090521076,-1048579,-524289,-12586753,-135528837,-603980040,1609791102,-273318337,-8638619,-1429210593,-514875473,-940585134,-134402309,-288915313,14}; /* >1 file: if it can't use textfile as lastfile, set to 0 */
+int gobo41[] = { -1,-1,-1,-1,-8388609,-1,-1,-1,2147483647,-67108865,-1,-16778241,-1,-939532289,-33025,-19955569,15};                                       /* always set to 1 for NEW progs */
+int gobo42[] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};                                         /* always set to 1 for NEW progs */
+int gobo_any[] = {0,0,0,0,0,0,33554432,0,0,0,0,0,0,0,0,0,0};   /* processes which work with absolutely ANY files (i.e. including non-CDP valid files): set to 1, else set to 0 */
+int gobozero[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};      /* set all gobos to 0 */
+
+const char* cdp_version = "8.0.0";
+
+/*******************************************************************/
+
+int main(int argc, char *argv[])
+{
+    char temp[200];
+    int  progno, gobindex, charindex;
+    int mask;
+    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if(argc != 2) {
+        fprintf(stdout,"ERROR: Bad call 1 to gobosee\n");
+        fflush(stdout);
+        return 1;
+    }
+    if (sscanf(argv[1],"%d",&progno) !=1) {
+        fprintf(stdout,"ERROR: Cannot read program number.\n");
+        fflush(stdout);
+        return 1;
+    }
+    temp[0] = ENDOFSTR;
+    if(progno == MIX_MULTI) {
+        fprintf(stdout,"INFO: Multichannel_mixing is a special case.\n");
+        return 1;
+    }
+    progno--;
+    gobindex = progno/INT_SIZE;
+    charindex = progno % INT_SIZE;
+    mask = 1;
+    if (charindex > 0)
+        mask <<= charindex;
+    if(gobo1[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo2[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo3[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo4[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo5[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo6[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo7[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo8[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo9[gobindex] & mask)      strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo10[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo11[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo12[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo13[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo14[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo15[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo16[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo17[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo18[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo19[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo20[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo21[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo22[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo23[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo24[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo25[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo26[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo27[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo28[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo29[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo30[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo31[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo32[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo33[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo34[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo35[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo36[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo37[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo38[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo39[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo40[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo41[gobindex] & mask)     strcat(temp,"1");   else    strcat(temp,"0");
+    if(gobo_any[gobindex] & mask)   strcat(temp,"1");   else    strcat(temp,"0");
+    fprintf(stdout,"INFO: %s\n",temp);
+    return 1;
+}

dev/misc/histconv.c

@@ -0,0 +1,1401 @@
+/*
+ * 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 <string.h>
+#include <ctype.h>
+
+#define CDP_PROPS_CNT (34)
+#define CDP_PROGRAM_DIR	("cdprog")
+#define	ENDOFSTR	('\0')
+#define NUMERICVAL_MARKER ('@')
+
+void	get_progname(int progno,char *p);
+int 	skipwordandspace(char **q);
+int 	getvalandskipspace(char **q,int *ival);
+int 	getwordandskipspace(char **q,char *j);
+void 	get_modename(int progno,int modeno,char *p);
+void 	to_ucase(char *str);
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char *argv[])
+{
+	char temp[1000], temp2[1000], temp3[32], c, *p, *q, *r;
+	FILE *fpo, *fpi;
+	int OK, i, isprog = 1, linecnt = 1, filecnt, progno, modeno;
+
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc != 3) {
+		fprintf(stderr,"USAGE: histconv infile outfile\n");
+		return 1;
+	}
+	if((fpi = fopen(argv[1],"r"))==NULL) {
+		fprintf(stderr,"Cannot open file %s\n",argv[1]);
+		return 1;
+	}
+	if((fpi = fopen(argv[1],"r"))==NULL) {
+		fprintf(stderr,"Cannot open file %s to read\n",argv[1]);
+		return 1;
+	}
+	if((fpo = fopen(argv[2],"w"))==NULL) {
+		fprintf(stderr,"Cannot open file %s to write\n",argv[2]);
+		return 1;
+	}
+	while(fgets(temp,1000,fpi)!=NULL) {
+		if(strlen(temp) <= 0) {
+			fprintf(fpo,"Insufficient information on line %d\n",linecnt);
+			isprog = !isprog;
+			linecnt++;
+			continue;
+		}
+		if(isprog) {
+			p = temp;
+			if(*p == '#') {
+				p++;
+				p += strlen(CDP_PROGRAM_DIR);
+				p++;
+				if(!isprint(*p)) {
+					fprintf(fpo,"Invalid program name on line %d\n",linecnt);
+					isprog = !isprog;
+					linecnt++;
+					continue;
+				}
+				q = temp;	
+				while(*p != ENDOFSTR) {		/* Get rid of directory name */
+					*q = *p;
+					q++;
+					p++;
+				}
+				*q = ENDOFSTR;
+				p = temp;
+ 				if(!skipwordandspace(&p)) {
+					fprintf(fpo,"Not enough words on line %d\n",linecnt);
+					isprog = !isprog;
+					linecnt++;
+					continue;
+				}
+				c = *p;
+				*p = ENDOFSTR;
+				strcpy(temp2,temp);
+				q = temp2;
+				to_ucase(temp2);
+				*p = c;
+				if(!getvalandskipspace(&p,&progno)) {
+					fprintf(fpo,"Failed to get program number on line %d\n",linecnt);
+					isprog = !isprog;
+					linecnt++;
+					continue;
+				}
+
+				r = temp3;
+				get_progname(progno,r);
+				to_ucase(temp3);								
+				strcat(temp2,temp3);
+				strcat(temp2," ");
+
+				if(!getvalandskipspace(&p,&modeno)) {
+					fprintf(fpo,"Failed to get mode number on line %d\n",linecnt);
+					isprog = !isprog;
+					linecnt++;
+					continue;
+				}
+				get_modename(progno,modeno,r);
+				to_ucase(temp3);								
+				strcat(temp2,temp3);
+				strcat(temp2," ");
+
+				if(!getvalandskipspace(&p,&filecnt)) {
+					fprintf(fpo,"Failed to get filecnt on line %d\n",linecnt);
+					isprog = !isprog;
+					linecnt++;
+					continue;
+				}
+				if(*p == ENDOFSTR) {
+					fprintf(fpo,"Insufficient information on line %d\n",linecnt);
+					isprog = !isprog;
+					linecnt++;
+					continue;
+				}
+				if(filecnt > 0) {				
+					OK = 1;
+					for(i=0;i<CDP_PROPS_CNT;i++) {
+						if(!skipwordandspace(&p)) {
+							OK  = 0;
+							break;
+						}
+					}
+					if(!OK) {
+						fprintf(fpo,"Not enough words on line %d\n",linecnt);
+						isprog = !isprog;
+						linecnt++;
+						continue;
+					}										
+					r = temp3;
+					for(i=0;i<filecnt;i++) {
+						if(!getwordandskipspace(&p,r)) {
+							fprintf(fpo,"Failed to get sufficient infile names on line %d\n",linecnt);
+							isprog = !isprog;
+							linecnt++;
+							continue;
+						}
+						strcat(temp2,r);
+						strcat(temp2," ");
+					}
+				}
+   				skipwordandspace(&p);			/* skip outfilename */
+				r = temp3;					/* remove numericval markers */
+				while(*p != ENDOFSTR) {
+					getwordandskipspace(&p,r);
+					if(*r == NUMERICVAL_MARKER) {
+						r++;
+						strcat(temp2,r);
+						strcat(temp2," ");
+						r--;
+					} else {
+						strcat(temp2,r);
+						strcat(temp2," ");
+					}
+				}
+				*r++ = '\n';
+				*r = ENDOFSTR;
+				fprintf(fpo,"%s",temp2);
+			} else {
+				p = temp;
+				r = temp3;					/* remove numericval markers */
+				q = temp2;
+				*q = ENDOFSTR;
+				while(*p != ENDOFSTR) {
+					getwordandskipspace(&p,r);
+					if(*r == NUMERICVAL_MARKER) {
+						r++;
+						strcat(temp2,r);
+						strcat(temp2," ");
+						r--;
+					} else {
+						strcat(temp2,r);
+						strcat(temp2," ");
+					}
+				}
+				*r++ = '\n';
+				*r = ENDOFSTR;
+				fprintf(fpo,"%s",temp2);
+			}
+		} else {
+			fprintf(fpo,"%s",temp);
+		}
+		isprog = !isprog;
+		linecnt++;
+	}
+	return 0;
+}
+
+
+int skipwordandspace(char **q)
+{
+	char *p;
+	p = *q;
+	while(!isspace(*p) && *p != ENDOFSTR)
+		p++;
+	if(*p==ENDOFSTR)
+		return 0;
+	while(isspace(*p) && *p != ENDOFSTR)
+		p++;
+	*q = p;
+	if(*p==ENDOFSTR)
+		return 0;
+	return 1;
+}
+
+
+int getvalandskipspace(char **q,int *ival)
+{
+	char *p, *r, c;
+	p = *q;
+	r = p;
+	while(!isspace(*p))
+		p++;
+	c = *p;
+	*p = ENDOFSTR;
+	if(sscanf(r,"%d",ival)<1) {
+		return 0;
+	}
+	*p = c;
+	while(isspace(*p))
+		p++;
+	*q = p;
+	return 1;
+}
+
+
+int getwordandskipspace(char **q,char *j)
+{
+	char *p, *r, c;
+	p = *q;
+	r = p;
+	while(!isspace(*p))
+		p++;
+	c = *p;
+	*p = ENDOFSTR;
+	strcpy(j,r);
+	*p = c;
+	while(isspace(*p))
+		p++;
+	*q = p;
+	return 1;
+}
+
+
+void get_progname(int progno,char *p)
+{
+	switch(progno){
+	case(1):  	strcpy(p,"gain");	break;
+	case(2):  	strcpy(p,"gate");	break;
+	case(3):  	strcpy(p,"bare_partials");	break;
+	case(4):  	strcpy(p,"clean");	break;
+	case(5):  	strcpy(p,"cut");	break;
+	case(6):  	strcpy(p,"grab_window");	break;
+	case(7):  	strcpy(p,"magnify_window");	break;
+	case(8):  	strcpy(p,"spectrum");	break;
+	case(9):  	strcpy(p,"time");	break;
+	case(10): 	strcpy(p,"alternate_harmonics");	break;
+	case(11): 	strcpy(p,"octave_shift");	break;
+	case(12): 	strcpy(p,"pitch_shift");	break;
+	case(13): 	strcpy(p,"tune_spectrum");	break;
+	case(14): 	strcpy(p,"choose_partials");	break;
+	case(15): 	strcpy(p,"chord");	break;
+	case(16): 	strcpy(p,"chord_(keep_fmnts)");	break;
+	case(17): 	strcpy(p,"filter");	break;
+	case(18): 	strcpy(p,"graphic_eq");	break;
+	case(19): 	strcpy(p,"bands");	break;
+	case(20): 	strcpy(p,"arpeggiate");	break;
+	case(21): 	strcpy(p,"pluck");	break;
+	case(22): 	strcpy(p,"tracery");	break;
+	case(23): 	strcpy(p,"blur_&_trace");	break;
+	case(24): 	strcpy(p,"accumulate");	break;
+	case(25): 	strcpy(p,"exaggerate");	break;
+	case(26): 	strcpy(p,"focus");	break;
+	case(27): 	strcpy(p,"fold_in");	break;
+	case(28): 	strcpy(p,"freeze");	break;
+	case(29): 	strcpy(p,"step_through");	break;
+	case(30): 	strcpy(p,"average");	break;
+	case(31): 	strcpy(p,"blur");	break;
+	case(32): 	strcpy(p,"supress");	break;
+	case(33): 	strcpy(p,"chorus");	break;
+	case(34): 	strcpy(p,"drunkwalk");	break;
+	case(35): 	strcpy(p,"shuffle");	break;
+	case(36): 	strcpy(p,"weave");	break;
+	case(37): 	strcpy(p,"noise");	break;
+	case(38): 	strcpy(p,"scatter");	break;
+	case(39): 	strcpy(p,"spread");	break;
+	case(40): 	strcpy(p,"linear_shift");	break;
+	case(41): 	strcpy(p,"inner_glissando");	break;
+	case(42): 	strcpy(p,"waver");	break;
+	case(43): 	strcpy(p,"warp");	break;
+	case(44): 	strcpy(p,"invert");	break;
+	case(45): 	strcpy(p,"glide");	break;
+	case(46): 	strcpy(p,"bridge");	break;
+	case(47): 	strcpy(p,"morph");	break;
+	case(48): 	strcpy(p,"extract_pitch");	break;
+	case(49): 	strcpy(p,"track_pitch");	break;
+	case(50): 	strcpy(p,"approximate_pitch");	break;
+	case(51): 	strcpy(p,"exaggerate_contour");	break;
+	case(52): 	strcpy(p,"invert_pitch_contour");	break;
+	case(53): 	strcpy(p,"quantise_pitch");	break;
+	case(54): 	strcpy(p,"randomise_pitch");	break;
+	case(55): 	strcpy(p,"smooth_pitch_contour");	break;
+	case(56): 	strcpy(p,"shift_pitch");	break;
+	case(57): 	strcpy(p,"vibrato_pitch_data");	break;
+	case(58): 	strcpy(p,"cut_pitchfile");	break;
+	case(59): 	strcpy(p,"mend_pitchfile");	break;
+	case(60): 	strcpy(p,"repitch_pitchdata");	break;
+	case(61): 	strcpy(p,"repitch_(to_textfile)");	break;
+	case(62): 	strcpy(p,"transpose");	break;
+	case(63): 	strcpy(p,"transpose(keep_fmnts)");	break;
+	case(64): 	strcpy(p,"extract");	break;
+	case(65): 	strcpy(p,"impose");	break;
+	case(66): 	strcpy(p,"vocode");	break;
+	case(67): 	strcpy(p,"view");	break;
+	case(68): 	strcpy(p,"get_&_view");	break;
+	case(69): 	strcpy(p,"add_formants_to_pitch");	break;
+	case(70): 	strcpy(p,"sum");	break;
+	case(71): 	strcpy(p,"difference");	break;
+	case(72): 	strcpy(p,"interleave");	break;
+	case(73): 	strcpy(p,"windowwise_max");	break;
+	case(74): 	strcpy(p,"mean");	break;
+	case(75): 	strcpy(p,"cross_channels");	break;
+	case(76): 	strcpy(p,"window_count");	break;
+	case(77): 	strcpy(p,"channel");	break;
+	case(78): 	strcpy(p,"get_frequency");	break;
+	case(79): 	strcpy(p,"view_level_as_pseudo-sndfile");	break;
+	case(80): 	strcpy(p,"print_octbands_to_file");	break;
+	case(81): 	strcpy(p,"print_energy_centres_to_file");	break;
+	case(82): 	strcpy(p,"print_freq_peaks_to_file");	break;
+	case(83): 	strcpy(p,"print_analysis_data_to_file_only");	break;
+	case(84): 	strcpy(p,"display_info_on_pitchfile");	break;
+	case(85): 	strcpy(p,"check_for_pitch_zeros");	break;
+	case(86): 	strcpy(p,"pitch_view_as_psuedo-sndfile");	break;
+	case(87): 	strcpy(p,"pitch_to_testtone_spectrum");	break;
+	case(88): 	strcpy(p,"print_pitch_data_to_file_only");	break;
+	case(100): 	strcpy(p,"cyclecnt");	break;
+	case(101): 	strcpy(p,"reshape");	break;
+	case(102): 	strcpy(p,"envelope");	break;
+	case(103): 	strcpy(p,"average");	break;
+	case(104): 	strcpy(p,"omit");	break;
+	case(105): 	strcpy(p,"multiply");	break;
+	case(106): 	strcpy(p,"divide");	break;
+	case(107): 	strcpy(p,"harmonic");	break;
+	case(108): 	strcpy(p,"fractal");	break;
+	case(109): 	strcpy(p,"reverse");	break;
+	case(110): 	strcpy(p,"shuffle");	break;
+	case(111): 	strcpy(p,"repeat");	break;
+	case(112): 	strcpy(p,"interpolate");	break;
+	case(113): 	strcpy(p,"delete");	break;
+	case(114): 	strcpy(p,"replace");	break;
+	case(115): 	strcpy(p,"telescope");	break;
+	case(116): 	strcpy(p,"filter");	break;
+	case(117): 	strcpy(p,"interact");	break;
+	case(118): 	strcpy(p,"pitch");	break;
+	case(119): 	strcpy(p,"zigzag");	break;
+	case(120): 	strcpy(p,"loop");	break;
+	case(121): 	strcpy(p,"scramble");	break;
+	case(122): 	strcpy(p,"iterate");	break;
+	case(123): 	strcpy(p,"drunkwalk");	break;
+	case(124): 	strcpy(p,"simple");	break;
+	case(125): 	strcpy(p,"of groups");	break;
+	case(126): 	strcpy(p,"decorated");	break;
+	case(127): 	strcpy(p,"pre-decorations");	break;
+	case(128): 	strcpy(p,"post-decorations");	break;
+	case(129): 	strcpy(p,"ornamented");	break;
+	case(130): 	strcpy(p,"pre-ornate");	break;
+	case(131): 	strcpy(p,"post-ornate");	break;
+	case(132): 	strcpy(p,"of_motifs");	break;
+	case(133): 	strcpy(p,"motifs_in_hf");	break;
+	case(134): 	strcpy(p,"timed");	break;
+	case(135): 	strcpy(p,"timed_groups");	break;
+	case(136): 	strcpy(p,"timed_motifs");	break;
+	case(137): 	strcpy(p,"timed_mtfs_in_hf");	break;
+	case(138): 	strcpy(p,"count");	break;
+	case(139): 	strcpy(p,"omit");	break;
+	case(140): 	strcpy(p,"duplicate");	break;
+	case(141): 	strcpy(p,"reorder");	break;
+	case(142): 	strcpy(p,"repitch");	break;
+	case(143): 	strcpy(p,"rerhythm");	break;
+	case(144): 	strcpy(p,"remotif");	break;
+	case(145): 	strcpy(p,"timewarp");	break;
+	case(146): 	strcpy(p,"get");	break;
+	case(147): 	strcpy(p,"position");	break;
+	case(148): 	strcpy(p,"align");	break;
+	case(149): 	strcpy(p,"reverse");	break;
+	case(150): 	strcpy(p,"create");	break;
+	case(151): 	strcpy(p,"extract");	break;
+	case(152): 	strcpy(p,"impose");	break;
+	case(153): 	strcpy(p,"replace");	break;
+	case(154): 	strcpy(p,"warping");	break;
+	case(155): 	strcpy(p,"reshaping");	break;
+	case(156): 	strcpy(p,"replotting");	break;
+	case(157): 	strcpy(p,"dovetailing");	break;
+	case(158): 	strcpy(p,"curtailing");	break;
+	case(159): 	strcpy(p,"swell");	break;
+	case(160): 	strcpy(p,"attack");	break;
+	case(161): 	strcpy(p,"pluck");	break;
+	case(162): 	strcpy(p,"tremolo");	break;
+	case(163): 	strcpy(p,"bin_to_brk");	break;
+	case(164): 	strcpy(p,"bin_to_db-brk");	break;
+	case(165): 	strcpy(p,"brk_to_bin");	break;
+	case(166): 	strcpy(p,"db-brk_to_bin");	break;
+	case(167): 	strcpy(p,"db-brk_to_brk");	break;
+	case(168): 	strcpy(p,"brk_to_db-brk");	break;
+	case(169): 	strcpy(p,"merge_two_sounds");	break;
+	case(170): 	strcpy(p,"crossfade");	break;
+	case(171): 	strcpy(p,"merge_channels");	break;
+	case(172): 	strcpy(p,"inbetweening");	break;
+	case(173): 	strcpy(p,"mix");	break;
+	case(174): 	strcpy(p,"get_level");	break;
+	case(175): 	strcpy(p,"attenuate");	break;
+	case(176): 	strcpy(p,"shuffle");	break;
+	case(177): 	strcpy(p,"timewarp");	break;
+	case(178): 	strcpy(p,"spacewarp");	break;
+	case(179): 	strcpy(p,"sync");	break;
+	case(180): 	strcpy(p,"sync_attack");	break;
+	case(181): 	strcpy(p,"test");	break;
+	case(182): 	strcpy(p,"format");	break;
+	case(183): 	strcpy(p,"dummy");	break;
+	case(184): 	strcpy(p,"variable");	break;
+	case(185): 	strcpy(p,"fixed");	break;
+	case(186): 	strcpy(p,"lopass/hipass");	break;
+	case(187): 	strcpy(p,"variable");	break;
+	case(188): 	strcpy(p,"bank");	break;
+	case(189): 	strcpy(p,"bank_frqs");	break;
+	case(190): 	strcpy(p,"userbank");	break;
+	case(191): 	strcpy(p,"varibank");	break;
+	case(192): 	strcpy(p,"sweeping");	break;
+	case(193): 	strcpy(p,"iterated");	break;
+	case(194): 	strcpy(p,"phasing");	break;
+	case(195): 	strcpy(p,"loudness");	break;
+	case(196): 	strcpy(p,"spatialisation");	break;
+	case(197): 	strcpy(p,"pitch");	break;
+	case(198): 	strcpy(p,"rev/echo");	break;
+	case(199): 	strcpy(p,"brassage");	break;
+	case(200): 	strcpy(p,"sausage");	break;
+	case(201): 	strcpy(p,"radical");	break;
+	case(202): 	strcpy(p,"analysis");	break;
+	case(203): 	strcpy(p,"synthesis");	break;
+	case(204): 	strcpy(p,"extract");	break;
+	case(206): 	strcpy(p,"cutout_&_keep");	break;
+	case(207): 	strcpy(p,"cutend_&_keep");	break;
+	case(208): 	strcpy(p,"cutout_at_zero-crossings");	break;
+	case(209): 	strcpy(p,"remove_segment");	break;
+	case(210): 	strcpy(p,"remove_many_segments");	break;
+	case(211): 	strcpy(p,"insert_sound");	break;
+	case(212): 	strcpy(p,"insert_silence");	break;
+	case(213): 	strcpy(p,"join");	break;
+	case(214): 	strcpy(p,"multiples");	break;
+	case(215): 	strcpy(p,"extract/convert_channels");	break;
+	case(216): 	strcpy(p,"&_clean");	break;
+	case(217): 	strcpy(p,"change_specification");	break;
+	case(218): 	strcpy(p,"bundle");	break;
+	case(219): 	strcpy(p,"sort_files");	break;
+	case(220): 	strcpy(p,"backup");	break;
+	case(221): 	strcpy(p,"recover_from_dump");	break;
+	case(222): 	strcpy(p,"diskspace");	break;
+	case(223): 	strcpy(p,"properties");	break;
+	case(224): 	strcpy(p,"duration");	break;
+	case(225): 	strcpy(p,"list_sound_durations");	break;
+	case(226): 	strcpy(p,"sum_durations");	break;
+	case(227): 	strcpy(p,"subtract_durations");	break;
+	case(228): 	strcpy(p,"sample_count_as_time");	break;
+	case(229): 	strcpy(p,"time_as_sample_count");	break;
+	case(230): 	strcpy(p,"maximum_sample");	break;
+	case(231): 	strcpy(p,"loudest_channel");	break;
+	case(232): 	strcpy(p,"largest_hole");	break;
+	case(233): 	strcpy(p,"compare_files");	break;
+	case(234): 	strcpy(p,"compare_channels");	break;
+	case(235): 	strcpy(p,"print_sound_data");	break;
+	case(236): 	strcpy(p,"convert_units");	break;
+	case(237): 	strcpy(p,"waveform");	break;
+	case(238): 	strcpy(p,"noise");	break;
+	case(239): 	strcpy(p,"silent_file");	break;
+	case(240): 	strcpy(p,"extract_column");	break;
+	case(241): 	strcpy(p,"insert_column");	break;
+	case(242): 	strcpy(p,"join_columns");	break;
+	case(243): 	strcpy(p,"column_maths");	break;
+	case(244): 	strcpy(p,"column_music");	break;
+	case(245): 	strcpy(p,"column_rand");	break;
+	case(246): 	strcpy(p,"column_sort");	break;
+	case(247): 	strcpy(p,"column_create");	break;
+	case(248): 	strcpy(p,"hold");	break;
+	case(249): 	strcpy(p,"remove_copies");	break;
+	case(250): 	strcpy(p,"vectors");	break;
+	case(251): 	strcpy(p,"silence_masks");	break;
+	default:	strcpy(p,"UNKNOWN_PROGRAM");	break;
+	}
+}
+
+void get_modename(int progno,int modeno,char *p)
+{
+	switch(progno) {
+	case(4):
+		switch(modeno) {
+		case(1):	strcpy(p,"from_specified_time");	break; 
+		case(2):	strcpy(p,"anywhere");	break; 
+		case(3):	strcpy(p,"above_specified_frq");	break; 
+		case(4):	strcpy(p,"by_comparison_method");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(8):
+		switch(modeno) {
+		case(1):	strcpy(p,"above_given_frq");	break; 
+		case(2):	strcpy(p,"below_given_frq");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(9):
+		switch(modeno) {
+		case(1):	strcpy(p,"do_time_stretc_");	break; 
+		case(2):	strcpy(p,"get_output_length");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(10):
+		switch(modeno) {
+		case(1):	strcpy(p,"delete_odd_harmonics");	break; 
+		case(2):	strcpy(p,"delete_even_harmonics");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(11):
+		switch(modeno) {
+		case(1):	strcpy(p,"up");	break; 
+		case(2):	strcpy(p,"down");	break; 
+		case(3):	strcpy(p,"down_with_bass_boost");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(12):
+		switch(modeno) {
+		case(1):	strcpy(p,"8va_shift_up");	break; 
+		case(2):	strcpy(p,"8va_shift_down");	break; 
+		case(3):	strcpy(p,"8va_shift_up_and_down");	break; 
+		case(4):	strcpy(p,"shift_up");	break; 
+		case(5):	strcpy(p,"shift_down");	break; 
+		case(6):	strcpy(p,"shift_up_and_down");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(13):
+		switch(modeno) {
+		case(1):	strcpy(p,"tunings_as_frqs");	break; 
+		case(2):	strcpy(p,"tunings_as_midi");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(14):
+		switch(modeno) {
+		case(1):	strcpy(p,"harmonic_series");	break; 
+		case(2):	strcpy(p,"octaves");	break; 
+		case(3):	strcpy(p,"odd_harmonics_only");	break; 
+		case(4):	strcpy(p,"linear_frq_steps");	break; 
+		case(5):	strcpy(p,"displaced_harmonics");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(17):
+		switch(modeno) {
+		case(1):	strcpy(p,"high_pass");	break; 
+		case(2):	strcpy(p,"high_pass_normalised");	break; 
+		case(3):	strcpy(p,"low_pass");	break; 
+		case(4):	strcpy(p,"low_pass_normalised");	break; 
+		case(5):	strcpy(p,"high_pass_with_gain");	break; 
+		case(6):	strcpy(p,"low_pass_with_gain");	break; 
+		case(7):	strcpy(p,"bandpass");	break; 
+		case(8):	strcpy(p,"bandpass_normalised");	break; 
+		case(9):	strcpy(p,"notch");	break; 
+		case(10):	strcpy(p,"notch_normalised");	break; 
+		case(11):	strcpy(p,"bandpass_with_gain");	break; 
+		case(12):	strcpy(p,"notch_with_gain");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(18):
+		switch(modeno) {
+		case(1):	strcpy(p,"standard_bandwidth");	break; 
+		case(2):	strcpy(p,"various_bandwidths");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(20):
+		switch(modeno) {
+		case(1):	strcpy(p,"on");	break; 
+		case(2):	strcpy(p,"boost");	break; 
+		case(3):	strcpy(p,"boost_below");	break; 
+		case(4):	strcpy(p,"boost_above");	break; 
+		case(5):	strcpy(p,"on_below");	break; 
+		case(6):	strcpy(p,"on_above");	break; 
+		case(7):	strcpy(p,"once_below");	break; 
+		case(8):	strcpy(p,"once_above");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(22):
+		switch(modeno) {
+		case(1):	strcpy(p,"trace_all");	break; 
+		case(2):	strcpy(p,"trace_above_frq");	break; 
+		case(3):	strcpy(p,"trace_below_frq");	break; 
+		case(4):	strcpy(p,"trace_between_frqs");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(28):
+		switch(modeno) {
+		case(1):	strcpy(p,"amplitudes");	break; 
+		case(2):	strcpy(p,"frequencies");	break; 
+		case(3):	strcpy(p,"amps_&_frqs");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(33):
+		switch(modeno) {
+		case(1):	strcpy(p,"scatter_amps");	break; 
+		case(2):	strcpy(p,"scatter_frqs");	break; 
+		case(3):	strcpy(p,"scatter_frqs_up");	break; 
+		case(4):	strcpy(p,"scatter_frqs_down");	break; 
+		case(5):	strcpy(p,"scatter_amps_&_frqs");	break; 
+		case(6):	strcpy(p,"scatter_amp_&_frqs_up");	break; 
+		case(7):	strcpy(p,"scatter_amp_&_frqs_down");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(40):
+		switch(modeno) {
+		case(1):	strcpy(p,"shift_all");	break; 
+		case(2):	strcpy(p,"shift_above_frq");	break; 
+		case(3):	strcpy(p,"shift_below_frq");	break; 
+		case(4):	strcpy(p,"shift_between_frqs");	break; 
+		case(5):	strcpy(p,"shift_outside_frqs");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(41):
+		switch(modeno) {
+		case(1):	strcpy(p,"shepard_tone_glis");	break; 
+		case(2):	strcpy(p,"inharmonic_glis");	break; 
+		case(3):	strcpy(p,"self_glis");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(42):
+		switch(modeno) {
+		case(1):	strcpy(p,"standard");	break; 
+		case(2):	strcpy(p,"user_specified");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(44):
+		switch(modeno) {
+		case(1):	strcpy(p,"standard");	break; 
+		case(2):	strcpy(p,"retain_src_envelope");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(46):
+		switch(modeno) {
+		case(1):	strcpy(p,"standard");	break; 
+		case(2):	strcpy(p,"outlevel_follows_minimum");	break; 
+		case(3):	strcpy(p,"outlevel_follows_file1");	break; 
+		case(4):	strcpy(p,"outlevel_follows_file2");	break; 
+		case(5):	strcpy(p,"outlevel_moves_from_1_to_2");	break; 
+		case(6):	strcpy(p,"outlevel_moves_from_2_to_1");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(47):
+		switch(modeno) {
+		case(1):	strcpy(p,"linear_or_curved");	break; 
+		case(2):	strcpy(p,"cosinusoidal");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(48):
+		switch(modeno) {
+		case(1):	strcpy(p,"to_binary_file");	break; 
+		case(2):	strcpy(p,"to_textfile");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(49):
+		switch(modeno) {
+		case(1):	strcpy(p,"to_binary_file");	break; 
+		case(2):	strcpy(p,"to_textfile");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(50):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch_data_out");	break; 
+		case(2):	strcpy(p,"transposition_data_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(51):
+		switch(modeno) {
+		case(1):	strcpy(p,"range:_pitch_out");	break; 
+		case(2):	strcpy(p,"range:_transposition_out");	break; 
+		case(3):	strcpy(p,"contour:_pitch_out");	break; 
+		case(4):	strcpy(p,"contour:_transpos_out");	break; 
+		case(5):	strcpy(p,"range_&_contour:_pitch_out");	break; 
+		case(6):	strcpy(p,"range_&_contour:_transpos_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(52):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch_data_out");	break; 
+		case(2):	strcpy(p,"transposition_data_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(53):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch_data_out");	break; 
+		case(2):	strcpy(p,"transposition_data_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(54):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch_data_out");	break; 
+		case(2):	strcpy(p,"transposition_data_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(55):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch_data_out");	break; 
+		case(2):	strcpy(p,"transposition_data_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(56):
+		switch(modeno) {
+		case(1):	strcpy(p,"shift_by_ratio");	break; 
+		case(2):	strcpy(p,"shift_by_semitones");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(57):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch_data_out");	break; 
+		case(2):	strcpy(p,"transposition_data_out");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(58):
+		switch(modeno) {
+		case(1):	strcpy(p,"from_starttime");	break; 
+		case(2):	strcpy(p,"to_endtime");	break; 
+		case(3):	strcpy(p,"between_times");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(60):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch+pitch_to_transpos");	break; 
+		case(2):	strcpy(p,"pitch+transpos_to_pitch");	break; 
+		case(3):	strcpy(p,"transpos+transpos_to_transpos");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(61):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitch+pitch_to_transpos");	break; 
+		case(2):	strcpy(p,"pitch+transpos_to_pitch");	break; 
+		case(3):	strcpy(p,"transpos+transpos_to_transpos");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(62):
+		switch(modeno) {
+		case(1):	strcpy(p,"transpos_as_ratio");	break; 
+		case(2):	strcpy(p,"transpos_in_octaves");	break; 
+		case(3):	strcpy(p,"transpos_in_semitones");	break; 
+		case(4):	strcpy(p,"transpos_as_binary_data");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(63):
+		switch(modeno) {
+		case(1):	strcpy(p,"transpos_as_ratio");	break; 
+		case(2):	strcpy(p,"transpos_in_octaves");	break; 
+		case(3):	strcpy(p,"transpos_in_semitones");	break; 
+		case(4):	strcpy(p,"transpos_as_binary_data");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(65):
+		switch(modeno) {
+		case(1):	strcpy(p,"replace_formants");	break; 
+		case(2):	strcpy(p,"superimpose_formants");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(74):
+		switch(modeno) {
+		case(1):	strcpy(p,"mean_amp_&_pitch");	break; 
+		case(2):	strcpy(p,"mean_amp_&_frq");	break; 
+		case(3):	strcpy(p,"amp_file1:_mean_pich");	break; 
+		case(4):	strcpy(p,"amp_file1:_mean_frq");	break; 
+		case(5):	strcpy(p,"amp_file2:_mean_pich");	break; 
+		case(6):	strcpy(p,"amp_file2:_mean_frq");	break; 
+		case(7):	strcpy(p,"max_amp:_mean_pitch");	break; 
+		case(8):	strcpy(p,"max_amp:_mean_frq");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(82):
+		switch(modeno) {
+		case(1):	strcpy(p,"order_by_frq_&_time");	break; 
+		case(2):	strcpy(p,"order_by_loudness_&_time");	break; 
+		case(3):	strcpy(p,"order_by_frq_(untimed)");	break; 
+		case(4):	strcpy(p,"order_by_loudness_(untimed)");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(86):
+		switch(modeno) {
+		case(1):	strcpy(p,"see_pitch");	break; 
+		case(2):	strcpy(p,"see_transposition");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(101):
+		switch(modeno) {
+		case(1):	strcpy(p,"fixed_level_square");	break; 
+		case(2):	strcpy(p,"square");	break; 
+		case(3):	strcpy(p,"fixed_level_triangle");	break; 
+		case(4):	strcpy(p,"triangle");	break; 
+		case(5):	strcpy(p,"invert_halfcycles");	break; 
+		case(6):	strcpy(p,"click");	break; 
+		case(7):	strcpy(p,"sine");	break; 
+		case(8):	strcpy(p,"exaggerate_contour");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(102):
+		switch(modeno) {
+		case(1):	strcpy(p,"rising");	break; 
+		case(2):	strcpy(p,"falling");	break; 
+		case(3):	strcpy(p,"troughed");	break; 
+		case(4):	strcpy(p,"user_defined");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(113):
+		switch(modeno) {
+		case(1):	strcpy(p,"in_given_order");	break; 
+		case(2):	strcpy(p,"retain_loudest");	break; 
+		case(3):	strcpy(p,"delete_weakest");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(116):
+		switch(modeno) {
+		case(1):	strcpy(p,"high_pass");	break; 
+		case(2):	strcpy(p,"low_pass");	break; 
+		case(3):	strcpy(p,"band_pass");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(117):
+		switch(modeno) {
+		case(1):	strcpy(p,"interleave");	break; 
+		case(2):	strcpy(p,"resize");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(119):
+		switch(modeno) {
+		case(1):	strcpy(p,"random");	break; 
+		case(2):	strcpy(p,"user_specified");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(120):
+		switch(modeno) {
+		case(1):	strcpy(p,"loop_advances_to_end");	break; 
+		case(2):	strcpy(p,"give_output_duration");	break; 
+		case(3):	strcpy(p,"give_loop_repetitions");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(121):
+		switch(modeno) {
+		case(1):	strcpy(p,"completely_random");	break; 
+		case(2):	strcpy(p,"scramble_src:_then_again..");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(122):
+		switch(modeno) {
+		case(1):	strcpy(p,"give_duration");	break; 
+		case(2):	strcpy(p,"give_count");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(123):
+		switch(modeno) {
+		case(1):	strcpy(p,"completely_drunk");	break; 
+		case(2):	strcpy(p,"sober_moments");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(124):
+	case(125):
+	case(126):
+	case(127):
+	case(128):
+	case(129):
+	case(130):
+	case(131):
+	case(132):
+	case(134):
+	case(135):
+	case(136):
+		switch(modeno) {
+		case(1):	strcpy(p,"over_harmonic_field");	break; 
+		case(2):	strcpy(p,"over_harmonic_fields");	break; 
+		case(3):	strcpy(p,"over_harmonic_set");	break; 
+		case(4):	strcpy(p,"over_harmonic_sets");	break; 
+		case(5):	strcpy(p,"neutral");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(133):
+	case(137):
+		switch(modeno) {
+		case(1):	strcpy(p,"over_harmonic_field");	break; 
+		case(2):	strcpy(p,"over_harmonic_fields");	break; 
+		case(3):	strcpy(p,"over_harmonic_set");	break; 
+		case(4):	strcpy(p,"over_harmonic_sets");	break; 
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(142):
+	case(143):
+	case(144):
+		switch(modeno) {
+		case(1):	strcpy(p,"no_grain_repeats");	break; 
+		case(2):	strcpy(p,"repeat_each_grain");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(150):
+	case(151):
+		switch(modeno) {
+		case(1):	strcpy(p,"binary_output");	break; 
+		case(2):	strcpy(p,"textfile_output");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(152):
+	case(153):
+		switch(modeno) {
+		case(1):	strcpy(p,"env_from_other_sndfile");	break; 
+		case(2):	strcpy(p,"env_in_binary_file");	break; 
+		case(3):	strcpy(p,"env_in_textfile");	break; 
+		case(4):	strcpy(p,"env_in_db_textfile");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(154):
+	case(155):
+	case(156):
+		switch(modeno) {
+		case(1):	strcpy(p,"normalise");	break; 
+		case(2):	strcpy(p,"time_reverse");	break; 
+		case(3):	strcpy(p,"exaggerate");	break; 
+		case(4):	strcpy(p,"attenuate");	break; 
+		case(5):	strcpy(p,"lift_all");	break; 
+		case(6):	strcpy(p,"time-stretch");	break; 
+		case(7):	strcpy(p,"flatten");	break; 
+		case(8):	strcpy(p,"gate");	break; 
+		case(9):	strcpy(p,"invert");	break; 
+		case(10):	strcpy(p,"limit");	break; 
+		case(11):	strcpy(p,"corrugate");	break; 
+		case(12):	strcpy(p,"expand");	break; 
+		case(13):	strcpy(p,"trigger_bursts");	break; 
+		case(14):	strcpy(p,"to_ceiling");	break; 
+		case(15):	strcpy(p,"ducked");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(158):
+		switch(modeno) {
+		case(1):	strcpy(p,"give_start_&_end_of_fade");	break; 
+		case(2):	strcpy(p,"give_start_&_dur_of_fade");	break; 
+		case(3):	strcpy(p,"give_start_of_fade-to-end");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(160):
+		switch(modeno) {
+		case(1):	strcpy(p,"where_gate_exceeded");	break; 
+		case(2):	strcpy(p,"near_time_given");	break; 
+		case(3):	strcpy(p,"at_exact_time_given");	break; 
+		case(4):	strcpy(p,"at_max_level_in_file");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(162):
+		switch(modeno) {
+		case(1):	strcpy(p,"frqwise");	break; 
+		case(2):	strcpy(p,"pitchwise");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(170):
+		switch(modeno) {
+		case(1):	strcpy(p,"linear");	break; 
+		case(2):	strcpy(p,"cosinusoidal");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(172):
+		switch(modeno) {
+		case(1):	strcpy(p,"automatic");	break; 
+		case(2):	strcpy(p,"give_mix_ratios");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(174):
+		switch(modeno) {
+		case(1):	strcpy(p,"maximum_level");	break; 
+		case(2):	strcpy(p,"clipping_times");	break; 
+		case(3):	strcpy(p,"maxlevel_&_cliptimes");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(176):
+		switch(modeno) {
+		case(1):	strcpy(p,"duplicate_lines");	break; 
+		case(2):	strcpy(p,"reverse_order_filenames");	break; 
+		case(3):	strcpy(p,"scatter_order_filenames");	break; 
+		case(4):	strcpy(p,"first_filename_to_all");	break; 
+		case(5):	strcpy(p,"omit_lines");	break; 
+		case(6):	strcpy(p,"omit_alternate_lines");	break; 
+		case(7):	strcpy(p,"dupl_lines,_new_filename");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(177):
+		switch(modeno) {
+		case(1):	strcpy(p,"sort_entry_times");	break; 
+		case(2):	strcpy(p,"reverse_timing_pattern");	break; 
+		case(3):	strcpy(p,"reverse_timing_&_names");	break; 
+		case(4):	strcpy(p,"freeze_timegaps");	break; 
+		case(5):	strcpy(p,"freeze_timegaps_&_names");	break; 
+		case(6):	strcpy(p,"scatter_entry_times");	break; 
+		case(7):	strcpy(p,"shuffle_up_entry_times");	break; 
+		case(8):	strcpy(p,"add_to_timegaps");	break; 
+		case(9):	strcpy(p,"create_timegap_1");	break; 
+		case(10):	strcpy(p,"create_timegap_2");	break; 
+		case(11):	strcpy(p,"create_timegap_3");	break; 
+		case(12):	strcpy(p,"create_timegap_4");	break; 
+		case(13):	strcpy(p,"enlarge_timegap_1");	break; 
+		case(14):	strcpy(p,"enlarge_timegap_2");	break; 
+		case(15):	strcpy(p,"enlarge_timegap_3");	break; 
+		case(16):	strcpy(p,"enlarge_timegap_4");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(178):
+		switch(modeno) {
+		case(1):	strcpy(p,"fix_position");	break; 
+		case(2):	strcpy(p,"narrow");	break; 
+		case(3):	strcpy(p,"sequence_leftwards");	break; 
+		case(4):	strcpy(p,"sequence_rightwards");	break; 
+		case(5):	strcpy(p,"scatter");	break; 
+		case(6):	strcpy(p,"scatter_alternating");	break; 
+		case(7):	strcpy(p,"twist_whole_mix");	break; 
+		case(8):	strcpy(p,"twist_a_line");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(179):
+		switch(modeno) {
+		case(1):	strcpy(p,"at_midtimes");	break; 
+		case(2):	strcpy(p,"at_endtimes");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(185):
+		switch(modeno) {
+		case(1):	strcpy(p,"boost-or-cut_below_frq");	break; 
+		case(2):	strcpy(p,"boost-or-cut_above_frq");	break; 
+		case(3):	strcpy(p,"boost-or-cut_around_frq");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(186):
+		switch(modeno) {
+		case(1):	strcpy(p,"bands_as_frq_(hz)");	break; 
+		case(2):	strcpy(p,"bands_as_midi");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(187):
+		switch(modeno) {
+		case(1):	strcpy(p,"high_pass");	break; 
+		case(2):	strcpy(p,"low_pass");	break; 
+		case(3):	strcpy(p,"band_pass");	break; 
+		case(4):	strcpy(p,"notch");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(188):
+	case(189):
+		switch(modeno) {
+		case(1):	strcpy(p,"harmonics");	break; 
+		case(2):	strcpy(p,"alternate_harmonics");	break; 
+		case(3):	strcpy(p,"subharmonics");	break; 
+		case(4):	strcpy(p,"harmonics_with_offset");	break; 
+		case(5):	strcpy(p,"fixed_number_of_bands");	break; 
+		case(6):	strcpy(p,"fixed_interval_between");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(190):
+		switch(modeno) {
+		case(1):	strcpy(p,"bands_as_frq_(hz)");	break; 
+		case(2):	strcpy(p,"bands_as_midi");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(191):
+		switch(modeno) {
+		case(1):	strcpy(p,"bands_as_frq_(hz)");	break; 
+		case(2):	strcpy(p,"bands_as_midi");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(192):
+		switch(modeno) {
+		case(1):	strcpy(p,"high_pass");	break; 
+		case(2):	strcpy(p,"low_pass");	break; 
+		case(3):	strcpy(p,"band_pass");	break; 
+		case(4):	strcpy(p,"notch");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(193):
+		switch(modeno) {
+		case(1):	strcpy(p,"bands_as_frq_(hz)");	break; 
+		case(2):	strcpy(p,"bands_as_midi");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(194):
+		switch(modeno) {
+		case(1):	strcpy(p,"phase_shift_filter");	break; 
+		case(2):	strcpy(p,"phasing_effect");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(195):
+		switch(modeno) {
+		case(1):	strcpy(p,"gain");	break; 
+		case(2):	strcpy(p,"dBgain");	break; 
+		case(3):	strcpy(p,"normalise");	break; 
+		case(4):	strcpy(p,"force_level");	break; 
+		case(5):	strcpy(p,"balance_srcs");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(196):
+		switch(modeno) {
+		case(1):	strcpy(p,"pan");	break; 
+		case(2):	strcpy(p,"mirror");	break; 
+		case(3):	strcpy(p,"mirror_panning_file");	break; 
+		case(4):	strcpy(p,"narrow");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(197):
+		switch(modeno) {
+		case(1):	strcpy(p,"tape_transpose_by_time-ratio");	break; 
+		case(2):	strcpy(p,"tape_transpose_by_semitones");	break; 
+		case(3):	strcpy(p,"see_transposition_by_time-ratio");	break; 
+		case(4):	strcpy(p,"see_transposition_by_semitones");	break; 
+		case(5):	strcpy(p,"tape_accelerate");	break; 
+		case(6):	strcpy(p,"tape_vibrato");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(198):
+		switch(modeno) {
+		case(1):	strcpy(p,"delay");	break; 
+		case(2):	strcpy(p,"varying_delay");	break; 
+		case(3):	strcpy(p,"stadium");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(199):
+		switch(modeno) {
+		case(1):	strcpy(p,"pitchshift");	break; 
+		case(2):	strcpy(p,"timesqueeze");	break; 
+		case(3):	strcpy(p,"reverb");	break; 
+		case(4):	strcpy(p,"scramble");	break; 
+		case(5):	strcpy(p,"granulate");	break; 
+		case(6):	strcpy(p,"brassage");	break; 
+		case(7):	strcpy(p,"full_monty");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(201):
+		switch(modeno) {
+		case(1):	strcpy(p,"reverse");	break; 
+		case(2):	strcpy(p,"shred");	break; 
+		case(3):	strcpy(p,"scrub_over_heads");	break; 
+		case(4):	strcpy(p,"lower_resolution");	break; 
+		case(5):	strcpy(p,"ring_modulate");	break; 
+		case(6):	strcpy(p,"cross_modulate");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(202):
+		switch(modeno) {
+		case(1):	strcpy(p,"standard");	break; 
+		case(2):	strcpy(p,"get_spec_envelope_only");	break; 
+		case(3):	strcpy(p,"get_spec_magnitudes_only");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(206):
+	case(207):
+	case(208):
+	case(209):
+	case(210):
+	case(211):
+	case(212):
+		switch(modeno) {
+		case(1):	strcpy(p,"time_in_seconds");	break; 
+		case(2):	strcpy(p,"time_as_sample_count");	break; 
+		case(3):	strcpy(p,"time_as_grouped_samples");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(214):
+		switch(modeno) {
+		case(1):	strcpy(p,"make_a_copy");	break; 
+		case(2):	strcpy(p,"make_multiple_copies");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(215):
+		switch(modeno) {
+		case(1):	strcpy(p,"extract_a_channel");	break; 
+		case(2):	strcpy(p,"extract_all_channels");	break; 
+		case(3):	strcpy(p,"zero_a_channel");	break; 
+		case(4):	strcpy(p,"convert_stereo_to_mono");	break; 
+		case(5):	strcpy(p,"convert_mono_to_stereo");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(216):
+		switch(modeno) {
+		case(1):	strcpy(p,"gated_extraction");	break; 
+		case(2):	strcpy(p,"preview_extraction");	break; 
+		case(3):	strcpy(p,"top_and_tail");	break; 
+		case(4):	strcpy(p,"remove_dc");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(217):
+		switch(modeno) {
+		case(1):	strcpy(p,"change_sampling_rate");	break; 
+		case(2):	strcpy(p,"convert_sample_format");	break; 
+		case(3):	strcpy(p,"change_properties");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(218):
+		switch(modeno) {
+		case(1):	strcpy(p,"any_files");	break; 
+		case(2):	strcpy(p,"non-text_files");	break; 
+		case(3):	strcpy(p,"same_type");	break; 
+		case(4):	strcpy(p,"same_properties");	break; 
+		case(5):	strcpy(p,"same_channels");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(219):
+		switch(modeno) {
+		case(1):	strcpy(p,"by_filetype");	break; 
+		case(2):	strcpy(p,"by_sampling_rate");	break; 
+		case(3):	strcpy(p,"by_duration");	break; 
+		case(4):	strcpy(p,"by_log_duration");	break; 
+		case(5):	strcpy(p,"into_duration_order");	break; 
+		case(6):	strcpy(p,"find_rogues");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(220):
+		switch(modeno) {
+		case(1):	strcpy(p,"string_sounds_together");	break; 
+		case(2):	strcpy(p,"dump_sndfiles");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(236):
+		switch(modeno) {
+		case(1):	strcpy(p,"midi_to_frq");	break; 
+		case(2):	strcpy(p,"frq_to_midi");	break; 
+		case(3):	strcpy(p,"note_to_frq");	break; 
+		case(4):	strcpy(p,"note_to_midi");	break; 
+		case(5):	strcpy(p,"frq_to_note");	break; 
+		case(6):	strcpy(p,"midi_to_note");	break; 
+		case(7):	strcpy(p,"frq_ratio_to_semitones");	break; 
+		case(8):	strcpy(p,"frq_ratio_to_interval");	break; 
+		case(9):	strcpy(p,"interval_to_frq_ratio");	break; 
+		case(10):	strcpy(p,"semitones_to_frq_ratio");	break; 
+		case(11):	strcpy(p,"octaves_to_frq_ratio");	break; 
+		case(12):	strcpy(p,"octaves_to_semitones");	break; 
+		case(13):	strcpy(p,"frq_ratio_to_octaves");	break; 
+		case(14):	strcpy(p,"semitones_to_octaves");	break; 
+		case(15):	strcpy(p,"semitones_to_interval");	break; 
+		case(16):	strcpy(p,"frq_ratio_to_time_ratio");	break; 
+		case(17):	strcpy(p,"semitones_to_time_ratio");	break; 
+		case(18):	strcpy(p,"octaves_to_time_ratio");	break; 
+		case(19):	strcpy(p,"interval_to_time_ratio");	break; 
+		case(20):	strcpy(p,"time_ratio_to_frq_ratio");	break; 
+		case(21):	strcpy(p,"time_ratio_to_semitones");	break; 
+		case(22):	strcpy(p,"time_ratio_to_octaves");	break; 
+		case(23):	strcpy(p,"time_ratio_to_interval");	break; 
+		case(24):	strcpy(p,"gain_factor_to_db_gain");	break; 
+		case(25):	strcpy(p,"db_gain_to_gain_factor");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(237):
+		switch(modeno) {
+		case(1):	strcpy(p,"sine");	break; 
+		case(2):	strcpy(p,"square");	break; 
+		case(3):	strcpy(p,"saw");	break; 
+		case(4):	strcpy(p,"ramp");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	case(251):
+		switch(modeno) {
+		case(1):	strcpy(p,"time_in_seconds");	break; 
+		case(2):	strcpy(p,"time_as_sample_count");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+		break;
+	default:
+		switch(modeno) {
+		case(0): strcpy(p,"");	break;
+		default: strcpy(p,"UNKNOWN-MODE");	break;
+		}
+	}
+}
+
+void to_ucase(char *str)
+{
+	char *p = str, cc;
+	while(*p != ENDOFSTR) {
+		if(isalpha(*p) && *p > 96) {
+			cc = (char)(*p - 32);
+			*p = cc;
+		}
+		p++;
+	}
+}

dev/misc/kbhit.c

@@ -0,0 +1,311 @@
+/*
+ * 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
+ *
+ */
+
+
+
+
+
+
+/* ***************************************************************************
+ *
+ *          Copyright 1992-2002 by Pete Wilson All Rights Reserved
+ *           50 Staples Street : Lowell Massachusetts 01851 : USA
+ *        http://www.pwilson.net/   [email protected]   +1 978-454-4547
+ *
+ * This item is free software: you can redistribute it and/or modify it as 
+ * long as you preserve this copyright notice. Pete Wilson prepared this item 
+ * hoping it might be useful, but it has NO WARRANTY WHATEVER, not even any 
+ * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+ *
+ *************************************************************************** */
+
+/* ***************************************************************************
+ *
+ *                          KBHIT.C
+ *
+ * Based on the work of W. Richard Stevens, Advanced Programming in
+ *   the Unix Environment," Addison-Wesley; and of Floyd Davidson. 
+ *
+ * Contains these functions:
+ *
+ *  To set the TTY mode:
+ *     tty_set_raw() Unix setup to read a character at a time.
+ *     tty_set_cooked() Unix setup to reverse tty_set_raw()
+ *
+ *  To read keyboard input:
+ *     kb_getc()      keyboard get character, NON-BLOCKING. If a char
+ *                      has been typed, return it. Else return 0.
+ *     kb_getc_w()    kb get char with wait: BLOCKING. Wait for a char
+ *                      to be typed and return it.
+ *
+ *  How to use:
+ *     tty_set_raw()  set the TTY mode to read one char at a time.
+ *     kb_getc()      read chars one by one.
+ *     tty_set_cooked() VERY IMPORTANT: restore cooked mode when done.
+ *
+ * Revision History:
+ *
+ *     DATE                  DESCRIPTION
+ * -----------    --------------------------------------------
+ * 12-jan-2002     new
+ * 20-aug-2002     cleanup
+ *
+ *************************************************************************** */
+
+#ifdef __cplusplus
+  extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <termios.h>
+#include <unistd.h>
+#include <errno.h>
+
+#ifndef STDIN_FILENO
+  #define STDIN_FILENO 0
+#endif
+
+extern int errno;                 
+
+static struct termios termattr, save_termattr;
+static int ttysavefd = -1;
+static enum 
+{ 
+  RESET, RAW, CBREAK 
+} ttystate = RESET;
+
+/* ***************************************************************************
+ *
+ * set_tty_raw(), put the user's TTY in one-character-at-a-time mode.
+ * returns 0 on success, -1 on failure.
+ *
+ *************************************************************************** */
+int
+set_tty_raw(void) 
+{
+  int i;
+
+  i = tcgetattr (STDIN_FILENO, &termattr);
+  if (i < 0) 
+  {
+    printf("tcgetattr() returned %d for fildes=%d\n",i,STDIN_FILENO); 
+    perror ("");
+    return -1;
+  }
+  save_termattr = termattr;
+
+  termattr.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
+  termattr.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+  termattr.c_cflag &= ~(CSIZE | PARENB);
+  termattr.c_cflag |= CS8;
+  termattr.c_oflag &= ~(OPOST);
+   
+  termattr.c_cc[VMIN] = 1;
+  termattr.c_cc[VTIME] = 0;
+
+  i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
+  if (i < 0) 
+  {
+    printf("tcsetattr() returned %d for fildes=%d\n",i,STDIN_FILENO); 
+    perror("");
+    return -1;
+  }
+   
+  ttystate = RAW;
+  ttysavefd = STDIN_FILENO;
+
+  return 0;
+}
+
+/* ***************************************************************************
+ *
+ * set_tty_cbreak(), put the user's TTY in cbreak mode.
+ * returns 0 on success, -1 on failure.
+ *
+ *************************************************************************** */
+int 
+set_tty_cbreak() 
+{
+  int i;
+
+  i = tcgetattr (STDIN_FILENO, &termattr);
+  if (i < 0) 
+  {
+    printf("tcgetattr() returned %d for fildes=%d\n",i,STDIN_FILENO); 
+    perror ("");
+    return -1;
+  }
+
+  save_termattr = termattr;
+
+  termattr.c_lflag &= ~(ECHO | ICANON);
+  termattr.c_cc[VMIN] = 1;
+  termattr.c_cc[VTIME] = 0;
+      
+  i = tcsetattr (STDIN_FILENO, TCSANOW, &termattr);
+  if (i < 0) 
+  {
+    printf("tcsetattr() returned %d for fildes=%d\n",i,STDIN_FILENO); 
+    perror ("");
+    return -1;
+  }
+  ttystate = CBREAK;
+  ttysavefd = STDIN_FILENO;
+
+  return 0;
+}
+
+/* ***************************************************************************
+ *
+ * set_tty_cooked(), restore normal TTY mode. Very important to call
+ *   the function before exiting else the TTY won't be too usable.
+ * returns 0 on success, -1 on failure.
+ *
+ *************************************************************************** */
+int
+set_tty_cooked() 
+{
+  int i;
+  if (ttystate != CBREAK && ttystate != RAW) 
+  {
+    return 0;
+  }
+  i = tcsetattr (STDIN_FILENO, TCSAFLUSH, &save_termattr);
+  if (i < 0) 
+  {
+    return -1;
+  }
+  ttystate = RESET;
+  return 0;
+}
+
+/* ***************************************************************************
+ *
+ * kb_getc(), if there's a typed character waiting to be read,
+ *   return it; else return 0.
+ *
+ *************************************************************************** */
+unsigned char
+kb_getc(void) 
+{
+  unsigned char ch;
+  ssize_t size;
+
+  size = read (STDIN_FILENO, &ch, 1);
+  if (size == 0)
+  {
+    return 0;
+  }
+  else
+  {
+    return ch;
+  }
+}
+
+/* ***************************************************************************
+ *
+ * kb_getc_w(), wait for a character to be typed and return it.
+ *
+ *************************************************************************** */
+unsigned char
+kb_getc_w(void) 
+{
+  unsigned char ch;
+  size_t size;
+
+  while (1)
+  {
+
+    usleep(20000);        /* 1/50th second: thanks, Floyd! */
+
+    size = read (STDIN_FILENO, &ch, 1);
+    if (size > 0)
+    {
+      break;
+    }
+  }
+  return ch;
+}
+
+
+#define TEST
+#ifdef TEST
+
+void echo(unsigned char ch);
+
+static enum 
+{ 
+  CH_ONLY, CH_HEX 
+} how_echo = CH_ONLY;
+
+int 
+main(int argc, char * argv[])
+{
+  unsigned char ch;
+
+  printf("Test Unix single-character input.\n");
+
+  set_tty_raw();         /* set up character-at-a-time */
+  
+  while (1)              /* wait here for a typed char */
+  {
+    usleep(20000);       /* 1/50th second: thanks, Floyd! */
+    ch = kb_getc();      /* char typed by user? */
+    if (0x03 == ch)      /* might be control-C */
+    {
+      set_tty_cooked();  /* control-C, restore normal TTY mode */
+      return 1;          /* and get out */
+    }
+    echo(ch);            /* not control-C, echo it */
+  }
+}
+
+void
+echo(unsigned char ch)
+{
+  switch (how_echo)
+  {
+  case CH_HEX:
+    printf("%c,0x%x  ",ch,ch);
+    break;
+  default:
+  case CH_ONLY:
+    printf("%c", ch);
+    break;
+  }
+
+  fflush(stdout);      /* push it out */
+}
+
+#endif /* test */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+

dev/misc/listdate.c

@@ -0,0 +1,124 @@
+/*
+ * 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 <string.h>
+#include <ctype.h>
+#include <osbind.h>
+#include <time.h>
+#define ENDOFSTR ('\0')
+const char* cdp_version = "7.1.0";
+
+int main(int argc, char *argv[]) {
+//TW UPDATE
+	unsigned long tickdur = 0, start = hz1000();
+	time_t now = time(0);
+	char *q, *p, *z, temp[64];
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(now < 0)
+		return 0;
+	z = temp;
+	z = ctime((const time_t *)&now);
+	p = z;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+
+	q = p;
+	while(!isspace(*p))
+		p++;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;
+    
+	strcpy(temp,q);	/* Aug */
+	p++;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;
+    // RWD  if just one digit, addd leading zero for Mac and Linux Windows-style - expected by Soundloom
+#ifndef WIN32
+    if(strlen(q)==1){
+        strcat(temp,"0");
+    }
+#endif
+	strcat(temp,q);	/* Aug25 */
+	strcat(temp,"_");	/* Aug25_ */
+	p++;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+
+	q = p;
+	while(*p != ':')
+		p++;
+	*p = ENDOFSTR;
+	strcat(temp,q);	/* Aug25_10 */
+	strcat(temp,"-");	/* Aug25_10- */
+	p++;
+	q = p;
+	while(*p != ':')
+		p++;
+	*p = ENDOFSTR;
+	strcat(temp,q);	/* Aug25_10- */
+	strcat(temp,"-");	/* Aug25_10-10- */
+	p++;
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;
+	strcat(temp,q);	/* Aug25_10-10- */
+	strcat(temp,".");	/* Aug25_10-10-53. */
+	p++;
+	q = p;
+	while(isspace(*p))
+		p++;
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;	
+	strcat(temp,q);	/* Wed_Aug25_10_10_53.1999 */
+	fprintf(stdout,"%s",temp);
+	fflush(stdout);
+//TW UPDATE: waiting
+	while(tickdur == 0)
+		tickdur = hz1000() - start;
+	return 0;
+}
+

dev/misc/logdate.c

@@ -0,0 +1,111 @@
+/*
+ * 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 <string.h>
+#include <ctype.h>
+#include <osbind.h>
+#include <time.h>
+#define ENDOFSTR ('\0')
+const char* cdp_version = "7.1.0";
+
+int main(int argc, char *argv[]) {
+//TW UPDATE
+	unsigned long tickdur = 0, start = hz1000();
+	time_t now = time(0);
+	char *q, *p, *z, temp[64], temp2[64];
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(now < 0)
+		return 0;
+	z = temp;
+	z = ctime((const time_t *)&now);
+	p = z;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+
+	q = p;
+	while(!isspace(*p))
+		p++;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;
+	strcpy(temp2,q);	/* Aug */
+	p++;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;
+	strcat(temp2,q);	/* Aug25 */
+	strcat(temp2,"_");	/* Aug25_ */
+	p++;
+
+	while(isspace(*p))	/* SAFETY */
+		p++;
+
+	q = p;
+	while(*p != ':')
+		p++;
+	*p = ENDOFSTR;
+	strcat(temp2,q);	/* Aug25_10 */
+	strcat(temp2,"-");	/* Aug25_10_ */
+	p++;
+	q = p;
+	while(*p != ':')
+		p++;
+	*p = ENDOFSTR;
+	strcat(temp2,q);	/* Aug25_10_10 */
+	strcat(temp2,".");	/* Aug25_10_10. */
+	p++;
+	while(!isspace(*p))
+		p++;
+	while(isspace(*p))
+		p++;
+	q = p;
+	while(!isspace(*p))
+		p++;
+	*p = ENDOFSTR;	
+	strcat(temp2,q);	/* Wed_Aug25_10_10.1999 */
+	fprintf(stdout,"%s",temp2);
+	fflush(stdout);
+//TW UPDATE: wait
+	while (tickdur == 0)
+		tickdur = hz1000() - start;
+	return 0;
+}
+

dev/misc/maxsamp2.c

@@ -0,0 +1,461 @@
+/*
+ * Copyright (c) 1983-2020 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
+ *
+ */
+
+
+
+/**************************************************************************
+
+                MAXSAMP2.C
+
+    usage   maxsamp2 infile
+
+    Finds the maximum sample of a file and writes it to the header.
+
+    Based on maxsamp in CDPARSE
+
+**************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <osbind.h>
+#include <math.h>
+#include <float.h>
+#include <float.h>
+#include <sfsys.h>
+#include <cdplib.h>
+
+/*static void   usage(void);*/
+static void report(void);
+static int  tidy_up(int);
+static void min_sec(int,int,int*,double*);
+static void find_fmax(float*,int,int);
+static int  try_header(int);
+static int  open_in(char*,int);
+static int  get_big_buf(void);
+static int  get_max_samp(int,int);
+static int  smpflteq(double f1,double f2);
+static void force_new_header(void);
+
+float *bigfbuf; /* buffer used to read samples from soundfile   */
+
+size_t buflen;  /* buffer length in samps (eventually) */
+int ifd;    /* input soundfile descriptor           */
+int srate = 44100;  /* sampling rate of input       */
+int channels = 2;   /* number of channels of input      */
+
+double maxpdamp = DBL_MIN;  /* value of maximum negative sample */
+double maxndamp = DBL_MAX;  /* value of maximum positive sample */
+float maxpfamp;     /* float value of maximum positive sample   */
+float maxnfamp;     /* float value of maximum negative sample   */
+double maxdamp  = 0.0;  /* value of maximum sample          */
+
+int maxloc = 0; /* location of maximum sample       */
+int repeats = 1;    /* counts how many times the maximum repeats */
+int pos_repeats = 0;
+int neg_repeats = 0;
+int in_header = 0;
+
+unsigned int maxnloc, maxploc;
+unsigned int *maxcnloc, *maxcploc;
+double *maxcpdamp, *maxcndamp;
+int *posreps, *negreps;
+const char* cdp_version = "7.1.0";
+
+int open_in(char *name,int force_read)      /* opens input soundfile and gets header */
+{
+    int is_sound = 0;
+    SFPROPS props = {0};
+    int open_type;
+    if(force_read)
+        open_type = CDP_OPEN_RDWR;
+    else 
+        open_type = CDP_OPEN_RDONLY;
+    if( (ifd = sndopenEx(name,0,open_type)) < 0 )   {
+        fprintf(stdout,"INFO: Cannot open file: %s\n\t",name);
+        fflush(stdout);
+        return(-1);
+    }
+    if(!snd_headread(ifd,&props)) {
+        fprintf(stdout,"Failure to read sample size\n");
+        fflush(stdout);
+        return(-1);
+    }
+    if(props.type != 0) {
+        fprintf(stdout,"Not a soundfile\n");
+        fflush(stdout);
+        return(-1);
+    }
+    srate = props.srate;
+    channels = props.chans;
+
+    return(is_sound);
+}
+
+int get_big_buf(void)   /* allocates memory for the biggest possible buffer */
+{
+    size_t i;
+
+    buflen = (size_t) Malloc(-1) - sizeof(float);
+
+    /* if less than one sector available */
+    if( buflen < SECSIZE || ((bigfbuf=(float*)Malloc(buflen+sizeof(float))) == NULL)) {
+        fprintf(stdout,"ERROR: Failed to allocate float buffer.\n");
+        fflush(stdout);
+        return 0;
+    }
+    i = ((size_t)bigfbuf+sizeof(float)-1)/sizeof(float)*sizeof(float);  /* align bigbuf to word boundary */
+    bigfbuf = (float*)i;
+
+    buflen /= sizeof(float);
+    buflen = (buflen/channels) * channels;      /* align buflen to channel boundaries */
+    if(buflen <= 0) {
+        fprintf(stdout,"ERROR: Failed to allocate float buffer.\n");
+        fflush(stdout);
+        return 0;
+    }
+    return 1;
+}
+
+int get_max_samp(int ifd,int force_read)
+{
+    int got;
+    int totalsamps = 0;
+    int mins;
+    double sec;
+    int total_got = 0;
+    int j;
+
+    switch(force_read) {
+    case(0):
+        if(try_header(ifd) >= 0)    //  No forcing: "try_header" succeeds. Maxsamp can be >0 or 0
+            return(0);
+        break;
+    case(2):
+        if(try_header(ifd) > 0)     //  "try_header" succeeds. Maxsamp can be >0 but NOT 0
+            return(0);              //  if maxsamp is 0, searching for maxsamp is forced
+        force_read = 1;
+        break;
+        /* else if info is not in header */
+    }
+    /* read and find maximum */
+    while( (got = fgetfbufEx(bigfbuf,(int) buflen,ifd,0)) > 0 ) {
+        total_got += got;
+        find_fmax(bigfbuf,got,totalsamps);
+        totalsamps += got;
+    }
+    if( got < 0 ) {
+        min_sec((int)(totalsamps/channels),srate,&mins,&sec);
+        fprintf(stdout,"ERROR: An error has occured. The current Location is:\t %d min %6.3lf sec\n",mins,sec);
+        fprintf(stdout,"ERROR: The maximum sample found so far is: %lf\n",maxdamp);
+        fflush(stdout);
+        return(-1);
+    }
+    maxpdamp = maxcpdamp[0];
+    maxndamp = maxcndamp[0];
+    maxploc  = maxcploc[0];
+    maxnloc  = maxcnloc[0];
+    pos_repeats = posreps[0];
+    neg_repeats = negreps[0];
+    for(j=1;j < channels; j++) {
+        if(maxcpdamp[j] > maxpdamp) {
+            maxpdamp = maxcpdamp[j];
+            maxploc  = maxcploc[j];
+            pos_repeats = posreps[j];
+        } else if (maxcpdamp[j] < maxpdamp)
+            ;
+        else if(maxcploc[j] < maxploc)  // equal +ve vals
+            maxploc = maxcploc[j];
+        if(maxcndamp[j] < maxndamp) {
+            maxndamp = maxcndamp[j];
+            maxnloc  = maxcnloc[j];
+            neg_repeats = negreps[j];
+        } else if (maxcndamp[j] > maxndamp)
+            ;
+        else if(maxcnloc[j] < maxnloc)  // equal -ve vals
+            maxnloc = maxcnloc[j];
+    }
+    maxpfamp = (float)maxpdamp;
+    maxnfamp = (float)maxndamp;
+    if(maxpdamp > -maxndamp)
+        maxdamp = maxpdamp;
+    else
+        maxdamp = fabs(maxndamp);
+    return(0);
+}
+
+void
+report(void)
+{
+    int mins, maxchan = 0;
+    double sec;
+    if (!in_header && !pos_repeats && !neg_repeats) {
+        fprintf(stdout,"INFO: All samples are zero.\n");
+        fflush(stdout);
+        return;
+    }
+    if(in_header) {
+        fprintf(stdout,"KEEP: %lf %d %d\n",maxdamp,maxloc,-1);
+    } else {
+        if(maxpdamp > -maxndamp) {
+            maxloc = maxploc;
+            repeats = pos_repeats;
+        } else if(maxpdamp < -maxndamp) {
+            maxloc = maxnloc;
+            repeats = neg_repeats;
+        } else {
+            maxloc  = min(maxploc,maxnloc);
+            repeats = neg_repeats + pos_repeats;
+        }
+        maxchan = (maxloc % channels)+1;
+        maxloc /= channels;
+        fprintf(stdout,"KEEP: %lf %d %d\n",maxdamp,maxloc,repeats);
+        if(pos_repeats)
+            fprintf(stdout,"INFO: Maximum positive sample:      %f\n",maxpfamp);
+        if(neg_repeats)
+            fprintf(stdout,"INFO: Maximum negative sample:      %f\n",maxnfamp);
+    }
+    fprintf(stdout,"INFO: Maximum ABSOLUTE sample:      %lf\n",maxdamp);
+    min_sec(maxloc,srate,&mins,&sec);
+    if(maxchan > 0)
+        fprintf(stdout,"INFO: Location of maximum sample:   %d min %7.4lf sec: chan %d\n",mins,sec,maxchan);
+    else
+        fprintf(stdout,"INFO: Location of maximum sample:   %d min %7.4lf sec\n",mins,sec);
+    if(!in_header) {
+        fprintf(stdout,"INFO: Number of times found:        %-d\n",repeats);
+    }
+    fprintf(stdout,"INFO: Maximum possible dB gain:     %-7.3lf\n",20.0*log10(1.0/maxdamp));
+    fprintf(stdout,"INFO: Maximum possible gain factor: %-9.3lf\n",1.0/maxdamp);
+    fflush(stdout);
+}
+    
+int tidy_up(int where)
+{
+    switch(where)
+    {
+    case 0:
+        Mfree(bigfbuf);
+    case 1:
+        sndcloseEx(ifd);
+    case 2:
+//       sffinish();
+    default:
+        break;
+    }
+    return(1);
+}
+    
+int main(int argc,char *argv[])
+{
+    int force_read = 0, j;
+    /*TICK */  // unsigned int time;
+    int is_sound;
+    /* get current time */
+//    time = hz200();
+
+    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if(argc == 3) {
+        if(sscanf(argv[2],"%d",&force_read) != 1) {
+            fprintf(stdout,"ERROR: bad 2nd parameter.\n");
+            fflush(stdout);
+            return tidy_up(3);
+        }
+        if(force_read < 1 || force_read > 2) {
+            fprintf(stdout,"ERROR: bad 2nd parameter.\n");
+            fflush(stdout);
+            return tidy_up(3);
+        }
+        argc--;
+    }
+    if(argc !=2) {
+        fprintf(stdout,"ERROR: wrong number of arguments.\n");
+        fflush(stdout);
+        return tidy_up(3);
+    }
+
+    /* initialise SFSYS */
+    if( sflinit("maxsamp2") < 0 )
+    {
+        fprintf(stdout,"ERROR: Cannot initialise soundfile system.\n");
+        fflush(stdout);
+        return tidy_up(3);
+    }
+
+    /* open input file */
+    if((is_sound = open_in(argv[1],force_read)) < 0)
+        return tidy_up(2);
+    /* get biggest buffer */
+    if(get_big_buf() == 0)
+        return tidy_up(1);
+
+    if((maxcploc = (unsigned int *)malloc(channels * sizeof(unsigned int))) == NULL)
+        return tidy_up(0);
+    if((maxcnloc = (unsigned int *)malloc(channels * sizeof(unsigned int))) == NULL)
+        return tidy_up(0);
+    if((maxcpdamp = (double *)malloc(channels * sizeof(double))) == NULL)
+        return tidy_up(0);
+    if((maxcndamp = (double *)malloc(channels * sizeof(double))) == NULL)
+        return tidy_up(0);
+    if((posreps = (int *)malloc(channels * sizeof(int))) == NULL)
+        return tidy_up(0);
+    if((negreps = (int *)malloc(channels * sizeof(int))) == NULL)
+        return tidy_up(0);
+    for(j=0;j<channels;j++) {
+        maxcploc[j] = 0;
+        maxcnloc[j] = 0;
+        maxcpdamp[j] = DBL_MIN;
+        maxcndamp[j] = DBL_MAX;
+        posreps[j] = 0;
+        negreps[j] = 0;
+
+    }
+
+    /* max soundfiles */
+    get_max_samp(ifd,force_read);
+
+    /* send report */
+    if(force_read)
+        force_new_header();
+    report();
+
+    /* tidy up */
+    return tidy_up(0);
+}
+
+/* converts samples into minutes and seconds */
+
+void min_sec(int value,int srate,int *mins,double *secs)
+{
+    *secs = (double)value/srate;
+    
+    *mins = (int)floor(*secs/60);
+    *secs -= *mins*60;
+}
+
+/**************************** SMPFLTEQ *******************************/
+#define SMP_FLTERR 0.0000005
+
+int smpflteq(double f1,double f2)
+{
+    double upperbnd, lowerbnd;
+    upperbnd = f2 + SMP_FLTERR;
+    lowerbnd = f2 - SMP_FLTERR;
+    if((f1>upperbnd) || (f1<lowerbnd))
+        return(0);
+    return(1);
+}
+
+/**************************** TRY_HEADER ****************************
+ *
+ * checks if maxsamp information is in header
+ */
+
+int try_header(int ifd)
+{
+    int j;
+    CHPEAK *peakdata;
+    int peaktime;
+    maxloc = sndsizeEx(ifd);
+
+    if((peakdata = (CHPEAK *)malloc(channels * sizeof(CHPEAK)))==NULL) {
+        return -1;
+    }
+    if(sndreadpeaks(ifd,channels,peakdata,&peaktime) < 0)
+        return -1;
+    for(j=0;j<channels;j++) {
+        if(peakdata[j].value > maxdamp) {
+            maxdamp = peakdata[j].value;
+            maxloc  = peakdata[j].position;
+        } else if(!(peakdata[j].value < maxdamp)) { /* i.e. equal values */
+            maxloc  = min(peakdata[j].position,(unsigned int)maxloc);
+        }
+    }
+    if(maxdamp == 0.0) {
+        maxloc = 0;
+        return 0;
+    }
+    in_header = 1;
+    return 1;
+}       
+
+void find_fmax(float *buffer,int samps,int totalsamps)
+{
+    int i, j;
+
+    for(j=0;j < channels; j++) {
+        maxpdamp = 0.0;
+        maxndamp = 0.0;
+        for( i=j ; i<samps ; i+=channels ) {
+            if(maxcpdamp[j] > 0.0 && smpflteq(buffer[i],maxcpdamp[j]))
+                posreps[j]++;
+            else if(maxcndamp[j] < 0.0 && smpflteq(buffer[i],maxcndamp[j]))
+                negreps[j]++;
+            else if( buffer[i] > maxcpdamp[j]) {
+                maxcpdamp[j] = buffer[i];
+                posreps[j] = 1;
+                maxcploc[j] = totalsamps + i;
+            } else if ( buffer[i] < maxcndamp[j] ) {
+                maxcndamp[j] = buffer[i];
+                negreps[j] = 1;
+                maxcnloc[j] = totalsamps + i;
+            }
+        }
+    }
+}
+
+void force_new_header(void) {
+    int j;
+    unsigned int maxp;
+    double maxv;
+    CHPEAK *peakdata;
+    if((peakdata = (CHPEAK *)malloc(channels * sizeof(CHPEAK)))==NULL) {
+        return;
+    }
+    for(j=0;j<channels;j++) {
+        if(-maxcpdamp[j] < maxcndamp[j]) {
+            maxv = maxcpdamp[j];
+            maxp = maxcploc[j];
+        } else if(-maxcpdamp[j] > maxcndamp[j]) {
+            maxv = maxcndamp[j];
+            maxp = maxcnloc[j];
+        } else {    // equal
+            if(maxcnloc[j] < maxcploc[j]) {
+                maxv = maxcndamp[j];
+                maxp = maxcnloc[j];
+            } else {
+                maxv = maxcpdamp[j];
+                maxp = maxcploc[j];
+            }
+        }
+        peakdata[j].value    = (float)maxv;
+        peakdata[j].position = maxp;
+    }
+    if(sndputpeaks(ifd,channels,peakdata)<0) {
+        fprintf(stderr,"NO HEADER WRITE: %s\n",sferrstr());
+    }
+}

dev/misc/mxfft.c

@@ -0,0 +1,804 @@
+/*
+ * 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 <globcon.h>
+#include <pvoc.h>
+#include <math.h>			/*RWD*/
+
+int fft_(),fftmx(),reals_();
+
+/*
+ *-----------------------------------------------------------------------
+ * subroutine:  fft
+ * multivariate complex fourier transform, computed in place
+ * using mixed-radix fast fourier transform algorithm.
+ *-----------------------------------------------------------------------
+ *
+ *	this is the call from C:
+ *		fft_(anal,banal,&one,&N2,&one,&mtwo);
+ *	CHANGED TO:-
+ *		fft_(anal,banal,one,N2,one,mtwo);
+ */
+
+int fft_(float *a, float *b, int nseg, int n, int nspn, int isn)
+		/*  a: pointer to array 'anal'  */
+		/*  b: pointer to array 'banal' */
+{
+	int exit_status;
+	int nfac[16];		/*  These are one bigger than needed   */
+						/*  because wish to use Fortran array  */
+						/* index which runs 1 to n, not 0 to n */
+
+	int 	m = 0, nf, k, kt, ntot, j, jj, maxf, maxp = 0;
+
+/* work space pointers */
+	float	*at, *ck, *bt, *sk;
+	int		*np;
+
+
+/* reduce the pointers to input arrays - by doing this, FFT uses FORTRAN
+   indexing but retains compatibility with C arrays */
+	a--;	b--;
+
+/*	
+ * determine the factors of n
+ */
+	k=nf=abs(n);
+   	if(nf==1) 
+		return(FINISHED);
+
+	nspn=abs(nf*nspn);
+	ntot=abs(nspn*nseg);
+
+	if(isn*ntot == 0){
+		sprintf(errstr,"zero in FFT parameters %d %d %d %d",nseg, n, nspn, isn);
+		return(DATA_ERROR);
+	}
+	for (m=0; !(k%16); nfac[++m]=4,k/=16);
+	for (j=3,jj=9; jj<=k; j+=2,jj=j*j)
+		for (; !(k%jj); nfac[++m]=j,k/=jj);
+
+      	if (k<=4){
+	      	kt = m;
+	      	nfac[m+1] = k;
+	      	if(k != 1) 
+			m++;
+	}
+	else{
+		if(k%4==0){
+		nfac[++m]=2;
+		k/=4;
+		}
+
+	 	kt = m;
+	       	maxp = max((kt+kt+2),(k-1));
+		for(j=2; j<=k; j=1+((j+1)/2)*2)
+			if(k%j==0){
+				nfac[++m]=j;
+				k/=j;
+			}
+	}
+	if(m <= kt+1) 
+		maxp = m + kt + 1;
+      	if(m+kt > 15) {
+			sprintf(errstr,"FFT parameter n has more than 15 factors : %d", n);
+	    	return(DATA_ERROR);
+	}
+      	if(kt!=0){
+	      	j = kt;
+		while(j)
+			nfac[++m]=nfac[j--];
+	}
+	maxf = nfac[m-kt];
+      	if(kt > 0) 
+		maxf = max(nfac[kt],maxf);
+
+/*  allocate workspace - assume no errors! */
+	at = (float *) calloc(maxf,sizeof(float));
+	ck = (float *) calloc(maxf,sizeof(float));
+	bt = (float *) calloc(maxf,sizeof(float));
+	sk = (float *) calloc(maxf,sizeof(float));
+	np = (int *) calloc(maxp,sizeof(int));
+
+/* decrement pointers to allow FORTRAN type usage in fftmx */
+	at--;	bt--;	ck--;	sk--;	np--;
+
+/* call fft driver */
+
+	if((exit_status = fftmx(a,b,ntot,nf,nspn,isn,m,&kt,at,ck,bt,sk,np,nfac))<0)
+		return(exit_status);
+
+/* restore pointers before releasing */
+	at++;	bt++;	ck++;	sk++;	np++;
+
+/* release working storage before returning - assume no problems */
+	(void) free(at);
+	(void) free(sk);
+	(void) free(bt);
+	(void) free(ck);
+	(void) free(np);
+    return(FINISHED);
+}
+
+/*
+ *-----------------------------------------------------------------------
+ * subroutine:  fftmx
+ * called by subroutine 'fft' to compute mixed-radix fourier transform
+ *-----------------------------------------------------------------------
+ */
+int fftmx(float *a,float *b,int ntot,int n,int nspan,int isn,int m,int *kt,
+			float *at,float *ck,float *bt,float *sk,int *np,int nfac[])
+{	
+	int	i,inc,
+		j,jc,jf, jj,
+		k, k1, k2, k3=0, k4,
+		kk,klim,ks,kspan, kspnn,
+		lim,
+		maxf,mm,
+		nn,nt;
+	double  aa, aj, ajm, ajp, ak, akm, akp,
+		bb, bj, bjm, bjp, bk, bkm, bkp,
+		c1, c2=0.0, c3=0.0, c72, cd,
+		dr,
+		rad, 
+		sd, s1, s2=0.0, s3 = 0.0, s72, s120;
+
+	double	xx;	/****** ADDED APRIL 1991 *********/
+	inc=abs(isn);
+	nt = inc*ntot;
+      	ks = inc*nspan;
+/******************* REPLACED MARCH 29: ***********************
+					rad = atan((double)1.0);
+**************************************************************/
+	rad = 0.785398163397448278900;
+/******************* REPLACED MARCH 29: ***********************
+			      		s72 = rad/0.625;
+			      		c72 = cos(s72);
+				      	s72 = sin(s72);
+**************************************************************/
+	c72 = 0.309016994374947451270;
+	s72 = 0.951056516295153531190;
+/******************* REPLACED MARCH 29: ***********************
+			      		s120 = sqrt((double)0.75);
+**************************************************************/
+      	s120 = 0.866025403784438707600;
+
+/* scale by 1/n for isn > 0 ( reverse transform ) */
+
+      	if (isn < 0){
+	      	s72 = -s72;
+	      	s120 = -s120;
+	      	rad = -rad;}
+	else{	ak = 1.0/(double)n;
+		for(j=1; j<=nt;j += inc){
+	        	a[j] = (float)(a[j] * ak);
+	        	b[j] = (float)(b[j] * ak);
+		}
+	}
+	kspan = ks;
+      	nn = nt - inc;
+      	jc = ks/n;
+
+/* sin, cos values are re-initialized each lim steps  */
+
+      	lim = 32;
+      	klim = lim * jc;
+      	i = 0;
+      	jf = 0;
+      	maxf = m - (*kt);
+      	maxf = nfac[maxf];
+      	if((*kt) > 0) 
+		maxf = max(nfac[*kt],maxf);
+
+/*
+ * compute fourier transform
+ */
+
+lbl40:
+	dr = (8.0 * (double)jc)/((double)kspan);
+/*************************** APRIL 1991 POW & POW2 not WORKING.. REPLACE *******
+	  	    cd = 2.0 * (pow2 ( sin((double)0.5 * dr * rad)) );
+*******************************************************************************/
+	xx =  sin((double)0.5 * dr * rad);
+      	cd = 2.0 * xx * xx;
+      	sd = sin(dr * rad);
+      	kk = 1;
+      	if(nfac[++i]!=2) goto lbl110;
+/*
+ * transform for factor of 2 (including rotation factor)
+ */
+      	kspan /= 2;
+      	k1 = kspan + 2;
+		do{	do{	k2 = kk + kspan;
+		      	ak = a[k2];
+		      	bk = b[k2];
+		      	a[k2] = (float)((a[kk]) - ak);
+		      	b[k2] = (float)((b[kk]) - bk);
+		      	a[kk] = (float)((a[kk]) + ak);
+		      	b[kk] = (float)((b[kk]) + bk);
+		      	kk = k2 + kspan;
+		} while(kk <= nn);
+	      	kk -= nn;
+	}while(kk <= jc);
+      	if(kk > kspan) goto lbl350;
+lbl60:  c1 = 1.0 - cd;
+      	s1 = sd;
+      	mm = min((k1/2),klim);
+      	goto lbl80;
+lbl70:	ak = c1 - ((cd*c1)+(sd*s1));
+      	s1 = ((sd*c1)-(cd*s1)) + s1;
+      	c1 = ak;
+lbl80:	do{	do{	k2 = kk + kspan;
+		      	ak = a[kk] - a[k2];
+		      	bk = b[kk] - b[k2];
+		      	a[kk] = a[kk] + a[k2];
+		      	b[kk] = b[kk] + b[k2];
+		      	a[k2] = (float)((c1 * ak) - (s1 * bk));
+		      	b[k2] = (float)((s1 * ak) + (c1 * bk));
+		      	kk = k2 + kspan;
+		}while(kk < nt);
+	      	k2 = kk - nt;
+	      	c1 = -c1;
+	      	kk = k1 - k2;
+	}while(kk > k2);
+      	kk += jc;
+      	if(kk <= mm) goto lbl70;
+      	if(kk < k2)  goto lbl90;
+      	k1 += (inc + inc);
+      	kk = ((k1-kspan)/2) + jc;
+      	if(kk <= (jc+jc)) goto lbl60;
+      	goto lbl40;
+lbl90: 	s1 = ((double)((kk-1)/jc)) * dr * rad;
+      	c1 = cos(s1);
+      	s1 = sin(s1);
+      	mm = min( k1/2, mm+klim);
+      	goto lbl80;
+/*
+ * transform for factor of 3 (optional code)
+ */
+
+
+lbl100:	k1 = kk + kspan;
+	k2 = k1 + kspan;
+	ak = a[kk];
+	bk = b[kk];
+      	aj = a[k1] + a[k2];
+      	bj = b[k1] + b[k2];
+      	a[kk] = (float)(ak + aj);
+      	b[kk] = (float)(bk + bj);
+      	ak += (-0.5 * aj);
+      	bk += (-0.5 * bj);
+      	aj = (a[k1] - a[k2]) * s120;
+      	bj = (b[k1] - b[k2]) * s120;
+      	a[k1] = (float)(ak - bj);
+      	b[k1] = (float)(bk + aj);
+      	a[k2] = (float)(ak + bj);
+      	b[k2] = (float)(bk - aj);
+      	kk = k2 + kspan;
+      	if(kk < nn)     goto lbl100;
+      	kk -= nn;
+      	if(kk <= kspan) goto lbl100;
+      	goto lbl290;
+
+/*
+ * transform for factor of 4
+ */
+
+lbl110:	if(nfac[i] != 4) goto lbl230;
+      	kspnn = kspan;
+      	kspan = kspan/4;
+lbl120:	c1 = 1.0;
+      	s1 = 0;
+      	mm = min( kspan, klim);
+      	goto lbl150;
+lbl130:	c2 = c1 - ((cd*c1)+(sd*s1));
+      	s1 = ((sd*c1)-(cd*s1)) + s1;
+/*
+ * the following three statements compensate for truncation
+ * error.  if rounded arithmetic is used, substitute
+ * c1=c2
+ *
+ * c1 = (0.5/(pow2(c2)+pow2(s1))) + 0.5;
+ * s1 = c1*s1;
+ * c1 = c1*c2;
+ */
+      	c1 = c2;
+lbl140:	c2 = (c1 * c1) - (s1 * s1);
+      	s2 = c1 * s1 * 2.0;
+      	c3 = (c2 * c1) - (s2 * s1);
+      	s3 = (c2 * s1) + (s2 * c1);
+lbl150:	k1 = kk + kspan;
+      	k2 = k1 + kspan;
+      	k3 = k2 + kspan;
+      	akp = a[kk] + a[k2];
+      	akm = a[kk] - a[k2];
+      	ajp = a[k1] + a[k3];
+      	ajm = a[k1] - a[k3];
+      	a[kk] = (float)(akp + ajp);
+       	ajp = akp - ajp;
+      	bkp = b[kk] + b[k2];
+      	bkm = b[kk] - b[k2];
+      	bjp = b[k1] + b[k3];
+      	bjm = b[k1] - b[k3];
+      	b[kk] = (float)(bkp + bjp);
+      	bjp = (float)(bkp - bjp);
+      	if(isn < 0) goto lbl180;
+      	akp = akm - bjm;
+      	akm = akm + bjm;
+      	bkp = bkm + ajm;
+      	bkm = bkm - ajm;
+      	if(s1 == 0.0) goto lbl190;
+lbl160:	a[k1] = (float)((akp*c1) - (bkp*s1));
+      	b[k1] = (float)((akp*s1) + (bkp*c1));
+      	a[k2] = (float)((ajp*c2) - (bjp*s2));
+      	b[k2] = (float)((ajp*s2) + (bjp*c2));
+      	a[k3] = (float)((akm*c3) - (bkm*s3));
+      	b[k3] = (float)((akm*s3) + (bkm*c3));
+      	kk = k3 + kspan;
+      	if(kk <= nt)   goto lbl150;
+lbl170: kk -= (nt - jc);
+      	if(kk <= mm)   goto lbl130;
+      	if(kk < kspan) goto lbl200;
+      	kk -= (kspan - inc);
+      	if(kk <= jc)   goto lbl120;
+      	if(kspan==jc)  goto lbl350;
+      	goto lbl40;
+lbl180:	akp = akm + bjm;
+      	akm = akm - bjm;
+      	bkp = bkm - ajm;
+      	bkm = bkm + ajm;
+      	if(s1 != 0.0)  goto lbl160;
+lbl190:	a[k1] = (float)akp;
+      	b[k1] = (float)bkp;
+      	a[k2] = (float)ajp;
+      	b[k2] = (float)bjp;
+      	a[k3] = (float)akm;
+      	b[k3] = (float)bkm;
+      	kk = k3 + kspan;
+      	if(kk <= nt) goto lbl150;
+      	goto lbl170;
+lbl200: s1 = ((double)((kk-1)/jc)) * dr * rad;
+      	c1 = cos(s1);
+      	s1 = sin(s1);
+      	mm = min( kspan, mm+klim);
+      	goto lbl140;
+
+/*
+ * transform for factor of 5 (optional code)
+ */
+
+lbl210:	c2 = (c72*c72) - (s72*s72);
+      	s2 = 2.0 * c72 * s72;
+lbl220:	k1 = kk + kspan;
+      	k2 = k1 + kspan;
+      	k3 = k2 + kspan;
+      	k4 = k3 + kspan;
+      	akp = a[k1] + a[k4];
+      	akm = a[k1] - a[k4];
+      	bkp = b[k1] + b[k4];
+      	bkm = b[k1] - b[k4];
+      	ajp = a[k2] + a[k3];
+      	ajm = a[k2] - a[k3];
+      	bjp = b[k2] + b[k3];
+      	bjm = b[k2] - b[k3];
+      	aa = a[kk];
+      	bb = b[kk];
+      	a[kk] = (float)(aa + akp + ajp);
+      	b[kk] = (float)(bb + bkp + bjp);
+      	ak = (akp*c72) + (ajp*c2) + aa;
+      	bk = (bkp*c72) + (bjp*c2) + bb;
+      	aj = (akm*s72) + (ajm*s2);
+      	bj = (bkm*s72) + (bjm*s2);
+      	a[k1] = (float)(ak - bj);
+      	a[k4] = (float)(ak + bj);
+      	b[k1] = (float)(bk + aj);
+      	b[k4] = (float)(bk - aj);
+      	ak = (akp*c2) + (ajp*c72) + aa;
+      	bk = (bkp*c2) + (bjp*c72) + bb;
+      	aj = (akm*s2) - (ajm*s72);
+	bj = (bkm*s2) - (bjm*s72);
+	a[k2] = (float)(ak - bj);
+      	a[k3] = (float)(ak + bj);
+      	b[k2] = (float)(bk + aj);
+      	b[k3] = (float)(bk - aj);
+      	kk = k4 + kspan;
+      	if(kk < nn)     goto lbl220;
+      	kk -= nn;
+      	if(kk <= kspan) goto lbl220;
+      	goto lbl290;
+
+/*
+ * transform for odd factors
+ */
+
+lbl230:	k = nfac[i];
+	kspnn = kspan;
+	kspan /= k;
+	if(k==3)   goto lbl100;
+	if(k==5)   goto lbl210;
+	if(k==jf)  goto lbl250;
+      	jf = k;
+      	s1 = rad/(((double)(k))/8.0);
+      	c1 = cos(s1);
+      	s1 = sin(s1);
+      	ck[jf] = 1.0f;
+	sk[jf] = 0.0f;
+	for(j=1; j<k ; j++){
+		ck[j] = (float)((ck[k])*c1 + (sk[k])*s1);
+	      	sk[j] = (float)((ck[k])*s1 - (sk[k])*c1);
+	      	k--;
+	      	ck[k] = ck[j];
+	      	sk[k] = -(sk[j]);
+	}
+lbl250:	k1 = kk;
+      	k2 = kk + kspnn;
+	aa = a[kk];
+	bb = b[kk];
+      	ak = aa;
+      	bk = bb;
+      	j = 1;
+      	k1 += kspan;
+		do{	k2 -= kspan;
+	      	j++;
+	      	at[j] = a[k1] + a[k2];
+	      	ak = at[j] + ak;	
+	      	bt[j] = b[k1] + b[k2];
+	      	bk = bt[j] + bk;	
+	      	j++;
+	      	at[j] = a[k1] - a[k2];
+	      	bt[j] = b[k1] - b[k2];
+	      	k1 += kspan;
+	}while(k1 < k2);
+      	a[kk] = (float)ak;
+      	b[kk] = (float)bk;
+      	k1 = kk;
+      	k2 = kk + kspnn;
+      	j = 1;
+lbl270:	k1 += kspan;
+      	k2 -= kspan;
+      	jj = j;
+      	ak = aa;
+      	bk = bb;
+      	aj = 0.0;
+      	bj = 0.0;
+      	k = 1;
+		do{	k++;
+	      	ak = (at[k] * ck[jj]) + ak;
+	      	bk = (bt[k] * ck[jj]) + bk;	
+	      	k++;
+	      	aj = (at[k] * sk[jj]) + aj;
+	      	bj = (bt[k] * sk[jj]) + bj;
+	      	jj += j;
+	      	if (jj > jf) 
+			jj -= jf;
+	}while(k < jf);
+      	k = jf - j;
+      	a[k1] = (float)(ak - bj);
+      	b[k1] = (float)(bk + aj);
+      	a[k2] = (float)(ak + bj);
+      	b[k2] = (float)(bk - aj);
+      	j++;
+      	if(j < k)     goto lbl270;
+      	kk += kspnn;
+      	if(kk <= nn)  goto lbl250;
+      	kk -= nn;
+      	if(kk<=kspan) goto lbl250;
+
+/*
+ * multiply by rotation factor (except for factors of 2 and 4)
+ */
+
+lbl290:	if(i==m) goto lbl350;
+      	kk = jc + 1;
+lbl300:	c2 = 1.0 - cd;
+      	s1 = sd;
+      	mm = min( kspan, klim);
+      	goto lbl320;
+lbl310:	c2 = c1 - ((cd*c1) + (sd*s1));
+      	s1 = s1 + ((sd*c1) - (cd*s1));
+lbl320:	c1 = c2;
+      	s2 = s1;
+      	kk += kspan;
+lbl330:	ak = a[kk];
+      	a[kk] = (float)((c2*ak) - (s2 * b[kk]));
+      	b[kk] = (float)((s2*ak) + (c2 * b[kk]));
+      	kk += kspnn;
+      	if(kk <= nt) goto lbl330;
+      	ak = s1*s2;
+      	s2 = (s1*c2) + (c1*s2);
+      	c2 = (c1*c2) - ak;
+      	kk -= (nt - kspan);
+     	if(kk <= kspnn) goto lbl330;
+      	kk -= (kspnn - jc);
+      	if(kk <= mm)   goto lbl310;
+      	if(kk < kspan) goto lbl340;
+      	kk -= (kspan - jc - inc);
+      	if(kk <= (jc+jc)) goto lbl300;
+      	goto lbl40;
+lbl340:	s1 = ((double)((kk-1)/jc)) * dr * rad;
+      	c2 = cos(s1);
+      	s1 = sin(s1);
+     	mm = min( kspan, mm+klim);
+      	goto lbl320;
+
+/*
+ * permute the results to normal order---done in two stages
+ * permutation for square factors of n
+ */
+
+lbl350:	np[1] = ks;
+      	if (!(*kt)) goto lbl440;
+      	k = *kt + *kt + 1;
+      	if(m < k) 
+		k--;
+	np[k+1] = jc;
+		for(j=1; j < k; j++,k--){
+		np[j+1] = np[j] / nfac[j];
+	      	np[k] = np[k+1] * nfac[j];
+	}
+      	k3 = np[k+1];
+      	kspan = np[2];
+      	kk = jc + 1;
+      	k2 = kspan + 1;
+      	j = 1;
+      	if(n != ntot) goto lbl400;
+/*
+ * permutation for single-variate transform (optional code)
+ */
+lbl370:	do{	ak = a[kk];
+	      	a[kk] = a[k2];
+	      	a[k2] = (float)ak;
+	      	bk = b[kk];
+	      	b[kk] = b[k2];
+	      	b[k2] = (float)bk;
+	      	kk += inc;
+	      	k2 += kspan;
+	}while(k2 < ks);
+lbl380:	do{	k2 -= np[j++];
+	      	k2 += np[j+1];
+	}while(k2 > np[j]);
+      	j = 1;
+lbl390:	if(kk < k2){
+		goto lbl370;
+	}
+      	kk += inc;
+      	k2 += kspan;
+      	if(k2 < ks) goto lbl390;
+      	if(kk < ks) goto lbl380;
+      	jc = k3;
+      	goto lbl440;
+/*
+ * permutation for multivariate transform
+ */
+lbl400:	do{	do{	k = kk + jc;
+				do{	ak = a[kk];
+			      	a[kk] = a[k2];
+			      	a[k2] = (float)ak;
+			      	bk = b[kk];
+			      	b[kk] = b[k2];
+			      	b[k2] = (float)bk;
+			      	kk += inc;
+			      	k2 += inc;
+			}while(kk < k);
+		      	kk += (ks - jc);
+		      	k2 += (ks - jc);
+		}while(kk < nt);
+	      	k2 -= (nt - kspan);
+	      	kk -= (nt - jc);
+	}while(k2 < ks);
+lbl420:	do{	k2 -= np[j++];
+	      	k2 += np[j+1];
+	}while(k2 > np[j]);
+      	j = 1;
+lbl430:	if(kk < k2) 	 goto lbl400;
+      	kk += jc;
+      	k2 += kspan;
+      	if(k2 < ks)      goto lbl430;
+      	if(kk < ks)      goto lbl420;
+      	jc = k3;
+lbl440:	if((2*(*kt))+1 >= m)
+		return(FINISHED);
+
+      	kspnn = *(np + *(kt) + 1);
+      	j = m - *kt;		
+      	nfac[j+1] = 1;
+lbl450:	nfac[j] = nfac[j] * nfac[j+1];
+      	j--;
+      	if(j != *kt) goto lbl450;
+      	*kt = *(kt) + 1;
+      	nn = nfac[*kt] - 1;
+      	jj = 0;
+      	j = 0;
+      	goto lbl480;
+lbl460:	jj -= k2;
+      	k2 = kk;
+      	kk = nfac[++k];
+lbl470:	jj += kk;
+      	if(jj >= k2) goto lbl460;
+      	np[j] = jj;
+lbl480:	k2 = nfac[*kt];
+      	k = *kt + 1;	
+      	kk = nfac[k];
+      	j++;
+      	if(j <= nn) goto lbl470;
+/* Determine permutation cycles of length greater than 1 */
+      	j = 0;
+      	goto lbl500;
+lbl490:	k = kk;
+     	kk = np[k];	
+      	np[k] = -kk;	
+      	if(kk != j) goto lbl490;
+      	k3 = kk;
+lbl500:	kk = np[++j];	
+      	if(kk < 0)  goto lbl500;
+      	if(kk != j) goto lbl490;
+      	np[j] = -j;
+      	if(j != nn) goto lbl500;
+      	maxf *= inc;
+/* Perform reordering following permutation cycles */
+      	goto lbl570;
+lbl510:	j--;
+      	if (np[j] < 0) goto lbl510;
+      	jj = jc;
+lbl520:	kspan = jj;
+      	if(jj > maxf) 
+		kspan = maxf;
+      	jj -= kspan;
+      	k = np[j];	
+      	kk = (jc*k) + i + jj;
+      	k1 = kk + kspan;
+      	k2 = 0;
+lbl530:	k2++;
+      	at[k2] = a[k1];
+      	bt[k2] = b[k1];
+      	k1 -= inc;
+      	if(k1 != kk) goto lbl530;
+lbl540:	k1 = kk + kspan;
+      	k2 = k1 - (jc * (k + np[k]));
+      	k = -(np[k]);
+lbl550:	a[k1] = a[k2];
+      	b[k1] = b[k2];
+      	k1 -= inc;
+      	k2 -= inc;
+      	if(k1 != kk) goto lbl550;
+      	kk = k2;
+      	if(k != j)   goto lbl540;
+      	k1 = kk + kspan;
+      	k2 = 0;
+lbl560:	k2++;
+      	a[k1] = at[k2];
+      	b[k1] = bt[k2];
+      	k1 -= inc;
+      	if(k1 != kk) goto lbl560;
+      	if(jj)       goto lbl520;
+      	if(j  != 1)  goto lbl510;
+lbl570:	j = k3 + 1;
+      	nt -= kspnn;
+      	i = nt - inc + 1;
+      	if(nt >= 0)  goto lbl510;
+      	return(FINISHED);; 
+}
+
+
+/*
+ *-----------------------------------------------------------------------
+ * subroutine:  reals
+ * used with 'fft' to compute fourier transform or inverse for real data
+ *-----------------------------------------------------------------------
+ *	this is the call from C:
+ *		reals_(anal,banal,N2,mtwo);
+ *	which has been changed from CARL call
+ *		reals_(anal,banal,&N2,&mtwo);
+ */
+
+int reals_(float *a, float *b, int n, int isn)
+
+			/* a refers to an array of floats 'anal'   */
+			/* b refers to an array of floats 'banal'  */
+/* See IEEE book for a long comment here on usage */
+
+{	int	inc,
+		j,
+		k,
+		lim,
+		mm,ml,
+		nf,nk,nh;
+ 
+	double	aa,ab,
+		ba,bb,
+		cd,cn,
+		dr,
+		em,
+		rad,re,
+		sd,sn;
+	double	xx;	/******* ADDED APRIL 1991 ******/
+/* adjust  input array pointers (called from C) */
+	a--;	b--;
+	inc=abs(isn);
+	nf=abs(n);
+      	if(nf*isn==0){
+			sprintf(errstr,"zero in reals parameters in FFT : %d : %d ",n,isn);
+	       	return(DATA_ERROR);;
+		}
+	 	nk = (nf*inc) + 2;
+      	nh = nk/2;
+/*****************************
+    	rad  = atan((double)1.0);
+******************************/
+	rad = 0.785398163397448278900;
+      	dr = -4.0/(double)(nf);
+/********************************** POW2 REMOVED APRIL 1991 *****************
+			      	cd = 2.0 * (pow2(sin((double)0.5 * dr * rad)));
+*****************************************************************************/
+	xx = sin((double)0.5 * dr * rad);
+      	cd = 2.0 * xx * xx;
+      	sd = sin(dr * rad);
+/*
+ * sin,cos values are re-initialized each lim steps
+ */
+      	lim = 32;
+      	mm = lim;
+      	ml = 0;
+      	sn = 0.0;
+	if(isn<0){
+		cn = 1.0;
+		a[nk-1] = a[1];
+		b[nk-1] = b[1]; }
+	else {
+		cn = -1.0;
+		sd = -sd;
+	}
+	 	for(j=1;j<=nh;j+=inc)	{
+        	k = nk - j;
+        	aa = a[j] + a[k];
+        	ab = a[j] - a[k];
+        	ba = b[j] + b[k];
+        	bb = b[j] - b[k];
+        	re = (cn*ba) + (sn*ab);
+        	em = (sn*ba) - (cn*ab);
+        	b[k] = (float)((em-bb)*0.5);
+        	b[j] = (float)((em+bb)*0.5);
+        	a[k] = (float)((aa-re)*0.5);
+		a[j] = (float)((aa+re)*0.5);
+        	ml++;
+		if(ml!=mm){
+			aa = cn - ((cd*cn)+(sd*sn));
+			sn = ((sd*cn) - (cd*sn)) + sn;
+			cn = aa;}
+		else {
+			mm +=lim;
+			sn = ((float)ml) * dr * rad;
+			cn = cos(sn);
+			if(isn>0)
+				cn = -cn;
+			sn = sin(sn);
+		}
+	}
+	return(FINISHED);
+}

dev/misc/paudition.c

@@ -0,0 +1,1043 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* PEDITAUD
+ *
+ * Hear a pitchfile being edited in the PDISPLAY routine in SoundLoom.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <osbind.h>
+#include <math.h>
+#include <float.h>
+#include <float.h>
+#include <sfsys.h>
+#include <cdplib.h>
+#include <pvoc.h>
+#include <paudition.h>
+
+char errstr[2400];
+
+#define NOT_PITCH (-1.0)
+
+#define ENDOFSTR                ('\0')
+#define ANALFILE_OUT            (1)
+#define SNDFILE_OUT             (0)
+#define WINDOW_AMP              (0.5)
+#define PARTIALS_IN_TEST_TONE   (6)
+#define PARTIAL_DECIMATION      (.25)
+#define VERY_TINY_AMP           (0.00000000000000000001)    /* 10^-20 */
+#define FLTERR                  (0.000002)
+
+static int headwrite(int ofd,int origstype,int origrate,float arate,int Mlen,int Dfac);
+static int get_data_from_pitchfile(float **pitches,int infilesize,int ifd);
+static int setup_amplitudes(int clength,double halfchwidth,double chwidth,float **testpamp,float **totpamp,float **chbot);
+static void do_finish(int n,int ifd,int ofd,float *bigbuf) ;
+static int make_buffer(float **bigbuf,int *big_fsize, int wanted);
+static int gen_testdata(int ofd,float *bigbuf,float *bigbufend,int big_fsize,
+    int wlength,int clength,int wanted,int *total_samps_written,float *pitches,
+    double chwidth,double halfchwidth,float *chbot,double nois_chanamp,float *testpamp,float *totpamp,
+    double nyquist,double pre_totalamp);
+static void gen_silence_in_sampbuf(float *sampbuf,double chwidth,double halfchwidth,int clength,
+    float *chbot,double nois_chanamp);
+static void gen_nois_in_sampbuf(float *sampbuf,double chwidth,double halfchwidth,int clength,
+    float *chbot,double nois_chanamp);
+static void gen_tone_in_sampbuf(double thisfrq,float *sampbuf,float *testpamp,float *totpamp,
+    double nyquist,double pre_totalamp,double chwidth,double halfchwidth,int wanted);
+static int pvoc_process_addon(int ifd,int ofd,int chans,int origrate,float arate,int Mlen,int Dfac);
+static void hamming(float *win,int winLen,int even);
+static int pvoc_float_array(int nnn,float **ptr);
+/*static int lcm(int a, int b);*/
+static void preset_sampbuf(float *sampbuf,double halfchwidth, int clength, float *chbot);
+static void normalise(double post_totalamp,double pre_totalamp,int wanted,float *sampbuf);
+static int flteq(double f1,double f2);
+static int outfloats(float *nextOut,float *maxsample,float *minsample,int *num_overflows,int todo, int ofd);
+
+#define MONO (1)
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char *argv[])
+{
+    float *pitches, *testpamp, *totpamp, *chbot;
+    float *bigbuf = NULL, *bigbufend;
+    int big_fsize, total_samps_written = 0;
+    int ofd = -1, ifd;
+    int wlength;
+    int origchans, origstype, origrate;
+    float arate;
+    int Mlen, Dfac;
+    int srate, chans;
+    double  chwidth, halfchwidth, nyquist, nois_chanamp, gain = 1.0, pre_totalamp;
+    int   wanted, clength;
+
+    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if(argc != 12) {
+        fprintf(stdout,"ERROR: Incorrect call to program which writes the sound.\n");
+        fflush(stdout);
+        return 1;
+    }
+    /* initialise SFSYS */
+    if( sflinit("paudition") < 0 ) {
+        fprintf(stdout,"ERROR: Cannot initialise soundfile system.\n");
+        fflush(stdout);
+        return 1;
+    }
+
+    /* open input file */
+    if((ifd = sndopenEx(argv[1],0,CDP_OPEN_RDONLY))<0)  {
+        fprintf(stdout,"INFO: Cannot open intermediate pitch data file: %s\n",argv[1]);
+        fflush(stdout);
+        do_finish(0,ifd,ofd,bigbuf);
+    }
+    wlength = sndsizeEx(ifd);
+
+    if(sscanf(argv[4],"%d",&origchans)!=1) {
+        fprintf(stdout,"ERROR: Cannot read original-channels data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[5],"%d",&origstype)!=1) {
+        fprintf(stdout,"ERROR: Cannot read original-sample-type data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[6],"%d",&origrate)!=1) {
+        fprintf(stdout,"ERROR: Cannot read original-sample-rate data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[7],"%f",&arate)!=1) {
+        fprintf(stdout,"ERROR: Cannot read analysis-rate data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[8],"%d",&Mlen)!=1) {
+        fprintf(stdout,"ERROR: Cannot read Mlen data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[9],"%d",&Dfac)!=1) {
+        fprintf(stdout,"ERROR: Cannot read Decimation Factor data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[10],"%d",&srate)!=1) {
+        fprintf(stdout,"ERROR: Cannot read sample-rate data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(sscanf(argv[11],"%d",&chans)!=1) {
+        fprintf(stdout,"ERROR: Cannot read channel data,\n");
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+//TW COMMENT: this is temporary analysis file
+
+    if((ofd = sndcreat_formatted(argv[2],-1,SAMP_FLOAT,
+            chans,srate,CDP_CREATE_NORMAL)) < 0) {
+        fprintf(stdout,"ERROR: Can't create file %s (It may already exist)\n", argv[2]);
+        fflush(stdout);
+        do_finish(1,ifd,ofd,bigbuf);
+        return 1;
+    }
+
+    wanted  = origchans ;       /* floatsams to read */
+    clength = wanted / 2;       /* channels to process */
+    nyquist     = (double)origrate/2.0;
+    chwidth     = nyquist/(double)(clength - 1);
+    halfchwidth = chwidth/2.0;
+
+    if(!get_data_from_pitchfile(&pitches,wlength,ifd)) {
+        do_finish(2,ifd,ofd,bigbuf);
+        return 1;
+    }
+
+    sndcloseEx(ifd);
+
+    pre_totalamp = WINDOW_AMP * gain;
+    nois_chanamp = pre_totalamp/(double)clength;
+    if(!setup_amplitudes(clength,halfchwidth,chwidth,&testpamp,&totpamp,&chbot)) {
+        do_finish(3,ifd,ofd,bigbuf);
+        return 1;
+    }
+
+    if(!make_buffer(&bigbuf,&big_fsize,wanted)) {
+        do_finish(3,ifd,ofd,bigbuf);
+        return 1;
+    }
+    bigbufend = bigbuf + big_fsize;
+
+    if(!gen_testdata(ofd,bigbuf,bigbufend,big_fsize,wlength,clength,wanted,&total_samps_written,
+        pitches,chwidth,halfchwidth,chbot,nois_chanamp,testpamp,totpamp,nyquist,pre_totalamp)) {
+        do_finish(4,ifd,ofd,bigbuf);
+        return 1;
+    }
+    chans = origchans;
+    if (!headwrite(ofd,origstype,origrate,arate,Mlen,Dfac)) {
+
+        fprintf(stdout,"ERROR: Failed to write valid header to output file.\n");
+        fflush(stdout);
+        do_finish(4,ifd,ofd,bigbuf);
+        return 1;
+    }
+    Mfree(bigbuf);
+    sndcloseEx(ofd);
+
+    if((ifd = sndopenEx(argv[2],0,CDP_OPEN_RDONLY))<0)  {
+        fprintf(stdout,"INFO: Cannot open intermediate analysis data file: %s\n",argv[2]);
+        fflush(stdout);
+        do_finish(0,ifd,ofd,bigbuf);
+        return 1;
+    }
+//TW COMMENT as this is a temporary sndfile: may as well leave it as SAMP_SHORT
+    if((ofd = sndcreat_formatted(argv[3],-1,SAMP_SHORT,
+            MONO,origrate,CDP_CREATE_NORMAL)) < 0) {
+        fprintf(stdout,"ERROR: Can't create output soundfile %s\n", argv[3]);
+        fflush(stdout);
+        do_finish(5,ifd,ofd,bigbuf);
+        return 1;
+    }
+    if(!pvoc_process_addon(ifd,ofd,chans,origrate,arate,Mlen,Dfac)) {
+        do_finish(6,ifd,ofd,bigbuf);
+        return 1;
+    }
+    do_finish(6,ifd,ofd,bigbuf);
+    return 1;
+}
+
+/***************************** HEADWRITE *******************************/
+
+int headwrite(int ofd,int origstype,int origrate,float arate,int Mlen,int Dfac)
+{
+    if(sndputprop(ofd,"original sampsize", (char *)&origstype, sizeof(int)) < 0){
+        fprintf(stdout,"ERROR: Failure to write original sample size. headwrite()\n");
+        fflush(stdout);
+        return(0);
+    }
+    if(sndputprop(ofd,"original sample rate", (char *)&origrate, sizeof(int)) < 0){
+        fprintf(stdout,"ERROR: Failure to write original sample rate. headwrite()\n");
+        fflush(stdout);
+        return(0);
+    }
+    if(sndputprop(ofd,"arate",(char *)&arate,sizeof(float)) < 0){
+        fprintf(stdout,"ERROR: Failed to write analysis sample rate. headwrite()\n");
+        fflush(stdout);
+        return(0);
+    }
+    if(sndputprop(ofd,"analwinlen",(char *)&Mlen,sizeof(int)) < 0){
+        fprintf(stdout,"ERROR: Failure to write analysis window length. headwrite()\n");
+        fflush(stdout);
+        return(0);
+    }
+    if(sndputprop(ofd,"decfactor",(char *)&Dfac,sizeof(int)) < 0){
+        fprintf(stdout,"ERROR: Failure to write decimation factor. headwrite()\n");
+        fflush(stdout);
+        return(0);
+    }
+    return(1);
+}
+
+/********************* GET_DATA_FROM_PITCHFILE *************************/
+
+
+int get_data_from_pitchfile(float **pitches,int wanted,int ifd)
+{
+    int samps_read;
+    if((*pitches = (float *)malloc(wanted * sizeof(float)))==NULL) {
+        fprintf(stdout,"ERROR: Insufficient memory to reread pitchdata.\n");
+        fflush(stdout);
+        return 0;
+    }
+    if((samps_read = fgetfbufEx(*pitches, wanted,ifd,0))<0) {
+        fprintf(stdout,"ERROR: Cannot reread pitchdata.\n");
+        fflush(stdout);
+        return 0;
+    }
+    if(samps_read!=wanted) {
+        fprintf(stdout,"ERROR: Problem rereading pitch data.\n");
+        fflush(stdout);
+        return 0;
+    }
+    return(1);
+}
+
+/****************************** SETUP_AMPLITUDES ***************/
+
+int setup_amplitudes(int clength,double halfchwidth,double chwidth,float **testpamp,float **totpamp,float **chbot)
+{   
+    int n, cc;
+    if((*testpamp = (float *)malloc(PARTIALS_IN_TEST_TONE * sizeof(float)))==NULL) {
+        fprintf(stdout,"ERROR: Insufficient memory A.\n");
+        fflush(stdout);
+        return 0;
+    }
+    if((*totpamp  = (float *)malloc(PARTIALS_IN_TEST_TONE * sizeof(float)))==NULL) {
+        fprintf(stdout,"ERROR: Insufficient memory B.\n");
+        fflush(stdout);
+        return 0;
+    }
+    (*totpamp)[0] = (*testpamp)[0] = 0.5f;
+    for(n = 1; n < PARTIALS_IN_TEST_TONE; n++)    /* ACTUAL PARTIAL AMPS */
+        (*testpamp)[n] = (float)((*testpamp)[n-1] * PARTIAL_DECIMATION);
+    for(n = 1; n < PARTIALS_IN_TEST_TONE; n++)    /* SUM OF PARTIAL AMPS */
+        (*totpamp)[n] = (float)((*totpamp)[n-1] + (*testpamp)[n]);
+    if((*chbot    = (float *)malloc(clength * sizeof(float)))==NULL) {
+        fprintf(stdout,"ERROR: Insufficient memory C.\n");
+        fflush(stdout);
+        return 0;
+    }
+    (*chbot)[0] = 0.0f;
+    (*chbot)[1] = (float)halfchwidth;
+    for(cc = 2 ;cc < clength; cc++)
+        (*chbot)[cc] = (float)((*chbot)[cc-1] + chwidth);
+    return 1;
+}
+
+/****************************** DO_FINISH *********************************/
+
+void do_finish(int n,int ifd,int ofd,float *bigbuf) 
+{
+    switch(n) {
+    case(2):
+        sndcloseEx(ofd);
+    case(1):
+        sndcloseEx(ifd);
+    case(0):
+//      sffinish();
+        break;
+    case(4):
+        Mfree(bigbuf);
+    case(3):
+        sndcloseEx(ofd);
+//      sffinish();
+        break;
+    case(6):
+        sndcloseEx(ofd);
+    case(5):
+        sndcloseEx(ifd);
+//      sffinish();
+        break;
+    }
+}
+
+/****************************** MAKE_BUFFER *********************************/
+
+int make_buffer(float **bigbuf,int *big_fsize, int wanted)
+{
+    size_t bigbufsize  = (size_t) Malloc(-1);
+    *big_fsize   = bigbufsize/sizeof(float);
+    if((*big_fsize  = ((*big_fsize)/wanted) * wanted)<=0) {
+        fprintf(stdout,"ERROR: Insufficient memory E.\n");
+        fflush(stdout);
+        return 0;
+    }
+    if((*bigbuf = (float*)Malloc(*big_fsize * sizeof(float)))==NULL) {
+        fprintf(stdout,"ERROR: Insufficient memory F.\n");
+        fflush(stdout);
+        return 0;
+    }
+    memset((char *)(*bigbuf),0,(*big_fsize * sizeof(float)));
+    return 1;
+}
+
+/************************* GEN_TESTDATA *************************/
+
+int gen_testdata(int ofd,float *bigbuf,float *bigbufend,int big_fsize,
+int wlength,int clength,int wanted,int *total_samps_written,float *pitches,
+double chwidth,double halfchwidth,float *chbot,double nois_chanamp,float *testpamp,float *totpamp,
+double nyquist,double pre_totalamp)
+{
+    double thisfrq;
+    int n = 0, samps_to_write, samps_written;
+    float *sampbuf = bigbuf;
+    int cc, vc;
+    while(n < wlength) {
+        thisfrq = (double)pitches[n];
+        if(thisfrq < NOT_PITCH)     /* NO SOUND FOUND : GENERATE SILENCE */
+            gen_silence_in_sampbuf(sampbuf,chwidth,halfchwidth,clength,chbot,nois_chanamp);
+        else if(thisfrq < 0.0)      /* NO PITCH FOUND : GENERATE NOISE */
+            gen_nois_in_sampbuf(sampbuf,chwidth,halfchwidth,clength,chbot,nois_chanamp);
+        else {              /* GENERATE TESTTONE AT FOUND PITCH */
+            preset_sampbuf(sampbuf,halfchwidth,clength,chbot);
+            gen_tone_in_sampbuf(thisfrq,sampbuf,testpamp,totpamp,nyquist,pre_totalamp,chwidth,halfchwidth,wanted);
+        }
+        if(n==0) {
+            for(cc = 0, vc = 0; cc < clength; cc++, vc += 2)
+                sampbuf[vc] = 0.0f;
+        }
+        if((sampbuf += wanted) >= bigbufend) {
+            if((samps_written = fputfbufEx(bigbuf,big_fsize,ofd))<0) {
+                fprintf(stdout,"ERROR: Can't write to analysis file.\n");
+                fflush(stdout);
+                return 0;
+            }
+            *total_samps_written += big_fsize;
+            memset((char *)bigbuf,0,big_fsize * sizeof(float));
+            sampbuf = bigbuf;
+        }
+        n++;
+    }
+    if(sampbuf != bigbuf) {
+        samps_to_write = (sampbuf - bigbuf);
+        *total_samps_written += samps_to_write;
+        if((samps_written = fputfbufEx(bigbuf,samps_to_write,ofd))<0) {
+            fprintf(stdout,"ERROR: Can't write to analysis file.\n");
+            fflush(stdout);
+            return 0;
+        }
+    }
+    return 1;
+}
+
+/*************************** GEN_SILENCE_IN_SAMPBUF *********************/
+
+void gen_silence_in_sampbuf(float *sampbuf,double chwidth,double halfchwidth,int clength,
+        float *chbot,double nois_chanamp)
+{
+    int cc, vc, clength_less_1 = clength - 1;
+    sampbuf[0] = (float)nois_chanamp;
+    sampbuf[1] = (float)(drand48() * halfchwidth);
+    for(cc = 1, vc = 2; cc < clength_less_1; cc++, vc += 2) {
+        sampbuf[vc+1] = (float)((drand48() * chwidth) + chbot[cc]);
+        sampbuf[vc]   = 0.0f;
+    }
+    sampbuf[vc+1] = (float)((drand48() * halfchwidth) + chbot[cc]);
+    sampbuf[vc]   = 0.0f;
+}
+
+/*************************** GEN_NOIS_IN_SAMPBUF *********************/
+
+void gen_nois_in_sampbuf(float *sampbuf,double chwidth,double halfchwidth,int clength,
+        float *chbot,double nois_chanamp)
+{
+    int cc, vc, clength_less_1 = clength - 1;
+    sampbuf[0] = (float)nois_chanamp;
+    sampbuf[1] = (float)(drand48() * halfchwidth);
+    for(cc = 1, vc = 2; cc < clength_less_1; cc++, vc += 2) {
+        sampbuf[vc+1] = (float)((drand48() * chwidth) + chbot[cc]);
+        sampbuf[vc]   = (float)nois_chanamp;
+    }
+    sampbuf[vc+1] = (float)((drand48() * halfchwidth) + chbot[cc]);
+    sampbuf[vc]   = (float)nois_chanamp;
+}
+
+/********************** GEN_TONE_IN_SAMPBUF ***************************/
+
+void gen_tone_in_sampbuf(double thisfrq,float *sampbuf,float *testpamp,float *totpamp,
+    double nyquist,double pre_totalamp,double chwidth,double halfchwidth,int wanted)
+{
+    int cc, vc, m, ampadjusted = 0;
+    int lastvc = -1;
+    double post_totalamp;
+    for(m=0;m<PARTIALS_IN_TEST_TONE;m++) {
+        cc = (int)((thisfrq + halfchwidth)/chwidth);
+        if((vc = cc)!=0)
+            vc = cc * 2;
+        if(vc != lastvc) {
+            sampbuf[vc]   = testpamp[m];
+            sampbuf[vc+1] = (float)thisfrq;
+        }
+        lastvc = vc;
+        if((thisfrq = thisfrq * 2.0) > nyquist) {
+            post_totalamp = (double)totpamp[m];
+            normalise(post_totalamp,pre_totalamp,wanted,sampbuf);
+            ampadjusted = 1;
+            break;
+        }
+    }
+    if(!ampadjusted) {
+        post_totalamp = (double)totpamp[PARTIALS_IN_TEST_TONE-1];
+        normalise(post_totalamp,pre_totalamp,wanted,sampbuf);
+    }
+}
+
+/******************************** NORMALISE ***************************/
+
+void normalise(double post_totalamp,double pre_totalamp,int wanted,float *sampbuf)
+{
+    double normaliser;
+    int vc;
+    if(post_totalamp < VERY_TINY_AMP)
+        return;
+    normaliser = pre_totalamp/post_totalamp;
+    for(vc = 0; vc < wanted; vc += 2) {
+        if(sampbuf[vc] > 0.0f)
+            sampbuf[vc] = (float)(sampbuf[vc] * normaliser);
+    }
+}
+
+/****************************** HAMMING ******************************/
+
+void hamming(float *win,int winLen,int even)
+{
+    float Pi,ftmp;
+    int i;
+
+/***********************************************************
+                    Pi = (float)((double)4.*atan((double)1.));
+***********************************************************/
+    Pi = (float)PI;
+    ftmp = Pi/winLen;
+
+    if (even) {
+        for (i=0; i<winLen; i++)
+        *(win+i) = (float)((double).54 + (double).46*cos((double)(ftmp*((float)i+.5))));
+        *(win+winLen) = 0.0f;}
+    else{   *(win) = 1.0f;
+        for (i=1; i<=winLen; i++)
+        *(win+i) =(float)((double).54 + (double).46*cos((double)(ftmp*(float)i)));
+    }
+    return;
+}
+
+/****************************** FLOAT_ARRAY ******************************/
+
+int pvoc_float_array(int nnn,float **ptr)
+{   /* set up a floating point array length nnn. */
+    *ptr = (float *) calloc(nnn,sizeof(float));
+    if(*ptr==NULL){
+        fprintf(stdout,"ERROR: insufficient memory for PVOC\n");
+        fflush(stdout);
+        return(0);
+    }
+    return(1);
+}
+
+/****************************** PVOC_PROCESS_ADDON ******************************/
+
+int pvoc_process_addon(int ifd,int ofd,int chans,int origrate,float arate,int Mlen,int Dfac)
+{
+    int num_overflows = 0;
+    float   *input,         /* pointer to start of input buffer */
+            *output,        /* pointer to start of output buffer */
+            *anal,          /* pointer to start of analysis buffer */
+            *syn,           /* pointer to start of synthesis buffer */
+            *banal,         /* pointer to anal[1] (for FFT calls) */
+            *bsyn,          /* pointer to syn[1]  (for FFT calls) */
+            *nextIn,        /* pointer to next empty word in input */
+            *nextOut,       /* pointer to next empty word in output */
+            *analWindow,    /* pointer to center of analysis window */
+            *synWindow,     /* pointer to center of synthesis window */
+            *maxAmp,        /* pointer to start of max amp buffer */
+            *avgAmp,        /* pointer to start of avg amp buffer */
+            *avgFrq,        /* pointer to start of avg frq buffer */
+            *env,           /* pointer to start of spectral envelope */
+            *i0,            /* pointer to amplitude channels */
+            *i1,            /* pointer to frequency channels */
+            *oldInPhase,    /* pointer to start of input phase buffer */
+            *oldOutPhase,   /* pointer to start of output phase buffer */
+            maxsample = 0.0, minsample = 0.0;
+
+    int     M = 0,          /* length of analWindow impulse response */
+            D = 0,          /* decimatin factor */
+            I = 0,          /* interpolation factor (default will be I=D)*/
+            pvoc_chans = chans - 2,
+            analWinLen,     /* half-length of analysis window */
+            synWinLen;      /* half-length of synthesis window */
+
+    int outCount,       /* number of samples written to output */
+            ibuflen,        /* length of input buffer */
+            obuflen,        /* length of output buffer */
+            nI = 0,         /* current input (analysis) sample */
+            nO,             /* current output (synthesis) sample */
+            nMaxOut;        /* last output (synthesis) sample */
+    int isr,            /* sampling rate */
+            endsamp = VERY_BIG_INT;
+
+    float   mag,            /* magnitude of analysis data */
+            phase,          /* phase of analysis data */
+            RoverTwoPi,     /* R/D divided by 2*Pi */
+            TwoPioverR,     /* 2*Pi divided by R/I */
+            F = (float)0,   /* fundamental frequency (determines pvoc_chans) */
+            sum,            /* scale factor for renormalizing windows */
+            rIn,            /* decimated sampling rate */
+            rOut,           /* pre-interpolated sampling rate */
+            R;              /* input sampling rate */
+
+    int     i,j,k,      /* index variables */
+            Dd,         /* number of new inputs to read (Dd <= D) */
+            Ii,         /* number of new outputs to write (Ii <= I) */
+            N2,         /* pvoc_chans/2 */
+            NO,         /* synthesis NO = pvoc_chans / P */
+            NO2,        /* NO/2 */
+            IO,         /* synthesis IO = I / P */
+            IOi,        /* synthesis IOi = Ii / P */
+            Mf = 0,     /* flag for even M */
+#ifdef SINGLE_SAMP
+            rv,         /* return value from fgetfloat */
+#endif
+            flag = 0;   /* end-of-input flag */
+
+#if defined(__SC__) && defined(SOFT_FP)
+    extern int _8087;
+    _8087 = 0;
+#endif
+
+    {
+        char *mem;
+
+        if((mem = malloc(64*SECSIZE)) == 0
+         ||sndsetbuf(ifd, mem, 64) < 0) {
+            fprintf(stdout, "ERROR: Can't set big input buffer for PVOC.\n");
+            return(0);
+        }
+    }
+
+    isr      = origrate;
+    M        = Mlen;
+    D        = Dfac;
+    R        = ((float) D * arate);
+
+    if(flteq(R,0.0)) {
+        fprintf(stdout, "ERROR: Problem: zero sampling rate in PVOC\n");
+        return(0);
+    }
+
+    N2 = pvoc_chans / 2;
+
+    F = (float)(R /(float)pvoc_chans);
+
+    Mf = 1 - M%2;
+
+    if (M < 7) {
+        fprintf(stdout,"WARNING: analWindow impulse response is too small\n");
+        fflush(stdout);
+    }
+    ibuflen = 4 * M;
+    obuflen = 4 * M;
+
+    I   = D;
+    NO  = pvoc_chans;   /* synthesis transform will be NO points */
+    NO2 = NO/2;
+    IO  = I;
+
+    /* set up analysis window: The window is assumed to be symmetric
+        with M total points.  After the initial memory allocation,
+        analWindow always points to the midpoint of the window
+        (or one half sample to the right, if M is even); analWinLen
+        is half the true window length (rounded down). Any low pass
+        window will work; a Hamming window is generally fine,
+        but a Kaiser is also available.  If the window duration is
+        longer than the transform (M > N), then the window is
+        multiplied by a sin(x)/x function to meet the condition:
+        analWindow[Ni] = 0 for i != 0.  In either case, the
+        window is renormalized so that the phase vocoder amplitude
+        estimates are properly scaled.  The maximum allowable
+        window duration is ibuflen/2. */
+
+    if(!pvoc_float_array(M+Mf,&analWindow))
+        return(0);
+    analWindow += (analWinLen = M/2);
+
+    hamming(analWindow,analWinLen,Mf);
+
+    for (i = 1; i <= analWinLen; i++)
+        *(analWindow - i) = *(analWindow + i - Mf);
+
+    if (M > pvoc_chans) {
+        if (Mf)
+        *analWindow *=(float)
+        ((double)pvoc_chans*sin((double)PI*.5/pvoc_chans)/(double)(PI*.5));
+        for (i = 1; i <= analWinLen; i++) 
+            *(analWindow + i) *=(float)
+            ((double)pvoc_chans * sin((double) (PI*(i+.5*Mf)/pvoc_chans) / (PI*(i+.5*Mf))));
+        for (i = 1; i <= analWinLen; i++)
+            *(analWindow - i) = *(analWindow + i - Mf);
+    }
+
+    sum = 0.0f;
+    for (i = -analWinLen; i <= analWinLen; i++)
+        sum += *(analWindow + i);
+
+    sum = (float)(2.0/sum);     /*factor of 2 comes in later in trig identity*/
+
+    for (i = -analWinLen; i <= analWinLen; i++)
+        *(analWindow + i) *= sum;
+
+    /* set up synthesis window:  For the minimal mean-square-error
+        formulation (valid for N >= M), the synthesis window
+        is identical to the analysis window (except for a
+        scale factor), and both are even in length.  If N < M,
+        then an interpolating synthesis window is used. */
+
+    if(!pvoc_float_array(M+Mf,&synWindow))
+        return(0);
+    synWindow += (synWinLen = M/2);
+
+    if (M <= pvoc_chans){
+        hamming(synWindow,synWinLen,Mf);
+        for (i = 1; i <= synWinLen; i++)
+            *(synWindow - i) = *(synWindow + i - Mf);
+
+        for (i = -synWinLen; i <= synWinLen; i++)
+            *(synWindow + i) *= sum;
+
+        sum = 0.0f;
+        for (i = -synWinLen; i <= synWinLen; i+=I)
+            sum += *(synWindow + i) * *(synWindow + i);
+
+        sum = (float)(1.0/ sum);
+
+        for (i = -synWinLen; i <= synWinLen; i++)
+            *(synWindow + i) *= sum;
+    } else {
+        hamming(synWindow,synWinLen,Mf);
+        for (i = 1; i <= synWinLen; i++)
+            *(synWindow - i) = *(synWindow + i - Mf);
+
+        if (Mf)
+            *synWindow *= (float)((double)IO * sin((double) (PI*.5/IO)) / (double)(PI*.5));
+        for (i = 1; i <= synWinLen; i++) 
+            *(synWindow + i) *=(float)
+            ((double)IO * sin((double) (PI*(i+.5*Mf)/IO)) /(double) (PI*(i+.5*Mf)));
+        for (i = 1; i <= synWinLen; i++)
+            *(synWindow - i) = *(synWindow + i - Mf);
+
+        sum = (float)(1.0/sum);
+
+        for (i = -synWinLen; i <= synWinLen; i++)
+            *(synWindow + i) *= sum;
+    }
+      
+    /* set up input buffer:  nextIn always points to the next empty
+        word in the input buffer (i.e., the sample following
+        sample number (n + analWinLen)).  If the buffer is full,
+        then nextIn jumps back to the beginning, and the old
+        values are written over. */
+
+    if(!pvoc_float_array(ibuflen,&input))
+        return(0);
+
+    nextIn = input;
+
+    /* set up output buffer:  nextOut always points to the next word
+        to be shifted out.  The shift is simulated by writing the
+        value to the standard output and then setting that word
+        of the buffer to zero.  When nextOut reaches the end of
+        the buffer, it jumps back to the beginning.  */
+
+    if(!pvoc_float_array(obuflen,&output))
+        return(0);
+
+    nextOut = output;
+    /* set up analysis buffer for (N/2 + 1) channels: The input is real,
+        so the other channels are redundant. oldInPhase is used
+        in the conversion to remember the previous phase when
+        calculating phase difference between successive samples. */
+
+    if(!pvoc_float_array(pvoc_chans+2,&anal))
+        return(0);
+    banal = anal + 1;
+
+    if(!pvoc_float_array(N2+1,&oldInPhase))
+        return(0);
+    if(!pvoc_float_array(N2+1,&maxAmp))
+        return(0);
+    if(!pvoc_float_array(N2+1,&avgAmp))
+        return(0);
+    if(!pvoc_float_array(N2+1,&avgFrq))
+        return(0);
+    if(!pvoc_float_array(N2+1,&env))
+        return(0);
+
+    /* set up synthesis buffer for (pvoc_chans/2 + 1) channels: (This is included
+        only for clarity.)  oldOutPhase is used in the re-
+        conversion to accumulate angle differences (actually angle
+        difference per second). */
+
+    if(!pvoc_float_array(NO+2,&syn))
+        return(0);
+    bsyn = syn + 1;
+
+    if(!pvoc_float_array(NO2+1,&oldOutPhase))
+        return(0);
+
+    /* initialization: input time starts negative so that the rightmost
+        edge of the analysis filter just catches the first non-zero
+        input samples; output time is always T times input time. */
+
+    outCount = 0;
+    rIn  = (float)(R/(float)D);
+    rOut = (float)(R/(float)I);
+    RoverTwoPi = (float)(rIn/TWOPI);
+    TwoPioverR = (float)(TWOPI/rOut);
+    nI = -(analWinLen / D) * D; /* input time (in samples) */
+    nO = nI;                    /* output time (in samples) */
+    Dd = analWinLen + nI + 1;   /* number of new inputs to read */
+    Ii = 0;             /* number of new outputs to write */
+    IOi = 0;
+    flag = 1;
+
+    /* main loop:  If endsamp is not specified it is assumed to be very large
+        and then readjusted when fgetfloat detects the end of input. */
+
+    while(nI < (endsamp + analWinLen)){
+#ifdef SINGLE_SAMP
+        for (i = 0; i < pvoc_chans+2; i++){     /* synthesis only */
+            if ((rv = fgetfloat((anal+i),ifd)) <= 0){
+                return 1;
+            }
+        }
+#else
+        if((i = fgetfbufEx(anal, pvoc_chans+2, ifd,0)) < 0) {
+            sfperror("pvoc: read error: ");
+            return(0);
+        }
+        if(i < pvoc_chans+2)
+            return 1;
+#endif
+
+    /* reconversion: The magnitude and angle-difference-per-second in syn
+        (assuming an intermediate sampling rate of rOut) are
+        converted to real and imaginary values and are returned in syn.
+        This automatically incorporates the proper phase scaling for
+        time modifications. */
+
+        if (NO <= pvoc_chans){
+            for (i = 0; i < NO+2; i++)
+                *(syn+i) = *(anal+i);
+        } else {
+            for (i = 0; i <= pvoc_chans+1; i++) 
+                *(syn+i) = *(anal+i);
+            for (i = pvoc_chans+2; i < NO+2; i++) 
+                *(syn+i) = 0.0f;
+        }
+        
+        for(i=0, i0=syn, i1=syn+1; i<= NO2; i++,i0+=2,i1+=2) {
+            mag = *i0;
+            *(oldOutPhase + i) += *i1 - ((float) i * F);
+            phase = *(oldOutPhase + i) * TwoPioverR;
+            *i0 = (float)((double)mag * cos((double)phase));
+            *i1 = (float)((double)mag * sin((double)phase));
+        }
+
+    /* synthesis: The synthesis subroutine uses the Weighted Overlap-Add
+        technique to reconstruct the time-domain signal.  The (pvoc_chans/2 + 1)
+        phase vocoder channel outputs at time n are inverse Fourier
+        transformed, windowed, and added into the output array.  The
+        subroutine thinks of output as a shift register in which 
+        locations are referenced modulo obuflen.  Therefore, the main
+        program must take care to zero each location which it "shifts"
+        out (to standard output). The subroutines reals and fft
+        together perform an efficient inverse FFT.  */
+
+        if(reals_(syn,bsyn,NO2,2)<0) {
+            fprintf(stdout,"ERROR: %s\n",errstr);
+            fflush(stdout);
+            return 0;
+        }
+        if(fft_(syn,bsyn,1,NO2,1,2)<0) {
+            fprintf(stdout,"ERROR: %s\n",errstr);
+            fflush(stdout);
+            return 0;
+        }
+        j = nO - synWinLen - 1;
+        while (j < 0)
+            j += obuflen;
+        j = j % obuflen;
+
+        k = nO - synWinLen - 1;
+        while (k < 0)
+            k += NO;
+        k = k % NO;
+
+        for (i = -synWinLen; i <= synWinLen; i++) { /*overlap-add*/
+            if (++j >= obuflen)
+                j -= obuflen;
+            if (++k >= NO)
+                k -= NO;
+            *(output + j) += *(syn + k) * *(synWindow + i);
+        }
+
+#ifdef SINGLE_SAMP
+        for (i = 0; i < IOi; i++) { /* shift out next IOi values */
+            fputfloat(nextOut,ofd);
+            *(nextOut++) = 0.;
+            if (nextOut >= (output + obuflen))
+                nextOut -= obuflen;
+            outCount++;
+        }
+#else
+        for (i = 0; i < IOi;) { /* shift out next IOi values */
+            int j;
+            int todo = min(IOi-i, output+obuflen-nextOut);
+            if(!outfloats(nextOut,&maxsample,&minsample,&num_overflows,todo, ofd))
+                return(0);
+            i += todo;
+            outCount += todo;
+            for(j = 0; j < todo; j++)
+                *nextOut++ = 0.0f;
+            if (nextOut >= (output + obuflen))
+                nextOut -= obuflen;
+        }
+#endif
+                    
+        if(flag                             /* flag means do this operation only once */
+        && (nI > 0) && (Dd < D)) {          /* EOF detected */
+            flag = 0;
+            endsamp = nI + analWinLen - (D - Dd);
+        }
+
+        nI += D;                /* increment time */
+        nO += IO;
+                                /* Dd = D except when the end of the sample stream intervenes */
+        Dd = min(D, max(0, D+endsamp-nI-analWinLen));
+
+        if (nO > (synWinLen + I))
+            Ii = I;
+        else if (nO > synWinLen)
+            Ii = nO - synWinLen;
+        else {
+            Ii = 0;
+            for (i=nO+synWinLen; i<obuflen; i++) {
+                if (i > 0)
+                    *(output+i) = 0.0f;
+            }
+        }
+        IOi = Ii;
+
+
+    }   /* End of main while loop */
+
+    nMaxOut = endsamp;
+    while (outCount <= nMaxOut){
+#ifdef SINGLE_SAMP
+        outCount++;
+        fputfloat(nextOut++,ofd);
+        if (nextOut >= (output + obuflen))
+            nextOut -= obuflen;
+#else
+        int todo = min(nMaxOut-outCount, output+obuflen-nextOut);
+        if(todo == 0)
+            break;
+        if(!outfloats(nextOut,&maxsample,&minsample,&num_overflows,todo, ofd))
+            return(0);
+        outCount += todo;
+        nextOut += todo;
+        if (nextOut >= (output + obuflen))
+            nextOut -= obuflen;
+#endif
+    }
+    return(1);
+}
+
+/************************************ OUTFLOATS ************************************
+ *TW 2002 no longer need to do conversion to floats: this func is now just checking for clipping
+ *
+ *  ORIGINALLY (MCA) Converted floats -> shorts explicitly, since we are compiled with
+ *  hardware FP(probably), and the sound filing system is not!
+ *  (even without this, it should be more efficient!)
+ */
+int outfloats(float *nextOut,float *maxsample,float *minsample,int *num_overflows,int todo, int ofd)
+{
+    static float *sbuf = 0;
+    static int sblen = 0;
+    float *sp;
+    int cnt;
+    float val;
+
+    if(sblen < todo) {
+        if(sbuf != 0)
+            free(sbuf);
+        if((sbuf = (float *)malloc(todo*sizeof(float))) == 0) {
+            fprintf(stdout, "ERROR: PVOC can't allocate output buffer\n");
+            fflush(stdout);
+            return(0);
+        }
+        sblen = todo;
+    }
+
+    sp = sbuf;
+#ifdef NOOVERCHK
+    for(cnt = 0; cnt < todo; cnt++)
+        *sp++ = *nextOut++;
+#else
+    for(cnt = 0; cnt < todo; cnt++) {
+        val = *nextOut++;
+        if(val >= 1.0 || val <= -1.0) {
+            (*num_overflows)++;
+            if(val > 0.0f) {
+                if(val > *maxsample)
+                    *maxsample = val;
+                val = 1.0f;
+            }
+            if(val < 0.0f) {
+                if(val < *minsample)
+                    *minsample = val;
+                val = -1.0f;
+            }
+        }
+        *sp++ = val;
+    }
+#endif
+
+    if(fputfbufEx(sbuf, todo, ofd) < todo) {
+        fprintf(stdout,"ERROR: PVOC write error");
+        fflush(stdout);
+        return(0);
+    }
+    return(1);
+}
+
+/**************************** PRESET_SAMPBUF ******************************
+ *
+ * Preset all frqs to centre of channels.
+ */
+
+void preset_sampbuf(float *sampbuf,double halfchwidth, int clength, float *chbot)
+{
+    int cc, vc , clength_less_1 = clength -1;
+    sampbuf[1] = (float)(halfchwidth/2.0);
+    for(cc = 1, vc = 2; cc < clength_less_1; cc++, vc += 2)
+        sampbuf[vc+1] = (float)(chbot[cc] + halfchwidth);
+    sampbuf[vc+1]=(float)(chbot[clength_less_1]+(halfchwidth/2.0));
+}
+
+/**************************** FLTEQ *******************************/
+
+int flteq(double f1,double f2)
+{   double upperbnd, lowerbnd;
+    upperbnd = f2 + FLTERR;     
+    lowerbnd = f2 - FLTERR;     
+    if((f1>upperbnd) || (f1<lowerbnd))
+    return(0);
+    return(1);
+}
+

dev/misc/pdisplay.c

@@ -0,0 +1,100 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* PDISPLAY
+ *
+ * Open pitch data file (we already know the properties) 
+ * and send pitch data to output stream
+ * Close file.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <osbind.h>
+#include <math.h>
+#include <float.h>
+#include <float.h>
+#include <sfsys.h>
+#include <cdplib.h>
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char *argv[])
+{
+	size_t buflen,n;
+	int samps_read;
+	float *bigfbuf;
+	int ifd;
+
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc != 2) {
+		fprintf(stdout,"ERROR: Wrong number of arguments: pdisplay sndfilename.\n");
+		fflush(stdout);
+		return 1;
+	}
+	/* initialise SFSYS	*/
+	if( sflinit("pdisplay") < 0 ) {
+		fprintf(stdout,"ERROR: Cannot initialise soundfile system.\n");
+		fflush(stdout);
+		return 1;
+	}
+
+	buflen = (size_t) Malloc(-1);
+
+	if((bigfbuf=(float*)Malloc(buflen+sizeof(float))) == NULL) {
+		fprintf(stdout,"ERROR: Failed to allocate float buffer.\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	n = ((size_t)bigfbuf+sizeof(float)-1)/sizeof(float) * sizeof(float);	/* align bigbuf to word boundary */
+	bigfbuf = (float*)n;
+	buflen /= sizeof(float); 
+
+	/* open input file */
+	if( (ifd = sndopenEx(argv[1],0,CDP_OPEN_RDONLY)) < 0 )	{
+		fprintf(stdout,"INFO: Cannot open file: %s\n\t",argv[1]);
+		fflush(stdout);
+		Mfree(bigfbuf);
+//		sffinish();
+		return 1;
+	}
+
+    while((samps_read = fgetfbufEx(bigfbuf,(int) buflen,ifd,0)) > 0) {
+		for(n = 0; n < samps_read; n++) {
+			fprintf(stdout,"INFO: %lf\n",bigfbuf[n]);
+			fflush(stdout);
+		}			
+	}
+	Mfree(bigfbuf);
+	sndcloseEx(ifd);
+//	sffinish();
+	return 1;
+}

dev/misc/pmodify.c

@@ -0,0 +1,235 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* PMODIFY
+ *
+ * Open pitch text data file and write to pitch binary data file
+ * Close file.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <osbind.h>
+#include <math.h>
+#include <float.h>
+#include <float.h>
+#include <sfsys.h>
+#include <cdplib.h>
+
+static int headwrite(int ofd,int origchans,int origstype,int origrate,float arate,int Mlen,int Dfac);
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char *argv[])
+{
+	int samps_written;
+	size_t bufsize, buflen, n;
+	float *bigfbuf;
+	int ofd;
+	int origchans, origstype, origrate;
+	float arate;
+	int Mlen, Dfac;
+	int srate, chans;
+	double val;
+
+	FILE *fp;
+
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc != 11) {
+		fprintf(stdout,"ERROR: Incorrect call to program which writes the pitch data.\n");
+		fflush(stdout);
+		return 1;
+	}
+	/* initialise SFSYS	*/
+	if( sflinit("pdisplay") < 0 ) {
+		fprintf(stdout,"ERROR: Cannot initialise soundfile system.\n");
+		fflush(stdout);
+		return 1;
+	}
+
+	/* open input file */
+	if((fp = fopen(argv[1],"r"))==NULL)	{
+		fprintf(stdout,"INFO: Cannot open temporary data file: %s\n",argv[1]);
+		fflush(stdout);
+//		sffinish();
+	}
+
+//TW output is analysis file
+//	if((ofd = sndcreat(argv[2], -1, SAMP_FLOAT)) < 0) {
+//		fprintf(stdout,"ERROR: Can't create output file %s (It may already exist)\n", argv[2]);
+//		fflush(stdout);
+//		sffinish();
+//		return 1;
+ //	}
+	if(sscanf(argv[3],"%d",&origchans)!=1) {
+		fprintf(stdout,"ERROR: Cannot read original-channels data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[4],"%d",&origstype)!=1) {
+		fprintf(stdout,"ERROR: Cannot read original-sample-type data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[5],"%d",&origrate)!=1) {
+		fprintf(stdout,"ERROR: Cannot read original-sample-rate data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[6],"%f",&arate)!=1) {
+		fprintf(stdout,"ERROR: Cannot read analysis-rate data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[7],"%d",&Mlen)!=1) {
+		fprintf(stdout,"ERROR: Cannot read Mlen data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[8],"%d",&Dfac)!=1) {
+		fprintf(stdout,"ERROR: Cannot read Decimation Factor data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[9],"%d",&srate)!=1) {
+		fprintf(stdout,"ERROR: Cannot read sample-rate data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if(sscanf(argv[10],"%d",&chans)!=1) {
+		fprintf(stdout,"ERROR: Cannot read channel data,\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	if((ofd = sndcreat_formatted(argv[2], -1, SAMP_FLOAT,
+		chans,srate,CDP_CREATE_NORMAL)) < 0) {
+		fprintf(stdout,"ERROR: Cannot open output file\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	bufsize = (size_t) Malloc(-1);
+
+	if((bigfbuf=(float*)Malloc(bufsize+sizeof(float))) == NULL) {
+		fprintf(stdout,"ERROR: Failed to allocate float buffer.\n");
+		fflush(stdout);
+//		sffinish();
+		return 1;
+	}
+	n = ((size_t)bigfbuf+sizeof(float)-1)/sizeof(float) * sizeof(float);	/* align bigfbuf to word boundary */
+	bigfbuf = (float*)n;
+	buflen  = bufsize/sizeof(float);
+
+	n = 0;
+	while (fscanf(fp,"%lf",&val)==1) {
+		bigfbuf[n++] = (float)val; 		
+		if(n>=buflen) {
+			if((samps_written = fputfbufEx(bigfbuf,(int) buflen,ofd))<0) {
+				fprintf(stdout,"ERROR: Can't write to output soundfile: (is hard-disk full?).\n");
+				fflush(stdout);
+				Mfree(bigfbuf);
+				sndcloseEx(ofd);
+				return 1;
+			}
+			n = 0;
+		}		
+	}
+	if(n > 0) {
+		if((samps_written = fputfbufEx(bigfbuf,(int)n,ofd))<0) {
+			fprintf(stdout,"ERROR: Can't write to output soundfile: (is hard-disk full?).\n");
+			fflush(stdout);
+			Mfree(bigfbuf);
+			sndcloseEx(ofd);
+			return 1;
+		}
+	}
+	fclose(fp);
+	if (!headwrite(ofd,origchans,origstype,origrate,arate,Mlen,Dfac)) {
+		fprintf(stdout,"ERROR: Failed to write valid header to output file.\n");
+		fflush(stdout);
+		sndunlink(ofd);
+	}
+	Mfree(bigfbuf);
+	sndcloseEx(ofd);
+//	sffinish();
+	return 1;
+}
+
+/***************************** HEADWRITE *******************************/
+
+int headwrite(int ofd,int origchans,int origstype,int origrate,float arate,int Mlen,int Dfac)
+{
+	int property_marker = 1;
+
+	if(sndputprop(ofd,"orig channels", (char *)&origchans, sizeof(int)) < 0){
+		fprintf(stdout,"ERROR: Failure to write original channel data: headwrite()\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sndputprop(ofd,"original sampsize", (char *)&origstype, sizeof(int)) < 0){
+		fprintf(stdout,"ERROR: Failure to write original sample size. headwrite()\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sndputprop(ofd,"original sample rate", (char *)&origrate, sizeof(int)) < 0){
+		fprintf(stdout,"ERROR: Failure to write original sample rate. headwrite()\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sndputprop(ofd,"arate",(char *)&arate,sizeof(float)) < 0){
+		fprintf(stdout,"ERROR: Failed to write analysis sample rate. headwrite()\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sndputprop(ofd,"analwinlen",(char *)&Mlen,sizeof(int)) < 0){
+		fprintf(stdout,"ERROR: Failure to write analysis window length. headwrite()\n");
+		fflush(stdout);
+		return(0);
+	}
+	if(sndputprop(ofd,"decfactor",(char *)&Dfac,sizeof(int)) < 0){
+		fprintf(stdout,"ERROR: Failure to write decimation factor. headwrite()\n");
+		fflush(stdout);
+		return(0);
+	}
+    if(sndputprop(ofd,"is a pitch file", (char *)&property_marker, sizeof(int)) < 0){
+		fprintf(stdout,"ERROR: Failure to write pitch property: headwrite()\n");
+		fflush(stdout);
+		return(0);
+    }
+	return(1);
+}

dev/misc/progmach.c

@@ -0,0 +1,486 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/******** This program is called from TK/TCL to check file compatibility ******
+	***** and hence determine which programs will run with current files ******
+
+					see progmach.tk
+
+INPUT PARAMETERS TO THIS PROGRAM ARE
+
+(a)	#THESE ACCUMULATING FLAGS
+	1)	Count of input files
+	2)	Filetype of 1st infile
+	3)	Filetype of current infile
+	4)	shared- filetypes
+	5)	Bitflag re file compatibility (16+8+4+2)
+	#			16 = ALL INFILES OF SAME TYPE
+	#			8  = ALL INFILES OF SAME SRATE
+	#			4  = ALL INFILES OF SAME CHANNEL COUNT
+	#			2  = ALL INFILES HAVE ALL OTHER PROPERTIES COMPATIBLE
+	#			1  = AT LEAST 1 OF INFILES IS A BINARY FILE
+	#PROPS OF 1ST FILE (ONCE ASCERTAINED)
+	6)	srate
+	7)	chans
+	8)	arate
+	9)	stype
+	10)	origstype
+	11)	origrate
+	12)	Mlen
+	13)	Dfac
+	14)	origchans
+	15)	specenvcnt
+	16)	descriptor_samps
+
+b)	#THE FOLLOWING PROPERTIES OF THE CURRENT INPUT FILE
+	17)	filetype
+	18)	srate
+	19)	channels
+	20)	arate
+	21)	stype
+	22)	origstype
+	23)	origrate
+	24)	Mlen
+	25)	Dfac
+	26)	origchans
+	27)	specenvcnt
+	28)	descriptor_samps
+***********/
+
+#include <stdlib.h>
+//TW UPDATE
+#include <osbind.h>
+#include <stdio.h>
+#include <ctype.h>
+#include "filetype.h"
+#include <string.h>
+
+#define	SAME_FILETYPE_BIT	(16)
+#define	SAME_SRATE_BIT		(8)
+#define	SAME_CHANNELS_BIT	(4)
+#define	SAME_PROPS_BIT		(2)
+#define	ONE_BINFILE_BIT		(1)
+
+/* convert filetype to filetype-bit N  -> 2^(N-1) */
+
+#define	BRKFILE_BIT			 (1)		/* #define	BRKFILE			 (1) */
+#define	DB_BRKFILE_BIT		 (2)		/* #define	DB_BRKFILE		 (2) */
+#define UNRANGED_BRKFILE_BIT (4)		/* #define UNRANGED_BRKFILE  (3) */
+#define NUMLIST_BIT			 (8)		/* #define NUMLIST			 (4) */
+#define SNDLIST_BIT		 	 (16)		/* #define SNDLIST		 	 (5) */
+#define SYNCLIST_BIT		 (32)		/* #define SYNCLIST		 	 (6) */
+#define MIXFILE_BIT		     (64)		/* #define MIXFILE		     (7) */
+#define LINELIST_BIT		 (128)		/* #define LINELIST		 	 (8) */
+#define TEXTFILE_BIT		 (256)		/* #define TEXTFILE		 	 (9) */
+#define	SNDFILE_BIT			 (512)		/* #define	SNDFILE			 (10) */
+#define	ANALFILE_BIT		 (1024)		/* #define	ANALFILE		 (11) */
+#define	PITCHFILE_BIT		 (2048)		/* #define	PITCHFILE		 (12) */
+#define TRANSPOSFILE_BIT	 (4096)		/* #define TRANSPOSFILE	 	 (13) */
+#define	FORMANTFILE_BIT		 (8192)		/* #define	FORMANTFILE		 (14) */
+#define	ENVFILE_BIT			 (16384)	/* #define	ENVFILE			 (15) */
+
+#define SPECTRAL_BITS		 (15460)	/* All spectral type files */
+#define POSTANAL_BITS		 (14336)	/* pitch, transpos & formant files */
+#define BINFILE_BITS		 (32256)	/* All sndsys files: i.e. snd + spectral + envel */
+char	errstr[400];
+
+int convert_filetype_to_bit(int filetype);
+int flteq(double f1,double f2);
+unsigned int hz1000();
+const char* cdp_version = "7.1.0";
+
+int main(int argc, char *argv[])
+{
+	int 	filecnt, filetype, bitflag, channels;
+	int 	stype, origstype, Mlen, Dfac, origchans, specenvcnt, descriptor_samps;
+	int		srate, origrate, S_filetype;
+	double 	arate;
+//TW UPDATE
+	unsigned int start = hz1000();
+	
+	int		N_filetype, N_channels, N_stype, N_origstype, N_Mlen, N_Dfac;
+	int		N_origchans, N_specenvcnt, N_descriptor_samps;
+	int		N_srate, N_origrate;
+	double 	N_arate;
+	
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc!=29) {
+		fprintf(stdout,"ERROR: Bad number of arguments to progmach.\n");
+//TW UPDATE, as are all the following similar timer-insertions
+		while (!(hz1000() - start))
+			;
+		return -1;	   	/* is this correct way to return an error to TK ?? Ditto below!! */
+	}
+	if(sscanf(argv[1],"%d",&filecnt)!=1) {
+		fprintf(stdout,"ERROR: Bad filecnt argument to progmach.\n");
+		while (!(hz1000() - start))
+			;
+		return -1;
+	}
+	if(sscanf(argv[5],"%d",&bitflag)!=1) {
+		fprintf(stdout,"ERROR: Bad bitflag argument to progmach.\n");
+		while (!(hz1000() - start))
+			;
+		return -1;
+	}
+
+	if(filecnt < 0) {
+		fprintf(stdout,"ERROR: Bad value (%d) for filecnt in progmach.\n",filecnt);
+		while (!(hz1000() - start))
+			;
+		return -1;
+	} else if(filecnt==0) {
+
+	/* GET PARAMETERS FROM THE INFILE */
+
+		if(sscanf(argv[17],"%d", &filetype)!=1) {
+			fprintf(stdout,"ERROR: Bad filetype argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[18],"%d",&srate)!=1) {
+			fprintf(stdout,"ERROR: Bad srate argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[19],"%d", &channels)!=1) {
+			fprintf(stdout,"ERROR: Bad channels argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[20],"%lf",&arate)!=1) {
+			fprintf(stdout,"ERROR: Bad arate argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[21],"%d", &stype)!=1) {
+			fprintf(stdout,"ERROR: Bad stype argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[22],"%d", &origstype)!=1) {
+			fprintf(stdout,"ERROR: Bad origstype argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[23],"%d",&origrate)!=1) {
+			fprintf(stdout,"ERROR: Bad origrate argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[24],"%d", &Mlen)!=1) {
+			fprintf(stdout,"ERROR: Bad Mlen argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[25],"%d", &Dfac)!=1) {
+			fprintf(stdout,"ERROR: Bad Dfac argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[26],"%d", &origchans)!=1) {
+			fprintf(stdout,"ERROR: Bad origchans argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+	 	if(sscanf(argv[27],"%d", &specenvcnt)!=1) {
+			fprintf(stdout,"ERROR: Bad specenvcnt argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[28],"%d", &descriptor_samps)!=1) {
+			fprintf(stdout,"ERROR: Bad descriptor_samps argument to progmach from file %d.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		N_filetype = filetype;	  	/* current filetype = first filetype */
+ 		S_filetype = filetype;		/* shared filetype  = first filetype */
+
+	} else {	/* NOT THE FIRST FILE */
+
+	/* GET PARAMETERS FROM THE CUMULATIVE FLAG */
+
+		if(sscanf(argv[2],"%d",&filetype)!=1) {
+			fprintf(stdout,"ERROR: Bad file-0-type argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[4],"%d",&S_filetype)!=1) {
+			fprintf(stdout,"ERROR: Bad shared-filetypes argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[6], "%d",&srate)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 sample-rate argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[7], "%d",&channels)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 channels argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[8], "%lf",&arate)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 analysis-rate argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[9], "%d",&stype)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 sample-type argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[10], "%d",&origstype)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 original-sample-type argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[11],"%d",&origrate)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 original-sample-rate argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[12],"%d",&Mlen)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 Mlen argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[13],"%d",&Dfac)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 decimation-factor argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[14],"%d",&origchans)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 original-channels argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[15],"%d",&specenvcnt)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 specenvcnt argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[16],"%d",&descriptor_samps)!=1) {
+			fprintf(stdout,"ERROR: Bad file_0 descriptor_samps argument to progmach.\n");
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+
+	/* THEN GET PARAMETERS FROM THE INFILE */
+
+		if(sscanf(argv[17],"%d", &N_filetype)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d filetype argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;					
+		}
+/**
+		N_filetype = convert_filetype_to_bit(N_filetype);
+**/
+		if(sscanf(argv[18],"%d",&N_srate)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d sample-rate argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[19],"%d", &N_channels)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d channels argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[20],"%lf",&N_arate)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d analysis-rate argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;		
+		}
+		if(sscanf(argv[21],"%d", &N_stype)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d sample-type argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[22],"%d", &N_origstype)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d original-sample-type argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[23],"%d",&N_origrate)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d original-sample-rate argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[24],"%d", &N_Mlen)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d Mlen argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[25],"%d", &N_Dfac)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d decimation-factor argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[26],"%d", &N_origchans)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d original-channels argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+	 	if(sscanf(argv[27],"%d", &N_specenvcnt)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d specenvcnt argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+		if(sscanf(argv[28],"%d", &N_descriptor_samps)!=1) {
+			fprintf(stdout,"ERROR: Bad file %d descriptor_samps argument to progmach.\n",filecnt+1);
+			while (!(hz1000() - start))
+				;
+			return -1;
+		}
+
+	/* TEST THE NEW FILE AGAINST THE FIRST FILE */
+
+		if(bitflag & SAME_FILETYPE_BIT) {				/* if not same filetype */
+			if(N_filetype & IS_A_SNDSYSTEM_FILE) {
+				if(N_filetype!=filetype) {
+					bitflag &= (~SAME_FILETYPE_BIT);	/* unset SAME_FILETYPE_BIT */
+				}				
+			} else if((S_filetype &= N_filetype)==0) 	/* generate shared-filetypes */
+				bitflag &= (~SAME_FILETYPE_BIT);		/* unset SAME_FILETYPE_BIT */
+		}									
+
+		/* if not same srate */
+		if((bitflag & SAME_SRATE_BIT) && N_srate!=srate)
+			bitflag &= (~SAME_SRATE_BIT);				/* unset SAME_SRATE_BIT */
+
+		if(bitflag & SAME_CHANNELS_BIT) {
+														/* if 1 file is analfile, and other is anal-derived */
+													 	/* compare channels with origchans: if not equal */
+			if((filetype == IS_AN_ANALFILE) && ((N_filetype & IS_A_PTF_BINFILE)>ANALFILE)) {
+				if(channels != N_origchans)
+					bitflag &= (~SAME_CHANNELS_BIT);	/* unset SAME_CHANNELS_BIT */
+			} else if(((filetype & IS_A_PTF_BINFILE) > ANALFILE) && (N_filetype == IS_AN_ANALFILE)) {
+		 		if(N_channels != origchans)				 
+					bitflag &= (~SAME_CHANNELS_BIT);	/* simil */
+			} else if(channels != N_channels)			/* else simply compare channel-count, & if not equal */
+				bitflag &= (~SAME_CHANNELS_BIT);		/* unset SAME_CHANNELS_BIT */
+		}
+
+		if(bitflag & SAME_PROPS_BIT) {				    
+									  					/* If NOT (an analfile + a derived-from-anal file) */
+			if(!((filetype == IS_AN_ANALFILE) && ((N_filetype & IS_A_PTF_BINFILE)>ANALFILE))
+		    && !(((filetype & IS_A_PTF_BINFILE)>ANALFILE) && (N_filetype == IS_AN_ANALFILE))
+			&& origchans != N_origchans)				/* compare origchans, and if not equal.. */
+				bitflag &= (~SAME_PROPS_BIT);			/* unset SAME_PROPS_BIT */
+
+														/* If both are formants files */
+														/* & formant properties don't tally...*/
+			if((filetype == IS_A_FORMANTFILE) && (N_filetype == IS_A_FORMANTFILE)
+			&&((specenvcnt != N_specenvcnt) || (descriptor_samps != N_descriptor_samps)))
+				bitflag &= (~SAME_PROPS_BIT);			/* unset SAME_PROPS_BIT */
+			if(filetype != IS_A_SNDFILE) {
+				if((!flteq(arate,N_arate))					/* compare all other properties */
+//TW JUNE 2004: stype compatibility is no longer relevant: all internal calcs are floating point!!
+			/*	|| (origstype 		 != N_origstype) */
+				|| (origrate  		 != N_origrate)
+				|| (Mlen 	  		 != N_Mlen)
+				|| (Dfac 	  		 != N_Dfac)
+//TW JUNE 2004: stype compatibility is no longer relevant: all internal calcs are floating point!!
+			/*	|| (stype 			 != N_stype) */)
+					bitflag &= (~SAME_PROPS_BIT);			/* and if they don't tally. unset SAME_PROPS_BIT */
+			}
+		}
+	}
+
+	/* ARE THERE ANY BINARY P or T FILES, SO FAR */
+	/* Strictly speaking I'm being overlax in allowing binary Formant files here */ 
+	/*	but as there are no non-binary formant-files, no need to test for them!! */
+
+	if(!(bitflag & ONE_BINFILE_BIT)) {		       
+		if((N_filetype & IS_A_PTF_BINFILE)>ANALFILE)	/* IF current file is a binary filetype */
+			bitflag |= ONE_BINFILE_BIT;					/* set (at-least-one-binary-file)-BIT */
+	}
+
+	/* INCREMENT FILECNT */
+	filecnt++;
+
+	/* PRINT OUT THE CUMULATIVE FLAG */
+
+	fprintf(stdout,"%d %d %d %d %d %d %d %lf %d %d %d %d %d %d %d %d\n",
+			filecnt,filetype,N_filetype,S_filetype,bitflag,srate,channels,arate,stype,
+			origstype,origrate,Mlen,Dfac,origchans,specenvcnt,descriptor_samps);
+	return 0;
+}
+
+/**************************** FLTEQ *******************************/
+
+#define FLTERR (0.000002)
+
+int flteq(double f1,double f2)
+{   
+	double upperbnd, lowerbnd;
+	upperbnd = f2 + FLTERR;		
+	lowerbnd = f2 - FLTERR;		
+	if((f1>upperbnd) || (f1<lowerbnd))
+		return(0);
+	return(1);
+}
+

dev/misc/pview_flt.c

@@ -0,0 +1,343 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/**************************************************************************
+ *
+ * Convert snd data to text format suitable for Pview in Sound Loom
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <osbind.h>
+#include <math.h>
+#include <float.h>
+#include <sfsys.h>
+
+/*RWD: changed all fprintf tests to < 0 */
+/*Aug10-2005: fixed buflen bug from TW report */
+
+
+#define SHORTMONOSCALE		256.0		/* Scales shorts in range 0-32768 to display in range 0 128 */
+#define SHORTSTEREOSCALE	512.0		/* Scales shorts in range 0-32768 to display in stereorange 0 64 */
+#define FLOATMONOSCALE		128.0		/* Scales shorts in range 0-32768 to display in range 0 128 */
+#define FLOATSTEREOSCALE	64.0		/* Scales shorts in range 0-32768 to display in stereorange 0 64 */
+#define VIEW_WIDTH			900.0		/* width of sloom display */
+
+#define F_SECSIZE (512.0)
+/* 	Functions	*/
+
+static	int		tidy_up(int,unsigned int);
+static  int		open_in(char*);
+static	int		get_big_buf(void);
+static	int		make_textfile(char *filename);
+
+
+/*short *bigbuf;	*/	/* buffer used to read samples from soundfile 	*/
+float *bigbuf;
+
+size_t buflen;				/* buffer length in bytes			*/
+int  ifd;					/* input soundfile descriptor		*/
+int srate;					/* sampling rate of input			*/
+int  channels;				/* number of channels of input		*/
+int startsamp, endsamp;
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char *argv[])
+{
+	unsigned int start = hz1000();
+	char filename[200];
+
+	if((argc==2) && strcmp(argv[1],"--version")==0) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc!=4)  {
+		fprintf(stdout,"ERROR: Wrong number of arguments.\n");
+		fflush(stdout);
+		return tidy_up(2,start);
+	}
+	if(sscanf(argv[2],"%d",&startsamp)!=1) {
+		fprintf(stdout,"ERROR: cannot read start sample number.\n");
+		fflush(stdout);
+		return tidy_up(2,start);
+	}
+	if(sscanf(argv[3],"%d",&endsamp)!=1) {
+		fprintf(stdout,"ERROR: cannot read end sample number.\n");
+		fflush(stdout);
+		return tidy_up(2,start);
+	}
+	/* open input file */
+	if(open_in(argv[1]) < 0)
+		return tidy_up(2,start);
+
+	strcpy(filename,argv[1]);
+
+	/* get biggest buffer */
+	if(get_big_buf() == 0)
+		return tidy_up(1,start);
+		
+	/* max soundfiles */
+	if(make_textfile(filename)<0)
+		return tidy_up(1,start);
+
+	/* tidy up */
+	return tidy_up(0,start);
+}
+
+/**************************** OPEN_IN ****************************
+ *
+ * opens input soundfile and gets header 
+ */
+
+int open_in(char *name)	/* opens input soundfile and gets header */
+{
+	
+
+	if( (ifd = sndopenEx(name,0,CDP_OPEN_RDONLY)) < 0 )	{
+		fprintf(stdout,"INFO: Cannot open file: %s\n\t",name);
+		fflush(stdout);
+		return(-1);
+	}
+
+	/*	get sampling rate	*/
+
+	if(sndgetprop(ifd,"sample rate", (char *)&srate,sizeof(int)) < 0) {
+		srate = 44100;
+		fprintf(stdout,"WARNING: Cannot get sampling rate of %s : Default of 44100 assumed\n",name);
+		fflush(stdout);
+	}
+
+	/*	get channels 		*/
+
+	if(sndgetprop(ifd, "channels", (char*)&channels, sizeof(int)) < 0) {
+		channels = 2;
+		fprintf(stdout,"WARNING: Cannot get channels of %s Default of STEREO assumed\n",name);
+		fflush(stdout);
+	}
+	return 0;
+}
+
+/**************************** GET_BIG_BUF ****************************
+ *
+ * allocates memory for the biggest possible buffer 
+ */
+
+int	get_big_buf()
+{
+	size_t i;
+
+	buflen = (size_t) Malloc(-1) - sizeof(float);	/* allow for alignment */
+
+	/* if less than one sector available */
+	if( buflen < (F_SECSIZE * sizeof(float)) || (bigbuf=(float*)Malloc(buflen+sizeof(float))) == NULL) {
+		fprintf(stdout,"ERROR: Failed to allocate float buffer.\n");
+		fflush(stdout);
+		return 0;
+	}
+	i = ((size_t)bigbuf+sizeof(float)-1)/sizeof(float)*sizeof(float);	/* align bigbuf to word boundary */
+	bigbuf = (float*)i;
+	buflen = (size_t)((buflen/F_SECSIZE)*F_SECSIZE);
+	buflen /= sizeof(float);
+	/*Aug10-2005 */
+	buflen /= channels;
+	buflen *= channels;
+	return 1;
+}
+
+/**************************** MAKE TEXTFILE *****************************/
+
+int make_textfile(char *filename)
+{
+	int sampsgot, n, m, zoomfact;
+	double gpsample0, gpsample1;
+	int total_samps_got;
+	int gpcnt, sampout, sampouttrue;
+
+	/*RWD*/
+	int linecount = 0;
+
+	/* check header first */
+	FILE *fp;
+
+	/* read and find maximum */
+
+	if(channels > 2) {
+		fprintf(stdout,"ERROR: Process only works with mono or stereo files\n");
+		fflush(stdout);
+		return -1;
+	}
+	if((fp = fopen("cdptest00.txt","w"))==NULL) {
+		fprintf(stdout, "ERROR: Failed to open the Sound Loom display file 'cdptest00.txt'\n");
+		fflush(stdout);
+		return -1;
+	}
+	zoomfact = max(1,(int)ceil((double)(endsamp - startsamp)/VIEW_WIDTH));
+	if(fprintf(fp,"%d\n",zoomfact) < 1) {
+		fclose(fp);
+		fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+		fflush(stdout);
+		return -1;
+	}
+	gpcnt = 0;
+	gpsample0 = 0.0;
+	gpsample1 = 0.0;
+	total_samps_got = 0;
+	while((sampsgot = fgetfbufEx(bigbuf,(int) buflen,ifd,1)) > 0 ) {
+		switch(channels) {
+		case(1):
+			for(n=0;n<sampsgot;n++) {
+				total_samps_got++;
+				if(total_samps_got <= startsamp)
+					continue;
+				else if(total_samps_got > endsamp)
+					break;
+				if(zoomfact == 1)
+					gpsample0 = bigbuf[n];
+				else
+					gpsample0 += fabs(bigbuf[n]);
+				gpcnt++;
+				if(gpcnt >= zoomfact) {
+					gpsample0 /= (double)zoomfact;
+					sampout = (short)round(gpsample0 * FLOATMONOSCALE); 
+					if(fprintf(fp,"%lf %d\n",gpsample0,sampout) < 0) {
+						fclose(fp);
+						fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+						fflush(stdout);
+						return -1;
+					}
+					gpsample0 = 0.0;
+					gpcnt = 0;
+				}
+			}
+			if(gpcnt > 0) {
+				gpsample0 /= (double)gpcnt;
+				sampout = (short)round(gpsample0 * FLOATMONOSCALE); 
+					if(fprintf(fp,"%lf %d\n",gpsample0,sampout) < 0) {
+					fclose(fp);
+					fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+					fflush(stdout);
+					return -1;
+				}
+			}
+			break;
+		case(2):
+			for(n=0,m=1;m<sampsgot;n+=2,m+=2) {		 /*RWD test was using n */
+				total_samps_got++;
+				if(total_samps_got <= startsamp)
+					continue;
+				else if(total_samps_got > endsamp)
+					break;
+				if(zoomfact == 1) {
+					gpsample0 = bigbuf[n];
+					gpsample1 = bigbuf[m];
+				} else {
+					gpsample0 += fabs(bigbuf[n]);
+					gpsample1 += fabs(bigbuf[m]);
+				}
+				gpcnt++;
+				if(gpcnt >= zoomfact) {
+					gpsample0 /= (double)zoomfact;
+					gpsample1 /= (double)zoomfact;
+					sampout = (short)round(gpsample0 * FLOATSTEREOSCALE); 
+					
+					linecount++;
+					if(fprintf(fp,"%lf %d\n",gpsample0,sampout) < 0) {
+						fclose(fp);
+						fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+						fflush(stdout);
+						return -1;
+					}
+					sampout = (short)round(gpsample1 * FLOATSTEREOSCALE);
+					
+					linecount++;
+					if(fprintf(fp,"%lf %d\n",gpsample1,sampout) < 0) {
+						fclose(fp);
+						fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+						fflush(stdout);
+						return -1;
+					}
+					gpsample0 = 0.0;
+					gpsample1 = 0.0;
+					gpcnt = 0;
+				}
+			}
+			if(gpcnt > 0) {
+				gpsample0 /= (double)gpcnt;
+				gpsample1 /= (double)gpcnt;
+				sampout = (short)round(gpsample0 * FLOATSTEREOSCALE);
+				
+				linecount++;
+				if(fprintf(fp,"%lf %d\n",gpsample0,sampout) < 0) {
+					fclose(fp);
+					fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+					fflush(stdout);
+					return -1;
+				}
+				sampouttrue = (short)round(gpsample1);
+				sampout = (short)round(gpsample1 * FLOATSTEREOSCALE);
+				
+				linecount++;
+				if(fprintf(fp,"%lf %d\n",gpsample1,sampout) < 0) {
+					fclose(fp);
+					fprintf(stdout, "ERROR: Failed to complete data write to Sound Loom display file 'cdptest00.txt'\n");
+					fflush(stdout);
+					return -1;
+				}
+			}
+			break;
+		default:	  /*RWD*/
+			break;
+		}
+/*		break; */
+	}
+	fclose(fp);
+	return(0);
+}
+
+/**************************** TIDY_UP ****************************
+ *
+ * Exit, freeing buffers and closing files where necessary.
+ */
+
+int tidy_up(int where,unsigned int start)
+{
+	switch(where) {
+	case 0:
+		Mfree(bigbuf);
+	case 1:
+		sndcloseEx(ifd);
+	case 2:
+		sffinish();
+	default:
+		break;
+	}
+	while(!(hz1000() - start))
+		;
+	return(1);
+}
+	

dev/misc/stretcha.c

@@ -0,0 +1,387 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/*
+ *	$Log: stretcha.c%v $
+ * Revision 1.1  1995/12/20  17:28:54  trevor
+ * Initial revision
+ *
+ */
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include "sfsys.h"
+				   
+const char* cdp_version = "7.1.0";
+
+#define	PROG "STRETCHA"
+
+#define STRETCH			(1)
+#define DUR 			(1)
+#define	BEATS			(2)
+#define	TEMPO			(4)
+#define BEATS_AND_TEMPO	(6)
+#define	MINUTE			(60.0)
+#define	ENDOFSTR		('\0')
+#define FLTERR	    0.000002
+
+int		inputt = 0, outputt = 0, result = 0;
+double	dur, beats, tempo, odur, obeats, otempo, answer;
+
+char	zag = (char)0, tthis;
+
+void	usage(void), help(void), logo(void);
+//void	read_properties(void);
+//void	write_properties(void);
+void	process_file(char *);
+void 	do_fraction(double);
+int 	flteq(double,double);
+
+
+
+#define finish(x)  return((x))
+
+int
+main(int argc, char *argv[])
+{
+	int n,ifd = -1;
+    int infilesize = 0;
+    SFPROPS props;
+
+	if(sflinit("stretcha")) {
+		sfperror("Initialisation");
+		finish(1);
+	}
+    if(argc==2 && strcmp(argv[1],"--version")==0){
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if(argc==2 && !strcmp(argv[1],"-h")) {
+		help();
+        return 0;
+    }
+    if(argc < 4 || argc > 6){
+		usage();
+        return 1;
+    }
+	if(*argv[1]++!='-') {
+	 	fprintf(stderr,"Parameter 1 must be a flag.\n");
+		finish(1);
+	}
+ 	switch(*argv[1]) {
+	case('s'):	result = STRETCH;	break;
+	case('c'):	result = BEATS;		break;
+	default:
+	 	fprintf(stderr,"Unknown flag '-%c' as 1st parameter.\n",*argv[1]);
+		finish(1);
+	}
+	n = 2;
+	while(n<argc) {
+		if(*argv[n]++!='-') {
+		 	fprintf(stderr,"Unknown parameter '%s'.\n",--argv[n]);
+			finish(1);
+		}
+		tthis = *argv[n];
+		switch(*argv[n]++) {
+		case('d'):
+			if(inputt & DUR) {
+				if(tthis==zag)
+					fprintf(stderr,"Repetition of flag -%c\n",zag);
+				else
+					fprintf(stderr,"You cannot have 2 input durations (-d and -f).\n");
+				finish(1);
+			}
+			zag = 'd';
+			if((inputt & TEMPO) || (inputt & BEATS)) {
+				fprintf(stderr,"You cannot have input duration (-%c) AND input tempo (-t) or beatcnt (-b).\n",zag);
+				finish(1);
+			}
+			inputt |= DUR;
+			if(sscanf(argv[n],"%lf",&dur)!=1) {
+				fprintf(stderr,"Cannot read duration value with -d flag.\n");
+				finish(1);
+			}
+			break;
+		case('f'):
+			if(inputt & DUR) {
+				if(tthis==zag)
+					fprintf(stderr,"Repetition of flag -%c\n",zag);
+				else
+					fprintf(stderr,"You cannot have 2 input durations (-d and -f).\n");
+				finish(1);
+			}
+			zag = 'f';
+			if((inputt & TEMPO) || (inputt & BEATS)) {
+				fprintf(stderr,"You cannot have input duration (-%c) AND input tempo (-t) or beatcnt (-b).\n",zag);
+				finish(1);
+			}
+			inputt |= DUR;
+			//open_infile(argv[n]);
+			//read_infile_size();
+			//read_and_check_properties();
+            ifd = sndopenEx(argv[n],0,CDP_OPEN_RDONLY);
+            if(ifd < 0){
+                fprintf(stderr,"unable to open sfile %s: %s\n",argv[n],sferrstr());
+                return 1;
+            }
+            infilesize = sndsizeEx(ifd);
+            if(infilesize < 0){
+                fprintf(stderr,"error reading sfile %s: %s\n",argv[n],sferrstr());
+                return 1;
+            }
+            if(snd_headread(ifd,&props) < 0){
+                fprintf(stderr,"error reading sfile props: %s: %s\n",argv[n],sferrstr());
+                return 1;
+            }
+			dur	 = (double)(infilesize/props.chans)/(double) props.srate;
+			break;
+		case('b'):
+			if(inputt & BEATS)
+				fprintf(stderr,"Repetition of flag -b\n");
+			inputt |= BEATS;
+			if(inputt & DUR) {
+				fprintf(stderr,"You cannot have input duration (-%c) AND input beatcnt (-b).\n",zag);
+				finish(1);
+			}
+			if(sscanf(argv[n],"%lf",&beats)!=1) {
+				fprintf(stderr,"Cannot read number of beats with -b flag.\n");
+				finish(1);
+			}
+			break;
+		case('t'):
+			if(inputt & TEMPO)
+				fprintf(stderr,"Repetition of flag -t\n");
+			inputt |= TEMPO;
+			if(inputt & DUR) {
+				fprintf(stderr,"You cannot have input duration (-%c) AND input tempo (-t).\n",zag);
+				finish(1);
+			}
+			if(sscanf(argv[n],"%lf",&tempo)!=1) {
+				fprintf(stderr,"Cannot read tempo value with -t flag.\n");
+				finish(1);
+			}
+			break;
+		case('D'):
+			if(outputt & DUR)
+				fprintf(stderr,"Repetition of flag -D\n");
+			outputt |= DUR;
+			if((outputt & TEMPO) || (outputt & BEATS)) {
+				fprintf(stderr,"You can't have output duration (-D) AND output tempo (-T) or output beatcnt (-B).\n");
+				finish(1);
+			}
+			if(sscanf(argv[n],"%lf",&odur)!=1) {
+				fprintf(stderr,"Cannot read output duration value with -D flag.\n");
+				finish(1);
+			}
+			break;
+		case('B'):
+			if(outputt & BEATS)
+				fprintf(stderr,"Repetition of flag -B\n");
+			outputt |= BEATS;
+			if(outputt & DUR) {
+				fprintf(stderr,"You can't have output duration (-D) AND output beatcnt (-B).\n");
+				finish(1);
+			}
+			if(sscanf(argv[n],"%lf",&obeats)!=1) {
+				fprintf(stderr,"Cannot read number of output beats with -B flag.\n");
+				finish(1);
+			}
+			break;
+		case('T'):
+			if(outputt & TEMPO)
+				fprintf(stderr,"Repetition of flag -T\n");
+			outputt |= TEMPO;
+			if(outputt & DUR) {
+				fprintf(stderr,"You can't have output duration (-D) AND output tempo (-T).\n");
+				finish(1);
+			}
+			if(sscanf(argv[n],"%lf",&otempo)!=1) {
+				fprintf(stderr,"Cannot read output tempo value with -T flag.\n");
+				finish(1);
+			}
+			break;
+		default:
+		 	fprintf(stderr,"Unknown flag '-%c'.\n",*--argv[n]);
+			finish(1);
+		}
+		n++;
+	}
+	if(!inputt) {
+		fprintf(stderr,"No input values given (-d,-f,-t,-b).\n");
+		finish(1);
+	}
+	if(!outputt) {
+		fprintf(stderr,"No output values given (-D,-T,-B).\n");
+		finish(1);
+	}
+	if(result==BEATS && outputt!=TEMPO) {
+		if(outputt & TEMPO)
+			fprintf(stderr,"For a crotchet count (-c) you must have output tempo (-T) ONLY.\n");
+		else
+			fprintf(stderr,"For a crotchet count (-c) you must have output tempo (-T) (ONLY).\n");
+		finish(1);
+	}
+	if((outputt & BEATS) && !(outputt & TEMPO)) {
+		fprintf(stderr,"Output beatcount given (-B) WITHOUT output tempo (-T).\n");
+		finish(1);
+	}
+	if((inputt & BEATS) && !(inputt & TEMPO)) {
+		fprintf(stderr,"Input beatcount given (-b) WITHOUT input tempo (-t).\n");
+		finish(1);
+	}
+	if(inputt==TEMPO && result!=STRETCH) {
+		fprintf(stderr,"Tempo input (-t) ALONE, can only be used with stretching (-s).\n");
+		fprintf(stderr,"Otherwise you need an input beatcount (-b).\n");
+		finish(1);
+	}
+	if(inputt==TEMPO && outputt!=TEMPO) {
+		fprintf(stderr,"Tempo input ONLY (-t), with stretching (-s), needs a tempo ONLY output (-T).\n");
+		fprintf(stderr,"Otherwise you need an input beatcount (-b).\n");
+		finish(1);
+	}
+	if(inputt!=TEMPO &&	result==BEATS && outputt!=TEMPO) {
+		fprintf(stderr,"Output must be tempo ONLY (-T) with crotchet count (-b).\n");
+		finish(1);
+	}
+	if(inputt!=TEMPO &&	result==STRETCH && outputt==TEMPO) {
+		fprintf(stderr,"Output must be duration (-D: or -T WITH -B) if stretching (-s) a duration.\n");
+		finish(1);
+	}
+	switch(result) {
+	case(BEATS):
+		if(inputt==BEATS_AND_TEMPO)
+			dur  = beats * MINUTE/tempo;
+		answer = dur * otempo/MINUTE;
+		printf("Number of beats at new tempo = %lf ",answer);
+		do_fraction(answer);
+		if(!flteq(answer,1.0) && answer < 1.0)
+			printf("of a ");
+		printf("crotchet");
+		if(!flteq(answer,1.0) && answer > 1.0)
+			printf("s");
+		printf("\n");
+		break;						
+	case(STRETCH):
+		if(inputt==TEMPO)
+			answer = tempo/otempo;
+		else {
+			if(inputt == BEATS_AND_TEMPO)
+				dur  = beats * MINUTE/tempo;
+			if(outputt== BEATS_AND_TEMPO)
+				odur = obeats * MINUTE/otempo;
+			answer = odur/dur;
+		}
+		printf("Stretchfactor = %lf\n",answer);
+		break;
+	}
+	finish(0);
+}
+
+/*************************************** USAGE ***********************************/
+
+void usage(void)
+{
+	logo();
+	fprintf(stderr, "USAGES:\n");
+	fprintf(stderr, "stretcha -c -ddur|-fsndfile|(-bbeats -ttempo) -Touttempo\n");
+	fprintf(stderr, "stretcha -s -ddur|-fsndfile|(-bbeats -ttempo) -Doutdur|(-Boutbeats -Touttempo)\n");
+	fprintf(stderr, "stretcha -s             -tintempo             -Touttempo\n\n");
+	fprintf(stderr, "-----------for more information, type 'stretcha -h' -------------\n");
+}
+/*************************************** HELP ***********************************/
+															  
+void help(void)
+{
+	fprintf(stderr, "stretcha -s takes...\n");
+	fprintf(stderr, "\t    An INPUT DURATION and an OUTPUT DURATION.\n");
+	fprintf(stderr, "\tOR: An INPUT TEMPO    and an OUTPUT TEMPO.\n");
+	fprintf(stderr, "It calculates stretch required to timewarp a sound from one frame to other.\n\n");
+	fprintf(stderr, "stretcha -c takes...\n");
+	fprintf(stderr, "\t    AN INPUT DURATION and AN OUTPUT TEMPO.\n");
+	fprintf(stderr, "It calculates number of crotchet beats sound will occupy at new tempo.\n\n");
+	fprintf(stderr, "INPUT DURATION is input in secs, or as a sndfile (the program finds its dur),\n");
+	fprintf(stderr, "	 or as a crotchet count (possibly fractional) WITH a tempo.\n");
+	fprintf(stderr, "OUTPUT DURATION can be secs, or can be a crotchet count WITH a tempo.\n\n");
+}
+
+/*********************************** DO_FRACTION ******************************/
+
+void do_fraction(double val)
+{
+	int n, m, k = 0;
+	double d, test;
+	for(n=2;n<17;n++) {
+		d = 1.0/(double)n;
+		if((test = fmod(val,d))< FLTERR || d - test < FLTERR) {
+			m = (int)(val/d);	/* truncate */
+			if(!flteq((double)m * d,val))
+				m++;  			
+			if(!flteq((double)m * d,val)) {
+				m-=2;  			
+				if(!flteq((double)m * d,val)) {
+				    fprintf(stderr,"Problem in fractions\n");
+				    return;
+				}
+			}			
+			if(m > n) {
+				k  = m/n;		/* truncate */
+				m -= k * n;
+			}
+			printf("(");
+			if(k)
+				printf("%d & ",k);
+			printf("%d/%d) ",m,n);
+			break;
+		}
+	}
+}
+
+/*********************************** FLTEQ ******************************/
+
+int flteq(double a,double b)
+{
+	double hibound = a + FLTERR;
+	double lobound = a - FLTERR;
+	if(b > hibound || b < lobound)
+		return(0);
+	return(1);
+}
+
+
+ /******************************** LOGO() **********************************/
+
+void logo()
+{   printf("\t    ***************************************************\n");
+    printf("\t    *           COMPOSERS DESKTOP PROJECT             *\n");
+    printf("\t                    %s $Revision: 6.0.0 $\n",PROG);
+    printf("\t    *                                                 *\n");
+    printf("\t    *       Calculate required time-stretches.        *\n");
+    printf("\t    *                                                 *\n");
+    printf("\t    *                by TREVOR WISHART                *\n");
+    printf("\t    ***************************************************\n\n");
+}
+

dev/misc/tkusage.c

@@ -0,0 +1,4941 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/*
+ * SOUND LOOM Release 9: November 2: 2004
+ */
+
+#include <stdio.h>
+#include <structures.h>
+#include <processno.h>
+#include <edit.h>
+#include <house.h>
+#include <string.h>
+
+#define TE_1	-1
+#define TE_2	-2
+#define TE_3	-3
+#define TE_4	-4
+#define TE_5	-5
+#define TE_6	-6
+#define TE_7	-7
+#define TE_8	-8
+#define TE_9	-9
+#define TE_10	-10
+#define TE_11	-11
+#define TE_12	-12
+#define TE_13	-13
+#define TE_14	-14
+#define TE_15	-15
+#define TE_16	-16
+#define TE_17	-17
+#define TE_18	-18
+#define TE_19	-19
+#define TE_20	-20
+#define TE_21	-21
+#define TE_22	-22
+#define TE_23	-23
+#define TE_24	-24
+#define TE_25	-25
+#define TE_26	-26
+#define TE_27	-27
+#define TE_28	-28
+#define TE_29	-29
+#define TE_30	-30
+#define TE_31	-31
+const char* cdp_version = "7.1.0";
+
+/******************************** TKUSAGE ********************************/
+
+int main(int argc, char *argv[])
+{
+	int process;
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc!=2) {
+		fprintf(stdout,"ERROR: Error in usage program tkusage\n");
+		return -1;
+	}
+	if(sscanf(argv[1],"%d",&process)!=1) {
+		fprintf(stdout,"ERROR: Failed to read process number in tkusage\n");
+		return -1;
+	}
+	switch(process) {
+	case(GAIN):
+		fprintf(stdout,"INFO: AMPLIFY OR ATTENUATE THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN may vary over time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(LIMIT):
+		fprintf(stdout,"INFO: ELIMINATE CHANNEL DATA BELOW A THRESHOLD AMP\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THRESHOLD AMPLITUDE may vary over time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BARE):
+		fprintf(stdout,"INFO: ZERO THE DATA IN CHANNELS WHICH DO NOT CONTAIN HARMONICS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Process needs TWO INPUT FILES,\n");
+		fprintf(stdout,"INFO: an Analysis File, and a Pitchfile you have derived from it.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The PITCHFILE should normally be extracted\n");
+		fprintf(stdout,"INFO: using KEEP PITCH ZEROS flag to mark any unpitched material.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CLEAN):
+		fprintf(stdout,"INFO: REMOVE NOISE FROM PVOC ANALYSIS FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXTRA FILE REQUIRED-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In all MODES except BY COMPARISON METHOD, ONE extra input file required.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Extra file is an analysis file cut from the 1st infile\n");
+		fprintf(stdout,"INFO: to show typical noise (only) component of main signal.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BY COMPARISON METHOD, TWO extra input files required.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Extra files are both analysis files cut from 1st infile\n");
+		fprintf(stdout,"INFO: to show typical noise (1st) & typical good signal (2nd).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FROM SPECIFIED TIME\n");
+		fprintf(stdout,"INFO:     Deletes channel (after skiptime) FROM THE TIME its level falls below\n");
+		fprintf(stdout,"INFO:     (noisgain adjusted) max level seen for that channel in comparison file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ANYWHERE\n");
+		fprintf(stdout,"INFO:     Deletes channel (after skiptime) ANYWHERE its level falls below\n");
+		fprintf(stdout,"INFO:     (noisgain adjusted) max level seen for that channel in comparison file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ABOVE SPECIFED FRQ\n");
+		fprintf(stdout,"INFO:     Deletes channel as in 'ANYWHERE'\n");
+		fprintf(stdout,"INFO:     but ONLY for channels of frq > LOW FRQ LIMIT.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BY COMPARISON METHOD\n");
+		fprintf(stdout,"INFO:     Deletes channel EVERYWHERE, whose level in GFILE is ALWAYS below\n");
+		fprintf(stdout,"INFO:     (noisgain adjusted) max level seen for same channel in NFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SKIPTIME.......may be set to time where good src. signal level established.\n");
+		fprintf(stdout,"INFO: NOISE PREGAIN..multiplies noiselevels found in comparison files\n");
+		fprintf(stdout,"INFO: before they are used for comparison with main signal.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CUT):
+		fprintf(stdout,"INFO: CUT SECTION OUT OF ANALYSIS FILE, BETWEEN STARTTIME & ENDTIME (SECS)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAB):
+		fprintf(stdout,"INFO: GRAB A SINGLE ANALYSIS WINDOW\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: at time FREEZE MOMENT.\n");
+		fprintf(stdout,"INFO: A time beyond end of file will grab last window in file,\n");
+		fprintf(stdout,"INFO: (window at time zero is always uninteresting).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MAGNIFY):
+		fprintf(stdout,"INFO: MAGNIFY A SINGLE ANALYSIS WINDOW\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: at time FREEZE MOMENT, to duration OUTFILE DURATION.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(STRETCH):
+		fprintf(stdout,"INFO: STRETCH THE FREQUENCIES IN THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ DIVIDE...............frq above or below which stretching takes place.\n");
+		fprintf(stdout,"INFO: TOP OF SPECTRUM STRETCH..transposition ratio for topmost spectral components.\n");
+		fprintf(stdout,"INFO: STRETCH EXPONENT.........specifies the type of stretching required.\n");
+		fprintf(stdout,"INFO: PROCESS DEPTH............controls effect on source (from no effect to full),\n");
+		fprintf(stdout,"INFO: .........................0 gives no stretching, 1 gives full stretching.\n");
+		fprintf(stdout,"INFO: .........................Use to change the stretching from moment to moment.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TSTRETCH):
+		fprintf(stdout,"INFO: TIME-STRETCHING OF INFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: without changing the pitch.\n");
+		fprintf(stdout,"INFO: In mode GET OUTPUT LENGTH, program calculates length of output, only.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ALT):
+		fprintf(stdout,"INFO: DELETE ALTERNATE HARMONICS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Requires TWO INPUT FILES, an Analysis file and a Pitch data file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Additional pitchfile must be derived from input analysis file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Mode DELETE ODD HARMONICS\n");
+		fprintf(stdout,"INFO: can produces octave up transposition with NO formant change.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(OCT):
+		fprintf(stdout,"INFO: OCTAVE TRANSPOSE WITHOUT FORMANT SHIFT\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Requires TWO INPUT FILES, an Analysis file and a Pitch data file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Additional pitchfile must be derived from input analysis file.\n");
+		fprintf(stdout,"INFO: TRANSPOSITION RATIO..is integer: 2 is an octave, 3 is a 12th etc.\n");
+		fprintf(stdout,"INFO:                      as in the harmonic series.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SHIFTP):
+		fprintf(stdout,"INFO: SHIFT PITCH OF (PART OF) SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ DIVIDE...... is freq above or below which transposition takes place.\n");
+		fprintf(stdout,"INFO: TRANSPOSITION....is transposition above or below FRQ DIVIDE.\n");
+		fprintf(stdout,"INFO: TRANSPOSITION 1..is transposition above FRQ DIVIDE. (semitones)\n");
+		fprintf(stdout,"INFO: TRANSPOSITION 2..is transposition below FRQ DIVIDE. (semitones)\n");
+		fprintf(stdout,"INFO: DEPTH............is effect on source (from no effect to full)).\n");
+		fprintf(stdout,"INFO: .................0 gives no shift, 1 gives full shift.\n");
+		fprintf(stdout,"INFO: .................Use to change the shifting from moment to moment.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TUNE):
+		fprintf(stdout,"INFO: REPLACE SPECTRAL FRQS BY HARMONICS OF SPECIFIED PITCH(ES)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Data required is a pitch, or a textfile containing pitches.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FOCUS..........degree of focusing of partial pitches onto template.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CLARITY........degree to which non-template partials are suppressed.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TRACE..........number of (window_by_window) most prominent channels\n");
+		fprintf(stdout,"INFO: ...............to be replaced by template frqs. (default, all channels)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ LIMIT..frqs below this are ignored.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PICK):
+		fprintf(stdout,"INFO: RETAIN ONLY CHANNELS WHICH MIGHT HOLD SPECIFIED PARTIALS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FUNDAMENTAL FRQ..of harmonic series, (or of calculation).\n");
+		fprintf(stdout,"INFO: FRQ STEP.........Frequency step to be added to another frequency.\n");
+		fprintf(stdout,"INFO: CLARITY..........extent to which data in other channels is suppressed.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CHORD):
+		fprintf(stdout,"INFO: TRANSPOSITIONS OF SPECTRUM SUPERIMPOSED WITHIN EXISTING SPECTRAL ENVELOPE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Data required is file of (possibly fractional) semitone transposition values.\n");
+		fprintf(stdout,"INFO: BOTTOM FRQ..frqs below this are filtered out.\n");
+		fprintf(stdout,"INFO: TOP FRQ.....frqs above this are filtered out.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MULTRANS):
+		fprintf(stdout,"INFO: TRANSPOSED VERSIONS OF SPECTRUM SUPERIMPOSED ON ORIGINAL\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Data required is file of (possibly fractional) semitone transposition values.\n");
+		fprintf(stdout,"INFO: BOTTOM FRQ..frqs below this are filtered out.\n");
+		fprintf(stdout,"INFO: TOP FRQ.....frqs above this are filtered out.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FILT):
+		fprintf(stdout,"INFO: FILTER THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FILTER EDGE(S) WIDTH.....is the width of filter skirts, in Hz.\n");
+		fprintf(stdout,"INFO: GAIN..is overall amplification of resulting sound.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GREQ):
+		fprintf(stdout,"INFO: GRAPHIC EQ ON SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STANDARD BANDWIDTH\n");
+		fprintf(stdout,"INFO: ....Data file has ONE bandwidth (octaves)\n");
+		fprintf(stdout,"INFO: ....followed by centre frqs of all filter bands (Hz).\n");
+		fprintf(stdout,"INFO: VARIOUS BANDWIDTHS\n");
+		fprintf(stdout,"INFO: ....Data file has a pair of values for EVERY filter band,\n");
+		fprintf(stdout,"INFO: ....representing centre frq of the band (Hz) followed by bandwidth (octaves).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SPLIT):
+		fprintf(stdout,"INFO: SPLIT SPECTRUM INTO BANDS & PROCESS THESE INDIVIDUALLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile of lines each with the following data..\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: lofrq   hifrq   bitflag   [amp1   amp2   [+]transpose]\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOFRQ and HIFRQ define the limits of a frequency band in the spectrum\n");
+		fprintf(stdout,"INFO:            which you wish to modify.\n");
+		fprintf(stdout,"INFO:            These bands should NOT OVERLAP one another.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BITFLAG has 4 bits (e.g. '0101' or '1000')\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If bit 1 (on the left) is set: There is an amplitude change to the whole band.\n");
+		fprintf(stdout,"INFO:            Put an amplitude multiplier ('amp1') in the line.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If bit 2 is set: The amplitude of the band ramps from amp1 to amp2.\n");
+		fprintf(stdout,"INFO:            Put the start and end amplitude multipliers ('amp1' and 'amp2') in the line.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If bit 3 is set: The band is transposed, or shifted.\n");
+		fprintf(stdout,"INFO:            To transpose, put a frequency multiplier ('transpose') in the line,\n");
+		fprintf(stdout,"INFO:            To shift, put in a frequency shift value in Hz, BUT precede it with a '+' sign.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If bit 4 (on the right) is set: the transposed partials are ADDED to the original spectrum.\n");
+		fprintf(stdout,"INFO:            (Normally they will REPLACE the originals.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 'amp1', 'amp2' &/or 'transpose' MUST be present, where required by the preceding bitflag.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ARPE):
+		fprintf(stdout,"INFO: ARPEGGIATE THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES--------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ON...........Play components inside arpeggiated band ONLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BOOST........Amplify snds in band. Others play unamplified.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BELOW_BOOST..INITIALLY Play components in & below band ONLY.\n");
+		fprintf(stdout,"INFO: .............THEN amplify snds in band. Others play unamplified.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ABOVE_BOOST..INITIALLY Play components in & above band ONLY.\n");
+		fprintf(stdout,"INFO: .............THEN amplify snds in band. Others play unamplified.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BELOW........Play components in & below arpeggiated band ONLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ABOVE........Play components in & above arpeggiated band ONLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ONCE_BELOW...INITIALLY Play components in and below band ONLY.\n");
+		fprintf(stdout,"INFO: .............THEN play whole sound as normal.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ONCE_ABOVE...INITIALLY Play components in and above arpeggiated band ONLY.\n");
+		fprintf(stdout,"INFO: .............THEN play whole sound as normal.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: WAVETYPE..............1=downramp : 2=sin : 3=saw : 4=upramp\n");
+		fprintf(stdout,"INFO: RATE OF SWEEP.........arpeggio sweeps per second.\n");
+		fprintf(stdout,"INFO: START PHASE...........start_phase of arpeggio sweep.\n");
+		fprintf(stdout,"INFO: LOFRQ LIMIT...........lowest freq arpeg sweeps down to.\n");
+		fprintf(stdout,"INFO: HIFRQ LIMIT...........highest freq arpeg sweeps up to.\n");
+		fprintf(stdout,"INFO: BANDWIDTH.............bandwidth of sweep band (in Hz).\n");
+		fprintf(stdout,"INFO: AMPLIFICATION.........amplification of arpegiated components.\n");
+		fprintf(stdout,"INFO: NONLINEAR DECAY.......Nonlinear decay of arpegtones. >1 faster, <1 slower.\n");
+		fprintf(stdout,"INFO: SUSTAIN WINDOWS.......Number of windows over which arpegtones sustained.\n");
+		fprintf(stdout,"INFO: TRACK FRQ CHANGE.... .Amplified tones track changing frq of src.\n");
+		fprintf(stdout,"INFO: SUSTAINS RUN TO ZERO..Amplified tones allowed to decay to zero\n");
+		fprintf(stdout,"INFO: ......................before new arpegtone attack initiated\n");
+		fprintf(stdout,"INFO: ......................(Default: Re-attack once decayed below input level)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PLUCK):
+		fprintf(stdout,"INFO: EMPHASISE SPECTRAL CHANGES (use e.g. with HILITE ARPEG)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN...amplitude gain applied to newly prominent spectral components.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(S_TRACE):
+		fprintf(stdout,"INFO: RETAIN THE N LOUDEST PARTIALS ONLY (ON A WINDOW-BY-WINDOW BASIS)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BLTR):
+		fprintf(stdout,"INFO: TIME-AVERAGE, AND TRACE, THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BLURRING FACTOR..is number of windows over which to average the spectrum.\n");
+		fprintf(stdout,"INFO: TRACING INDEX....is number of (loudest) channels to retain, in each window.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ACCU):
+		fprintf(stdout,"INFO: SUSTAIN EACH SPECTRAL BAND, UNTIL LOUDER DATA APPEARS IN THAT BAND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DECAY RATE....sutained channel data decays by DECAYRATE per sec.\n");
+		fprintf(stdout,"INFO: GLISS RATE....sutained channel data glisses at GLISRATE 8vas per sec.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EXAG):
+		fprintf(stdout,"INFO: EXAGGERATE SPECTRAL CONTOUR\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXAGGERATION >0 will widen troughs: <0 will widen peaks.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FOCUS):
+		fprintf(stdout,"INFO: FOCUS SPECTRAL ENERGY ONTO PEAKS IN SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FILTER BANDWIDTH.........bandwidth of peak-centred filters, in octaves.\n");
+		fprintf(stdout,"INFO: BOTTOM FRQ...............is bottom frequency to start peak search.\n");
+		fprintf(stdout,"INFO: TOP FRQ..................is frequency to end peak search.\n");
+		fprintf(stdout,"INFO: WINDOWCNT FOR STABILITY..Number of windows over which to scan for peak stability.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FOLD):
+		fprintf(stdout,"INFO: OCTAVE-TRANSPOSE SPECTRAL COMPONENTS INTO SPECIFIED RANGE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FREEZE):
+		fprintf(stdout,"INFO: FREEZE SPECTRAL CHARACTERISTICS IN SOUND, AT GIVEN TIMES \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Requied data is a textfile of times at which spectrum is frozen.\n");
+		fprintf(stdout,"INFO: These times may be preceded by character MARKERS....\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 'a' meaning, use this window as freezewindow for AFTER this time.\n");
+		fprintf(stdout,"INFO: 'b' meaning, use this window as freezewindow for BEFORE this time.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Otherwise, times are end-or-start of a freeze thus established.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FREEZE2):
+		fprintf(stdout,"INFO: HOLD SOUND SPECTRUM, AT GIVEN TIMES \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Datafile contains times at which spectrum is held, & hold-duration.\n");
+		fprintf(stdout,"INFO: These data items must be paired correctly.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(STEP):
+		fprintf(stdout,"INFO: STEP-FRAME THROUGH SOUND BY FREEZING SPECTRUM AT REGULAR TIME INTERVALS\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(AVRG):
+		fprintf(stdout,"INFO: AVERAGE SPECTRAL ENERGY OVER N ADJACENT CHANNELS\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BLUR):
+		fprintf(stdout,"INFO: TIME-AVERAGE THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BLURRING FACTOR is number of windows over which to average spectrum.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SUPR):
+		fprintf(stdout,"INFO: SUPPRESS THE N LOUDEST PARTIALS (ON A WINDOW-BY-WINDOW BASIS)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CHORUS):
+		fprintf(stdout,"INFO: CHORUSING BY RANDOMISING AMPLITUDES AND/OR FREQUENCIES OF PARTIALS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AMP SPREAD is maximum random scatter of partial-amps.\n");
+		fprintf(stdout,"INFO: FRQ SPREAD is maximum random scatter of partial-frqs.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DRUNK):
+		fprintf(stdout,"INFO: MODIFY SOUND BY DRUNKEN WALK ALONG ANALYSIS WINDOWS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RANGE IN WINDOWS...is maximum step (in windows) for drunken walk.\n");
+		fprintf(stdout,"INFO: STARTTIME IN FILE..is time (in secs) in file to begin walk.\n");
+		fprintf(stdout,"INFO: OUTFILE DURATION...is required duration of outfile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SHUFFLE):
+		fprintf(stdout,"INFO: SHUFFLE ORDER OF ANALYSIS WINDOWS IN FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is 2 strings of letters, separated by a '-' or ':'\n");
+		fprintf(stdout,"INFO: The first string is the DOMAIN, and the 2nd, the IMAGE.\n");
+		fprintf(stdout,"INFO: e.g. 'abc-abbabcc'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DOMAIN.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Letters represent group of consecutive inputfile analysis_windows.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. 'abcd'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IMAGE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Any permutation of, or selection from, the domain letters.\n");
+		fprintf(stdout,"INFO: (domain letters may be omitted or repeated in the image string).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. 'aaaaaaadaaa'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Inputfile windows are shuffled according to this same mapping.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GROUPSIZE Windows may be grouped in sets of GROUPSIZE\n");
+		fprintf(stdout,"INFO: ..........before being shuffled (as groups), and in this case\n");
+		fprintf(stdout,"INFO: ..........each domain-letter represents a group of GROUPSIZE windows.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(WEAVE):
+		fprintf(stdout,"INFO: MODIFY SOUND BY WEAVING AMONGST ANALYSIS WINDOWS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Special data file contains a list of integers\n");
+		fprintf(stdout,"INFO: which define successive steps (in windows) through the input file.\n");
+		fprintf(stdout,"INFO: Steps may be forward or backwards.\n" );
+		fprintf(stdout,"INFO: The step sequence is repeated until end of infile is reached.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Weave must obey the following rules....\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RULE 1:  NO step can exceed a certain limit value\n");
+		fprintf(stdout,"INFO: RULE 2:  NO window reached in a weave can be BEFORE startwindow of weave.\n");
+		fprintf(stdout,"INFO: RULE 3:  FINAL window must be AFTER the weave startwindow.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Otherwise, weave may be forward or backward, or remain at same window.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(NOISE):
+		fprintf(stdout,"INFO: PUT NOISE IN THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SCAT):
+		fprintf(stdout,"INFO: RANDOMLY THIN OUT THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ-BLOCKS TO KEEP....Number of (randomly-chosen) blocks to keep, per window.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ RANGE OF BLOCK....(Rounded internally to a multiple of channel width).\n");
+		fprintf(stdout,"INFO: ......................(default is width of 1 analysis channel).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: KEEP RANDOM SET ONLY..Number of blocks actually kept randomised\n");
+		fprintf(stdout,"INFO: ......................between 1 & FRQ-BLOCKS TO KEEP.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SPREAD):
+		fprintf(stdout,"INFO: SPREAD PEAKS OF SPECTRUM, INTRODUCING CONTROLLED NOISINESS\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SHIFT):
+		fprintf(stdout,"INFO: LINEAR FREQUENCY SHIFT OF (PART OF) THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ DIVIDE...............frq at which shifting starts or stops.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ & HIGH FRQ.......define range inside or outside which shift takes place.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOG INTERP CHANGING FRQ..useful only if any input params are time-varying,\n");
+		fprintf(stdout,"INFO:..........................and frqshift vals are all +ve, or all -ve.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GLIS):
+		fprintf(stdout,"INFO: CREATE GLISSANDI INSIDE THE (CHANGING) SPECTRAL ENVELOPE OF ORIGINAL SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GLISS RATE.......in semitones per second (-ve val for downward gliss).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARTIAL SPACING..in Hz for partials in inharmonic glide.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: HIGH FRQ LIMIT...is top of spectrum.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(WAVER):
+		fprintf(stdout,"INFO: OSCILLATE BETWEEN HARMONIC AND INHARMONIC STATE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX SPECTRAL STRETCH..is max spectral stretch in inharmonic state.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXPONENT..............defines type of stretch in inharmonic state.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INVERT):
+		fprintf(stdout,"INFO: INVERT THE SPECTRUM\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GLIDE):
+		fprintf(stdout,"INFO: INTERPOLATE, LINEARLY, BETWEEN 2 SINGLE ANALYSIS WINDOWS\n");
+		fprintf(stdout,"INFO: EXTRACTED WITH spec grab.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BRIDGE):
+		fprintf(stdout,"INFO: MAKE A BRIDGING-INTERPOLATION BETWEEN TWO SOUND SPECTRA\n");
+		fprintf(stdout,"INFO: BY INTERPOLATING BETWEEN 2 TIME-SPECIFIED WINDOWS IN THE 2 INFILES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2ND FILE OFFSET......time infile2 starts, relative to start of file1.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ INTERP AT START..fraction of 2nd sound's frq interpolated at START.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AMP INTERP AT START..fraction of 2nd sound's amp interpolated at START.\n");
+		fprintf(stdout,"INFO: .....................If an OFFSET is used, when these interps NOT set to zero,\n");
+		fprintf(stdout,"INFO: .....................outsound starts from point where 2nd sound enters.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQ INTERP AT END....fraction of 2nd sound's frq interpolated at END.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AMP INTERP AT END....fraction of 2nd sound's amp interpolated at END.\n");
+		fprintf(stdout,"INFO: .....................if these are set < 1.0\n");
+		fprintf(stdout,"INFO: .....................outsound ends at end of 1st sound to end.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STARTTIME IN FILE1.. of window where interpolation begins.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENDTIME IN FILE1.... of window where interpolation ends.\n");
+		fprintf(stdout,"INFO: .....................if START and END are not specified\n");
+		fprintf(stdout,"INFO: .....................interp runs from OFFSET to end of 1st file to end.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MORPH):
+		fprintf(stdout,"INFO: MORPH ONE SPECTRUM INTO ANOTHER.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: -------------------------------------------------------\n");
+		fprintf(stdout,"INFO: MODES..\n");
+		fprintf(stdout,"INFO: (1) interpolate LINEARLY (exponent 1)\n");
+		fprintf(stdout,"INFO:         or over a curve of increasing (exp >1) or decreasing (exp <1) slope.\n");
+		fprintf(stdout,"INFO: (2) interpolate over a COSINUSOIDAL spline.\n");
+		fprintf(stdout,"INFO: -------------------------------------------------------\n");
+		fprintf(stdout,"INFO: PARAMETERS..\n");
+		fprintf(stdout,"INFO: Start and End times for Interpolation of Channel Frequencies.\n");
+		fprintf(stdout,"INFO: Start and End times for Interpolation of Channel Amplitudes.\n");
+		fprintf(stdout,"INFO: Exponents of the Interpolations (see above).\n");
+		fprintf(stdout,"INFO: (In COSIN mode, these skew the cosinusional interpolation).\n");
+		fprintf(stdout,"INFO: 2nd FILE ENTRY TIME is time-delay of entry of 2nd file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PITCH):
+		fprintf(stdout,"INFO: ATTEMPT TO EXTRACT PITCH FROM SPECTRAL DATA.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1st OUTPUTFILE, if resynthesized, produces tone at detected pitch.\n");
+		fprintf(stdout,"INFO: 2nd OUTPUTFILE contains the extracted pitch data.\n");
+		fprintf(stdout,"INFO: In mode TO BINARY FILE this is a binary output file.\n");
+		fprintf(stdout,"INFO: In mode TO TEXTFILE this is a brkpnt text file of time/pitch pairs.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN-TUNE RANGE................ range within which harmonics accepted as in tune.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN WINDOWS TO CONFIRM PITCH..minimum number of adjacent windows that must be\n");
+		fprintf(stdout,"INFO: ..............................pitched, for pitch-value to be registered.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SIGNAL TO NOISE RATIO........ in decibels.\n");
+		fprintf(stdout,"INFO: ..............................Windows more than this below the maximum level\n");
+		fprintf(stdout,"INFO: ..............................in the sound, are assumed to be noise,\n");
+		fprintf(stdout,"INFO: ..............................& any detected pitch is assumed spurious.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: VALID HARMONICS COUNT........ how many of loudest peaks in spectrum must be\n");
+		fprintf(stdout,"INFO: ..............................harmonics to confirm sound is pitched.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW PITCH LIMIT.............. frequency of LOWEST acceptable pitch.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: HIGH PITCH LIMIT..............frequency of HIGHEST acceptable pitch.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DATAREDUCTION................ acceptable pitch-ratio error in data reduction.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_APPROX):
+		fprintf(stdout,"INFO: MAKE AN APPROXIMATE COPY OF A PITCHFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH SCATTER RANGE...Interval over which pitch +- randomly varies from orig.\n");
+		fprintf(stdout,"INFO: TIME SCATTER RANGE....Time-interval by which pitchval can stray from orig time.\n");
+		fprintf(stdout,"INFO: CONTOUR SCAN RANGE....Time-interval over which pitch contour scanned.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_EXAG):
+		fprintf(stdout,"INFO: EXAGGERATE PITCH CONTOUR OF A PITCH DATA FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MEANPITCH...........pitch around which intervals stretched.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_INVERT):
+		fprintf(stdout,"INFO: INVERT PITCH CONTOUR OF A PITCH DATA FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is either '0' (if no mapping is required)\n");
+		fprintf(stdout,"INFO: or a a textfile of paired values showing how intervals\n");
+		fprintf(stdout,"INFO: (in, possibly fractional, semitones) are to be mapped\n");
+		fprintf(stdout,"INFO: onto their inversions.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INVERSION CENTRE...pitch around which pitchline inverted.\n");
+		fprintf(stdout,"INFO: LOW PITCH LIMIT....lowest pitch permissible.\n");
+		fprintf(stdout,"INFO: HIGH PITCH LIMIT...highest pitch permissible.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_QUANTISE):
+		fprintf(stdout,"INFO: QUANTISE PITCHES IN A PITCH DATA FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile of (possibly fractional) MIDI pitchvals\n");
+		fprintf(stdout,"INFO: over which pitch to be quantised.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DUPLICATE Q-SET IN ALL OCTAVES\n");
+		fprintf(stdout,"INFO: ....causes entered pitches to be duplicated in all 8vas,\n");
+		fprintf(stdout,"INFO: ....to generate actual quantisation set used.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_RANDOMISE):
+		fprintf(stdout,"INFO: RANDOMISE PITCH LINE IN A PITCH DATA FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX INTERVAL OF STRAY..(semitones) is interval over which pitches can +- randomvary.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESTEP...............is max timestep between random pitch fluctuations.\n");
+		fprintf(stdout,"INFO:........................Actual timesteps are random values less than this.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RANGE SLEW.............e.g. 2: upward variation range twice that of downward.\n");
+		fprintf(stdout,"INFO: .......................e.g -3: downward variation range 3 times that of upward.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_SMOOTH):
+		fprintf(stdout,"INFO: SMOOTH PITCH CONTOUR IN A PITCH DATA FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMEFRAME..over which to interpolate pitch values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MEANPITCH..is pitch from which peaks measured for interpolation\n");
+		fprintf(stdout,"INFO: ...........between PEAK value in each timeframe block of pitch values.\n");
+		fprintf(stdout,"INFO: ...........(and must be within pitch range, in every timeframe block).\n");
+		fprintf(stdout,"INFO: ...........Peak is maximum displacement from mean (up or down).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_SYNTH):
+		fprintf(stdout,"INFO: SYNTHESIZE SPECTRUM OF A SOUND FOLLOWING PITCH IN INPUT PITCHFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARTIAL LEVELS......level of each partial, in turn, starting from 1st.\n");
+		fprintf(stdout,"INFO: Use as many or as few partials as required.\n");
+		fprintf(stdout,"INFO: Levels must lie beween 0 and 1.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_GEN):
+		fprintf(stdout,"INFO: CREATE A BINARY PITCHDATA FILE FROM INFORMATION IN A TEXTFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH DATA......A file of pitch values and associated times, as time-value pairs.\n");
+		fprintf(stdout,"INFO: ......................These may be note names (A-G), possibly followed by '#'(sharp) or 'b' (flat),\n");
+		fprintf(stdout,"INFO: ......................all followed by an octave value (where 0 is octave starting at middle C).\n");
+		fprintf(stdout,"INFO: ......................ALTERNATIVELY these may be numeric MIDI values (possibly fractional).\n");
+		fprintf(stdout,"INFO: SAMPLE RATE OF GOAL SNDFILE.\n");
+		fprintf(stdout,"INFO: ......................Typical use would be to generate a synthesized vowel stream,\n");
+		fprintf(stdout,"INFO: ......................and this parameter specifies the sample rate of the output SOUND\n");
+		fprintf(stdout,"INFO: ......................of any such subsequent process.\n");
+		fprintf(stdout,"INFO: ANALYSIS POINTS.......(2-32768 (power of 2)): default 1024\n");
+		fprintf(stdout,"INFO: ......................More points give better freq resolution\n");
+		fprintf(stdout,"INFO: ......................but worse time-resolution (e.g. rapidly changing spectrum).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OVERLAP...............Filter overlap factor (1-4): default 3\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_INTERP):
+		fprintf(stdout,"INFO: REMOVE UNPITCHED OR SILENT WINDOWS, BY INTERPOLATING BETWEEN EXISTING PITCHES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) GLIDE ............ interpolated pitch moves smoothly from pitch\n");
+		fprintf(stdout,"INFO: ..................... before noise-or-silence to pitch after it.\n");
+		fprintf(stdout,"INFO: 1) SUSTAIN........... pitch before noise-or-silence is sustained\n");
+		fprintf(stdout,"INFO: ..................... until a new pitch occurs.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_VOWELS):
+		fprintf(stdout,"INFO: SYNTHESIZE (POSSIBLY CHANGING) VOWEL SPECTRUM OF SOUND FOLLOWING PITCHFILE PITCH.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: VOWELS......file containing paired times and vowels, where vowels can be....\n");
+		fprintf(stdout,"INFO: ee    as in 'heat'               i     as in 'hit'                e     as in 'pet'                ai    as in 'hate'\n");
+		fprintf(stdout,"INFO: a     as in 'pat'                ar    as in 'heart'              o     as in 'hot'                or    as in 'taught'\n");
+		fprintf(stdout,"INFO: oa    as in 'boat'               u     as in 'hood'               oo    as in 'mood'\n");
+		fprintf(stdout,"INFO: xx    as in Southern English 'hub'\n");
+		fprintf(stdout,"INFO: x     neutral vowel as in 'herb' or 'the'\n");
+		fprintf(stdout,"INFO: aii   as in Scottish educAted    uu    as in Scottish edUcated    ui     as in Scottish cOUld\n");
+		fprintf(stdout,"INFO: n     as in 'Now'                m     as in 'Make'               r      as in 'Raw'               th    as in 'THe'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Times must start at zero, and increase.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FORMANT HALF-WIDTH ........half-width of formant peaks, in Hz, as a fraction of formant centre-frq.\n");
+		fprintf(stdout,"INFO: FORMANT PEAK STEEPNESS ....is steepness of the formant peaks.\n");
+		fprintf(stdout,"INFO: FORMANT PEAK RANGE ........is the ratio of (max) peak range to (max) total range.\n");
+		fprintf(stdout,"INFO: EMPHASIS ON FUNDAMENTAL ...is (relative) amplitude of fundamental, if it falls outside a formant.\n");
+		fprintf(stdout,"INFO: HOARSENESS .........is extent of (random) variation of partial frqs from frequency of true harmonics.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(VFILT):
+		fprintf(stdout,"INFO: IMPOSE (POSSIBLY CHANGING) VOWEL SPECTRUM ON A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: VOWELS......file containing paired times and vowels, where vowels can be....\n");
+		fprintf(stdout,"INFO: ee    as in 'heat'               i     as in 'hit'                e     as in 'pet'                ai    as in 'hate'\n");
+		fprintf(stdout,"INFO: a     as in 'pat'                ar    as in 'heart'              o     as in 'hot'                or    as in 'taught'\n");
+		fprintf(stdout,"INFO: oa    as in 'boat'               u     as in 'hood'               oo    as in 'mood'\n");
+		fprintf(stdout,"INFO: xx    as in Southern English 'hub'\n");
+		fprintf(stdout,"INFO: x     neutral vowel as in 'herb' or 'the'\n");
+		fprintf(stdout,"INFO: aii   as in Scottish educAted    uu    as in Scottish edUcated    ui     as in Scottish cOUld\n");
+		fprintf(stdout,"INFO: n     as in 'Now'                m     as in 'Make'               r      as in 'Raw'               th    as in 'THe'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Times must start at zero, and increase.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FORMANT HALF-WIDTH .......half-width of formant peaks, in Hz, as a fraction of formant centre-frq.\n");
+		fprintf(stdout,"INFO: FORMANT PEAK STEEPNESS ...is steepness of the formant peaks.\n");
+		fprintf(stdout,"INFO: FORMANT PEAK RANGE .......is the ratio of (max) peak range to (max) total range.\n");
+		fprintf(stdout,"INFO: THRESHOLD ................spectral window only affected if its level exceeds a proportion of vowel envelope level for window\n");
+		fprintf(stdout,"INFO: ..........................Threshold is this proportion.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_INSERT):
+		fprintf(stdout,"INFO: MARK AS UNPITCHED THOSE WINDOWS IN BINARY PITCHFILE BETWEEN GIVEN TIME-PAIRS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERTION TIMEPAIRS.......Times between which data is marked as unpitched.\n");
+		fprintf(stdout,"INFO: Time can be given in seconds, or as sample-cnt in the corresponding soundfile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_SINSERT):
+		fprintf(stdout,"INFO: MARK AS SILENT THOSE WINDOWS IN BINARY PITCHFILE BETWEEN GIVEN TIME-PAIRS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERTION TIMEPAIRS.......Times between which data is marked as silent.\n");
+		fprintf(stdout,"INFO: Time can be given in seconds, or as sample-cnt in the corresponding soundfile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_PTOSIL):
+		fprintf(stdout,"INFO: IN A BINARY PITCHFILE, CONVERT ALL PITCHED WINDOWS TO SILENCE.\n");
+		break;
+	case(P_NTOSIL):
+		fprintf(stdout,"INFO: IN A BINARY PITCHFILE, CONVERT ALL UNPITCHED WINDOWS TO SILENCE.\n");
+		break;
+	case(ANALENV):
+		fprintf(stdout,"INFO: EXTRACT THE WINDOW-LOUDNESS ENVELOPE OF AN ANALYSIS FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Extract the total loudness of each window\n");
+		fprintf(stdout,"INFO: in format compatible with pitch or formant data taken from same analysis file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MAKE2):
+		fprintf(stdout,"INFO: GENERATE SPECTRUM FROM PITCH, FORMANT AMD ENVELOPE DATA.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: outfile is analysis file which must be resynthesized to hear.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_TRANSPOSE):
+		fprintf(stdout,"INFO: TRANSPOSES PITCHES IN PITCHDATA FILE BY CONSTANT NO OF SEMITONES.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_VIBRATO):
+		fprintf(stdout,"INFO: ADD VIBRATO TO PITCH IN A PITCH DATA FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: VIBRATO FRQ....frequency of vibrato itself (Hz).\n");
+		fprintf(stdout,"INFO: VIBRATO RANGE..max interval vibrato moves from central pitch.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_CUT):
+		fprintf(stdout,"INFO: CUT OUT AND KEEP A SEGMENT OF A BINARY PITCH-DATAFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_FIX):
+		fprintf(stdout,"INFO: MASSAGE PITCH DATA IN A BINARY PITCHFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If NOT in Instrument-Create or Bulk-Process mode,\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: This is a GRAPHIC EDITOR FOR PITCH DATA.\n");
+		fprintf(stdout,"INFO: and HELP is provided on the window which appears.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OTHERWISE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Pitchdata should first be viewed with PITCH VIEW (PITCH INFO menu)....\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THEN THE FOLLOWING RULES SHOULD BE OBSERVED.........\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (1)\n");
+		fprintf(stdout,"INFO: When pitches are removed they are replaced by a 'no-pitch' indicator.\n");
+		fprintf(stdout,"INFO: These (and any already existing unpitched windows in the file) can be\n");
+		fprintf(stdout,"INFO: converted to pitch-data (by interpolation between adjacent pitches)\n");
+		fprintf(stdout,"INFO: using the INTERPOLATE flag.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (2)\n");
+		fprintf(stdout,"INFO: With multiple flags, ORDER of operations inside program is....\n");
+		fprintf(stdout,"INFO: REMOVE-TIMEWISE, REMOVE-FRQWISE, SMOOTH, FORCE-ENDVALS, INTERP\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(REPITCH):
+		fprintf(stdout,"INFO: GENERATE TRANSPOSITION DATA FROM 2 SETS OF PITCH DATA,\n" );
+		fprintf(stdout,"INFO: OR TRANSPOSE PITCH DATA WITH TRANSPOSITION DATA,\n" );
+		fprintf(stdout,"INFO: OR COMBINE 2 SETS OF TRANSPOSITION DATA TO FORM NEW TRANSPOSITION DATA,\n");
+		fprintf(stdout,"INFO: PRODUCING BINARY DATAFILE OUTPUT.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Input files may be binary files, or text brkpnt files BUT...\n");
+		fprintf(stdout,"INFO: It's IMPOSSIBLE to generate binary outfile from exclusively brkpnt infiles.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(REPITCHB):
+		fprintf(stdout,"INFO: GENERATE TRANSPOSITION DATA FROM 2 SETS OF PITCH DATA,\n" );
+		fprintf(stdout,"INFO: OR TRANSPOSE PITCH DATA WITH TRANSPOSITION DATA,\n" );
+		fprintf(stdout,"INFO: OR COMBINE 2 SETS OF TRANSPOSITION DATA TO FORM NEW TRANSPOSITION DATA,\n");
+		fprintf(stdout,"INFO: PRODUCING A TIME/VAL BRKPNT TEXTFILE OUTPUT.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Input files may be binary files, or text brkpnt files.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DATAREDUCTION..is acceptable pitch error in brkpntfile data-reduction.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TRNSF):
+		fprintf(stdout,"INFO: TRANSPOSE SPECTRUM : BUT RETAIN ORIGINAL SPECTRAL ENVELOPE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODE names refer to the type of data which is to be used.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MINFRQ...minimum frq, below which data is filtered out.\n");
+		fprintf(stdout,"INFO: MAXFRQ...maximum frq, above which data is filtered out.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TRNSP):
+		fprintf(stdout,"INFO: TRANSPOSE SPECTRUM (SPECTRAL ENVELOPE ALSO MOVES)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODE names refer to the type of data which is to be used.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MINFRQ...minimum frq, below which data is filtered out.\n");
+		fprintf(stdout,"INFO: MAXFRQ...maximum frq, above which data is filtered out.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FORMANTS):
+		fprintf(stdout,"INFO: EXTRACT EVOLVING FORMANT ENVELOPE FROM AN ANALYSIS FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FORM):
+		fprintf(stdout,"INFO: IMPOSE SPECTRAL ENVELOPE IN A FORMANTFILE\n");
+		fprintf(stdout,"INFO: ON SPECTRUM IN AN ANALYSIS FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REPLACE FORMANTS......New formants REPLACE existing formant envelope.\n");
+		fprintf(stdout,"INFO: SUPERIMPOSE FORMANTS..New formants IMPOSED ON TOP OF existing formants.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ LIMIT...frq, below which spectrum is set to zero.\n");
+		fprintf(stdout,"INFO: HIGH FRQ LIMIT..frq, above which spectrum is set to zero.\n");
+		fprintf(stdout,"INFO: GAIN............adjustment to spectrum loudness (normally < 1.0).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(VOCODE):
+		fprintf(stdout,"INFO: IMPOSE SPECTRAL ENVELOPE OF 2nd SOUND, ON 1st SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ LIMIT...frq below which data is filtered out.\n");
+		fprintf(stdout,"INFO: HIGH FRQ LIMIT..frq above which data is filtered out.\n");
+		fprintf(stdout,"INFO: GAIN............adjustment to output level (normally < 1.0).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FMNTSEE):
+		fprintf(stdout,"INFO: CONVERT FORMANT DATA IN A BINARY FORMANTDATA FILE TO 'SNDFILE' FOR VIEWING.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The resulting logarithmically scaled display indicates formant shapes,\n");
+		fprintf(stdout,"INFO: but NOT the absolute amplitude values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DISPLAY FORMANTBAND DATA....displays information about formant banding used.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: WARNING: DO NOT ATTEMPT TO PLAY THE RESULTING 'SOUNDFILE'\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FORMSEE):
+		fprintf(stdout,"INFO: EXTRACT FORMANTS FROM ANALFILE AND WRITE AS 'SNDFILE' FOR VIEWING.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The resulting logarithmically scaled display indicates formant shapes,\n");
+		fprintf(stdout,"INFO: but NOT the absolute amplitude values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DISPLAY IN SEMITONE BANDS does just that (Default: equal hz bands).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: WARNING: DO NOT ATTEMPT TO PLAY THE RESULTING 'SOUNDFILE'\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MAKE):
+		fprintf(stdout,"INFO: GENERATE SPECTRUM FROM PITCH & FORMANT DATA ONLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: outfile is analysis file which must be resynthesized to hear.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SUM):
+		fprintf(stdout,"INFO: FIND SUM OF TWO SPECTRA.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CROSSOVER is amount of 2nd spectrum added to 1st\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DIFF):
+		fprintf(stdout,"INFO: FIND DIFFERENCE OF TWO SPECTRA.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CROSSOVER is amount of 2nd spectrum subtracted from 1st.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(LEAF):
+		fprintf(stdout,"INFO: INTERLEAVE WINDOWS FROM INFILES, LEAFSIZE WINDOWS PER LEAF.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MAX):
+		fprintf(stdout,"INFO: IN EACH CHANNEL, IN EACH WINDOW, TAKE MAX VAL AMONGST INPUT FILES.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MEAN):
+		fprintf(stdout,"INFO: GENERATE SPECTRAL 'MEAN' OF 2 SOUNDS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ LIMIT...... .of channels to average.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: HIGH FRQ LIMIT.......of channels to average.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHANNELS TO COMPARE..Number of significant chans to compare.\n");
+		fprintf(stdout,"INFO: .....................Default: All within range.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CROSS):
+		fprintf(stdout,"INFO: REPLACE CHANNEL AMPLITUDES OF 1st FILE WITH THOSE OF 2nd.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INTERPOLATION is degree of replacement.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(WINDOWCNT):
+		fprintf(stdout,"INFO: RETURNS NUMBER OF ANALYSIS WINDOWS IN INFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CHANNEL):
+		fprintf(stdout,"INFO: RETURNS CHANNEL NUMBER CORRESPONDING TO FREQUENCY GIVEN.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FREQUENCY):
+		fprintf(stdout,"INFO: RETURNS CENTRE FRQ OF CHANNEL SPECIFIED.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(LEVEL):
+		fprintf(stdout,"INFO: CONVERTS (VARYING) LEVEL OF ANALFILE TO PSEUDO-SNDFILE\n");
+		fprintf(stdout,"INFO: (1 WINDOW -> 1 SAMPLE)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: View with a sndfile display program. DO NOT ATTEMPT TO PLAY FILE!!\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(OCTVU):
+		fprintf(stdout,"INFO: DISPLAY TIMEVARYING AMPLITUDE OF SPECTRUM, WITHIN OCTAVE BANDS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESTEP.........is timestep between viewing bands.\n");
+		fprintf(stdout,"INFO: .................Band-energy is totalled over each timestep duration.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FUNDAMENTAL FRQ..Bands centered on octave transpositions of fundamental.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The reported values are RELATIVE levels only\n");
+		fprintf(stdout,"INFO: and the lowest band includes all energy down to '0Hz'.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTFILE is a text file\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PEAK):
+		fprintf(stdout,"INFO: LOCATE TIME-VARYING ENERGY CENTRE OF SPECTRUM.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ LIMIT..above which spectral search begins\n");
+		fprintf(stdout,"INFO: TIME WINDOW....for energy averaging: in SECONDS\n");
+		fprintf(stdout,"INFO: FRQ WINDOW.....for energy averaging: in SEMITONES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTFILE is a text file of lines of data in form...\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:               WINDOW starttime endtime : PEB lofrq TO hifrq'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (where 'PEB' means PEAK ENERGY BAND)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(REPORT):
+		fprintf(stdout,"INFO: REPORT ON LOCATION OF FREQUENCY PEAKS IN EVOLVING SPECTRUM,\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PEAKS TO FIND.......(max) number of peaks to find.\n");
+		fprintf(stdout,"INFO: LOW FRQ LIMIT.......bottom frequency to start peak search.\n");
+		fprintf(stdout,"INFO: HIGH FRQ LIMIT......top frequency to stop peak search.\n");
+		fprintf(stdout,"INFO: WINDOWS TO AVERAGE..number of windows over which peaks averaged.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTFILE is a textfile\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PRINT):
+		fprintf(stdout,"INFO: PRINT DATA IN ANALYSIS FILE AS TEXT TO FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME.......in file at which printout begins.\n");
+		fprintf(stdout,"INFO: WINDOWCNT..number of windows to print.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Outfile is a textfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: WARNING: using more than a few windows will generate a huge textfile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_INFO):
+		fprintf(stdout,"INFO: DISPLAY INFORMATION ABOUT PITCHDATA IN PITCHFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Finds mean pitch, max and min pitch (with timings), as Hz and MIDI.\n");
+		fprintf(stdout,"INFO: And displays total range, in octaves and semitones.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_ZEROS):																	 
+		fprintf(stdout,"INFO: SHOWS WHETHER PITCHFILE CONTAINS UNINTERPOLATED ZEROS (UNPITCHED WINDOWS).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_SEE):																	 
+		fprintf(stdout,"INFO: CONVERT BINARY PITCHFILE OR TRANSPOSITION-FILE TO PSEUDO-SNDFILE, TO VIEW.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEE PITCH\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ........SCALE FACTOR multiplies pitch vals, for ease of viewing.\n");
+		fprintf(stdout,"INFO: ........Pitch data scaled by (e.g.) 100 can be read directly from 'sndfile'\n");
+		fprintf(stdout,"INFO: ........(Remembering to divide numeric values by 100).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEE TRANSPOSITION\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ........Transposition data is automatically scaled to half max range,\n");
+		fprintf(stdout,"INFO: ........And displayed in log format\n");
+		fprintf(stdout,"INFO: ........giving a schematic idea ONLY, of transposition data.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: View with a sndfile display program. DO NOT ATTEMPT TO PLAY FILE!!\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_HEAR):
+		fprintf(stdout,"INFO: CONVERT BINARY PITCHFILE TO ANALYSIS TESTTONE FILE.\n");
+		fprintf(stdout,"INFO: (RESYNTHESISE TO HEAR PITCH).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_WRITE):
+		fprintf(stdout,"INFO: CONVERT A BINARY PITCH-DATAFILE TO A TIME/FRQ BRKPNT TEXTFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DATA REDUCTION acceptable pitch error in brkpntfile data-reduction.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT):
+		fprintf(stdout,"INFO: MODIFY SHAPE OF 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_ENV):
+		fprintf(stdout,"INFO: IMPOSE ENVELOPE OVER EACH GROUP OF cyclecnt 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT....is number of wavecycles under a single envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RISE-DECAY EXPONENT..is exponent for envelope rise or decay:\n");
+		fprintf(stdout,"INFO: .....................If OMMITED envelope rise/decay is linear.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TROUGHING............is trough of envelope (0-1: default 0).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: in USER-DEFINED MODE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile of time/val(0-1) pairs defining an envelope,\n");
+		fprintf(stdout,"INFO: where time units are arbitrary\n");
+		fprintf(stdout,"INFO: as the envelope is stretched to each cycle(set) duration.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_AVG):
+		fprintf(stdout,"INFO: AVERAGE THE WAVESHAPE OVER N 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT..is number of cycles to average over ( > 1)\n");
+		fprintf(stdout,"INFO: MAX WAVELEN........max permissible wavelength in seconds.\n");
+		fprintf(stdout,"INFO: SKIPCYCLES:........number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_OMT):
+		fprintf(stdout,"INFO: OMIT A OUT OF EVERY B 'WAVECYCLES' REPLACING THEM BY SILENCE\n");
+		fprintf(stdout,"INFO: B van vary in time, but cannot be > A (!)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_MLT):
+		fprintf(stdout,"INFO: DISTORTION BY MULTIPLYING WAVECYCLE FREQUENCY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: try SMOOTHED flag if glitches appear.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_DIV):
+		fprintf(stdout,"INFO: DISTORTION BY DIVIDING WAVECYCLE FREQUENCY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: N = divider (integer only: range 2-16)\n");
+		fprintf(stdout,"INFO: INTERPOLATED........slower, but cleaner.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_HRM):
+		fprintf(stdout,"INFO: HARMONIC DISTORTION BY SUPERIMPOSING 'HARMONICS' ONTO 'WAVECYCLES'.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile containing harmonic_no/amplitude pairs.\n");
+		fprintf(stdout,"INFO: where amplitude of src sound is taken to be 1.0\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PRE_ATTENUATION.....is applied to input sound before processing.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_FRC):
+		fprintf(stdout,"INFO: SUPERIMPOSE MINIATURE COPIES OF SRC 'WAVECYCLES' ONTO THEMSELVES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCALING FACTOR.....(integer) division of scale of src wave.\n");
+		fprintf(stdout,"INFO: RELATIVE LOUDNESS..loudness of scaled component, relative to src (1.0).\n");
+		fprintf(stdout,"INFO: PRE_ATTENUATION....applied to input sound before processing.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_REV):
+		fprintf(stdout,"INFO: CYCLE_REVERSAL DISTORTION.'WAVECYCLES' REVERSED IN GROUPS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT...Number of cycles (>0) in reversed groups.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_SHUF):
+		fprintf(stdout,"INFO: DISTORTION BY SHUFFLING 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is 2 strings of letters, separated by a '-'  or ':'\n");
+		fprintf(stdout,"INFO: The first string is the DOMAIN, and the 2nd, the IMAGE.\n");
+		fprintf(stdout,"INFO: e.g. 'abc-abbabcc'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DOMAIN.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Letters represent group of consecutive wavecycles.\n");
+		fprintf(stdout,"INFO: e.g. 'abcd'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IMAGE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: any permutation of, or selection from, the domain letters.\n");
+		fprintf(stdout,"INFO: (domain letters may be omitted or repeated in the image string).\n");
+		fprintf(stdout,"INFO: e.g. 'aaaaaaadaaa'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT..(integer) number of wavecycles in groups to operate on.\n");
+		fprintf(stdout,"INFO: SKIP CYCLES .......(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_RPT):
+		fprintf(stdout,"INFO: TIMESTRETCH FILE BY REPEATING 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MULTIPLIER:..........(integer) number of times each wavecycle(grp) repeats.\n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT:...(integer) number wavecycles in repeated groups.\n");
+		fprintf(stdout,"INFO: SKIP CYCLES:.........(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_RPT2):
+		fprintf(stdout,"INFO: REPEAT 'WAVECYCLES' THEN SKIP CYCLES  TO AVOID TIMESTRETCHING FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MULTIPLIER:..........(integer) number of times each wavecycle(grp) repeats.\n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT:...(integer) number wavecycles in repeated groups.\n");
+		fprintf(stdout,"INFO: SKIP CYCLES:.........(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_RPTFL):
+		fprintf(stdout,"INFO: TIMESTRETCH FILE BY REPEATING 'WAVECYCLES' ABOVE A CERTAIN WAVELENGTH\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MULTIPLIER:..........(integer) number of times each wavecycle(grp) repeats.\n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT:...(integer) number wavecycles in repeated groups.\n");
+		fprintf(stdout,"INFO: SKIP CYCLES:.........(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: HIGH FRQ LIMIT:.......Frequency below which wavecycles are counted.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_INTP):
+		fprintf(stdout,"INFO: TIMESTRETCH FILE BY REPEATING 'WAVECYCLES' & INTERPOLATING BETWEEN THEM.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MULTIPLIER: (integer) is number of times each wavecycle repeats.\n");
+		fprintf(stdout,"INFO: SKIPCYCLES: (integer) is number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_DEL):
+		fprintf(stdout,"INFO: TIMECONTRACT FILE BY DELETING 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN GIVEN ORDER:..1 in CYCLECNT wavecycle(group)s retained\n");
+		fprintf(stdout,"INFO: RETAIN LOUDEST:..Strongest 1 in CYCLECNT wavecycle(group)s retained\n");
+		fprintf(stdout,"INFO: DELETE WEAKEST:..Weakest   1 in CYCLECNT wavecycle(group)s deleted\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT..(integer) number of wavecycles in deleted groups.\n");
+		fprintf(stdout,"INFO: SKIPCYCLES:........(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_RPL):
+		fprintf(stdout,"INFO: STRONGEST WAVECYCLE, IN EACH WAVECYCLE GROUP, REPLACES OTHERS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT..(integer) number of wavecycles in group of replacements.\n");
+		fprintf(stdout,"INFO: SKIP CYCLES........(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_TEL):
+		fprintf(stdout,"INFO: TIMECONTRACT SOUND BY TELESCOPING cyclecnt 'WAVECYCLES' TO 1\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE-GROUP COUNT....sizeof group to telescope.\n");
+		fprintf(stdout,"INFO: SKIP CYCLES..........(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: TO AVERAGE CYCLELEN..telescopes to average cyclelen in group.(Default: telescope to longest.)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_FLT):
+		fprintf(stdout,"INFO: TIMECONTRACT SOUND BY FILTERING OUT 'WAVECYCLES'\n");
+		fprintf(stdout,"INFO: EXCLUDED BY FRQ LIMITS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SKIP CYCLES.....(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: N.B. timevarying freq1, freq2 may not cross each other, nor be equal.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_INT):
+		fprintf(stdout,"INFO: TIME-DOMAIN INTERACTION OF SOUNDS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INTERLEAVE..wavecycles from the two infiles are interleaved.\n");
+		fprintf(stdout,"INFO: RESIZE......wavecycle-lengths of 1st file are imposed on wavecycles of 2nd\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_CYCLECNT):
+		fprintf(stdout,"INFO: COUNT 'WAVECYCLES' IN SNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_PCH):
+		fprintf(stdout,"INFO: PITCHWARP 'WAVECYCLES' OF SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SKIP CYCLES....(integer) number of wavecycles to skip at start of file\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_OVERLOAD):
+		fprintf(stdout,"INFO: CLIP THE SOUND AND ADD DISTORTION WAVEFORM OVER THE CLIPPED PORTIONS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NOISE.........peaks of signal replaced by noise.\n");
+		fprintf(stdout,"INFO: WAVEFORM......peaks of signal replaced by signal of given frequency.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GATE LEVEL WHERE SIGNAL IS CLIPPED....level at which signal is clipped\n");
+		fprintf(stdout,"INFO: DEPTH OF DISTORTION GLAZE....depth of distortion pattern imposed on clipped portions.\n");
+		fprintf(stdout,"INFO: FREQUENCY OF DISTORT SIGNAL...(mode WAVEFORM only) frequency of distortion signal.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DISTORT_PULSED):
+		fprintf(stdout,"INFO: IMPOSE AN IMPULSE STREAM OVER INPUT SOUND, OR OVER A CYCLING SEGMENT OF THAT SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IMPOSE....impose impulse stream on the input sound.\n");
+		fprintf(stdout,"INFO: SYNTH......select a specified duration of wavecycles from the input src, at a specified time,\n");
+		fprintf(stdout,"INFO:                  and use as a looped sound source on which the impulses are imposed.\n");
+		fprintf(stdout,"INFO: SYNTH2.....the same, but specify starttime as a samplecnt,\n");
+		fprintf(stdout,"INFO:                  and select a specified NUMBER of wavecycles.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IMPULSE ENVELOPE......... ...a breakpoint file describing the envelope shape of the impulse.\n");
+		fprintf(stdout,"INFO:             whatever time units used will be scaled to the duration of the impulses.\n");
+		fprintf(stdout,"INFO: PULSE STREAM START-TIME IN SRC SOUND ...time in src sound where impulses begin.\n");
+		fprintf(stdout,"INFO: DURATION OF IMPULSE STREAM.............time for which impulses persist.\n");
+		fprintf(stdout,"INFO: FREQUENCY OF IMPULSES (HZ).............frequency of the impulses\n");
+		fprintf(stdout,"INFO: RANDOMISATION OF FREQUENCY OF IMPULSES........max amount of semitone wander.\n");
+		fprintf(stdout,"INFO:         of the impulse are randomised, from impulse to impulse.\n");
+		fprintf(stdout,"INFO: RANDOMISATION OF TIME CONTOUR OF AN IMPULSE........time-positions of amplitude peaks & troughs\n");
+		fprintf(stdout,"INFO:         of the impulse are randomised, from impulse to impulse.\n");
+		fprintf(stdout,"INFO: RANDOMISATION_OF_AMPLITUDE_CONTOUR_OF_AN_IMPULSE....shape created by amplitude peaks & troughs\n");
+		fprintf(stdout,"INFO:         of the impulse is randomised, from impulse to impulse.\n");
+		fprintf(stdout,"INFO: DURATION (or NUMBER) OF WAVECYCLES TO GRAB AS SOUND SRC INSIDE IMPULSES......(SYNTHESIS MODES ONLY)\n");
+		fprintf(stdout,"INFO:         at the specified starttime, wavecycles are chosen from src sound,\n");
+		fprintf(stdout,"INFO:         and used as the 'waveform' on which the impulses are imposed\n");
+		fprintf(stdout,"INFO: SEMITONE TRANSPOSITION CONTOUR OF SOUND INSIDE EACH IMPULSE.....\n");
+		fprintf(stdout,"INFO:         within each impulse, the sound material is pitchwarped, using the semitone contour defined here.\n");
+		fprintf(stdout,"INFO: MAX SEMITONE RANGE OF RANDOMISATION OF TRANSPOSITION CONTOUR............\n");
+		fprintf(stdout,"INFO:         within each impulse, the transposition contour is itself randomised, from impulse to impulse.\n");
+		fprintf(stdout,"INFO: KEEP START OF SRC BEFORE IMPULSES BEGIN ... if impulses begin at a time beyond start of src sound,\n");
+		fprintf(stdout,"INFO:          the opening unpulsed segment of the sound is retained in the output.\n");
+		fprintf(stdout,"INFO: KEEP END OF SRC AFTER IMPULSES FINISH ... if impulses end at a time before end of src sound,\n");
+		fprintf(stdout,"INFO:          the closing unpulsed segment of the sound is retained in the output.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Works on MONO files only\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ZIGZAG):
+		fprintf(stdout,"INFO: READ BACK AND FORTH INSIDE SOUNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In mode USER SPECIFIED\n");
+		fprintf(stdout,"INFO: Required data is textfile containing sequence of times to zigzag between.\n");
+		fprintf(stdout,"INFO: Each step-between-times must be > (3 * splicelen).\n");
+		fprintf(stdout,"INFO: Successive zigsteps moving in same (time-)direction are concatenated.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RANDOM SEED..a number to generate a replicable random sequence. (>0)\n");
+		fprintf(stdout,"INFO: .............enter same number on next program run, to get same outfile.\n");
+		fprintf(stdout,"INFO: .............(Default: (0) random sequence is different every time).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(LOOP):
+		fprintf(stdout,"INFO: LOOP INSIDE SOUNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEARCHFIELD........makes step advance irregular, within timeframe of SEARCHFIELD.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FROM INFILE START..flag forces outfile to play from beginning of infile\n");
+		fprintf(stdout,"INFO: ...................(even if looping doesn't begin there).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SCRAMBLE):
+		fprintf(stdout,"INFO: SCRAMBLE THE SOUND BY CUTTING RANDOMLY AND REORGANISING CUT CHUNKS RANDOMLY\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COMPLETELY RANDOM........Random chunks cut from file, and spliced end to end.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCRAMBLE SRC:THEN AGAIN..Whole file is cut into random chunks, and these rearranged\n");
+		fprintf(stdout,"INFO: .........................then this process is repeated differently.. and again..etc\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN CHUNKLEN.........minimum chunklen to cut.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX CHUNKLEN.........maximum chunklen to cut.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHUNK LENGTH.........average chunklen to cut.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCATTER COEFFICIENT..Randomisation of chunk lengths.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEED VALUE...........same seed-number producea identical output on rerun\n");
+		fprintf(stdout,"INFO: .....................(Default: (0) random sequence is different every time).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RUN FROM SND START:..wherever first randomly located chunk is\n");
+		fprintf(stdout,"INFO: .....................outfile plays up to its start before scrambling.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RUN TO SND END:......wherever last randomly located chunk is\n");
+		fprintf(stdout,"INFO: .....................outfile plays on to end of src sound.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ITERATE):
+		fprintf(stdout,"INFO: ITERATE AN INPUT SOUND IN A FLUID MANNER\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ****  WARNING: Do NOT use with large files. ****\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DELAY..................(average) delay between iterations. Default:infile dur.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH SCATTER..........max of random pitchshift of each iteration: semitones\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AMPLITUDE SCATTER......max of random amp-reduction on each iteration.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PROGRESSIVE FADE.......(average) amplitude fade beween iterations.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OVERALL GAIN...........(special) value 0, gives best guess for no distortion.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEED RANDOM GENERATOR..same number produces identical output on rerun,\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ITERATE_EXTEND):
+		fprintf(stdout,"INFO: EXTEND A SOUND BY FREEZING A SPECIFIED PART OF IT, BY FLUID ITERATION\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ****  WARNING: Do NOT use with large files. ****\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1)    Specify (minimum) duration of output.\n");     
+		fprintf(stdout,"INFO: 2)    Specify number of repetitions in extended segment.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME WHEN ITERATED SEGMENT ENDS\n");
+		fprintf(stdout,"INFO:       if there is portion of original sound beyond the segment to be extended,\n");
+		fprintf(stdout,"INFO:       output duration will be greater than this parameter value.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DELAY..................(average) delay between iterations. Default:infile dur.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH SCATTER..........max of random pitchshift of each iteration: semitones\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AMPLITUDE SCATTER......max of random amp-reduction on each iteration.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START OF TIME FREEZE...time at which freezing iteration begins.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: END OF TIME FREEZE.....time at which freezing iteration ends.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN OF FROZEN SEGMENT.....multiplies output level of frozen segment.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEED RANDOM GENERATOR..same number produces identical output on rerun,\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DRUNKWALK):
+		fprintf(stdout,"INFO: DRUNKEN-WALK THROUGH INPUT SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In mode SOBER MOMENTS input sound is read soberly at holds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOCUS............Time in src around which drunkwalk happens(secs) CAN MOVE THRO SRC\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AMBITUS..........(half)width of region from within which sound-segments read.(secs)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STEP.............Max length of (random) step between segment-reads.\n");
+		fprintf(stdout,"INFO: .................(always WITHIN ambitus: automatically adjusted where too large)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CLOCKTICK........Time between segment reads = (average) segment duration.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEGMENT OVERLAY..Mutual overlap of segments in output.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEED VALUE...... Any set value gives reproducible output.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EQ):
+		fprintf(stdout,"INFO: CUT OR BOOST, ABOVE, BELOW OR AROUND A GIVEN FRQ\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BWIDTH.... filter bandwidth in Hz\n");
+		fprintf(stdout,"INFO: BOOST/CUT..is the boost or cut, in dB\n");
+		fprintf(stdout,"INFO: FREQ.......is the filter frequency in Hz\n");
+		fprintf(stdout,"INFO: PRESCALE...scales the INPUT to the filter.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(LPHP):
+		fprintf(stdout,"INFO: FIXED LOW PASS OR HIGH PASS FILTER.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTENUATION..Gain reduction of filter, in dB.\n");
+		fprintf(stdout,"INFO: .............Greater attenuation, sharper filter, but longer to calculate.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PASS-BAND....last pitch to be passed by the filter.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STOP-BAND....first pitch to be stopped by the filter.\n");
+		fprintf(stdout,"INFO: .............If stop-band is above pass-band, this is a lopass filter.\n");
+		fprintf(stdout,"INFO: .............If stop-band is below pass-band, this is a hipass filter.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PRESCALE.....Prescale input level: Avoid overflows.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FSTATVAR):
+		fprintf(stdout,"INFO: LOPASS, HIGH-PASS, BANDPASS, OR NOTCH FILTER WITH VARIABLE FRQ\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ACUITY.....acuity of filter: Smaller vals give tighter filter.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN.......overall gain on output:  Rule of thumb:\n");
+		fprintf(stdout,"INFO: ...........if acuity = (1/3)to-power-n: gain = (2/3)-to-power-n\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FREQUENCY..frq of filter\n");
+		fprintf(stdout,"INFO: DECAY TAIL...time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FLTBANKN):
+		fprintf(stdout,"INFO: BANK OF FILTERS, WITH TIME-VARIABLE Q\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Q..................Q (tightness) of filters.\n");
+		fprintf(stdout,"INFO: GAIN...............overall gain.\n");
+		fprintf(stdout,"INFO: LOW FRQ............lofrq limit of filter bank.\n");
+		fprintf(stdout,"INFO: HIGH FRQ...........hifrq limit of filter bank.\n");
+		fprintf(stdout,"INFO: FRQ RANDOMISATION..Random scatter of filter frqs.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FLTBANKC):
+		fprintf(stdout,"INFO: GENERATE A LIST OF FREQUENCIES FOR USE AS A FILTERBANK\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You can add your own amplitudes to the textfile & use if with USERBANK\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ............lofrq limit of filter bank.\n");
+		fprintf(stdout,"INFO: HIGH FRQ...........hifrq limit of filter bank.\n");
+		fprintf(stdout,"INFO: FRQ RANDOMISATION..Random scatter of filter frqs.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FLTBANKU):
+		fprintf(stdout,"INFO: USER-DEFINED FILTERBANK,WITH TIME-VARIABLE Q\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BANDS AS FRQ (HZ):..Filter-pitches as frq in Hz.\n");
+		fprintf(stdout,"INFO: BANDS AS MIDI:......Filter-pitches as MIDI values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Filter data is a file with Pitch & Amp of filters\n");
+		fprintf(stdout,"INFO: (paired, one pair on each line).\n");
+		fprintf(stdout,"INFO: where amplitude may be expressed in decibels or as a +ve number,\n");
+		fprintf(stdout,"INFO: and comment-lines (starting with ';') may be used.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Q:........Q (tightness) of filter\n");
+		fprintf(stdout,"INFO: GAIN......overall gain on output.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FLTBANKV):
+		fprintf(stdout,"INFO: USER-DEFINED TIME_VARYING FILTERBANK,WITH TIME-VARIABLE Q\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REQUIRED DATAFILE-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: a textfile with lines of data for filter bands at successive times\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Each line contains the following items\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:           Time   Pitch1 Amp1   [Pitch2 Amp2    etc....].\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Where pitch and Amp values must be paired: and any number of pairs can be used in a line,\n");
+		fprintf(stdout,"INFO: BUT each line must have SAME number of pairs on it.\n");
+		fprintf(stdout,"INFO: (To eliminate a band in any line(s), set its amplitude to 0.0).\n");
+		fprintf(stdout,"INFO: Time values (in secs) must be in ascending order (and >=0.0)\n");
+		fprintf(stdout,"INFO: Pitch vals may be EITHER frq, OR MIDI, depending on Mode.\n");
+		fprintf(stdout,"INFO: Amp values may be numeric, or dB values (e.g. -4.1dB).\n");
+		fprintf(stdout,"INFO: and comment-lines may be used: start these with ';'.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Q....................Q (tightness) of filter.\n");
+		fprintf(stdout,"INFO: GAIN.................overall gain.\n");
+		fprintf(stdout,"INFO: NUMBER OF HARMONICS..No of harmonics (of each pitch) to use: Default 1.\n");
+		fprintf(stdout,"INFO: .....................Very high harmonics of high pitches may be too high to calculate. (check with Max Harmonic button)\n");
+		fprintf(stdout,"INFO: .....................No-of-pitches times no-of-harmonics determines program speed.\n");
+		fprintf(stdout,"INFO: ROLL OFF.............Level drop (in dB) from one harmonic to next.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...........Time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: DOUBLE FILTERING.....More sharply defined filter frequencies.\n");
+		fprintf(stdout,"INFO: DROP OUT ON OVERFLOW.The filter is designed to adjust its internal level to prevent numerical overflow from\n");
+		fprintf(stdout,"INFO: .....................causing runaway distortion. If you are concerned to avoid any overflows at all,\n");
+		fprintf(stdout,"INFO: .....................setting this flag will cause the filter to stop calculating if any overflow is detected.\n");
+		fprintf(stdout,"INFO: .....................The filter gain can then be turned down, and the filter launched again.\n");
+		break;
+	case(FLTBANKV2):
+		fprintf(stdout,"INFO: USER-DEFINED TIME_VARYING FILTERBANK,WITH TIME-VARIABLE Q AND PARTIALS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REQUIRED DATAFILE-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: a textfile with lines of data for filter bands at successive times & for partials similarly\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FIRST set of lines contain the following items\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:           Time   Pitch1 Amp1   [Pitch2 Amp2    etc....].\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Where pitch and Amp values must be paired: and any number of pairs can be used in a line,\n");
+		fprintf(stdout,"INFO: BUT each line must have SAME number of pairs on it.\n");
+		fprintf(stdout,"INFO: (To eliminate a band in any line(s), set its amplitude to 0.0).\n");
+		fprintf(stdout,"INFO: Time values (in secs) must be in ascending order (and >=0.0)\n");
+		fprintf(stdout,"INFO: Pitch vals may be EITHER frq, OR MIDI, depending on Mode.\n");
+		fprintf(stdout,"INFO: Amp values must be numeric.\n");
+		fprintf(stdout,"INFO: and comment-lines may be used: start these with ';'.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: There must then be a SEPARATING LINE starting with a '#' sign\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SECOND set of lines contain the following items\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:           Time:   PartialNo1 Amp1   [PartialNo2 Amp2    etc....].\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Where partial numbers and Amp values must be paired: and any number of pairs can be used in a line,\n");
+		fprintf(stdout,"INFO: BUT each line must have SAME number of pairs on it.\n");
+		fprintf(stdout,"INFO: (To eliminate a band in any line(s), set its amplitude to 0.0).\n");
+		fprintf(stdout,"INFO: Time values (in secs) must be in ascending order (and >=0.0)\n");
+		fprintf(stdout,"INFO: Partial numbers can be fractional but must be >= 1.0\n");
+		fprintf(stdout,"INFO: Amp values may be numeric.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The first time value in each line set MUST BE ZERO.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Q....................Q (tightness) of filter.\n");
+		fprintf(stdout,"INFO: GAIN.................overall gain.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...........Time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: DOUBLE FILTERING.....More sharply defined filter frequencies.\n");
+		break;
+	case(FLTITER):
+		fprintf(stdout,"INFO: ITERATE SOUND, WITH CUMULATIVE FILTERING BY A FILTERBANK.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile with Pitch & Amp of filters\n");
+		fprintf(stdout,"INFO: (paired, one pair on each line).\n");
+		fprintf(stdout,"INFO: Pitch, as Hz or MIDI.\n");
+		fprintf(stdout,"INFO: Amp, can be entered as dB vals or numerically.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Q.......................Q (tightness) of filter.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN....................overrall gain in filtering process.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DELAY...................(average) delay between iterations (secs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTFILE DURATION........(min) duration of output file (>infile duration).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PRESCALE................gain on the INPUT to the filtering process.\n");
+		fprintf(stdout,"INFO:.........................If 0.0, Program automatically divides input level by\n");
+		fprintf(stdout,"INFO:.........................the max number of sound overlays occuring in process.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX PITCH SHIFT.........max pitchshift of any segment: (fractions of) semitones\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX LOUDNESS SHIFT......max amplitude reduction of any segment. (numeric)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH NOT INTERPOLATED..during pitch shift: (fast but dirty).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXPONENTIAL DECAY...... each seg gets quieter before next enters.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NO NORMALISATION........segs may grow or fall in level quickly.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(FLTSWEEP):
+		fprintf(stdout,"INFO: FILTER WHOSE FOCUS-FREQUENCY SWEEPS OVER A RANGE OF FREQUENCIES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ACUITY......Smaller vals give tighter filter.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN........overall gain on output:   Rule of thumb:\n");
+		fprintf(stdout,"INFO: ............if acuity = (1/3)to-power-n: gain = (2/3)-to-power-n\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOW FRQ.....lowest frq to sweep to.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: HIGH FRQ....highest frq to sweep to.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SWEEP FRQ...frq of the sweep itself.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PHASE.......start of sweep: Range(0-1)\n");
+		fprintf(stdout,"INFO: ............e.g. to sweep once over range,\n");
+		fprintf(stdout,"INFO: ............set sweepfrq to infiledur/2 (default)\n");
+		fprintf(stdout,"INFO: ............and set phase to 0 (upsweep) or .5(downsweep)\n");
+		fprintf(stdout,"INFO: DECAY TAIL...time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ALLPASS):
+		fprintf(stdout,"INFO: PHASESHIFT SOUND, OR PRODUCE 'PHASING' EFFECT\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN................ In mode PHASING EFFECT,\n");
+		fprintf(stdout,"INFO: .....................effect increases as gain increases from -1\n");
+		fprintf(stdout,"INFO: .....................BUT a gain of 1.0 will produce complete phase cancellation\n");
+		fprintf(stdout,"INFO: .....................and the output signal will be zero.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PRESCALE.............gain on the INPUT to the filtering process.\n");
+		fprintf(stdout,"INFO: DECAY TAIL...........time allowed for filter resonance to decay,once source sound has finished.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LINEAR INTERP DELAY..(default: logarithmic interp of changing delay vals)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_COUNT):
+		fprintf(stdout,"INFO: COUNT GRAINS FOUND IN A SOUND (AT GIVEN GATE & MINHOLE VALUES)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_OMIT):
+		fprintf(stdout,"INFO: OMIT A PROPORTION OF GRAINS FROM GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GRAINS TO KEEP...... .number of grains to keep from each set of 'out_of' grains\n");
+		fprintf(stdout,"INFO: ......................may vary over time, but must not exceed 'out_of'.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUT OF THIS MANY.....'keep' grains kept, from each 'out_of' grains set\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_DUPLICATE):
+		fprintf(stdout,"INFO: DUPLICATE GRAINS IN GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL...........required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_REORDER):
+		fprintf(stdout,"INFO: REORDER GRAINS IN GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a string such as 'adb:c' or 'adb-c'\n");
+		fprintf(stdout,"INFO: indicating how grains are to be reordered.\n");
+		fprintf(stdout,"INFO: The example means use grains 1 (a), 4 (d) and 2 (b) in sequence,\n");
+		fprintf(stdout,"INFO: then begin this grain-jumping pattern again, BUT start at grain3 (c):\n");
+		fprintf(stdout,"INFO: Then continue to advance in this fashion until no grains left in infile.\n");
+		fprintf(stdout,"INFO: The ':' (or '-') is obligatory.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_REPITCH):
+		fprintf(stdout,"INFO: REPITCH GRAINS IN GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NO GRAIN REPEATS..Lengthen or shorten each grain in turn, without repeating any grains:\n");
+		fprintf(stdout,"INFO: ..................on reaching end of stretch list, cycle back to its start.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REPEAT EACH GRAIN Play grain at each new length, before proceeding to next grain.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is textfile listing transpositions as (+ve or -ve) semitone shifts.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_RERHYTHM):
+		fprintf(stdout,"INFO: CHANGE RHYTHM OF GRAINS IN GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NO GRAIN REPEATS..Lengthen or shorten each grain in turn, without repeating any grains:\n");
+		fprintf(stdout,"INFO: ..................on reaching end of stretch list, cycle back to its start.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REPEAT EACH GRAIN Play grain at each new length, before proceeding to next grain.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile listing duration-multipliers.\n");
+		fprintf(stdout,"INFO: if any inter-grain time reduced below MINGRAINTIME\n");
+		fprintf(stdout,"INFO: it will be set to MINGRAINTIME.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_REMOTIF):
+		fprintf(stdout,"INFO: CHANGE PITCH AND RHYTHM OF GRAINS IN GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NO GRAIN REPEATS..Lengthen or shorten each grain in turn, without repeating any grains:\n");
+		fprintf(stdout,"INFO: ..................on reaching end of stretch list, cycle back to its start.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REPEAT EACH GRAIN Play grain at each new length, before proceeding to next grain.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile containing transposition-timemultiplier PAIRS.\n");
+		fprintf(stdout,"INFO: Transpositions are (+ve or -ve) semitone shifts.\n");
+		fprintf(stdout,"INFO: Time-multipliers change the grain duration.\n");
+		fprintf(stdout,"INFO: if any inter-grain time reduced below MINGRAINTIME\n");
+		fprintf(stdout,"INFO: it will be set to MINGRAINTIME.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_TIMEWARP):
+		fprintf(stdout,"INFO: STRETCH (OR SHRINK) DURATION OF GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: WITHOUT STRETCHING GRAINS THEMSELVES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESTRETCH-RATIO.....is degree of stretching/shrinking of intergrain time.\n");
+		fprintf(stdout,"INFO: ......................a value of 2 doubles the intergrain time.\n");
+		fprintf(stdout,"INFO: ......................a value of .5 halves the intergrain time.\n");
+		fprintf(stdout,"INFO: ......................if any inter-grain time reduced below a certain MINGRAINTIME,\n");
+		fprintf(stdout,"INFO: ......................it will be set to MINGRAINTIME.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_REVERSE):
+		fprintf(stdout,"INFO: REVERSE ORDER OF GRAINS IN A GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: WITHOUT REVERSING GRAINS THEMSELVES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_GET):
+		fprintf(stdout,"INFO: LOCATE TIMINGS OF GRAIN-ONSETS IN A GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUT-TEXTFILE will contain a list of grain-onset timings, in seconds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_POSITION):
+		fprintf(stdout,"INFO: REPOSITION GRAIN-ONSETS IN A GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile containing a list of grain-onset timings, in seconds.\n");
+		fprintf(stdout,"INFO: (Which might be obtained with GRAIN GET)\n");
+		fprintf(stdout,"INFO: if any inter-grain time reduced below MINGRAINTIME\n");
+		fprintf(stdout,"INFO: it will be set to MINGRAINTIME.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GRAINTIME OFFSET......added to ALL grain timings.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME....min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE..track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: ......................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GRAIN_ALIGN):
+		fprintf(stdout,"INFO: SYNCHRONISE GRAIN-ONSETS IN 2nd GRAINY-SOUND\n");
+		fprintf(stdout,"INFO: WITH THOSE IN THE 1st.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1st infile provides grain-onset times.\n");
+		fprintf(stdout,"INFO: 2nd infile provides the actual grains to be retimed.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GRAINTIME OFFSET.........added to ALL output grain timings.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX TIME BETWEEN GRAINS..if program sends a warning that it has found grain too large for buffer.\n");
+		fprintf(stdout,"INFO:                                                   increase this value until no warning is sent.\n");
+		fprintf(stdout,"INFO: GATE LEVEL...............required signal level for grain to be seen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GATE LEVEL FOR 2nd FILE..is separate gate for file 2.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GRAIN-OFF TIME.......min duration of inter-grain holes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW-SIZE.....track signal level, with this windowsize (secs)\n");
+		fprintf(stdout,"INFO: .........................0 value turns off tracking.\n");
+		fprintf(stdout,"INFO: \n");					 
+		break;
+	case(MIX):
+		fprintf(stdout,"INFO: MIX SOUNDS AS INSTRUCTED IN A MIXFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIXING STARTTIME...starttime in mix (to start mixing later than zero).\n");
+		fprintf(stdout,"INFO: MIXING ENDTIME.....endtime in mix (to stop mix before its true end).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Note that the START and END params intended for mix TESTING purposes only.\n");
+		fprintf(stdout,"INFO: If you want to keep output from such a testmix, you should TOPNTAIL it.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTENUATION.......reduce the mix level, if necessary.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ALTERNATIVE MIX....slower,but may avoid clipping in special circumstances.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXTEST):
+		fprintf(stdout,"INFO: TEST THE SYNTAX OF A MIXFILE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXMAX):
+		fprintf(stdout,"INFO: TEST THE MAXIMUM LEVEL OF A MIX, DEFINED IN A MIXFILE\n");
+		fprintf(stdout,"INFO: AND SUGGEST A GAIN FACTOR TO AVOID OVERLOAD, IF NECESSARY\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIXING STARTTIME..starttime in mix (to start mixing later than zero).\n");
+		fprintf(stdout,"INFO: MIXING ENDTIME....endtime in mix (to stop mix before its true end).\n");
+		fprintf(stdout,"INFO: OUTTEXTFILE.......stores clipping locations (& maxlevel, in mode MAXLEVEL & CLIPTIMES).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You can alter the overall level of a mix with 'SUBMIX ATTENUATE'.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXFORMAT):
+		fprintf(stdout,"INFO: MIXFILES CONSIST OF LINES WITH ONE OF THE FOLLOWING FORMATS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: sndname   starttime_in_mix    chans     level\n");
+		fprintf(stdout,"INFO: sndname   starttime_in_mix    1         level        pan\n");
+		fprintf(stdout,"INFO: sndname   starttime_in_mix    2         leftlevel    leftpan    rightlevel    rightpan\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SNDNAME....name of MONO or STEREO sndfile: ALL MUST HAVE SAME SAMPLING RATE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHANS......number of channels in this soundfile (1 or 2 ONLY)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LEVEL......loudness, as number (1 = unity gain) or dB (0dB = unity gain)\n" );
+		fprintf(stdout,"INFO: ...........Mono & stereo files MAY have SINGLE level param (NO pan data).\n");
+		fprintf(stdout,"INFO: ...........In this case, MONO files in STEREO mixes are panned centrally.\n");
+		fprintf(stdout,"INFO: ...........OTHERWISE....\n");
+		fprintf(stdout,"INFO: ...........MONO files   MUST have 1 level & 1 pan parameter (ONLY).\n");
+		fprintf(stdout,"INFO: ...........STEREO files MUST have 2 level & 2 pan params(1 for each channel)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PAN........is spatial positioning of file (or file channel) in output mix.\n");
+		fprintf(stdout,"INFO: ...........-1 Hard Left : 0 Centre : 1 Hard Right\n");
+		fprintf(stdout,"INFO: ...........< -1 hard left & attenuated : > 1 hard right & attenuated.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ALSO\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1)  The mixfile list need NOT be in starttime order.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2)  Silence at start of mix IGNORED.(splice on afterwards if needed).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 3)  With exclusively mono inputs, with NO pan information, OR \n");
+		fprintf(stdout,"INFO:        when ALL panned hard left, or ALL hard right, output is MONO.\n");
+		fprintf(stdout,"INFO:        All other situations produce stereo output.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TAKE CARE WHEN PANNING BOTH CHANNELS OF A STEREO FILE.\n");
+		fprintf(stdout,"INFO: 4)  The channel contributions sum, so e.g. if both channels are\n");
+		fprintf(stdout,"INFO:        panned to same position without attenuation, overload possible.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 5)  You may test for max level in your mix output with SUBMIX GETLEVEL.\n");
+		fprintf(stdout,"INFO:        Reduce the mixfile level, if necessary, using SUBMIX ATTENUATE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 6)  You may put comment lines in mixfiles : Start such line with a ';'\n");
+		fprintf(stdout,"INFO:       Blank lines are ignored.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXDUMMY):
+		fprintf(stdout,"INFO: CONVERT A LIST OF SNDFILES INTO A BASIC MIXFILE (FOR EDITING)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIX_ON_GRID):
+		fprintf(stdout,"INFO: CONVERT A LIST OF SNDFILES INTO A BASIC MIXFILE (FOR EDITING) ON A GRID OF TIMES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIX GRID .... is a list of times (in ascending order) at which sounds are to be placed.\n");
+		fprintf(stdout,"INFO: ................ OR a list where times-to-be-used are marked by 'x' (before time, with no space)\n");
+		fprintf(stdout,"INFO: ................ to indicate which grid points are to be used for successive input sounds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ................ The number of (marked) times must be equal to the number of input sounds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ................ Times may be followed (on the same line only) by comments e.g. grid numbering.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(AUTOMIX):
+		fprintf(stdout,"INFO: MIX SEVERAL MONO OR STEREO FILES USING A TIME-CHANGING BALANCE-FUNCTION\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIX BALANCE FUNCTION .... is a list of value sets.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: .....Each set consists of a time, followed by the RELATIVE level of each file in the mix, at that time.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: .....The values WITHIN A LINE are used to set the RELATIVE levels of the sounds at that time.\n");
+		fprintf(stdout,"INFO: .....Whatever set of numbers you use, THESE ARE SCALED so the total set of levels used adds up to 1.0.\n");
+		fprintf(stdout,"INFO: .....(This means that if all signals are at max level, the output will never exceed max level:\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: .....YOU CANNOT USE THIS DATA TO VARY THE OVERALL LEVEL FROM LINE TO LINE.\n");
+		fprintf(stdout,"INFO: .....and, in particular, the values cannot ALL be zero.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: .....(Apply an envelope function (with ENVEL) to change the overall level of the mix output sound).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIX ENVELOPE FUNCTION ....Defines (possibly time-varying) gain to be apply to output AFTER BALANCING.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXTWARP):
+		fprintf(stdout,"INFO: TIMEWARP THE DATA IN A MIXFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START LINE...mixfile-line at which warping begins (default: 1st in file)\n");
+		fprintf(stdout,"INFO: END LINE.....mixfile-line at which warping ends  (default: last in file).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SORT ENTRY TIMES              sorts mixfile so lines are in time-order of entry.\n");
+		fprintf(stdout,"INFO: REVERSE TIMING PATTERN:  e.g. rit. of sound entries becomes an accel.\n");
+		fprintf(stdout,"INFO: REVERSE TIMING & NAMES  e.g. rit starting from file A to file Z becomes accel from file Z to A.\n");
+		fprintf(stdout,"INFO: FREEZE TIMEGAPS               all timegap between sound entries become same as FIRST timegap.\n");
+		fprintf(stdout,"INFO: FREEZE TIMEGAPS & NAMES  ditto, and all files take firstfile name.\n");
+		fprintf(stdout,"INFO: SCATTER ENTRY TIMES         in intervals between original entry times. SCATTER is degree of scattering, from none to max, Range(0-1).\n");
+		fprintf(stdout,"INFO: SHUFFLE UP ENTRY TIMES   shuffle times in file forward by time DISPLACEMENT secs (e.g from a specified line).\n");
+		fprintf(stdout,"INFO: ADD TO TIMEGAPS                 add fixed val PARAMETER secs, to timegaps between sounds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THE CREATE & ENLARGE MODES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If the parameter value is X, then\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CREATE FIXED TIMEGAPS 1..between all sounds,timegap = X secs\n");
+		fprintf(stdout,"INFO: CREATE FIXED TIMEGAPS 2..startval+X,startval+2X etc\n");
+		fprintf(stdout,"INFO: CREATE FIXED TIMEGAPS 3..startval*X startval*2X etc\n");
+		fprintf(stdout,"INFO: CREATE FIXED TIMEGAPS 4..startval*X     startval*X*X    etc\n");
+		fprintf(stdout,"INFO: ENLARGE TIMEGAPS 1.......multiply them by X.\n");
+		fprintf(stdout,"INFO: ENLARGE TIMEGAPS 2.......by +X, +2X,+3X  etc\n");
+		fprintf(stdout,"INFO: ENLARGE TIMEGAPS 3.......by *X *2X *3X\n");
+		fprintf(stdout,"INFO: ENLARGE TIMEGAPS 4.......by *X, *X*X, *X*X*X  etc. (CARE!!)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXSHUFL):
+		fprintf(stdout,"INFO: SHUFFLE THE DATA IN A MIXFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) DUPLICATE LINES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2) REVERSE ORDER FILENAMES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 3) SCATTER ORDER FILENAMES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 4) FIRST FILENAME TO ALL.....and hence first sound in all lines.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 5) OMIT LINES................(closing up timegaps appropriately).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 6) OMIT ALTERNATE LINES......(closing up timegaps appropriately).\n");
+		fprintf(stdout,"INFO: .............................In modes 5 & 6 mix must be in correct time-order.\n");
+		fprintf(stdout,"INFO: .............................mixfiles can be time-ordered using timewarp mode 1\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) DUPL LINES, NEW FILENAME..duplicate each line with new sound, newname.\n");
+		fprintf(stdout,"INFO: .............................Program checks 'newname' is compatible sndfile,BUT\n");
+		fprintf(stdout,"INFO: .............................NO SNDNAME CHECK turns OFF this checking.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START LINE..line at which shuffling begins (default: 1st in file)\n");
+		fprintf(stdout,"INFO: END LINE....line at which shuffling ends  (default: last in file).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXGAIN):
+		fprintf(stdout,"INFO: ALTER THE OVERALL LEVEL OF A MIXFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START LINE..line at which attenuation begins (default: 1st in file)\n");
+		fprintf(stdout,"INFO: END LINE....line at which attenuation ends  (default: last in file).\n");
+		fprintf(stdout,"INFO: GAINVAL.....must be > 0.0\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You can test the overall level of a mix with 'SUBMIX GETLEVEL'\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXSWARP):
+		fprintf(stdout,"INFO: ALTER THE SPATIAL DISTRIBUTION OF A MIXFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THE FOLLOWING MODES ARE TO BE UNDERSTOOD THUS----------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCATTER ALTERNATING..gives random positions but alternating\n");
+		fprintf(stdout,"INFO: .....................to left/right of centre of spatial range specified.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TWIST WHOLE MIX......Invert stereo in alternate lines of mixfile.\n");
+		fprintf(stdout,"INFO: .....................(Can be used to avoid clipping).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TWIST A LINE.........Invert stereo in specified line of mixfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START LINE...........line at which warping begins (default: 1st in file)\n");
+		fprintf(stdout,"INFO: END LINE.............line at which warping ends  (default: last in file).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXSYNC):
+		fprintf(stdout,"INFO: SYNCHRONISE SOUNDFILES IN A MIXFILE,\n");
+		fprintf(stdout,"INFO: OR GENERATE SUCH A MIXFILE FROM A LIST OF SNDFILES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INTEXTFILE......is list of sndfiles OR an existing mixfile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXSYNCATT):
+		fprintf(stdout,"INFO: SYNCHRONISE ATTACKS OF SOUNDFILES, IN A MIXFILE,\n");
+		fprintf(stdout,"INFO: OR GENERATE SUCH A MIXFILE FROM A LIST OF SNDFILES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Input file is a list of sndfiles OR an existing mixfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: With a sndfilelist (only), each sndname MAY be followed by 2 times,\n");
+		fprintf(stdout,"INFO: which delimit the search area for the sound's attack.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: WINDOW DIVIDER..is factor shortening window which scans for the attack.\n");
+		fprintf(stdout,"INFO: ................It can be 2,4,8,16, or 32 ONLY.\n");
+		fprintf(stdout,"INFO: POWER METHOD....finds peak-power segment, before locating its max sample.\n");
+		fprintf(stdout,"INFO: ................Default: program looks purely for maxsample.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The program estimates output levels required to prevent clipping,\n");
+		fprintf(stdout,"INFO: But estimate may be over-cautiously low: adjust with 'SUBMIX ATTENUATE'.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXTWO):
+		fprintf(stdout,"INFO: QUICK MIX OF 2 SNDFILES (HAVING SAME NUMBER OF CHANNELS)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STAGGER FILE2 ENTRY..2nd file enters, 'stagger' secs after first.\n");
+		fprintf(stdout,"INFO: SKIP INTO 2ND FILE...by 'skip' secs, before starting to mix.\n");
+		fprintf(stdout,"INFO: AMPLITUDE SKEW.......1st sound has 'skew' times more gain than 2nd.\n");
+		fprintf(stdout,"INFO: START MIX AT.........Start the mix at the time specified.\n");
+		fprintf(stdout,"INFO: CUT OFF MIX AT.......Stop the mix at the time specified.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Both files are halved in level\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXMANY):
+		fprintf(stdout,"INFO: QUICK MIX OF SEVERAL SNDFILES (HAVING SAME NUMBER OF CHANNELS)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXBALANCE):
+		fprintf(stdout,"INFO: MIX BETWEEN 2 SNDFILES USING A BALANCE FUNCTION.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BALANCE FUNCTION...Describes the relative level of the two sounds.\n");
+		fprintf(stdout,"INFO: ............................File 1 level is multiplied by the balance value.\n");
+		fprintf(stdout,"INFO: ............................File 2 level is multiplied by (1.0 minus the balance value).\n");
+		fprintf(stdout,"INFO: START OF MIX....\n");
+		fprintf(stdout,"INFO: END OF MIX......Use these to make just part of the mix.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXCROSS):
+		fprintf(stdout,"INFO: QUICK CROSSFADE BETWEEN SNDFILES (WITH SAME NUMBER OF CHANNELS).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Crossfade is from sndfile1 towards sndfile2.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STAGGER FILE2 ENTRY..2nd file starts 'stagger' secs. after 1st.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CROSSFADE SKEW.......f 1, cosinusoidal-crossfade is normal.\n");
+		fprintf(stdout,"INFO: .....................below 1, cosin-fade begins rapidly then slows.\n");
+		fprintf(stdout,"INFO: .....................above 1, cosin-fade begins slowly, then speeds up.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: Stagger approximated in c. hundredths of a sec. For more precise stagger,\n" );
+		fprintf(stdout,"INFO: splice silence to start of sndfile2 & use stagger 0 (or use SUBMIX MIX).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (Only spectral morphing will create true morph between 2 sounds).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXINTERL):
+		fprintf(stdout,"INFO: INTERLEAVE MONO FILES TO MAKE MULTICHANNEL OUTFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: First sndfile goes to left channel of stereo, (or channel 1 of 4), etc.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIXINBETWEEN):
+		fprintf(stdout,"INFO: GENERATE A SET OF SOUNDS IN-BETWEEN THE 2 INPUT SOUNDS\n");
+		fprintf(stdout,"INFO: THROUGH WEIGHTED MIXES OF THE INPUT SOUNDS,\n");
+		fprintf(stdout,"INFO: FROM MOSTLY SOUND1 TO MOSTLY SOUND2.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is your GENERIC name for the output sndfiles.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: New soundfiles will be called name001 name002 etc\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: AUTOMATIC......program generates amplitude ratios for the new sounds automatically\n");
+		fprintf(stdout,"INFO: ...............and FILES BETWEEN is number of inbetween outfiles to produce.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIXING RATIOS..Mixing Ratios is a ratio, or a list of ratios in a textfile.\n");
+		fprintf(stdout,"INFO: ...............These are the level of file2 RELATIVE to file 1,for each new outfile,\n");
+		fprintf(stdout,"INFO: ...............as FRACTIONS (Range 0-1)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Ensure NONE of the files to be created already exists!!\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_CREATE):
+		fprintf(stdout,"INFO: CREATE AN ENVELOPE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In mode BINARY OUTPUT....If you specify starttime > 0,\n");
+		fprintf(stdout,"INFO: .........................envelope values from 0 to starttime hold your startlevel.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In mode TEXTFILE OUTPUT..File starts at time you specify.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required Data is a textfile with the following format:\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:            time [e]level time [e]level ......\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: where time-level pairs can be repeated as often as desired.\n");
+		fprintf(stdout,"INFO: Level is a number between 0 and 1, or a dB value between -96 and 0\n");
+		fprintf(stdout,"INFO: (you must write 'dB' if you want dB).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If preceded by an 'e', envelope rises[falls] exponentially to that level.\n");
+		fprintf(stdout,"INFO: Default is linear rise[fall].\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Times are in seconds, must increase through the file,\n");
+		fprintf(stdout,"INFO: and be separated by a minimum amount to accomodate splices\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_EXTRACT):
+		fprintf(stdout,"INFO: EXTRACT ENVELOPE FROM AN INPUT SOUNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DATA REDUCTION determines quantity v. accuracy of data written to brkfile\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_PROPOR):
+		fprintf(stdout,"INFO: IMPOSE ENVELOPE, PROPORTIONALLY, ON AN INPUT SOUNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE IN TEXTFILE (envelope level values 0 - 32767)\n");
+		fprintf(stdout,"INFO:        the time values are scaled to run from time 0 to the duration of the soundfile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_IMPOSE):
+		fprintf(stdout,"INFO: IMPOSE AN ENVELOPE ON AN INPUT SOUNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ABOUT THE MODES----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENV FROM OTHER SNDFILE\n");
+		fprintf(stdout,"INFO: ENV IN BINARY FILE......In these modes the whole sndfile is enveloped.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENV IN TEXTFILE\n");
+		fprintf(stdout,"INFO: ENV IN DB TEXTFILE......In these modes, brkpnt may start (and end) at any time in file,\n");
+		fprintf(stdout,"INFO: ........................effectively editing it. Must have at least 2 brkpnt pairs.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_REPLACE):
+		fprintf(stdout,"INFO: REPLACE THE EXISTING ENVELOPE OF AN INPUT SOUNDFILE\n");
+		fprintf(stdout,"INFO: WITH A DIFFERENT ENVELOPE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In all cases, the entire sndfile is enveloped\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Especially useful for restoring the amplitude contour of a sound\n");
+		fprintf(stdout,"INFO: after filtering with time-varying Q-value.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_BRKTOENV):
+		fprintf(stdout,"INFO: CONVERT A (TEXT) BRKPNT ENVELOPE TO A BINARY ENVELOPE FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If brkpnt starttime > zero, new envelope will start from zero,\n");
+		fprintf(stdout,"INFO: holding the brktable startval as far as first brktable time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_ENVTOBRK):
+		fprintf(stdout,"INFO: CONVERT A BINARY ENVELOPE FILE TO A (TEXT) BRKPNT ENVELOPE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DATA REDUCTION determines quantity v. accuracy of data written to brkfile\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_ENVTODBBRK):
+		fprintf(stdout,"INFO: CONVERT BINARY ENVELOPE FILE TO (TEXT) BRKPNT ENVELOPE WITH dB VALUES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DATA REDUCTION determines quantity v. accuracy of data written to brkfile\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_DOVETAILING):
+		fprintf(stdout,"INFO: DOVETAIL SNDFILE BY ENVELOPING THE START AND END OF IT.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STANDARD         linear or exponential fades\n");
+		fprintf(stdout,"INFO: DOUBLE STRENGTH  doubly exponential fades\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INFADE-DUR.......is duration of start-of-file fade-in.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTFADE-DUR......is duration of end-of-file fade-out.\n");
+		fprintf(stdout,"INFO: .................Infade-dur and Outfade-dur must not overlap each another.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INFADE LINEAR....sets start fade to be linear: (default: exponential fade).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTFADE LINEAR....sets end fade to be linear: (default: exponential fade).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME TYPE ........ 0 takes param values in SECONDS: (default)\n");
+		fprintf(stdout,"INFO:                                    1 takes param values in SAMPLES:\n");
+		fprintf(stdout,"INFO:                                    2 takes param values in GROUPED_SAMPLES:\n");
+		fprintf(stdout,"INFO:                                    (e.g. in stereo, each sample-pair counts as 1 item)\n");
+		fprintf(stdout,"INFO: \n");			 
+		break;
+	case(ENV_CURTAILING):
+		fprintf(stdout,"INFO: CURTAIL SNDFILE BY FADING TO ZERO AT SOME TIME WITHIN IT.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START AND END : Give start and end times of fade.\n");
+		fprintf(stdout,"INFO: START AND DUR : Give start time of fade, and its duration.\n");
+		fprintf(stdout,"INFO: START OF FADE TO END : Give start time of fade only (fade proceeds to end of file).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The other modes are similar, with more pronounced fades...\n");
+		fprintf(stdout,"INFO: START AND END, DOUBLE STRENGTH\n");
+		fprintf(stdout,"INFO: START AND DUR, DOUBLE STRENGTH\n");
+		fprintf(stdout,"INFO: START OF FADE TO END, DOUBLE STRENGTH\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LINEAR FADE...sets fade to be linear: (default: exponential fade).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME TYPE ........ 0 takes param values in SECONDS: (default)\n");
+		fprintf(stdout,"INFO:                                    1 takes param values in SAMPLES:\n");
+		fprintf(stdout,"INFO:                                    2 takes param values in GROUPED_SAMPLES:\n");
+		fprintf(stdout,"INFO:                                    (e.g. in stereo, each sample-pair counts as 1 item)\n");
+		break;
+	case(ENV_WARPING):
+	case(ENV_RESHAPING):
+	case(ENV_REPLOTTING):
+		switch(process) {
+		case(ENV_WARPING):
+			fprintf(stdout,"INFO: MODIFY THE ENVELOPE OF A SOUNFILE\n");
+			fprintf(stdout,"INFO: \n");
+			break;
+		case(ENV_RESHAPING):
+			fprintf(stdout,"INFO: MODIFY THE ENVELOPE OF A BINARY ENVELOPE FILE\n");
+			fprintf(stdout,"INFO: \n");
+			break;
+		case(ENV_REPLOTTING):
+			fprintf(stdout,"INFO: MODIFY THE ENVELOPE OF A (TEXT) BRKPNT ENVELOPE FILE\n");
+			fprintf(stdout,"INFO: \n");
+			break;
+		}
+		fprintf(stdout,"INFO: --------------------------- MODES ----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NORMALISE----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Expand envelope so that highest point has max possible value.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME-REVERSE-------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Reverse the timing of the envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXAGGERATE---------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Exaggerate the envelope contour.\n");
+		fprintf(stdout,"INFO: Exaggeration less than 1, Low envelope vals boosted\n");
+		fprintf(stdout,"INFO: Exaggeration greater than 1, High envelope vals boosted.\n");
+		fprintf(stdout,"INFO: Value 1, gives no change.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTENUATE----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Change level of envelope by the specified multiplier.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LIFT ALL-----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Lift entire envelope level by the specified amount.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME-STRETCH-------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Timestretch the envelope by the specified multiplier.\n");
+		fprintf(stdout,"INFO: Note that a timestretch of less than 1 timeshrinks the envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FLATTEN------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Flatten envelope contour.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GATE---------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Envelope values below the gate value are set to zero.\n");
+		fprintf(stdout,"INFO: Smoothing zeroes low-level envelope chunks less than 'smoothing' windows long.\n");
+		fprintf(stdout,"INFO: A value of zero turns off the smoothing effect.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INVERT-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Levels below Gate-level are set to zero. All other levels,\n");
+		fprintf(stdout,"INFO: above & below Mirror value, are inverted to other side of mirror.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LIMIT--------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Levels above Threshold value squeezed down so envelope maxamp becomes Limit.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CORRUGATE----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Take all troughs in the envelope to zero.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXPAND-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Levels below Gate are set to zero. Other levels squeezed upwards\n");
+		fprintf(stdout,"INFO: so minimum level becomes Threshold value.\n");
+		fprintf(stdout,"INFO: Smoothing zeroes low-level envelope chunks less than 'smoothing' windows long.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TRIGGER BURSTS-----------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Create a new envelope of sudden on-bursts, from existing envelope,\n");
+		fprintf(stdout,"INFO: triggered by the rate of rise of the current envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Data file is a breakpoint envelope for the (triggered) bursts themselves.\n");
+		fprintf(stdout,"INFO: To trigger, average-level must be greater than Gate level,\n");
+		fprintf(stdout,"INFO: loudness-step must be greater than Min Trigger Level-rise,\n");
+		fprintf(stdout,"INFO: and it must have duration less than Max Trigger Duration\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TO CEILING---------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Force envelope up to its maximum level, everywhere.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DUCKED-------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Create ducking envelope from existing envelope.\n");
+		fprintf(stdout,"INFO: This can be used to create an envelope to apply to another sound\n");
+		fprintf(stdout,"INFO: which is to be mixed with the original sound.\n");
+		fprintf(stdout,"INFO: With Envelope WARPING:\n");
+		fprintf(stdout,"INFO: When input envelope exceeds Threshold, output envelope is reduced\n");
+		fprintf(stdout,"INFO: to Gate level. Elsewhere it is unchanged.\n");
+		fprintf(stdout,"INFO: With Envelope RESHAPING or REPLOTTING:\n");
+		fprintf(stdout,"INFO: When input envelope exceeds Threshold, output envelope takes\n");
+		fprintf(stdout,"INFO: Gate level. Elsewhere it gives unity gain.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COUNT PEAKS ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Count peaks in the envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_DBBRKTOENV):
+		fprintf(stdout,"INFO: CONVERT (TEXT) BRKPNT FILE WITH dB VALS TO BINARY ENVELOPE FILE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_DBBRKTOBRK):
+		fprintf(stdout,"INFO: CONVERT (TEXT) BRKPNT FILE WITH dB VALS TO GAIN VALS (0-1)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_BRKTODBBRK):
+		fprintf(stdout,"INFO: CONVERT A (TEXT) BRKPNT FILE WITH GAIN (0-1) VALS TO dB VALS\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_SWELL):
+		fprintf(stdout,"INFO: CAUSE SOUND TO FADE IN TO AND OUT FROM A PEAK MOMENT\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LINEAR FADE causes fades in and out to be linear: (default exponential).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_ATTACK):
+		fprintf(stdout,"INFO: EMPHASIZE THE ATTACK OF A SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN................Amplification of attack point.\n");
+		fprintf(stdout,"INFO: ....................For strong attack,\n");
+		fprintf(stdout,"INFO: ....................reduce overall level of src before processing.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTACK ONSET DUR....Attack onset duration (MS).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTACK DECAY DUR....Attack decay duration (MS).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LINEAR SLOPES.......sets fades to be linear (default exponential).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: and in various MODES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GATE LEVEL..........Level for attack point to be recognised.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: APPROX ATTACK TIME..Approx time in sound of attack point,in secs.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXACT ATTACK TIME...Exact time in sound of attack point,in secs.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_PLUCK):
+		fprintf(stdout,"INFO: PLUCK START OF SOUND (MONO FILES ONLY)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STARTSAMP..Sample, in src sound, at which pluck will END:\n");
+		fprintf(stdout,"INFO: ...........must be a sample AT A ZERO_CROSSING...\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: WAVELEN....no of (absolute) samples in pluck wavelen: \n");
+		fprintf(stdout,"INFO: ...........set to same as src_signal's wavelen immediately after STARTSAMP\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATKCYCLES..no of wavecycles in pluck-attack.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DECAYRATE..rate of decay of the pluck_attack.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ENV_TREMOL):
+		fprintf(stdout,"INFO: TREMOLO A SOUND\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FRQWISE....Interpolate linearly between frqs in any frq brktable (default).\n");
+		fprintf(stdout,"INFO: PITCHWISE..Interpolate logarithmically (like pitch). (Care with zero frqs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TREMOLO FREQUENCY..is frequency of the tremolo vibration itself.\n");
+		fprintf(stdout,"INFO: TREMOLO DEPTH......amplitude depth of tremolo.\n");
+		fprintf(stdout,"INFO: OVERALL GAIN.......Overall signal gain, or envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SIMPLE_TEX):
+	case(GROUPS):
+	case(DECORATED):
+	case(PREDECOR):
+	case(POSTDECOR):
+	case(ORNATE):
+	case(PREORNATE):
+	case(POSTORNATE):
+	case(MOTIFS):
+	case(MOTIFSIN):
+	case(TIMED):
+	case(TGROUPS):
+	case(TMOTIFS):
+	case(TMOTIFSIN):
+		fprintf(stdout,"INFO: TEXTURE MADE FROM ONE OR SEVERAL INPUT SOUND FILES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: TYPES OF TEXTURE--------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Texture can be SIMPLE,GROUPED,DECORATED,PREDECORATED,POSTDECORATED,\n");
+		fprintf(stdout,"INFO: ORNATE,PREORNATE,POSTORNATE, or made up of MOTIFS\n");
+		fprintf(stdout,"INFO: OR\n");
+		fprintf(stdout,"INFO: a texture where sound-entries are SPECIFICALLY TIMED\n");
+		fprintf(stdout,"INFO: and either simple,grouped, or made from motifs.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ORNAMENTS & MOTIFS........have user-specified pitch-shapes.\n");
+		fprintf(stdout,"INFO: DECORATIONS & GROUPS......have random pitch-shapes.\n");
+		fprintf(stdout,"INFO: DECORATIONS & ORNAMENTS...decorate the user-specified pitch-sequence.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: HARMONIC TYPES OF TEXTURE------------------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Textures are specified WITHIN A (possibly varying) RANGE OF PITCHES\n");
+		fprintf(stdout,"INFO: and within that range, the chosen pitches may be\n");
+		fprintf(stdout,"INFO: entirely RANDOM, on a HARMONIC SET (using pitches given),\n");
+		fprintf(stdout,"INFO: on a HARMONIC FIELD (uses 8va transpositions of pitches given),\n");
+		fprintf(stdout,"INFO: or on HARMONIC SETS, OR FIELDS, WHICH CHANGE THROUGH TIME.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: First note (only) of motifs are guaranateed to be on a harmonic set(field) note\n");
+		fprintf(stdout,"INFO: except in MOTIFS IN HF, where motifs notes are forced onto set (field) notes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: PARAMETERS FOR TEXTURE---------------------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (** starred items CANNOT vay in time)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTPUT DURATION...........**.(min) duration of outfile\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- TIMING PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EVENT PACKING ...............(average) time between event onsets.\n");
+		fprintf(stdout,"INFO: SKIPTIME BETWEEN GROUP,MOTIF ONSETS..(average) time between group,motif onsets.\n");
+		fprintf(stdout,"INFO: EVENT SCATTER................randomisation of event, group or motif onsets.\n");
+		fprintf(stdout,"INFO: PAUSE BEFORE LINE REPEATS....time between last event of line & start of repetition.\n");
+		fprintf(stdout,"INFO: TIME GRID UNIT...............minstep(MS) quantised timegrid (for event starttimes)\n");
+		fprintf(stdout,"INFO: TIME GRID FOR NOTEGROUPS.....a timegrid (MS) applying WITHIN groups (for grouped textures)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- SOUND PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1ST SND-IN-LIST TO USE,LAST..1st,last snd to use,from listed input sounds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- LOUDNESS PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN EVENT GAIN, MAX..........min & max level of input events\n");
+		fprintf(stdout,"INFO: MIN EVENT SUSTAIN, MAX.......min & max sustain-time of events.\n");
+		fprintf(stdout,"INFO: OVERALL ATTENUATION..........overall attenuation of the output\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: and for grouped textures\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GROUP AMPLITUDE CHANGE.......amplitude change within grouped-events\n");
+		fprintf(stdout,"INFO: GROUP AMPCONTOUR TYPE.....**.amplitude contour within grouped-events\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- PITCH PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN PITCH, MAX...............min & max pitch(MIDI): (gives transposition of input)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- SPATIAL PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NB: If STEREO source files are USED, SPATIALISATION parameters are IGNORED\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPATIAL POSITION.............centre of output sound-image.\n");
+		fprintf(stdout,"INFO: SPATIAL SPREAD...............spatial-spread of texture events.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: and for grouped textures\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GROUP SPATIALISATION TYPE.**.spatialisation of event within groups\n");
+		fprintf(stdout,"INFO: GROUP SPATIALISATION RANGE...spatial range within event-groups\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- OTHER GROUP PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN GROUP-PACKING-TIME,MAX...smallest,largest number of events in groups\n");
+		fprintf(stdout,"INFO: MIN GROUP PITCHRANGE, MAX....min,max pitchrange, in semitones, of events in groups\n");
+		fprintf(stdout,"INFO: MIN HFIELD NOTES RANGE,MAX...min,max number of hfield-notes range in groups\n");
+		fprintf(stdout,"INFO: MIN MOTIF-DUR-MULTIPLIER,MAX min,max multiplier of input duration of motif\n");
+		fprintf(stdout,"INFO: PITCH CENTRING............**.how decor pitches centre on line pitches\n");
+		fprintf(stdout,"INFO: FIXED TIMESTEP IN GROUP......notes in a group run at a fixed tempo.\n");
+		fprintf(stdout,"INFO: FIXED NOTE-SUSTAIN IN MOTIFS all notes in motif have same sustain-time as first.\n");
+		fprintf(stdout,"INFO: SCATTER DECOR INSTRS.........orns not confined to instr of ornd-note.\n");
+		fprintf(stdout,"INFO: DECORS TO HIGHEST NOTE.......orns on highest note of any chord: default,1st note\n");
+		fprintf(stdout,"INFO: DECORS ON EVERY NOTE.........ornaments on all notes of any chord.\n");
+		fprintf(stdout,"INFO: DISCARD ORIGINAL LINE........after decoration\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------- OTHER PARAMETERS -----------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEED.........................same seed-number: reproducible output (0: not so)\n");
+		fprintf(stdout,"INFO: PLAY ALL OF INSOUND..........always play whole input-sound (ignoring dur vals).\n");
+		fprintf(stdout,"INFO: PLAY FILES CYCLICALLY........play sounds in input order (always uses ALL input sounds).\n");
+		fprintf(stdout,"INFO: RANDOMLY PERMUTE EACH CYCLE..permute order of sounds, in each complete cycle.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: SOME SPECIAL PARAMETER VALUES---------------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GROUP SPATIALISATION TYPE VALUES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 0:still.................1:scattered(default)........2:towards-texture-centre\n");
+		fprintf(stdout,"INFO: 3:away-from-centre......4:follow-texmotion..........5:contrary-to-motion\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 4 & 5 only function if spatial position varies in time..\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GROUP AMPCONTOUR TYPE VALUES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 0:mixed(default)\n");
+		fprintf(stdout,"INFO: 1:cresc..............2:flat...............3:decresc..............4:cresc_or_flat\n");
+		fprintf(stdout,"INFO: 5:cresc_or_decresc...6:decresc_or_flat....[7:directed_to_event....8:directed_or_flat]\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH CENTRING VALUES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: how decoration pitches centre on decorated line pitches\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 0: centred(default)\n");
+		fprintf(stdout,"INFO: 1: above.................2: below...............3: centred_and_above\n");
+		fprintf(stdout,"INFO: 4: centred_and_below.....5: above_and_below.....6: all_types\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In all cases except 0, pitchrange shifts to tally with line pitch\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: NOTEDATA IS A TEXTFILE CONTAINING-----------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LINE 1: list of (possibly fictional) MIDI pitch of each input snd.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Then, where motifs, or event timings, or harmonic sets (fields) are required,\n");
+		fprintf(stdout,"INFO: or a pitchline is required for ornamenting or decorating..\n");
+		fprintf(stdout,"INFO: each subsequent group of lines specifies a NOTELIST\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: NOTELISTS MUST BE IN THIS ORDER-------------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Notelist of notes in any timing set\n");
+		fprintf(stdout,"INFO: Notelist of notes in any line TO BE ornamented or decorated\n"); 
+		fprintf(stdout,"INFO: Notelist of notes in any harmonic set(s) or field(s) specified.\n");
+		fprintf(stdout,"INFO: Notelist(s) of notes in any ornament(s) or motif(s) specified.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: For more than one harmonic set (field),\n");
+		fprintf(stdout,"INFO: data should specify chords, placed at appropriate times (see below).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: NOTELISTS HAVE THE FOLLOWING FORMAT---------------------------------------------\n");
+		fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: first line:  #N\n");
+		fprintf(stdout,"INFO: other lines: time(SECS)     infile_no      pitch(MIDI)      amp(MIDI)     dur(SECS)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: where N = number of notes (and therefore lines) in notelist to follow,\n");
+		fprintf(stdout,"INFO: and times in notelist must never decrease.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MOD_LOUDNESS):
+		fprintf(stdout,"INFO: ADJUST LOUDNESS OF A SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GAIN:.............adjust level by factor GAIN.\n");
+		fprintf(stdout,"INFO: GAINdB:...........adjust level by factor GAIN dB.\n");
+		fprintf(stdout,"INFO: NORMALISE:.. .....force level (if necessary) to given value.\n");
+		fprintf(stdout,"INFO: FORCE LEVEL:......force level to given value.\n");
+		fprintf(stdout,"INFO: BALANCE:..........force max level of file1 to max level of file 2.\n");
+		fprintf(stdout,"INFO: INVERT PHASE:...Invert phase of file.\n");
+		fprintf(stdout,"INFO: LOUDEST:..........Find loudest sound, and its level.\n");
+		fprintf(stdout,"INFO: EQUALISE:..........Force level of all sounds to that of loudest.\n");
+		fprintf(stdout,"INFO: PROPORTIONAL:......adjust level following envelope, which is stretched to match duration of infile.\n");
+		fprintf(stdout,"INFO: PROPORTIONAL dB:...adjust level following dB envelope, which is stretched to match duration of infile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MOD_SPACE):
+		fprintf(stdout,"INFO: CREATE OR ALTER DISTRIBUTION OF SOUND IN STEREO SPACE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PAN:.........Position or move mono sound in a stereo field.\n");
+		fprintf(stdout,"INFO: .............-1 Hard Left : 0 Centre : 1 Hard Right\n");
+		fprintf(stdout,"INFO: .............< -1 hard left & attenuated : > 1 hard right & attenuated.\n");
+		fprintf(stdout,"INFO: .............Prescale reduces input level to avoid clipping.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIRROR:......Invert stereo positions in a stereo file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIRROR PAN:..Invert stereo positions in a pan data file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NARROW:......Narrow the stereo image of a sound.\n");
+		fprintf(stdout,"INFO: .............     1   leaves stereo image as it is.\n");
+		fprintf(stdout,"INFO: .............    .5  narrows stereo image by half.\n");
+		fprintf(stdout,"INFO: .............     0   converts stereo image to mono.\n");
+		fprintf(stdout,"INFO: .............     -ve vals work similarly, but also invert stereo image.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SCALED_PAN):
+		fprintf(stdout,"INFO: DISTRIBUTE SOUND IN STEREO SPACE, WITH BREAKPOINT DATA TIME_SCALED TO SOUNDFILE DURATION.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PAN:.........-1 Hard Left : 0 Centre : 1 Hard Right\n");
+		fprintf(stdout,"INFO: .............< -1 hard left & attenuated : > 1 hard right & attenuated.\n");
+		fprintf(stdout,"INFO: PRESCALE .....reduces input level to avoid clipping.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SIN_TAB):
+		fprintf(stdout,"INFO: GENERATE A SINUSOIDALLY PANNING PAN-CONTROL FILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE LENGTH....is duration of one complete sinusoidal pan cycle\n");
+		fprintf(stdout,"INFO: PAN WIDTH.......is the width of the pan, from 0 to full width,1\n");
+		fprintf(stdout,"INFO: DURATION........is the duration of the output data file.\n");
+		fprintf(stdout,"INFO: QUANTISATION....is time step between successive space-positions specified in datafile.\n");
+		fprintf(stdout,"INFO: STARTPHASE......is the angular position at which the pan starts.\n");
+		fprintf(stdout,"INFO:                    0   starts at centre and moves right.\n");
+		fprintf(stdout,"INFO:                    90  starts at right.\n");
+		fprintf(stdout,"INFO:                    180 starts at centre and moves left.\n");
+		fprintf(stdout,"INFO:                    270 starts at left.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CYCLE LENGTH and PAN WIDTH may vary over time\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MOD_PITCH):
+		fprintf(stdout,"INFO: CHANGE THE SPEED & PITCH OF THE SRC SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) SPEED CHANGE...............also changing sound pitch.\n");
+		fprintf(stdout,"INFO: 2) SPEED CHANGE IN SEMITONES..speed shift given in semitones.\n");
+		fprintf(stdout,"INFO: 3) VARISPEED INFO.............see how outtimes relate to intimes.\n");
+		fprintf(stdout,"INFO: 4) VARISPEED SEMITONES INFO...see how outtimes relate to intimes.\n");
+		fprintf(stdout,"INFO: 5) ACCELERATE.................cause sound to accelerate.\n");
+		fprintf(stdout,"INFO: 6) VIBRATO....................add vibrato to sound.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In MODES 1-4 brkpnt times are infiletimes, unless flagged as outfiletimes.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In MODE 5....Acceleration is multiplication of speed reached at goaltime.\n");
+		fprintf(stdout,"INFO: .............If infile not exhausted by goaltime, outfile continues to accelerate.\n");
+		fprintf(stdout,"INFO: .............If infile finishes before goaltime, outfile won't reach accel val.\n");
+		fprintf(stdout,"INFO: ............ Starttime is time in input/output file at which acceleration begins.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: In MODE 6....Cycles-per-second is rate of vibrato shaking,\n");
+		fprintf(stdout,"INFO: .............and Depth is vibrato depth in (possibly fractional) semitones.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MOD_REVECHO):
+		fprintf(stdout,"INFO: CREATE ECHO OR REVERBERATION OR RESONANCE AROUND A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DELAY..........with feedback.\n");
+		fprintf(stdout,"INFO: VARYING DELAY..low frequency oscillator varying delay time.\n");
+		fprintf(stdout,"INFO: STADIUM ECHO...create echos like stadium P.A.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DELAYED SIGNAL IN MIX.....0 gives 'dry' result.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FEEDBACK..................gives resonance related to delay time.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOFRQ MODULATION DEPTH....is the depth of delay-variation sweep.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODULATION FRQ............freq of sweep:\n");
+		fprintf(stdout,"INFO: ..........................-ve frqs give random sweeping.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PHASE OF MODULATION.......determines where (high,low) sweep begins.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DELAY OF MODULATION...... determines when sweep begins.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LENGTH OF TAIL............to allow delayed signal to decay to zero.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INPUT PRESCALING..........prescales input level, to avoid overload.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RANDOM SEED...............Nonzero value gives reproducible output\n");
+		fprintf(stdout,"INFO: ..........................(with same seed) for random oscillations.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INVERT DELAYED SIGNAL.....for phasing effects.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ------------------ AND FOR STADIUM ---------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INPUT GAIN................Attenuates signal input to stadium.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LEVEL LOSS WITH DISTANCE..across stadium.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STADIUM SIZE MULTIPLIER...Multiplies average time between echos.\n");
+		fprintf(stdout,"INFO: ..........................(Default average echo time = 0.1 secs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NUMBER OF ECHOS...........Number of stadium echos produced.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MOD_RADICAL):
+		fprintf(stdout,"INFO: RADICAL CHANGES TO THE SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REVERSE: Sound plays backwards.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SHRED:  Shred sound within its existing duration.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        NUMBER OF SHREDS. ...number of repeats of shredding process.\n");
+		fprintf(stdout,"INFO:        AVERAGE CHUNKLENGTH..average length of chunks to cut & permute.\n");
+		fprintf(stdout,"INFO:        CUT SCATTER..........randomisation of cuts (0 to K): default 1.\n");
+		fprintf(stdout,"INFO:        .....................where K = total number of chunks (snd-duration/chunklen).\n");
+		fprintf(stdout,"INFO:        .....................If scatter = 0: snd reordered without shredding.\n");
+ 		fprintf(stdout,"INFO:        .....................NB:  chunklen*scatter MUST be smaller than snd buffer.\n");
+		fprintf(stdout,"INFO:        .....................NB2: If Input sound > internal buffer len,\n");
+		fprintf(stdout,"INFO:        .....................each buffer of sound shredded independently.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCRUB: BACK & FORTH, AS IF HANDWINDING OVER A TAPE-HEAD.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        MINIMUM OUTPUT DURATION........min duration of outfile required.\n");
+		fprintf(stdout,"INFO:        LOWEST DOWNWARD TRANSPOSITION..(semitones).\n");
+		fprintf(stdout,"INFO:        HIGHEST UPWARD TRANSPOSITION...(semitones).\n");
+		fprintf(stdout,"INFO:        SCRUBS START NO LATER THAN.....start before time 'start' secs.\n");
+		fprintf(stdout,"INFO:        SRCUBS END NO EARLIER THAN.....end after time 'end' secs.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOSE RESOLUTION: CONVERT TO LOWER SRATE, OR BIT-RESOLUTION.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        BIT_RESOLUTION....range(1 - 16): default 16-bit.\n");
+		fprintf(stdout,"INFO:        SRATE_DIVISION....range(1-256): default 1 (normal)\n");
+		fprintf(stdout,"INFO:        entered svalue will be rounded to a power of 2.\n");
+		fprintf(stdout,"INFO:        Works on MONO FILES ONLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: RING MODULATE AGAINST GIVEN FREQUENCY, CREATING SIDEBANDS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CROSS MODULATE TWO INFILES CREATING COMPLEX SIDEBANDS.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BRASSAGE):
+		fprintf(stdout,"INFO: GRANULAR RECONSTITUTION OF SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESHRINK..............Speed of advance in infile, relative to outfile. (>=0)\n");
+		fprintf(stdout,"INFO: ........................Inverse of timestretch, (& permits infinite timestretch).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DENSITY.................Amount of grain overlap (>0 : <1 leaves intergrain silence)\n");
+		fprintf(stdout,"INFO: ........................Extremely small values will cease to perform predictably.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GRAINSIZE...............grainsize in MS (must be > 2 * splicelen)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCHSHIFT..............is pitchshift of grains in +|- (fractions of) semitones.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOUDNESS RANGE..........is range of gain on grains.\n");
+		fprintf(stdout,"INFO: ........................Use only if amp is to vary (over range &/or through time)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STARTSPLICE.............length of startsplices on grains,in MS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENDSPLICE...............length of endsplices on grains,in MS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPATIAL POSITION........stereo position in outputfile. 0=L,1=R.\n");
+		fprintf(stdout,"INFO: ........................Space flag on MULTICHANNEL input, mixes it to mono before acting.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEARCHRANGE.............for nextgrain, before current 'now' in infile (Default 0 MS).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCATTER.................Randomisation of grain position (Range 0-1).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTPUT LENGTH...........max outfile length (if end of data not reached).\n");
+		fprintf(stdout,"INFO: ........................Set to ZERO (Default) for this parameter to be IGNORED.\n");
+		fprintf(stdout,"INFO: ........................BUT if TIMESHRINK is ANYWHERE 0: OUTLENGTH must be given.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHANNEL TO EXTRACT......Positive value is channel to extract, and process.\n");
+		fprintf(stdout,"INFO: ........................Zero (Default) processes all channels.\n");
+		fprintf(stdout,"INFO: ........................Negative values create spatialisation > stereo.\n");
+		fprintf(stdout,"INFO: ........................e.g. -5 creates a 5-channel spatialised output.\n");
+		fprintf(stdout,"INFO: ........................NB spatialisation only happens if \"spatial position\" is itself non-zero.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH NOT INTERPOLATED..No interpolation for transpose,(quick, dirty).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESHRINK LIMIT,\n");
+		fprintf(stdout,"INFO: DENSITY LIMIT, ETC..... allow range of values to be specified for any of these params.\n");
+		fprintf(stdout,"INFO: ........................e.g. With Density & Density Limit set\n");
+		fprintf(stdout,"INFO: ........................random density chosen between these values.\n");
+		fprintf(stdout,"INFO: ........................Density & Density Limit can THEMSELVES vary through time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SAUSAGE):
+		fprintf(stdout,"INFO: GRANULAR RECONSTITUTION OF SEVERAL SOUNDFILES, SCRAMBLED TOGETHER.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESHRINK..............Speed of advance in infiles, relative to outfile. (>=0)\n");
+		fprintf(stdout,"INFO: ........................Inverse of timestretch, (& permits infinite timestretch).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DENSITY.................Amount of grain overlap (>0 : <1 leaves intergrain silence)\n");
+		fprintf(stdout,"INFO: ........................Extremely small values will cease to perform predictably.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GRAINSIZE...............grainsize in MS (must be > 2 * splicelen)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCHSHIFT..............is pitchshift of grains in +|- (fractions of) semitones.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LOUDNESS RANGE..........is range of gain on grains.\n");
+		fprintf(stdout,"INFO: ........................Use only if amp is to vary (over range &/or through time)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STARTSPLICE.............length of startsplices on grains,in MS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENDSPLICE...............length of endsplices on grains,in MS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPATIAL POSITION........stereo position in outputfile. 0=L,1=R.\n");
+		fprintf(stdout,"INFO: ........................Space flag on MULTICHANNEL input, mixes it to mono before acting.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEARCHRANGE.............for nextgrain, before current 'now' in infile (Default 0 MS).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SCATTER.................Randomisation of grain position (Range 0-1).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTPUT LENGTH...........max outfile length (if end of data not reached).\n");
+		fprintf(stdout,"INFO: ........................Set to zero (Default) for this parameter to be ignored.\n");
+		fprintf(stdout,"INFO: ........................BUT if TIMESHRINK is ANYWHERE 0: OUTLENGTH must be given.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHANNEL TO EXTRACT......Causes process to work on just 1 specified channel\n");
+		fprintf(stdout,"INFO: ........................of a multichannel snd. Zero (Default) processes all channels.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH NOT INTERPOLATED..No interpolation for transpose,(quick, dirty).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIMESHRINK LIMIT,\n");
+		fprintf(stdout,"INFO: DENSITY LIMIT ETC.......allow range of values to be specified for any of these params.\n");
+		fprintf(stdout,"INFO: ........................e.g. With Density & Density Limit set\n");
+		fprintf(stdout,"INFO: ........................random density chosen between these values.\n");
+		fprintf(stdout,"INFO: ........................Density & Density Limit can THEMSELVES vary through time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PVOC_ANAL):
+		fprintf(stdout,"INFO: CONVERT SOUNDFILE TO SPECTRAL FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STANDARD ANALYSIS\n");
+		fprintf(stdout,"INFO: OUTPUT SPECTRAL ENVELOPE VALS ONLY\n");
+		fprintf(stdout,"INFO: OUTPUT SPECTRAL MAGNITUDE VALS ONLY\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ANALYSIS POINTS..(2-32768 (power of 2)): default 1024\n");
+		fprintf(stdout,"INFO: .................More points give better freq resolution\n");
+		fprintf(stdout,"INFO: .................but worse time-resolution (e.g. rapidly changing spectrum).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OVERLAP..........Filter overlap factor (1-4): default 3\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PVOC_SYNTH):
+		fprintf(stdout,"INFO: CONVERT SPECTRAL FILE TO SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(PVOC_EXTRACT):
+		fprintf(stdout,"INFO: ANALYSE THEN RESYNTHESIZE SOUND WITH VARIOUS OPTIONS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ANALYSIS POINTS......(2-32768 (power of 2)): default 1024\n");
+		fprintf(stdout,"INFO: .....................More points give better freq resolution\n");
+		fprintf(stdout,"INFO: .....................but worse time-resolution (e.g. rapidly changing spectrum).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ANALWINDOW OVERLAP...Range (1-4): default 3\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SELECT A CHANNEL.....resynthesizes odd (1) or even (2) channels only\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BOTTOM RESYNTH CHAN..ignore analysis chans below this in resynth (default: 0)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TOP RESYNTH CHANNEL..ignore chans above this in resynth (dflt: highest channel)\n");
+		fprintf(stdout,"INFO: .....................There is 1 channel for every 2 analysis points.\n");
+		fprintf(stdout,"INFO: .....................hence Top Resynth Channel should not be > ANALYSIS POINTS/2\n");
+		fprintf(stdout,"INFO: .....................To default to topmost channel, set it to ZERO.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NB If no parameters are set, the output sound will be the same as the input.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_CUT):
+		fprintf(stdout,"INFO: CUT & KEEP A SEGMENT OF A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME OF STARTCUT..is time in infile where segment to keep begins.\n");
+		fprintf(stdout,"INFO: TIME OF ENDCUT....is time in infile where segment to keep ends.\n");
+		fprintf(stdout,"INFO: SPLICELEN.........splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(STACK):
+		fprintf(stdout,"INFO: STACK TRANSPOSED COPIES OF A SOUND ON TOP OF ONE ANOTHER.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TRANSPOSITION DATA transposition in semitones.\n");
+		fprintf(stdout,"INFO: ...................If numeric (e.g. N semitones) stack consists of original sound\n");
+		fprintf(stdout,"INFO: ...................plus original sound transposed by N, 2N, 3N etc\n");
+		fprintf(stdout,"INFO: ...................If data in a file, stack consists of copies of original source\n");
+		fprintf(stdout,"INFO: ...................transposed by the values in the file.\n");
+		fprintf(stdout,"INFO: NUMBER OF ITEMS....Number of (transposed) copies to mix.\n");
+		fprintf(stdout,"INFO: STACK LEAN.........How much louder is highest sound in stack than lowest sound\n");
+		fprintf(stdout,"INFO: ATTACK TIME........At what time (in the original file) should the copies be synchronised.\n");
+		fprintf(stdout,"INFO: OVERALL GAIN.......Overall gain applied to the output stack\n");
+		fprintf(stdout,"INFO: HOW MUCH OF OUTPUT.......What proportion of the output to generate\n");
+		fprintf(stdout,"INFO:                    (if less than 1.0, output will cut off abruptly (click)\n");
+		fprintf(stdout,"INFO: \n");
+	case(EDIT_CUTMANY):
+		fprintf(stdout,"INFO: CUT & KEEP SEVERAL SPECIFIED SEGMENTS OF A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CUT TIMES.........Start and end times for each cut segment, in a file\n");
+		fprintf(stdout,"INFO: SPLICELEN.........splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_CUTEND):
+		fprintf(stdout,"INFO: CUT & KEEP END PORTION OF A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LENGTH TO KEEP..ending at end of input sound.\n");
+		fprintf(stdout,"INFO: SPLICELEN.......splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_ZCUT):
+		fprintf(stdout,"INFO: CUT & KEEP SEGMENT OF MONO SOUND, CUTTING AT ZERO-CROSSINGS (NO SPLICES).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME OF STARTCUT..(approx) time in infile where segment to keep begins.\n");
+		fprintf(stdout,"INFO: TIME OF ENDCUT....(approx) time in infile where segment to keep ends.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MANY_ZCUTS):
+		fprintf(stdout,"INFO: CUT & KEEP SEVERAL SEGMENT OF A MONO SOUND, CUTTING AT ZERO-CROSSINGS (NO SPLICES).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CUT TIMES.........Start and end times for each cut segment, in a file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_EXCISE):
+		fprintf(stdout,"INFO: DISCARD SPECIFIED CHUNK OF SOUND, CLOSING UP THE GAP.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME OF STARTCUT..starttime of excision.\n");
+		fprintf(stdout,"INFO: TIME OF ENDCUT....endtime of excision.\n");
+		fprintf(stdout,"INFO: SPLICELEN.........splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_EXCISEMANY):
+		fprintf(stdout,"INFO: DISCARD SPECIFIED CHUNKS OF A SOUND, CLOSING UP THE GAPS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXCISEFILE..is a texfile with (paired) start & end times of chunks\n");
+		fprintf(stdout,"INFO: ............to be removed. These must be in increasing time order.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICELEN...splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_INSERT):
+		fprintf(stdout,"INFO: INSERT A 2nd SOUND INTO AN EXISTING SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERTION TIME..where 2nd file inserted into 1st.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICELEN.......splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERT LEVEL....gain multiplier on inserted file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OVERWRITE.......overwrite 1st file with inserted file.\n");
+		fprintf(stdout,"INFO: ................(default .. insertion pushes infile apart).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_INSERT2):
+		fprintf(stdout,"INFO: INSERT A 2nd SOUND INTO AN EXISTING SOUND, REPLACING A SEGEMNT OF THAT SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERTION TIME..where 2nd file inserted into 1st.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: END TIME OF OVERWRITE..endtime of segment in 1st file to be overwritten by insertion.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICELEN.......splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERT LEVEL....gain multiplier on inserted file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_INSERTSIL):
+		fprintf(stdout,"INFO: INSERT SILENCE INTO AN EXISTING SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INSERTION TIME.......where silence inserted.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DURATION OF SILENCE..duration of silence\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICELEN............splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OVERWRITE............overwrite infile with inserted silence.\n");
+		fprintf(stdout,"INFO: .....................(default .. insertion pushes infile apart).\n");
+		fprintf(stdout,"INFO: RETAIN TRAILING SILENCE....retain silence written over end of file.\n");
+		fprintf(stdout,"INFO: .....................(default .. rejects insertion of silence at end of file).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(EDIT_JOIN):
+		fprintf(stdout,"INFO: JOIN FILES TOGETHER, ONE AFTER ANOTHER.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICE........duration of splices, in MS (default 15)\n");
+		fprintf(stdout,"INFO: SPLICE START..splices start of first file.\n");
+		fprintf(stdout,"INFO: SPLICE END....splices end of last file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_COPY):
+		fprintf(stdout,"INFO: PRODUCE COPIES OF THE INFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COPY ONCE\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COPY MANY\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       NUMBER OF DUPLICATES....is number of copies to produce.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       IGNORE EXISTING COPIES..don't overwrite files with any of these names.\n");
+		fprintf(stdout,"INFO:       ........................Otherwise process HALTS on discovering\n");
+		fprintf(stdout,"INFO:       ........................a pre-existing file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_DEL):
+		fprintf(stdout,"INFO: DELETE EXISTING COPIES OF A FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If you specify the generic name 'xx',\n");
+		fprintf(stdout,"INFO: Deletes any files having names xxN, where N is an integer.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CARE: No checks are made that these ARE COPIES of file xx!!\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEARCH FOR ALL COPIES...Program checks all names in numbered sequence.\n");
+		fprintf(stdout,"INFO: ........................Without this flag, once a numbered file is missing,\n");
+		fprintf(stdout,"INFO: ........................program checks for %d more named files before halting.\n",COPYDEL_OVERMAX);
+		fprintf(stdout,"INFO: ........................With flag, program searches for all possible\n");
+		fprintf(stdout,"INFO: ........................duplicate filenames. This may take some time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_CHANS):
+		fprintf(stdout,"INFO: EXTRACT OR CONVERT CHANNELS OF SOUNDFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXTRACT A CHANNEL\n");
+		fprintf(stdout,"INFO: ..........CHANNEL TO GET is channel to extract\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXTRACT ALL CHANNELS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ZERO ONE CHANNEL\n");
+		fprintf(stdout,"INFO: ..........CHANNEL TO ZERO is channel to set to zero.\n" );
+		fprintf(stdout,"INFO: ..........mono file goes to just one side of stereo outfile.\n");
+		fprintf(stdout,"INFO: ..........stereo file has one channel zeroed out.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: STEREO TO MONO\n");
+		fprintf(stdout,"INFO: ..........INVERT CHANNEL2 PHASE: inverts channel 2 phase before mixing.\n" );
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MONO TO STEREO\n");
+		fprintf(stdout,"INFO: ..........Creates a 2-channel equivalent of mono infile.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_BUNDLE):
+		fprintf(stdout,"INFO: COMPARE A LIST OF FILES BY TYPE OR PROPERTIES, AND LIST CHOSEN FILES IN A TEXTFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ANY FILES........Bundle all entered files.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NON-TEXT FILES...Bundle any non-text files entered.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAME TYPE........Bundle all non-text files of same type as first\n");
+		fprintf(stdout,"INFO: .................non-text file entered. e.g. all analysis files....\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAME PROPERTIES..Bundle all non-text files with same properties\n");
+		fprintf(stdout,"INFO: .................as first non-text file entered.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAME CHANNELS....If first non-text file entered is a soundfile,\n");
+		fprintf(stdout,"INFO: .................bundle only soundfiles with same channel count.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_SORT):
+		fprintf(stdout,"INFO: SORT FILES LISTED IN A TEXTFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BY FILETYPE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        Sorts files into different types.\n");
+		fprintf(stdout,"INFO:        Lists filenames in separate textfiles.. \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BY SAMPLE RATE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        Sorts any soundfiles to different sampling rates.\n");
+		fprintf(stdout,"INFO:        Lists filenames in separate textfiles.. \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BY DURATION\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        Sorts any soundfiles to different lengths.\n");
+		fprintf(stdout,"INFO:        SMALL  is max size of smallest files. (secs)\n");
+		fprintf(stdout,"INFO:        LARGE  is min size of largest files. (secs)\n");
+		fprintf(stdout,"INFO:        STEP   is size-steps between file types. (secs)\n");
+		fprintf(stdout,"INFO:        Use DON'T DISPLAY TIMINGS to suppress time values in outfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BY LOG DURATION\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        The same, except STEP is duration ratio between file types.\n");
+		fprintf(stdout,"INFO:        Use DON'T DISPLAY TIMINGS to suppress time values in outfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INTO DURATION ORDER\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        Sorts any sndfiles into duration order.\n");
+		fprintf(stdout,"INFO:        Use DON'T DISPLAY TIMINGS to suppress time values in outfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FIND ROGUES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        Sort out any non- or invalid soundfiles (ONLY).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_SPEC):
+		fprintf(stdout,"INFO: ALTER THE SPECIFICATION OF A SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHANGE SAMPLING RATE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                    New sampling rate must be one of...\n");
+		fprintf(stdout,"INFO:                    48000,24000,44100,22050,32000,16000\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CONVERT SAMPLE FORMAT\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                    Convert from integer to float, or vice versa.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHANGE PROPERTIES OF SOUND (USE WITH CAUTION!!)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       SAMPLE RATE..is the new sample rate to impose.\n");
+		fprintf(stdout,"INFO:       .............NB: this does NOT RESAMPLE the data.\n");
+		fprintf(stdout,"INFO:       .............Simply causes data to be read at different srate.\n");
+		fprintf(stdout,"INFO:       .............Sound has same number of samples, different duration,\n");
+		fprintf(stdout,"INFO:       .............and will appear to be transposed in pitch.\n");
+		fprintf(stdout,"INFO:       CHANNELS.....is the new channel count to impose.\n");
+		fprintf(stdout,"INFO:       .............NB: this does NOT RECHANNEL the data. e.g.\n");
+		fprintf(stdout,"INFO:       .............Stereo file set to mono will appear twice as long.\n");
+		fprintf(stdout,"INFO:       SAMPLE TYPE..(0=integers 1=floats) New sample type to impose.\n");
+		fprintf(stdout,"INFO:       .............USE ONLY TO RESTORE A CORRUPTED HEADER.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_EXTRACT):
+		fprintf(stdout,"INFO: EXTRACT SIGNIFICANT DATA FROM SNDFILES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GATED EXTRACTION.....Cut out & keep significant events from sndfile.\n");
+		fprintf(stdout,"INFO: .....................in separate files.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       GATE LEVEL .........level below which sounds are omitted.\n");
+		fprintf(stdout,"INFO:       SPLICE LENGTH.......in milliseconds (default 15ms)\n");
+		fprintf(stdout,"INFO:       ENDGATE LEVEL.......level below which END of sound cut off.\n");
+		fprintf(stdout,"INFO:                           (If set at zero, defaults to GATE value).\n");
+		fprintf(stdout,"INFO:       THRESHOLD ..........Level within extracted event must exceed threshold,\n");
+		fprintf(stdout,"INFO:                           if event is to be retained.(default 0)\n");
+		fprintf(stdout,"INFO:       RETAIN TO ..........N sectors before start of next sound-segment.(default 0)\n");
+		fprintf(stdout,"INFO:                           ('Sectors' are envelope blocks,see EXTRACTION PREVIEW)\n");
+		fprintf(stdout,"INFO:       BAKTRAK ............and keep N sectors prior to gate-on, but only if\n");
+		fprintf(stdout,"INFO:                           any segment level is above INITIAL LEVEL (see below).\n");
+		fprintf(stdout,"INFO:       INITIAL LEVEL.......for use with baktraking.\n");
+		fprintf(stdout,"INFO:       MIN DURATION........of segments to keep (secs).\n");
+		fprintf(stdout,"INFO:       GATE WINDOWS........Sound gates OFF only if level stays below gate\n");
+		fprintf(stdout,"INFO:                           for (GATE_WINDOWS+1) sectors. (default 0).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXTRACTION PREVIEW...create pseudo-sndfile showing envelope of sndfile,sector by sector.\n");
+		fprintf(stdout,"INFO: .....................View this file to choose parameters for GATED EXTRACTION.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TOP AND TAIL.........Remove low level signal from start and end of a sound.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       GATE LEVEL .....is level ABOVE which signal is accepted.\n");
+		fprintf(stdout,"INFO:                       (Range 0-1 : default 0).\n");
+		fprintf(stdout,"INFO:       SPLICE LENGTH...in milliseconds (default 15ms)\n");
+		fprintf(stdout,"INFO:       NO START TRIM...Don't trim beginning of file.\n");
+		fprintf(stdout,"INFO:       NO END TRIM.....Don't trim end of file.\n");
+		fprintf(stdout,"INFO:                       Default: trims BOTH.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: REMOVE DC............shift entire signal to eliminate DC drift.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FIX BY HAND............For each bad sample, give sample number and value you want it to be.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FIND AND LIST ONSETS.....Find start-times of significant events from sndfile.\n");
+		fprintf(stdout,"INFO: ..........................................and store in a textdata file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       GATE LEVEL .........level below which sounds are omitted.\n");
+		fprintf(stdout,"INFO:       ENDGATE LEVEL.......level below which END of sound cut off.\n");
+		fprintf(stdout,"INFO:                           (If set at zero, defaults to GATE value).\n");
+		fprintf(stdout,"INFO:       THRESHOLD ..........Level within extracted event must exceed threshold,\n");
+		fprintf(stdout,"INFO:                           if event is to be retained.(default 0)\n");
+		fprintf(stdout,"INFO:       BAKTRAK ............and keep N sectors prior to gate-on, but only if\n");
+		fprintf(stdout,"INFO:                           any segment level is above INITIAL LEVEL (see below).\n");
+		fprintf(stdout,"INFO:       INITIAL LEVEL.......for use with baktraking.\n");
+		fprintf(stdout,"INFO:       MIN DURATION........of segments to keep (secs).\n");
+		fprintf(stdout,"INFO:       GATE WINDOWS........Sound gates OFF only if level stays below gate\n");
+		fprintf(stdout,"INFO:                           for (GATE_WINDOWS+1) sectors. (default 0).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TOPNTAIL_CLICKS):
+		fprintf(stdout,"INFO: REMOVE CLICKS FROM START AND/OR END OF SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:       GATE LEVEL .....is level ABOVE which signal is accepted.\n");
+		fprintf(stdout,"INFO:                       (Range 0-1 : default 0).\n");
+		fprintf(stdout,"INFO:       SPLICE LENGTH...in milliseconds (default 2ms)\n");
+		fprintf(stdout,"INFO:       START TRIM......Trim beginning of file.\n");
+		fprintf(stdout,"INFO:       END TRIM........Trim end of file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_GATE):
+		fprintf(stdout,"INFO: CUT UP A SOUNDFILE AT ZERO AMPLITUDE POINTS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MIN ZERO CNT FOR CUT POINT....minimum number of consecutive zero samples (per channel).\n");
+		fprintf(stdout,"INFO:                               to indicate a silent gap in the file, where it can be cut.\n");
+		break;
+	case(HOUSE_BAKUP):
+		fprintf(stdout,"INFO: CONCATENATE FILES INTO BACKUP FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Takes any number of soundfiles and \n");
+		fprintf(stdout,"INFO: creates a 'sndfile' containing those files separated by silent gaps.\n\n");
+		fprintf(stdout,"INFO: Files must all have same number of channels.\n");
+		break;
+	case(HOUSE_DUMP):
+		fprintf(stdout,"INFO: DUMP FILES TO SPECIAL BAKUP FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Takes any number of any kind(s) of soundsystem files, and\n");
+		fprintf(stdout,"INFO: creates a 'sndfile' containing those files PLUS their headers.\n");
+		fprintf(stdout,"INFO: A textfile, listing the files SUCCESFULLY stored, is also created.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Each sound+HEADER is preceded by a 'bleep',\n");
+		fprintf(stdout,"INFO: (for identification purposes when searching sound-tape),\n");
+		fprintf(stdout,"INFO: and the output concluded by a longer bleep.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: This file can be stored and recovered from DAT, using DIGITAL OUTPUT and INPUT ONLY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Restore such dumped-files with RECOVER option.\n");
+		break;
+	case(HOUSE_RECOVER):
+		fprintf(stdout,"INFO: RECOVER DUMPED FILES.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: HEADER COPIES RETRIEVED..In dump file, each file has 100 header copies.\n");
+		fprintf(stdout,"INFO: ......................This parameter specifies the minimum fraction of copies to retrieve\n");
+		fprintf(stdout,"INFO: ......................to verify recovery.             Range (0 to 1)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MARKER VALIDITY.......fraction of bytes in header-marker to recover\n");
+		fprintf(stdout,"INFO: ......................to verify we've found a header.   Range (0 to 1)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: HEADER CONSISTENCY....fraction of bytes in one of header copies\n");
+		fprintf(stdout,"INFO: ......................that must tally with bytes in other versions\n");
+		fprintf(stdout,"INFO: ......................to qualify it as a true 'copy'.   Range (0 to 1)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SIGNAL SHIFT TO APLY..Bleep should be at level %d exactly,\n",SQUAREAMP);
+		fprintf(stdout,"INFO: ......................and should start with +ve values.\n");
+		fprintf(stdout,"INFO: ......................If not, this is the linear shift to apply to data\n");
+		fprintf(stdout,"INFO: ......................to get rid of the anomaly. (view file first).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PHASE INVERSION.......If the data is phase inverted, this flag restores the original phase\n");
+		fprintf(stdout,"INFO: ......................(it is applied AFTER any shift).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Recovered files will NOT be listed on the workspace.\n");
+		fprintf(stdout,"INFO: Recovery information is written to a REPORT FILE as well as to the screen.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Dumped datafiles must be transferred DIGITALLY to & from tape.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HOUSE_DISK):
+		fprintf(stdout,"INFO: DISPLAY AVAILABLE SPACE ON DISK.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If a sndfile is input, its sample rate will govern space calculations.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_PROPS):
+		fprintf(stdout,"INFO: DISPLAY PROPERTIES OF A SNDFILING-SYSTEM FILE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_SFLEN):
+		fprintf(stdout,"INFO: DISPLAY DURATION OF A SNDFILING-SYSTEM FILE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_TIMELIST):
+		fprintf(stdout,"INFO: LIST DURATIONS OF SEVERAL SNDFILING-SYSTEM FILES\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_LOUDLIST):
+		fprintf(stdout,"INFO: LIST MAXIMUM LEVEL OF SEVERAL SOUNDFILES\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_TIMESUM):
+		fprintf(stdout,"INFO: SUM DURATIONS OF SEVERAL SNDFILING-SYSTEM FILES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICELEN is in milliseconds. (Default: 15ms)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_TIMEDIFF):
+		fprintf(stdout,"INFO: FIND DIFFERENCE IN DURATION OF TWO SOUND FILES\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_SAMPTOTIME):
+		fprintf(stdout,"INFO: CONVERT SAMPLE COUNT TO TIME IN SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: with COUNT SAMPLES IN GROUPS  e.g. stereo file: sample-PAIRS counted.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_TIMETOSAMP):
+		fprintf(stdout,"INFO: CONVERT TIME TO SAMPLE COUNT IN SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: with COUNT SAMPLES IN GROUPS  e.g. stereo file: sample-PAIRS counted.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_MAXSAMP):
+		fprintf(stdout,"INFO: FIND MAXIMUM SAMPLE IN SOUNDFILE OR BINARY DATA FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FORCE SEARCH IN SOUND  Ignores any maxval written in header.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_MAXSAMP2):
+		fprintf(stdout,"INFO: FIND MAXIMUM SAMPLE OVER GIVEN TIMERANGE IN SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START TIME OF SEARCH Time in soundfile to start search for a maximum.\n");
+		fprintf(stdout,"INFO: END TIME OF SEARCH     Time in soundfile to stop search for a maximum.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_LOUDCHAN):
+		fprintf(stdout,"INFO: FIND LOUDEST CHANNEL IN A STEREO SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_FINDHOLE):
+		fprintf(stdout,"INFO: FIND LARGEST LOW LEVEL HOLE IN A SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THRESHOLD....hole only if level falls and stays below threshold.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_DIFF):
+		fprintf(stdout,"INFO: COMPARE 2 SOUND,ANALYSIS,PITCH,TRANSPOSITION,ENVELOPE, OR FORMANT FILES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THRESHOLD........................max permissible difference in data values:\n");
+		fprintf(stdout,"INFO: CNT..............................max number of differences to accept (default 1).\n");
+		fprintf(stdout,"INFO: IGNORE LENGTH DIFFERENCE.........continue comparing files anyway.\n");
+		fprintf(stdout,"INFO: IGNORE CHANNEL COUNT DIFFERENCE..continue comparing files anyway.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NB: This process works only with binary (non-text) files.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_CDIFF):
+		fprintf(stdout,"INFO: COMPARE CHANNELS IN A STEREO SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THRESHOLD..max permissible difference in data values.\n");
+		fprintf(stdout,"INFO: CNT........MAX NUMBER of differences to accept (default 1).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NB: The output sample display is counted in sample-pairs.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_PRNTSND):
+		fprintf(stdout,"INFO: PRINT SOUND SAMPLE DATA TO A TEXTFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CARE!!! large quantities of data.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INFO_MUSUNITS):
+		fprintf(stdout,"INFO:                                                                                           CONVERT BETWEEN DIFFERENT MUSICAL UNITS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INTERVAL   m2   = minor 2nd             2  = major 2nd\n");
+		fprintf(stdout,"INFO:                    m3   = minor 3rd             3  = major 3rd\n");
+		fprintf(stdout,"INFO:                    4    = perfect 4th           #4 = a tritone\n");
+		fprintf(stdout,"INFO:                    5    = perfect 5th\n");
+		fprintf(stdout,"INFO:                    m6   = minor 6th             6  = major 6th\n");
+		fprintf(stdout,"INFO:                    m7   = minor 7th             7  = major 7th\n");
+		fprintf(stdout,"INFO:                    +8     = an octave OR an octave shift up or down. The maximum range of intervals is up or down 2 octaves (a 15th).\n");
+		fprintf(stdout,"INFO:                    up      = an upward interval (default).\n");
+		fprintf(stdout,"INFO:                    down  = a downward interval.\n");
+		fprintf(stdout,"INFO:                    Intervals may also be displaced by quartertones.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: QTONE        +  = a quarter-tone further up.       - = a quarter-tone further down.        no = no quarter-tone displacement.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCH         As shown on the buttons.        Pitches may be displaced by quartertones.        Octave may be specified from the numeric pad.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NUMERIC    May be used to specify Midi value, Frequency, Frequency Ratio, Semitones, Octaves, Gain, Gain in dB, Timestretching factor, etc.\n");
+		fprintf(stdout,"INFO:                    OR the octave in which a Pitch occurs.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: INPUT        The (possible) type(s) of data you are inputting.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTPUT     The type of data which you wish to output.\n");
+		fprintf(stdout,"INFO:                   When no output button is highlighted, click first on the relevant INPUT button.\n");
+		fprintf(stdout,"INFO:                   Click on the appropriate output button to obtain the result.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                   Pitches are represented in the output by e.g. Ebu-2 or Ed3 where......\n");
+		fprintf(stdout,"INFO:                   'b' = flat                  '#' = sharp                  'u' = up a quarter-tone                  'd' = down a quarter-tone\n");
+		fprintf(stdout,"INFO:                   Numerals (-2, 3) represent the octave in which the note occurs. Octave 0 stretches from Middle C to just below the C above.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BARS        4.3 represents 4 bars and 3 beats\n");
+		break;
+	case(SYNTH_WAVE):
+		fprintf(stdout,"INFO: GENERATE SIMPLE WAVEFORMS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAMPLING RATE.......can be 48000, 24000, 44100, 22050, 32000, or 16000\n");
+		fprintf(stdout,"INFO: NUMBER OF CHANNELS..can be 1, 2 or 4\n");
+		fprintf(stdout,"INFO: DURATION............is duration of output snd, in seconds.\n");
+		fprintf(stdout,"INFO: FREQUENCY...........of output sound, in Hz\n");
+		fprintf(stdout,"INFO: AMPLITUDE...........of output sound: 0.0 < Range <= 1.0 (max & default).\n");
+		fprintf(stdout,"INFO: WAVEFORM TABLESIZE..is size of table storing waveform: defaults to 256\n");
+		fprintf(stdout,"INFO: ....................input value always rounded to multiple of 4.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MULTI_SYN):
+		fprintf(stdout,"INFO: GENERATE CHORD OVER SIMPLE WAVEFORM\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHORD DATA is a list of (possibly fractional) MIDI values, OR a list of Frequency Values\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAMPLING RATE.......can be 48000, 24000, 44100, 22050, 32000, or 16000\n");
+		fprintf(stdout,"INFO: NUMBER OF CHANNELS..can be 1, 2 or 4\n");
+		fprintf(stdout,"INFO: DURATION............is duration of output snd, in seconds.\n");
+		fprintf(stdout,"INFO: AMPLITUDE...........of output sound: 0.0 < Range <= 1.0 (max & default).\n");
+		fprintf(stdout,"INFO: WAVEFORM TABLESIZE..is size of table storing waveform: defaults to 4096\n");
+		fprintf(stdout,"INFO: ....................input value always rounded to multiple of 4.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SYNTH_NOISE):
+		fprintf(stdout,"INFO: GENERATE NOISE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAMPLING RATE.......can be 48000, 24000, 44100, 22050, 32000, or 16000\n");
+		fprintf(stdout,"INFO: NUMBER OF CHANNELS..can be 1, 2 or 4\n");
+		fprintf(stdout,"INFO: DURATION............is duration of output snd, in seconds.\n");
+		fprintf(stdout,"INFO: AMPLITUDE...........of output sound: 0.0 < Range <= 1.0 (max & default).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SYNTH_SIL):
+		fprintf(stdout,"INFO: MAKE SILENT SOUNDFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SAMPLING RATE.......can be 48000, 24000, 44100, 22050, 32000, or 16000\n");
+		fprintf(stdout,"INFO: NUMBER OF CHANNELS..can be 1, 2 or 4\n");
+		fprintf(stdout,"INFO: DURATION............is duration of output snd, in seconds.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SYNTH_SPEC):
+		fprintf(stdout,"INFO: MAKE STEREO FILE BY DEFINING SPECTRAL BANDS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DURATION.........of output data files\n");
+		fprintf(stdout,"INFO: CENTRE FREQUENCY.........Centre of the synthesized band\n");
+		fprintf(stdout,"INFO: BAND SPREAD.... width of band, in Hz, or as a transposition ratio.\n");
+		fprintf(stdout,"INFO: BAND FOCUS (MAX).... maximum tightness of the band.\n");
+		fprintf(stdout,"INFO: BAND FOCUS (MIN).....minimum tightness of band. If different from max,\n");
+		fprintf(stdout,"INFO:              band tightness varies at random between the two.\n");
+		fprintf(stdout,"INFO: TIME VARIATION.....extent to which band components fluctuate with time.\n");
+		fprintf(stdout,"INFO: SAMPLE RATE........sample rate of output audio file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPREAD_AS_TRANSPOSITION_RATIO......(default, a Hz bandwidth)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(INSERTSIL_MANY):
+		fprintf(stdout,"INFO: PUT (SEVERAL) SILENCING MASKS IN AN EXISTING SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME IN SECONDS..........Specify time in seconds.\n");
+		fprintf(stdout,"INFO: TIME AS SAMPLE COUNT.....Specify time as sample count (rounded to multiples of channel-cnt).\n");
+		fprintf(stdout,"INFO: TIME AS GROUPED SAMPLES..Specify time as grouped-sample count (e.g. 3 = 3 stereo-pairs).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXCISEFILE..is a texfile with (paired) start & end times of masks\n");
+		fprintf(stdout,"INFO: ............These must be in increasing time order.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICELEN...splice window in MS (default: %.0lf)\n",EDIT_SPLICELEN);
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(RANDCUTS):
+		fprintf(stdout,"INFO: CUT FILE RANDOMLY INTO CHUNKS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        AVERAGE CHUNKLENGTH..average length of chunks to cut & permute.\n");
+		fprintf(stdout,"INFO:        SCATTERING..........randomisation of cuts: default 1.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(RANDCHUNKS):
+		fprintf(stdout,"INFO: CUT SEVERAL CHUNKS FROM A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CHUNKCNT..is the number of chunks to cut\n");
+		fprintf(stdout,"INFO: MINCHUNK..is the length of the smallest chunk permitted\n");
+		fprintf(stdout,"INFO: MAXCHUNK..is the length of the largest chunk permitted\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: LINEAR DISTRIBUTION...more regular distribution of sizes \n");
+		fprintf(stdout,"INFO: ALL BEGIN AT SOUND START..all chunks start at start of sound \n");
+		break;
+	case(TE_3):
+		fprintf(stdout,"INFO:                                                                         POSSIBLE OPERATIONS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: There are 5 distinct ways to use the Table Editor, plus some additional options.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) SELECT A FILE CONTAINING COLUMNS OF DATA: MANIPULATE THE DATA IN A CHOSEN COLUMN.\n");
+		fprintf(stdout,"INFO: 2) CREATE A COLUMN OF DATA FROM SCRATCH.\n");
+		fprintf(stdout,"INFO: 3) CREATE A TABLE OF DATA FROM SCRATCH.\n");
+		fprintf(stdout,"INFO: 4) COMBINE THE DATA IN TWO DIFFERENT COLUMNS\n");
+		fprintf(stdout,"INFO: 5) COMBINE THE DATA IN TWO DIFFERENT TABLES\n");
+		fprintf(stdout,"INFO: +) EDIT OR TEST DATA, OR FIND PARTICULAR ITEMS, IN COLUMNS OF DATA\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: These are described below.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) SELECT A FILE CONTAINING COLUMNS OF DATA: MANIPULATE THE DATA IN A CHOSEN COLUMN.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) Choose a file from those listed in the 'FILES' list, by clicking on it.\n");
+		fprintf(stdout,"INFO:               It will be displayed in the 'INPUT TABLE' display.\n");
+		fprintf(stdout,"INFO:               1) If NO FILES are listed, this means you have NO (appropriate) textfiles listed on the workspace.\n");
+		fprintf(stdout,"INFO:               2) If your file IS on the workspace, but is NOT LISTED here, it may have the wrong kind of data.\n");
+		fprintf(stdout,"INFO:                     In particular, if your file does not have columns of data with the same number of items\n");
+		fprintf(stdout,"INFO:                     in every column, Try switching to 'Free Text Mode'.\n");
+		fprintf(stdout,"INFO:                     If this does not bring up your file, the Table Editor cannot handle it.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         b) Select a column from the file, by entering a column number and pressing OK,\n");
+		fprintf(stdout,"INFO:               on the 'INPUT TABLE' display.\n");
+		fprintf(stdout,"INFO:               1) The column will normally be displayed in COLUMN IN.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         c) Select where you want the RESULT of the operation to go.\n");
+		fprintf(stdout,"INFO:               1) Normally the result will be displayed in COLUMN OUT.\n");
+		fprintf(stdout,"INFO:               2) Select 'Result HERE' to put the result in COLUMN IN, overwriting the original.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         d) Select an operation from one of the menus.\n");
+		fprintf(stdout,"INFO:               1) You may also need to enter a parameter (at N) or several parameters\n");
+		fprintf(stdout,"INFO:                     (in which case a dialogue box will appear).\n");
+		fprintf(stdout,"INFO:               2) If the operation is successful, a modified column should appear.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         e) If you are not satisfied with the result, choose a different parameter value, or a different process from the menus.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         f) IF you are happy with the result, you can save it to a table.\n");
+		fprintf(stdout,"INFO:               1) You can keep just the column, as it is.\n");
+		fprintf(stdout,"INFO:               2) You can replace the column you got from the original table, inside that table.\n");
+		fprintf(stdout,"INFO:               3) You can replace some other column in the original table.\n");
+		fprintf(stdout,"INFO:               4) You can insert the column as a NEW column, in the original table.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         g) You can select further columns and process them in similar ways.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         h) You can put the resulting columns into either the ORIGINAL table (still displayed at left).\n");
+		fprintf(stdout,"INFO:               or into the NEW table you are building.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         i) Save the New table you have made, by giving it a name.\n");
+		fprintf(stdout,"INFO:               1) You may save the whole table, as is.\n");
+		fprintf(stdout,"INFO:               2) You may save each column of the table to a separate file.\n");
+		fprintf(stdout,"INFO:               3) You may save each row of the table to a separate file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         j) You can also RECYCLE the table, from the OUTPUT TABLE display to the INPUT TABLE.\n");
+		fprintf(stdout,"INFO:               N.B. You must be in 'File to Table' mode to do this.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2) CREATE A COLUMN OF DATA FROM SCRATCH.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) Select a process from the CREATE or CREATE2 menu.\n");
+		fprintf(stdout,"INFO:               1) You may also need to enter a parameter (at N) or several parameters\n");
+		fprintf(stdout,"INFO:                     (in which case a dialogue box will appear).\n");
+		fprintf(stdout,"INFO:               2) If the operation is successful, a column should appear in COLUMN OUT.\n");
+		fprintf(stdout,"INFO:               3) If the operation fails, a message will be displayed.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         b) You can force the column to be created in COLUMN IN, by selecting 'Result HERE'.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         c) You can transform the column with processes selected from the menus, as described above.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         d) You can save the resulting column as a table. (as described above)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         e) You can create further columns and ADD then as new columns to the OUTPUT TABLE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         f) You can save the output tabe, as described above.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 3) CREATE A TABLE OF DATA FROM SCRATCH.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) Select a process from the CREATE options in the TABLES menu.\n");
+		fprintf(stdout,"INFO:               Then write values (numeric or text) into a new table.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         b) You can now use the new table in the normal way described above.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 4) COMBINE THE DATA IN TWO DIFFERENT COLUMNS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) If you have data in both COLUMN IN and COLUMN OUT displays, you can combine their data.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         b) If you have data in COLUMN IN,\n");
+		fprintf(stdout,"INFO:               you can get a single column of data DIRECTLY  FROM A FILE, into COLUMN OUT,\n");
+		fprintf(stdout,"INFO:               by selecting 'File to column output' mode,\n");
+		fprintf(stdout,"INFO:               then selecting a file (from the FILES list) which contains JUST ONE column of data.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:               (Be sure to switch back to 'File to Table' mode afterwards).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         c) Select a process from the COMBINE or BRK menu.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         d) The result will usually appear in the OUTPUT TABLE,\n");
+		fprintf(stdout,"INFO:                and you can treat this in the usual ways (see above).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         e) Some COMBINE options write their result into one of the column displays,\n");
+		fprintf(stdout,"INFO:                (COLUMN IN or OUT depending on whether you have selected 'Result HERE'\n");
+		fprintf(stdout,"INFO:                or 'Result to OUTPUT). overwriting the original data,\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                You can treat this resulting column in the usual ways.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 5) COMBINE THE DATA IN TWO DIFFERENT TABLES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) Select Multiple Files mode.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         b) Select files from the FILES listing.\n");
+		fprintf(stdout,"INFO:                1) Their NAMES will be listed in the OUTPUT TABLE  display.\n");
+		fprintf(stdout,"INFO:                2) As each one is selected you will see its contents in INPUT TABLE.\n");
+		fprintf(stdout,"INFO:                3) You can de-select a file: click on its name in OUTPUT TABLE display.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         c) Select a process from the JOIN menu.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         d) The result of combining the tables will now appear in the OUTPUT TABLE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         e) It is possible to use the JOIN menu to create Vectored Batchfiles (see JOIN menu\n");
+		fprintf(stdout,"INFO:                for further information). In this case, there is the possibility to\n");
+		fprintf(stdout,"INFO:                save the Output Table as a BATCH FILE (the appropriate button will be highlighted).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ----------------------------------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: +) EDIT OR TEST DATA, OR FIND PARTICULAR ITEMS, IN COLUMNS OF DATA\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) Use the EDIT IN, EDIT OUT, AT CURSOR, FIND or TEST menus.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_2):
+		fprintf(stdout,"INFO:                                                 MENU FUNCTIONS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MOST FUNCTIONS convert values in COLUMN IN to new values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         a) Usually the new values appear in COLUMN OUT.\n");
+		fprintf(stdout,"INFO:         b) You can perform multiple operations on column data,\n");
+		fprintf(stdout,"INFO:               using 'Copy to IN' to recycle the COLUMN OUT data back to COLUMN IN.\n");
+		fprintf(stdout,"INFO:         c) You can force results to appear in COLUMN IN (overwriting original values),\n");
+		fprintf(stdout,"INFO:               by selecting 'Result HERE'.\n");
+		fprintf(stdout,"INFO:               You can then work 'in situ' in COLUMN IN, overwriting the original data as you go.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         d) You can also swap around the COLUMN IN & COLUMN OUT data.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: CREATE and CREATE2 Menu functions create values in the Column display you select\n");
+		fprintf(stdout,"INFO:         ('Result HERE' or 'Result to OUT').\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COMBINE Menu functions (and some BRK functions) combine values in COLUMN IN and OUT displays.\n");
+		fprintf(stdout,"INFO:         The result is placed in the New Table display, unless otherwise stated.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TABLES Menu functions act directly on TABLE INPUT display, giving the result in TABLE OUTPUT.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: JOIN Menu functions combine data directly from FILES into the OUTPUT TABLE display.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BRK Menu functions are designed for use with breakpoint file data.\n");
+		fprintf(stdout,"INFO:         They only become active when the input table is a breakpoint file.\n");
+		fprintf(stdout,"INFO:         However, most other functions can be applied to the values in such files.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVEL Menu functions are designed for use with normalised envelope file data.\n");
+		fprintf(stdout,"INFO:         They only become active when input file is such.\n");
+		fprintf(stdout,"INFO:         However, many other functions can be applied to the values in such file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEQ Menu functions are designed for use with sequencing file data (triples of time,transposition,level).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_4):
+		fprintf(stdout,"INFO:                                             PARAMETERS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Most functions take a parameter (N).\n");
+		fprintf(stdout,"INFO: Some functions take no parameter (any value you enter is ignored).\n");
+		fprintf(stdout,"INFO: Some functions work with or without a parameter.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Some functions take a 2nd parameter in the 'Threshold' box.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Some functions take several parameters (x1,x2 etc.).\n");
+		fprintf(stdout,"INFO: A special entry box will appear for you to enter these values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Each process checks parameter ranges, and advises if you are outside the limits.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_5):
+		fprintf(stdout,"INFO:                                                                          THRESHOLD\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THRESHOLD is either a special extra 'threshold' value, or a 2nd parameter to a process.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MATHS Menu Functions Add, Multiply, Divide, Find Reciprocals, and Raise to a Power\n");
+		fprintf(stdout,"INFO:         can be applied solely to values in input above or below a threshold value.\n");
+		fprintf(stdout,"INFO:         Other values remaining unaffected.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COMBINE Menu's search for values Equal to an input parameter, (and one or two other functions)\n");
+		fprintf(stdout,"INFO:         may use the threshold value as the maximum error allowed in assessing the equality of values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: One or two functions take Threshold values as a parameter (e.g. SPAN functions in CREATE2).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Most functions ignore the threshold value.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_1):
+		fprintf(stdout,"INFO:                                     FILE TO TABLE \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Contents of the selected file are listed in the TABLE INPUT, on the left.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                              FILE TO COLUMN OUTPUT ('File->Col' on MAC)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Data from file selected from filelist goes directly to COLUMN OUT display,\n");
+		fprintf(stdout,"INFO: but ONLY if it contains just a single column of data.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                               MULTIPLE FILES ('Many Files' on MAC)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: File selected from the filelist, which must contain one or more columns of data,\n");
+		fprintf(stdout,"INFO: can be combined directly into multiple column tables, using the JOIN menu.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                                     FREE TEXT MODE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Free Text mode handles most kinds of text input.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: This contrasts with the normal mode of operation, which handles only textfiles in which...\n");
+		fprintf(stdout,"INFO:         a) data is aligned in columns.\n");
+		fprintf(stdout,"INFO:         b) each column contains the same number of entries.\n");
+		fprintf(stdout,"INFO:         c) All the entries in any one column are of the same type (e.g. numeric, dB vals, text).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Free Text mode can be used to edit files with comment-lines, or mixfiles with lines of different lengths,\n");
+		fprintf(stdout,"INFO: or Csound scores with 'e' and 's' lines.\n");
+		break;
+	case(TE_14):
+		fprintf(stdout,"INFO:                                     CHANGE SLOPE BY FACTOR\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Assumes input represents a graph of values. Changes the slope of the graph.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_6):
+		fprintf(stdout,"INFO:                            CREATE X1 STEPS IN INTERVAL BETWEEN X2 AND X3, CURVATURE X4\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Curvature = 1 rises (or falls) evenly.\n");
+		fprintf(stdout,"INFO: Curvature < 1 rises quicker at start or falls quicker at end.\n");
+		fprintf(stdout,"INFO: Curvature > 1 rises quicker at end or falls quicker at start.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_7):
+		fprintf(stdout,"INFO:                            ENTRYTIMES OF EVENTS OF GIVEN DURATIONS TO MAINTAIN A GIVEN DENSITY\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Input values are event durations.\n");
+		fprintf(stdout,"INFO: Outputs are start times of successive events required to maintain the specified (vertical) density of events.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_8):
+		fprintf(stdout,"INFO:                                     ISOLATE GROUPS OF EVENTS USING SEPARATION <= N (ASCENDING ONLY) \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: For an ascending sequence of times, items close together (separation <= N) are replaced by start and end time of the group,\n");
+		fprintf(stdout,"INFO: while isolated items (separated from others by > N) are duplicated.\n");
+		fprintf(stdout,"INFO: The resulting pairs-of-times serve to bracket these isolated event-groups (groups having 1 or more members).\n");
+		fprintf(stdout,"INFO: This data might be 'SPANNED' to create an envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                                     RANDOMLY DELETE X1 ITEMS,BUT <= X2 ADJACENT ITEMS: SETS OF ADJACENT ITEMS REMAINING <= X3\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: For controlled random deletion.\n");
+		fprintf(stdout,"INFO: In a sequnce of events, randomly delete X1 items. Ensure that no more than X2 adjacent items are deleted.\n");
+		fprintf(stdout,"INFO: Ensure that the remaining sets of undeleted items are no longer than x3.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_9):
+		fprintf(stdout,"INFO:                                                       OVERLAP\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Time by which each event entry in a sequence overlaps the previous event.\n");
+		fprintf(stdout,"INFO: e.g. overlap = splice-length when items edited together.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_10):
+		fprintf(stdout,"INFO:                                                       PARTITIONS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You can partition a set into subsets ....\n");
+		fprintf(stdout,"INFO: For example, you have a set of 144 values in column1.\n");
+		fprintf(stdout,"INFO: Generate a column2 (with 144 entries) using the values 1,2 & 3 distributed at random.\n");
+		fprintf(stdout,"INFO: (See the CREATE menu).\n");
+		fprintf(stdout,"INFO: Use the random positions of the '1's ('2's and '3's) to select 3 random subsets from the original set.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_11):
+		fprintf(stdout,"INFO:                                                 RAISE NEGATIVE VALS TO POWER\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Negative vals raised to a power are TREATED IN A SPECIAL WAY.\n");
+		fprintf(stdout,"INFO: e.g. value -4 raised to the power of 3  becomes -64 i.e. minus (4-to-the-power-of-3).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_21):
+		fprintf(stdout,"INFO:                                     RANDOMISATION\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Imagine the items spaced out evenly.\n");
+		fprintf(stdout,"INFO: Each sits in a local space stretching from the midpoint between it and its lower neighbour,\n");
+		fprintf(stdout,"INFO: to the midpoint between it and its upper neighbour. (first and last points are handled differently).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Randomisation 0         Creates no randomisation of these original (equal-spaced) positions.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Randomisation 1         Each item can appear anywhere in its local space.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Randomisation > 0 < 1   Each item has its position randomised within its local space.\n");
+		fprintf(stdout,"INFO:                                                the randomisation increases with higher values.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Randomisation > 1           If the randomisation is N, each group of N items is placed at random\n");
+		fprintf(stdout,"INFO:                                                in the TOTAL space occupied by their N adjacent local spaces.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_12):
+		fprintf(stdout,"INFO:                                     RANK\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Lists each different-value item once only,\n");
+		fprintf(stdout,"INFO: placing most frequently occuring items at top of list,\n");
+		fprintf(stdout,"INFO: down to the least frequent, at the foot of the list.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_13):
+		fprintf(stdout,"INFO:                                                                         SCATTER VALUES OVER A QUANTISED GRID\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                       X1 VALS, QUANTISED OVER X2, SPREAD IN INTERVAL X3, WITH RANDOMISATION X4\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. place a set of X1 accents within a duration x3. The accents must occur ON THE BEAT (defined by quantisation time X2).\n");
+		fprintf(stdout,"INFO: The accents are to be placed randomly, with a degree of randomness specified by X4.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IF the randomness X4 <= 1 :      Imagine the duration divided into X1 EQUAL chunks.\n");
+		fprintf(stdout,"INFO: puts 1 event in each chunk, scattered away from that chunk's starttime by up to half distance to next chunk-starttime in either direction.\n");
+		fprintf(stdout,"INFO: Randomness 0 gives no scatter (acents are regular), Randomness 1 gives maximum scatter of this type.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: If the randomness X4 > 1 (where X4 is rounded to nearest integer) :       Imagine the duration divided into N = X1/X4  EQUAL large chunks.\n");
+		fprintf(stdout,"INFO: scatters each succesive group of X4 events randomly over the whole duration of the next N-length chunk.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                       X1 RANDOM VALS QUANTISED OVER X2: MIN OF X3, MAX OF X4, BETWEEN EACH INPUT COL PAIR\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. Place a set of (x1) accents at random. The accents must fall ON THE BEAT (defined by quantisation x2).\n");
+		fprintf(stdout,"INFO: The accents must fall only in time slots defined by successive pairs of values in the input column.\n");
+		fprintf(stdout,"INFO: There must be at least x3 and no more than x4 such accents in each time slot.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_15):
+		fprintf(stdout,"INFO:                                                                         SPAN VALUES BY OTHERS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                       EACH VALUE (T) GOES TO (T-THRESHOLD,T+N+THRESHOLD)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. Create the time-sequence for an an envelope with which to isolate individual events of roughly equal length.\n");
+		fprintf(stdout,"INFO: Threshold is splice length, N the typical event length. Use an alternating sequence (0110011..) to generate the envelope.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                       SPAN: EACH PAIR (T1,T2) GOES TO (T1-THRESHOLD,T1,T2,T2+N+THRESHOLD) \n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. Create the time-sequence for an an envelope with which to isolate groups of events, (individual) events being of roughly equal length.\n");
+		fprintf(stdout,"INFO: First event in group starts at T1 and last event in group starts at T2. Threshold is splice length, N the typical (individual) event length.\n");
+		fprintf(stdout,"INFO: Associate the new times created with an alternating sequence (0110011...) to generate the envelope. This creates an envelope\n");
+		fprintf(stdout,"INFO: rising at each T1-threshold to max at T1, and falling at T2+N, to min at T2+N+threshold. (All (time) values created are >= 0.)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_16):
+		fprintf(stdout,"INFO:                                                                         STACK VALUES FROM ZERO\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Assume input lists durations of successive events. Output gives start time of each event in such a list.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_17):
+		fprintf(stdout,"INFO:                                                                         SUM THE ABSOLUTE DIFFERENCES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Use, e.g., to find duration of a zigzagging process, from a list of times at which the source-read process reverses.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_18):
+		fprintf(stdout,"INFO:                                                                         SUPERIMPOSE ENVELOPES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: e.g. Extract part of a sound, treat it, and reinsert it in the original at the same place.\n");
+		fprintf(stdout,"INFO: The rise and fall envelope of the inserted sound needs to be mirrored in the envelope of the original sound, at the insertion point.\n");
+		fprintf(stdout,"INFO: This inverted envelope can be superimposed on any existing original-file envelope, using the 'superimpose inverted envelope' option.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: This process works only with NORMALISED envelopes (envelope levels lie between 0 and 1).\n");
+		fprintf(stdout,"INFO: In general, an inserted envelope should start and end with level 0 or 1.\n");
+		fprintf(stdout,"INFO: If it does not, its start level (or its inverse) will be imposed on all time points occuring before the insertion starttime.\n");
+		fprintf(stdout,"INFO: and its end level (or its inverse) on all time points occuring after the insertion endtime.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_19):
+		fprintf(stdout,"INFO:                                                                         TEMPER\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: With no parameter, adjust data onto standard (12 semitones per octave) equal-temperament scale.\n");
+		fprintf(stdout,"INFO: With e.g. parameter 9, adjust data onto a 9-steps-per-octave equal-temperament scale.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_20):
+		fprintf(stdout,"INFO:                                                     TIME SEQUENCE ,DURATION X1, FROM MIN STEP X2 TO MAX X3\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Create a sequence of successive time points of total duration x1. Time-step between successive points begins as x2 and ends as x3.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_22):
+		fprintf(stdout,"INFO:                                                     VECTORED BATCHFILES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: A Batchfile is a textfile containing several lines: each line is a command to run a program.\n");
+		fprintf(stdout,"INFO: Running the batchfile runs each program in turn.\n");
+		fprintf(stdout,"INFO: Batchfiles can be run from the Workspace page.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: A Vectored Batchfile is either:\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) a Batchfile which applies the SAME process to the SAME input file on each line,\n");
+		fprintf(stdout,"INFO:         using a different value for ONE (or more) of the parameters, in each line, OR....\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2) a Batchfile which applies the SAME process to a DIFFERENT input file on each line,\n");
+		fprintf(stdout,"INFO:         using a different value for ONE (or more) of the parameters, in each line.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The list of the different values for the SAME parameter, is the PARAMETER VECTOR.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_23):
+		fprintf(stdout,"INFO:                                                  TO CREATE A VECTORED BATCHFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (1) On the Workspace, choose ONE of the files you want to process, and set up the process on the PARAMETERS PAGE,\n");
+		fprintf(stdout,"INFO:         but INSTEAD OF RUNNING IT, save the process AS A BATCHFILE.\n");
+		fprintf(stdout,"INFO:         (This creates an elementary batchfile from which you will generate the Vectored Batchfile).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (2) Now put all the file(s) you want to process into the Chosen Files list on the Workspace.\n");
+		fprintf(stdout,"INFO:         (Lets assume you want to generate 6 processes). There are TWO DIFFERENT OPTIONS.........\n");
+		fprintf(stdout,"INFO:         (a) List 1 file FOR EACH parameter value you intend to use, so you will have 6 infiles with 6 vector-values.\n");
+		fprintf(stdout,"INFO:                   the 1st file is processed using the 1st value in the vector , the 2nd file using the 2nd value in the vector, and so on.\n");
+		fprintf(stdout,"INFO:         (b) List JUST ONE file: in this case the 6 parameter-vector values will be applied, in turn, to the SAME file\n");
+		fprintf(stdout,"INFO:                   to produce 6 separate outputs from the same input file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (3) In the TABLE EDITOR, use the CREATE menu to generate a list of values for ONE parameter (the parameter VECTOR), and save this file.\n");
+		fprintf(stdout,"INFO:         (in our example, the file will contain 6 values).\n");
+		fprintf(stdout,"INFO:         You can create vectors for more than one parameter of the batchfile you are working on,\n");
+		fprintf(stdout,"INFO:         but every one of these vectors must have the SAME NUMBER OF ENTRIES. (In our example they will all have 6 values).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (4) Switch the Table Editor to Multiple Files mode.\n");
+		fprintf(stdout,"INFO: (5) Select the Batchfile you just made, followed by the Vector file(s) you just created.\n");
+		fprintf(stdout,"INFO: (6) Select 'Create a Vectored Batchfile' from the JOIN menu.\n");
+		fprintf(stdout,"INFO: \n");
+	case(TE_24):
+		fprintf(stdout,"INFO:                                                     PARAMETERS, SAVING AND RUNNING\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: (7) You will be shown a parameter entry box. Consult the display at the foot of the parameter entry box, and enter.....\n");
+		fprintf(stdout,"INFO:         (a) The batchfile column-number having the INPUT FILE.\n");
+		fprintf(stdout,"INFO:         (b) The batchfile column-number having the OUTPUT FILE.\n");
+		fprintf(stdout,"INFO:         (c) The batchfile column-number of (each) PARAMETER you are replacing with a vector.\n");
+		fprintf(stdout,"INFO:                  If there is more than one vectored parameter, the column numbers for each of the vectored-parameters need to be entered\n");
+		fprintf(stdout,"INFO:                  IN THE SAME ORDER as the parameter vector-files you have listed on the Table Editor.\n");
+		fprintf(stdout,"INFO: (8) ***** SAVE the resulting table AS A BATCHFILE !!!!! *****\n");
+		fprintf(stdout,"INFO: (9) Run the resulting batchfile from the Workspace.\n");
+		break;
+	case(TE_25):
+		fprintf(stdout,"INFO:                                                     WARPING TIMES OR DATA\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Enter the File with the Data (DATAFILE) followed by the Warping File (WARPFILE).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The WARPFILE is a Breakpoint File of time-value pairs, where times MUST BEGIN AT ZERO.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TO WARP TIMES:\n");
+		fprintf(stdout,"INFO: 1)  Times in Warpfile correspond to (prewarped) times in Datafile.\n");
+		fprintf(stdout,"INFO: 2)  Warp Values must be greater than zero.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TO WARP VALUES IN AN EXISTING BREAKPOINT FILE:\n");
+		fprintf(stdout,"INFO: 1)  Times in Warpfile correspond to times in Datafile.\n");
+		fprintf(stdout,"INFO: 2)  Warp Values can take any value.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TO WARP VALUES IN AN EXISTING LIST OF VALUES:\n");
+		fprintf(stdout,"INFO: 1) Range of times in Warpfile is arbitrary, and will be mapped to length of the data in Datafile.\n");
+		fprintf(stdout,"INFO: 2) Warp Values can take any value.\n");
+		break;
+	case(TE_26):
+		fprintf(stdout,"INFO:                                                                  ******* MUSIC WORKPAD *******\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) TO GET (&/OR REMOVE) FILES\n");
+		fprintf(stdout,"INFO:           select file from right hand display, and press 'GET' or 'GET & REMOVE'\n");
+		fprintf(stdout,"INFO:           **** 'GET' IS NOT CUMULATIVE : do a 'PUT' before selecting more files ****\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2) TO PUT FILES INTO A LIST\n");
+		fprintf(stdout,"INFO:           You must 'GET' files first.\n");
+		fprintf(stdout,"INFO:           Select a position in the Right Hand display, and press 'PUT FILES'\n");
+		fprintf(stdout,"INFO:           (with NO POSITION selected, files go to the END of the display)\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_27):
+		fprintf(stdout,"INFO: The MUSIC TESTBED has various higher level facilities for organising musical material.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1)  BACKGROUND LISTINGS.\n");
+		fprintf(stdout,"INFO:           Files which you feel are musically related, can be gathered together in a BACKGROUND LISTING (B-List).\n");
+		fprintf(stdout,"INFO:           These B-Lists are NOT mutually exclusive i.e. any file can be listed in any number of B-lists.\n");
+		fprintf(stdout,"INFO:           Files in a B-List can be LOADED ONTO THE WORKSPACE AS A SET, so they can be worked on as a group.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:           The MUSIC WORKPAD allows you to sort and reorganise the sound materials you have previously stored in B-Lists.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2)  INTERPOLATION WORKSHOP.\n");
+		fprintf(stdout,"INFO:           Make sounds intermediate between two given sounds, by proportional mixing..\n");
+		fprintf(stdout,"INFO:           The INTERPOLATION WORKSHOP provides flexible ways to do this and to assess the results (by listening).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 3)  NAME GAMES.\n");
+		fprintf(stdout,"INFO:           Numerous operations may be performed upon SEGMENTS WITHIN FILENAMES.\n");
+		fprintf(stdout,"INFO:           If these segments refer to processes applied to the named sound, this allows such processes to be ordered & organised.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 4)  PITCH MARKS.\n");
+		fprintf(stdout,"INFO:           A sound file may be assigned a PITCH MARK, indicating its pitch or pitches.\n");
+		fprintf(stdout,"INFO:           Pitch Marks may be compared, transferred from one sound to another, etc. etc..\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 5)  PROPERTIES FILES.\n");
+		fprintf(stdout,"INFO:           Soundfiles can be assigned any number of (user-defined) properties, and these listed in a PROPERTIES FILE.\n");
+		fprintf(stdout,"INFO:           Property Files can be used to select sounds (e.g. those sharing one or more property) etc.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 7)  SKETCH SCORE\n");
+		fprintf(stdout,"INFO:           The SKETCH SCORE allows you drag sounds about on a page, to decide on (and rememeber) a rough sequence of events.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_28):
+		fprintf(stdout,"INFO:                                                              ******* BACKGROUND LISTINGS *******\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Background listings only accept files which are NOT in the CDP base directory (back them up first).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: B-lists allow files to be grouped together 'experimentally' while you test out musical ideas.\n");
+		fprintf(stdout,"INFO: Files in the same B-List can come from DIFFERENT directories.\n");
+		fprintf(stdout,"INFO: ALSO, Placing a file in one B-list does not preclude it from being placed in another.\n");
+		fprintf(stdout,"INFO: Hence different ideas about how sounds are (to be) grouped can be tested, remembered, and recalled.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Sounds in B-Lists Can be LOADED ONTO THE WORKSPACE AS A SET (or individually),\n");
+		fprintf(stdout,"INFO: either adding to what is already on the Workspace, or replacing it,\n");
+		fprintf(stdout,"INFO: so that these B-listed sounds can be worked on as a group.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: A sound in a B-List may be assigned a PITCHMARK, indicating the principle pitch(es) of the sound.\n");
+		fprintf(stdout,"INFO: (a Pitchmark is ASSOCIATED WITH THE SOUND, so can be viewed from any B-list the sound occurs in, or from the Workspace.)\n");
+		fprintf(stdout,"INFO: Pitchmarks are preserved when sounds are copied (e.g. to a new directory),\n");
+		fprintf(stdout,"INFO: and can themselves be copied from one sound to another.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PITCHMARKS CAN BE COMPARED, pairwise or with the Pitchmark of every other Pitchmarked sound.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_29):
+		fprintf(stdout,"INFO:                                                                  ******* MUSIC WORKPAD *******\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The MUSIC WORKPAD enables you to CREATE & DESTROY B-LISTS, GET FILES to them, and REORGANISE MATERIALS amongst them.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may work with existing B-lists, or Create new ones.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may Grab files from the Workspace, or from any specified directory on your system, to put in a B-list.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Files may be MOVED TO AND FROM DIFFERENT B-LISTS, or reordered within or deleted from a B-List, using 'GET' and 'PUT'\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may SEARCH ALL THE B-LISTS for files with similar names, or for files from the same directory,\n");
+		fprintf(stdout,"INFO:           (e.g. to discover what other B-lists you have placed a particular file in).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may LOAD THE DIRECTORY of a selected file onto the Workspace.\n");
+		fprintf(stdout,"INFO:           (e.g. to discover other related sounds ....assuming you stored related sounds in the same directory.)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may SEARCH THE SOUND LOOM LOGS, to discover how a particular file was made.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may VIEW THE PITCHMARK of any file that has one, and MAKE COMPARISONS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You may LOAD a file, or the directory of the file, ONTO THE WORKSPACE, for further work.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_30):
+		fprintf(stdout,"INFO:                                                                  ******* SKETCH SCORE *******\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The SKETCH SCORE enables you to place sounds on a large 'Score' page, arrange them in sequence, and play the whole sequence.\n");
+		fprintf(stdout,"INFO: You can also write Descriptive Comments on the Score.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:         1) Files can be grabbed from Background Listings,from the Workspace, of from elsewhere and positioned on the score.\n");
+		fprintf(stdout,"INFO:         2) Files may be placed anywhere on this score, dragged from one position to another, or removed.\n");
+		fprintf(stdout,"INFO:         3) Any single file on the Score can be Played, by clicking on it.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The Sequence of files on the score (or a specified part of it) can be joined together and\n");
+		fprintf(stdout,"INFO:          Played. You can use the complete sounds OR JUST A SMALL PART OF EACH.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The sequence of files (or a specified part of it) can be .....\n");
+		fprintf(stdout,"INFO:         1) Saved to a temporary mixfile, ready for more detailed work.\n");
+		fprintf(stdout,"INFO:         2) Grabbed to the Chosen Files list on the Workspace, for further work.\n");
+		fprintf(stdout,"INFO:         3) Saved to a new, or an existing, Background Listing.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The SKETCH SCORE is a 'pre-sequencer', rather than a true sequencer or mixing environment.\n");
+		fprintf(stdout,"INFO: It allows you to quickly test ideas before committing to a real mix.\n");
+		fprintf(stdout,"INFO: It is intended as an aid in decision-making about the larger-scale form of a piece, once\n");
+		fprintf(stdout,"INFO: substantial chunks of material have already been made which need to be appropriately ordered.\n");
+		fprintf(stdout,"INFO: You can quickly test ideas about the ultimate sequence of events \n");
+		fprintf(stdout,"INFO: by joining just a small part of each large file and listening to the result.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NB: Scores are always backed up in the last state in which they contained sounds.\n");
+		fprintf(stdout,"INFO:         If you exit from an EMPTY score, then recall it, the last sounds which appeared on it will reapear.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(TE_31):
+		fprintf(stdout,"INFO:                                                          ******* INTERPOLATION WORKSHOP *******\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: The INTERPOLATION WORKSHOP uses the program 'submix inbetween' to generate sounds intermediate between two given sounds,\n");
+		fprintf(stdout,"INFO: through a simple mixing process. True spectral interpolation happens only if the 2 sounds are synchronised at zero-crossings\n");
+		fprintf(stdout,"INFO: (as happens with the CDP 'DISTORT' processes).  However, aurally convincing results can be obtained with other sounds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TO MAKE AN INTERPOLATION\n");
+		fprintf(stdout,"INFO:         1) Select onto the Chosen Files list of the Workspace the two sounds you wish to interpolate between.\n");
+		fprintf(stdout,"INFO:         2) Start the INTERPOLATION WORKSHOP : the two sounds will now appear on its own display panel.\n");
+		fprintf(stdout,"INFO:         3) You can create intermediate sounds immediately (or at any time you have ONLY 2 sounds in this list) by...\n");
+		fprintf(stdout,"INFO:                 a) Specifying how many intermediate sounds to make.\n");
+		fprintf(stdout,"INFO:                 b) Giving those new sounds a (generic) name.\n");
+		fprintf(stdout,"INFO:                 c) Specifying the interpolation skew.  (Use default value 1: if dissatisfied with the result, try a different value.)\n");
+		fprintf(stdout,"INFO:                 d) Hitting the interpolate button.\n");
+		fprintf(stdout,"INFO:         4) The newly created sounds will be listed in the panel BETWEEN the two original sounds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: YOU CAN NOW LISTEN....\n");
+		fprintf(stdout,"INFO:         a) To the whole listed sequence of sounds.\n");
+		fprintf(stdout,"INFO:         b) To a sequence of sounds (or any individual sound) you select with the mouse.\n");
+		fprintf(stdout,"INFO:         c) To the listed sequence of sounds, APART FROM those you select with the mouse.\n");
+		fprintf(stdout,"INFO: YOU CAN DELETE...\n");
+		fprintf(stdout,"INFO:         a) Particular sounds, selected with the mouse. (But you are prevented from deleting the ORIGINAL two sounds selected from the Workspace).\n");
+		fprintf(stdout,"INFO:         b) The entire interpolation sequence you just made (e.g. in order to try different parameters for the interpolation).\n");
+		fprintf(stdout,"INFO: YOU CAN MAKE ADDITIONAL INTERPOLATIONS between ANY ADJACENT PAIR of sounds on the list....\n");
+		fprintf(stdout,"INFO:         a) Choose two adjacent sounds with the mouse.\n");
+		fprintf(stdout,"INFO:         b) Proceed exactly as for the original interpolation.\n");
+		fprintf(stdout,"INFO: AND YOU CAN FINISH by...\n");
+		fprintf(stdout,"INFO:         a) CONCLUDING: retaining all the files remaining on the listing.\n");
+		fprintf(stdout,"INFO:         b) QUITTING: Which deletes all the interpolated files you made (but NOT the original two sources).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ACC_STREAM):
+		fprintf(stdout,"INFO: REPEAT A SOUND AT A SERIES OF SPECIFIED TIMES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        TIME OF EVENTS..times at which the sound will play.\n");
+		fprintf(stdout,"INFO:        ATTENUATION.......level reduction (e.g. to accomodate attack overlaps).\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HF_PERM1):
+    	fprintf(stdout,"INFO: GENERATE ALL CHORDS POSSIBLE FROM NOTES IN A GIVEN SET,\n");
+    	fprintf(stdout,"INFO: RESTRICTING CHORDS TO WITHIN A GIVEN RANGE OF PITCH,\n");
+    	fprintf(stdout,"INFO: AND USING EACH NOTE (OR ITS OCTAVE TRANSPOSITION) ONCE ONLY PER CHORD.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SOUND OUT................Outputs 1 soundfile of the chords.\n");
+		fprintf(stdout,"INFO: SOUNDS OUT...............Outputs several soundfiles, chords grouped by the sort prodecure(s) you specify.\n");
+		fprintf(stdout,"INFO: TEXT OUT ................Outputs list of chords described by their note names.\n");
+		fprintf(stdout,"INFO: MIDI OUT ................Outputs list of chords described by the MIDI values of the notes in them.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Sound-out & Sounds-Out modes only....\n");
+		fprintf(stdout,"INFO:        SAMPLE RATE OF THE SOUND OUTPUT\n");
+		fprintf(stdout,"INFO:        DURATION OF EACH CHORD GENERATED (SECS)\n");
+		fprintf(stdout,"INFO:        DURATION OF PAUSES BETWEEN CHORDS (SECS)\n");
+		fprintf(stdout,"INFO: Sound-out only: ....\n");
+		fprintf(stdout,"INFO:        DURATION OF PAUSES BETWEEN CHORD-GROUPS (SECS)\n");
+		fprintf(stdout,"INFO: All modes....\n");
+		fprintf(stdout,"INFO:        MIN NUMBER OF NOTES PER CHORD\n");
+		fprintf(stdout,"INFO:        BOTTOM NOTE OF THE PITCH RANGE OF THE CHORDS\n");
+		fprintf(stdout,"INFO:        OCTAVE IN WHICH THIS NOTE OCCURS...zero = octave upwards from Middle C\n");
+		fprintf(stdout,"INFO:        TOP NOTE OF THE PITCH RANGE OF THE CHORDS\n");
+		fprintf(stdout,"INFO:        OCTAVE IN WHICH THIS NOTE OCCURS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        SORT CHORDS BY   ....ROOT             Chord with lowest root note comes first.\n");
+		fprintf(stdout,"INFO:                                        ....TOPNOTE          Chord with highest top note comes first.\n");
+		fprintf(stdout,"INFO:                                        ....PITCHCLASS SET   Chords with same (8va equivalent) notes grouped together.\n");
+		fprintf(stdout,"INFO:                                        ....CHORD TYPE       Chords of same interval structure grouped together.\n");
+		fprintf(stdout,"INFO:                                        ....    1 of each:   only 1 representative of each chord retained.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        CHORDS ONLY OF SPECIFIED MIN NO OF NOTES\n");
+		fprintf(stdout,"INFO:          .... Don't generate chords with more notes than minimum specified.\n");
+		fprintf(stdout,"INFO:        SMALLEST SPAN FIRST (ELSE LARGEST) (inoperative with CHORD TYPE sorts)\n");
+		fprintf(stdout,"INFO:          .... In each subgroup, put smallest span chord first (otherwise it goes last).\n");
+		fprintf(stdout,"INFO:        SORT BY ALTERNATIVE METHOD (ELSE BY DENSITY) (inoperative with CHORD TYPE sorts)\n");
+		fprintf(stdout,"INFO:          .... By default, chords in each subgroup are sorted by density.\n");
+		fprintf(stdout,"INFO:          .... If flag is set,\n");
+		fprintf(stdout,"INFO:          .... For ROOT or TOP NOTE sort, subgroups sorted by the way intervals are stacked inside chord.\n");
+		fprintf(stdout,"INFO:          .... For PITCHCLASS SET sort, subgroups sorted by size of containing interval, then by density.\n");
+		fprintf(stdout,"INFO:        ELIMINATE CHORDS DUPLICATED AT OCTAVES\n");
+		fprintf(stdout,"INFO:          .... Where exactly same chord occurs in more than one octave, eliminate duplicates.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(HF_PERM2):
+    	fprintf(stdout,"INFO: GENERATE ALL CHORDS POSSIBLE FROM MIDI VALUES IN A GIVEN SET,\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SOUND OUT................Outputs 1 soundfile of the chords.\n");
+		fprintf(stdout,"INFO: SOUNDS OUT...............Outputs several soundfiles, chords grouped by the sort prodecure(s) you specify.\n");
+		fprintf(stdout,"INFO: TEXT OUT ................Outputs list of chords described by their note names.\n");
+		fprintf(stdout,"INFO: MIDI OUT ................Outputs list of chords described by the MIDI values of the notes in them.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Sound-out & Sounds-Out modes only....\n");
+		fprintf(stdout,"INFO:        SAMPLE RATE OF THE SOUND OUTPUT\n");
+		fprintf(stdout,"INFO:        DURATION OF EACH CHORD GENERATED (SECS)\n");
+		fprintf(stdout,"INFO:        DURATION OF PAUSES BETWEEN CHORDS (SECS)\n");
+		fprintf(stdout,"INFO: Sound-out only: ....\n");
+		fprintf(stdout,"INFO:        DURATION OF PAUSES BETWEEN CHORD-GROUPS (SECS)\n");
+		fprintf(stdout,"INFO: All modes....\n");
+		fprintf(stdout,"INFO:        MIN NUMBER OF NOTES PER CHORD\n");
+		fprintf(stdout,"INFO:        SORT CHORDS BY   ....ROOT             Chord with lowest root note comes first.\n");
+		fprintf(stdout,"INFO:                                        ....TOPNOTE          Chord with highest top note comes first.\n");
+		fprintf(stdout,"INFO:                                        ....PITCHCLASS SET   Chords with same (8va equivalent) notes grouped together.\n");
+		fprintf(stdout,"INFO:                                        ....CHORD TYPE       Chords of same interval structure grouped together.\n");
+		fprintf(stdout,"INFO:                                        ....    1 of each:   only 1 representative of each chord retained.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:        CHORDS ONLY OF SPECIFIED MIN NO OF NOTES\n");
+		fprintf(stdout,"INFO:          .... Don't generate chords with more notes than minimum specified.\n");
+		fprintf(stdout,"INFO:        SMALLEST SPAN FIRST (ELSE LARGEST) (inoperative with CHORD TYPE sorts)\n");
+		fprintf(stdout,"INFO:          .... In each subgroup, put smallest span chord first (otherwise it goes last).\n");
+		fprintf(stdout,"INFO:        SORT BY ALTERNATIVE METHOD (ELSE BY DENSITY) (inoperative with CHORD TYPE sorts)\n");
+		fprintf(stdout,"INFO:          .... By default, chords in each subgroup are sorted by density.\n");
+		fprintf(stdout,"INFO:          .... If flag is set,\n");
+		fprintf(stdout,"INFO:          .... For ROOT or TOP NOTE sort, subgroups sorted by the way intervals are stacked inside chord.\n");
+		fprintf(stdout,"INFO:          .... For PITCHCLASS SET sort, subgroups sorted by size of containing interval, then by density.\n");
+		fprintf(stdout,"INFO:        ELIMINATE CHORDS DUPLICATED AT OCTAVES\n");
+		fprintf(stdout,"INFO:          .... Where exactly same chord occurs in more than one octave, eliminate duplicates.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(DEL_PERM):
+    	fprintf(stdout,"INFO: DELAY AND TRANSFORM EACH INPUT MIDI VALUE, CUMULATIVELY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO:    DELAY PERMUTATION\n");
+		fprintf(stdout,"INFO:    ......list of pairs of values, in textfile\n");
+		fprintf(stdout,"INFO:    ......1st value of the pair is a semitone transposition\n");
+		fprintf(stdout,"INFO:    ......2nd value of pair is a time-multiplier of duration (<1)\n");
+		fprintf(stdout,"INFO:    ......Sum of all time-multipliers must be equal to 1\n");
+		fprintf(stdout,"INFO:    SAMPLE RATE              sample rate of the sound output\n");
+		fprintf(stdout,"INFO:    INITIAL DURATION OF NOTES length of each input note, before it is transformed\n");
+		fprintf(stdout,"INFO:    CYCLES OF PERMUTATION    number of times the permutation is recursively applied.\n");
+		break;
+	case(DEL_PERM2):
+    	fprintf(stdout,"INFO: DELAY AND TRANSFORM INPUT SOUND (assumed to be at MIDI 60) AT INPUT MIDI VALUES, CUMULATIVELY.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO:    DELAY PERMUTATION\n");
+		fprintf(stdout,"INFO:    ......list of pairs of values, in textfile\n");
+		fprintf(stdout,"INFO:    ......1st value of the pair is a semitone transposition\n");
+		fprintf(stdout,"INFO:    ......2nd value of pair is a time-multiplier of duration (<1)\n");
+		fprintf(stdout,"INFO:    ......Sum of all time-multipliers must be equal to 1\n");
+		fprintf(stdout,"INFO:    CYCLES OF PERMUTATION    number of times the permutation is recursively applied.\n");
+		break;
+	case(TWIXT):
+    	fprintf(stdout,"INFO: SWITCH, AT GIVEN TIMES, BETWEEN SEVERAL FILES, AS THEY 'PLAY' IN PARALLEL.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+  		fprintf(stdout,"INFO: TIME-SEGMENTS IN SEQUENCE.........Proceed from first time-segment to 2nd to 3rd etc.\n");
+    	fprintf(stdout,"INFO: TIME-SEGMENTS PERMUTED............Permute the sequence of time-segments.\n");
+    	fprintf(stdout,"INFO: TIME-SEGMENTS AT RANDOM..........Chose any time-segment, at random.\n");
+		fprintf(stdout,"INFO: TEST SWITCH TIMES....................Chops up first file (only) at the given times,\n");
+		fprintf(stdout,"INFO: ............................................producing segments as separate output files.\n");
+		fprintf(stdout,"INFO: ............................................to test accuracy of file segmentation times.\n");
+		fprintf(stdout,"INFO: PREVIEW SOURCE1 ENVELOPE........Generate a view of the envelope of 1st file,\n");
+		fprintf(stdout,"INFO: ............................................to permit choice of intelligent gating.\n");
+		fprintf(stdout,"INFO: EXTRACT SWITCH TIMES..............Use intelligent gating to generate switch times from first file.\n");				   
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SWITCH TIMES ....... is a texfile containing times which divide the files into segments.\n");
+		fprintf(stdout,"INFO:                                    Include time zero if you want start of files to be used as a segment.\n");
+		fprintf(stdout,"INFO: SPLICE LENGTH (MS) ....... is (approx) length of splices used on segments, in milliseconds.\n");
+		fprintf(stdout,"INFO: NUMBER OF SEGMENTS TO OUTPUT ....... (Only relevant with the random modes).\n");
+		fprintf(stdout,"INFO: WEIGHTING OF FIRST FILE ....... First file occurs N times more often then other files.\n");
+		fprintf(stdout,"INFO: RANDOM PERM OF FILES ....... Sequence of files chosen is randomly permuted..\n");
+		fprintf(stdout,"INFO:                                    except that output always begins with first file in your list.\n");
+		fprintf(stdout,"INFO:                                    (default: files taken in order given in chosen-files list.)\n");
+		break;
+	case(SPHINX):
+    	fprintf(stdout,"INFO: SWITCH, AT GIVEN INPUT-FILE TIMES, BETWEEN SEVERAL FILES,\n");
+    	fprintf(stdout,"INFO: BUT SWITCH-TIMES ASSOCIATED WITH EACH FILE ARE NOT NECESSARILY THE SAME.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+    	fprintf(stdout,"INFO:      IN TIME ORDER..................Proceed from 1st time-segment to 2nd to 3rd etc.\n");
+    	fprintf(stdout,"INFO:      RANDOMLY REORDERED.......Permute the sequence of time-segments.\n");
+    	fprintf(stdout,"INFO:      RANDOM CHOICE...............Chose any time-segment, at random.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:      SWITCH TIMES ....... is a texfile containing times which divide the files into segments.\n");
+		fprintf(stdout,"INFO:                                Include zero if start of files to be used, and file endtime, if end of file to be used.\n");
+		fprintf(stdout,"INFO:                                The 1st times in each file should all be on line 1.\n");
+		fprintf(stdout,"INFO:                                The 2nd times in each file should all be on line 2.  ETC.....\n");
+		fprintf(stdout,"INFO:                                Each file must have the SAME NUMBER of switch times.\n");
+		fprintf(stdout,"INFO:      SPLICE LENGTH (MS) ....... is (approx) length of splices used on segments, in milliseconds.\n");
+		fprintf(stdout,"INFO:      NUMBER OF SEGMENTS TO OUTPUT ....... (Only relevant with the random modes).\n");
+		fprintf(stdout,"INFO:      WEIGHTING OF FIRST FILE ....... First file occurs N times more often then other files.\n");
+		fprintf(stdout,"INFO:      RANDOM PERM OF FILES ....... File sequence randomly permuted (except 1st file always starts output)\n");
+		fprintf(stdout,"INFO:                                (default: files taken in order given in chosen-files list.)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: GENERATING A DATA FILE FOR SPHINX ------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:      1) Run Mode PREVIEW SOURCE1 ENVELOPE and then EXTRACT SWITCH TIMES\n");
+		fprintf(stdout,"INFO:                to automatically generate list of segment onsets for 1st file in your list.\n");
+		fprintf(stdout,"INFO:      2) Run Mode TEST SWITCH TIMES to check segment onset times are good.\n");
+		fprintf(stdout,"INFO:      3) IF NOT: Use 'Nudge Times' on Parameters page to modify (& test) segment onset times.\n");
+		fprintf(stdout,"INFO:      4) Rotate the file-list on workspace, and generate the next edit-times file. ETC.\n");
+		fprintf(stdout,"INFO:      5) Use the TABLE EDITOR in MULTIPLE FILES MODE to merge all these individual datafiles.\n");
+		fprintf(stdout,"INFO:            a) Select the data files you have created from the listing at left,\n");
+		fprintf(stdout,"INFO:            b) Use the JOIN menu, 'Put Cols of one file next to cols of another'\n");
+		fprintf(stdout,"INFO:            c) Save resulting output table as your sphinx datafile.\n");
+		break;
+	case(NOISE_SUPRESS):
+    	fprintf(stdout,"INFO: REPLACE NOISE CONSTITUENTS IN FILE BY SILENCE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SPLICE LENGTH (MS) for splice editing out noise.\n");
+		fprintf(stdout,"INFO: MINIMUM NOISE FREQUENCY (HZ) frequency above which signal treated as potential noise.\n");
+		fprintf(stdout,"INFO: MAXIMUM DURATION OF NOISE TO KEEP (MS)\n");
+		fprintf(stdout,"INFO: MINIMUM DURATION OF TONE TO KEEP (MS)\n");
+		fprintf(stdout,"INFO: RETAIN NOISE RATHER THAN TONE keeps only the noise components\n");
+		break;
+	case(TIME_GRID):
+    	fprintf(stdout,"INFO: DIVIDE SOURCE INTO SET OF ADJACENT GRIDS.\n");
+    	fprintf(stdout,"INFO: A GRID SHOWS WINDOWS OF SOURCE, AT ORIGINAL TIMES, SEPARATED BY SILENCE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NUMBER OF GRIDS: number of grids into which source is to be partitioned.\n");
+		fprintf(stdout,"INFO: WIDTH OF GRID WINDOWS: size of grid windows, in seconds.\n");
+		fprintf(stdout,"INFO: SPLICE LENGTH: length of splices, in milliseconds.\n");
+		break;
+	case(SEQUENCER):
+    	fprintf(stdout,"INFO: PRODUCE SEQUENCE OF INPUT SOUND PLAYED AT TRANSPOSITIONS & TIMES SPECIFIED.\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEQUENCE VALUES IN FILE\n");
+		fprintf(stdout,"INFO: Required data is a textfile containing TIME : TRANSPOSITION : LEVEL triples.\n");
+		fprintf(stdout,"INFO: Transpositions are (+ve or -ve) semitone shifts.\n");
+		fprintf(stdout,"INFO: Level values multiple the original event's level.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTENUATION: to reduce level, should sequencing overload.\n");
+		break;
+	case(SEQUENCER2):
+    	fprintf(stdout,"INFO: PRODUCE SEQUENCE OF SEVERAL INPUT SOUNDS PLAYED AT TRANSPOSITIONS & TIMES SPECIFIED.\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) SEQUENCE VALUES IN FILE : Required data is a textfile containing ......\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:          On the FIRST line:   The (MIDI) pitch of each input file.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:          On ALL OTHER lines:  A set of Five values for each event in ther output...\n");
+		fprintf(stdout,"INFO:              a) Input Sound Number.\n");
+		fprintf(stdout,"INFO:              b) Time (secs).             (times must be in increasing order).\n");
+		fprintf(stdout,"INFO:              c) MIDI pitch.\n");
+		fprintf(stdout,"INFO:              d) Loudness                      (a multiplier).\n");
+		fprintf(stdout,"INFO:              e) Duration                      (if [transposed]-source is shorter than 'Duration'.\n");
+		fprintf(stdout,"INFO:                                                              sound duration cannot be extended)\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 2) ATTENUATION: to reduce level, should sequencing overload.\n");
+		fprintf(stdout,"INFO: 2) SPLICE (MS): to cut short events, if they are too long.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(CONVOLVE):
+    	fprintf(stdout,"INFO: CONVOLVE THE FIRST SOUND WITH THE SECOND.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: Each sample of the first sound is multiplied by each sample of the 2nd.\n");
+ 		fprintf(stdout,"INFO: Typically, the 2nd sound is a loud all-frequency sound (e.g. a gunshot)\n");
+ 		fprintf(stdout,"INFO: in a reverberant space. Convolution imposes the reverberant characteristics\n");
+ 		fprintf(stdout,"INFO: of that space onto the first sound.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: The second (convolving) sound must not be longer than the first (convolved) sound.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: This process is very slow!!.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+  		fprintf(stdout,"INFO: NORMAL.\n");
+  		fprintf(stdout,"INFO: TIME_VARYING.....convolving file can be transposed in a time-varying way.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS (TIME_VARYING MODE ONLY) ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEMITONE TRANSPOSITION OF CONVOLVING FILE....may vary through time.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BAKTOBAK):
+    	fprintf(stdout,"INFO: JOIN A TIME-REVERSED COPY OF THE SOUND, TO A NORMAL COPY, IN THAT ORDER.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME OF JOIN  Time in src file where join-cut is to be made.\n");
+		fprintf(stdout,"INFO: SPLICE LENGTH (MS) Length of the splice, in milliseconds.\n");
+		break;
+	case(ADDTOMIX):
+    	fprintf(stdout,"INFO: ADD SOUNDFILES TO AN EXISTING MIXFILE.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: SOUNDFILES ARE ADDED, (AT MAX LEVEL AND TIME ZERO), TO FOOT OF AN EXISTING MIXFILE.\n");
+ 		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIX_PAN):
+    	fprintf(stdout,"INFO: PAN ENTRIES IN A MIXFILE.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: SOUNDFILES ARE PLACED AT POSITIONS SPECIFIED BY A PAN VALUE,\n");
+ 		fprintf(stdout,"INFO: or BY VALUES READ FROM A TIME-VARYING BRKPOINT FILE.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: THE SOUNDS THEMSELVES DO NOT PAN.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: IF THERE IS ANY STEREO FILE IN THE ORIGINAL MIX,\n");
+ 		fprintf(stdout,"INFO: WHEN THE RESULTING MIX IS USED TO GENERATE SOUND OUTPUT\n");
+ 		fprintf(stdout,"INFO: THAT STEREO FILE WILL BE MERGED TO A MONO STREAM,\n");
+ 		fprintf(stdout,"INFO: AND THAT STREAM POSITIONED IN THE STEREO SPACE OF THE OUTPUT.\n");
+		break;
+	case(SHUDDER):
+    	fprintf(stdout,"INFO: SHUDDER\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PRODUCE (RANDOMISED) TREMULATIONS ON STEREO FILE\n");
+ 		fprintf(stdout,"INFO: WHICH CAN BE SPREAD OVER THE STEREO STAGE\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START_TIME of the Shuddering.\n");
+		fprintf(stdout,"INFO: FREQUENCY  of the Shuddering.\n");
+		fprintf(stdout,"INFO: RANDOMISATION of the Shuddering. (0 - 1)\n");
+		fprintf(stdout,"INFO: SPATIAL_SPREAD of the Shuddering. (0 - 1)\n");
+		fprintf(stdout,"INFO: LOUDNESS DEPTH (MIN & MAX) of the Shuddering. (0 - 1)\n");
+		fprintf(stdout,"INFO: EVENT WIDTH (MIN & MAX), in seconds, of the Shudder events.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: BALACE CHANNEL LEVELS, Boost overall level of quieter channel,\n");
+		fprintf(stdout,"INFO:         if peak level more than 1dB lower than peak level of other channel.\n");
+		break;
+	case(MIX_AT_STEP):
+    	fprintf(stdout,"INFO: CREATE MIXFILE FROM TWO OR MORE SOUNDS, WITH GIVEN TIME STEP BETWEEN ENTRIES\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: TIME STEP between entry of the sounds.\n");
+		break;
+	case(FIND_PANPOS):
+    	fprintf(stdout,"INFO: FIND PAN POSITION OF SOUND IN STEREO IMAGE\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: AT TIME : Time in file at which to assess stereo position.\n");
+ 		fprintf(stdout,"INFO: N.B. IF TIME IS SET TO ZERO, the process assesses the ENTIRE FILE.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: The process only works with Stereo files.\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: This process assumes that (approx) the SAME sound is present in both the Left & Right channels.\n");
+		fprintf(stdout,"INFO: This will be the case if the stereo file is the result of panning a previously mono sound source.\n");
+		break;
+	case(CLICK):
+    	fprintf(stdout,"INFO: GENERATE A SEQUENCE OF CLICKS\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: TAKES DATAFILE CONTAINING SEQUENCE OF DATA LINES -------------------\n");
+ 		fprintf(stdout,"INFO: EACH DATA LINE HAS A LINE NUMBER followed by 3 or 4 DATA ITEMS, separated by spaces, EITHER in the form...\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: GP  0  27.3          for a general pause of 27.3 secs.\n");
+ 		fprintf(stdout,"INFO: GP  1  18.7          for a general pause of 18.7 secs. with an accent at start.\n");
+ 		fprintf(stdout,"INFO: TIME  123.5          Set the absolute time to 123.5 (time must be LATER than previous event).\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: OR the following set of items.....\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: 1) TEMPO     :  in form....(with no spaces around '=')\n");
+ 		fprintf(stdout,"INFO:          1=144                 (for crotchet = 144)      2=75.3         (for minim = 75.3)\n");
+ 		fprintf(stdout,"INFO:          0.5=180             (for quaver = 180)        1.5=100       (for dotted crotchet = 100)\n");
+ 		fprintf(stdout,"INFO:          1=144.3to89.5   (for tempo change from crotchet = 144.3 to crotchet = 89.5)\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO:          A SINGLE DOT ('.') can be used to indicate 'same tempo', BUT not after a changing tempo\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: 2) BARRING :  in form    4:4    or    6:8    or    7:16    etc. (no spaces around ':')\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO:          A SINGLE DOT ('.') can be used to indicate 'same barring', BUT only after barring has been established.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: 3) COUNT     :  i.e. number of bars in this format.\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: ----------------------- and optionally -----------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: 4) ACCENTS :  in one of the forms....(no spaces within the pattern)\n");
+ 		fprintf(stdout,"INFO:                           1.....          strong beat followed by 5 weak beats\n");
+ 		fprintf(stdout,"INFO:                           1..1..         strong beat (start) and secondary beat (at 4) with weak beats between\n");
+ 		fprintf(stdout,"INFO:                           100100      strong beat and secondary beat, with NO intermediate beats\n");
+ 		fprintf(stdout,"INFO:                           ETC.\n");
+		fprintf(stdout,"INFO: IF ACCENT PATTERN OMITTED, default patterns used. These are....\n");
+		fprintf(stdout,"INFO: An accent on start of each bar, plus....\n");
+		fprintf(stdout,"INFO: a) in 6:8, 9:8, 12:8, 15:8 etc, or 6:4, 6:16, 6:32 or 9:4, 9:16 etc.\n");
+		fprintf(stdout,"INFO:           Sound on every specified unit (4,8,16,32 etc.) with Secondary accents every 3rd beat.\n");
+		fprintf(stdout,"INFO: b) in all other meters,\n");
+		fprintf(stdout,"INFO:           Sound on every specified unit (4,8,16,32 etc.), but NO secondary accents\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: ----------------------- also -----------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: comments preceded by ';' can be used e.g.  ;Section 1\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: OTHER PARAMETERS-----------------------------------------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                                            IN MODE 'FROM TIME'\n");
+ 		fprintf(stdout,"INFO: MAKE CLICK FROM TIME ..... Generate clicktrack, beginning at score time given here.\n");
+ 		fprintf(stdout,"INFO:                            If time is given as ZERO, output will include any clicks prior to music zero.\n");
+ 		fprintf(stdout,"INFO: MAKE CLICK TO TIME ......... Generate clicktrack, ending at score time given here.\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                                            IN MODE 'FROM LINE'\n");
+ 		fprintf(stdout,"INFO: MAKE CLICK FROM DATA LINE ..... Generate clicktrack, beginning at data line.\n");
+ 		fprintf(stdout,"INFO: MAKE CLICK TO DATA LINE ......... Generate clicktrack, ending at data line.\n");
+ 		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO:                                                   IN ALL MODES\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: MUSIC STARTS AT LINE...........Usually clicks will begin BEFORE the true start of the music,\n");
+ 		fprintf(stdout,"INFO:                                      and in this case music-zero-time will come AFTER the start of the clicks.\n");
+ 		fprintf(stdout,"INFO:                        This parameter allows you to specify at which line in the data the music itself begins.\n");
+ 		fprintf(stdout,"INFO: SHOW LINE TIMES ..... Running display of times at which each data line begins (relative to music zero).\n");
+		break;
+	case(DOUBLETS):
+    	fprintf(stdout,"INFO: SLICE UP SOUND, REPEATING SLICED SEGMENTS\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: SEGMENTATION LENGTH .... duration of sliced segments.\n");
+ 		fprintf(stdout,"INFO: SEGMENT REPEATS .............. number of times each segment is repeated.\n");
+ 		fprintf(stdout,"INFO: RETAIN ORIGINAL DURATION ...step through file fast enough to keep up with time in source file.\n");
+		break;
+	case(SYLLABS):
+    	fprintf(stdout,"INFO: SLICE TEXT INTO ITS CONTIGUOUS SYLLABLES\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+ 		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: SYLLABLE TIMES .... List of syllable starttimes, plus endtime of last syllable.\n");
+ 		fprintf(stdout,"INFO: DOVETAIL ...........Time (MS) allowed for syllable overlap.\n");
+ 		fprintf(stdout,"INFO: SPLICELENGTH .......Duration (MS) of editing splices.\n");
+ 		fprintf(stdout,"INFO: IN PAIRS .......Cut all syllable-pairs (default, cut individual syllables).\n");
+		break;
+	case(JOIN_SEQ):
+		fprintf(stdout,"INFO: JOIN FILES TOGETHER, ONE AFTER ANOTHER, IN A GIVEN PATTERN\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PATTERN.......File numbers, in the sequence in which they are to be joined.\n");
+		fprintf(stdout,"INFO: SPLICE........duration of splices, in MS (default 15)\n");
+		fprintf(stdout,"INFO: SPLICE START..splices start of first file.\n");
+		fprintf(stdout,"INFO: SPLICE END....splices end of last file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(JOIN_SEQDYN):
+		fprintf(stdout,"INFO: JOIN FILES TOGETHER, ONE AFTER ANOTHER, IN A GIVEN PATTERN, WITH A LOUDNESS PATTERNING\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PATTERN.......File numbers, in the sequence in which they are to be joined.\n");
+		fprintf(stdout,"INFO: .....................each followed by the relative loudness of that pattern item.\n");
+		fprintf(stdout,"INFO: SPLICE........duration of splices, in MS (default 15)\n");
+		fprintf(stdout,"INFO: SPLICE START..splices start of first file.\n");
+		fprintf(stdout,"INFO: SPLICE END....splices end of last file.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MAKE_VFILT):
+		fprintf(stdout,"INFO: CONVERT EACH VALUE IN A LIST OF MIDI VALUES IN A TEXTFILE\n");
+		fprintf(stdout,"INFO: TO A FIXED-PITCH FILTER-DATA-FILE FOR THE VARI-FILTER\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(BATCH_EXPAND):
+		fprintf(stdout,"INFO: USE EXISTING BATCHFILE AS A MODEL TO WORK ON OTHER SOUNDFILES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+  		fprintf(stdout,"INFO: 1) ONE PARAM.\n");
+		fprintf(stdout,"INFO:       a) EXISTING BATCHFILE MUST OPERATE ON A SINGLE SOUNDFILE.\n");
+		fprintf(stdout,"INFO:       b) PARAMETER TO BE REPLACED MUST BE SAME VALUE FOR EACH BATCHFILE LINE.\n");
+		fprintf(stdout,"INFO:  SAME SEQUENCE OF OPERATIONS APPLIED TO EACH IN-SNDFILE USING EACH NEW PARAM IN TURN\n");
+		fprintf(stdout,"INFO: e.g. Batchfile\n");
+		fprintf(stdout,"INFO: filter varibank 2 in1.wav in1_a  filt0.txt 10 2 14 -h36 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 in1.wav in1_b  filt1.txt 20 2 14 -h38 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 in1.wav in1_c  filt2.txt 30 2 14 -h40 -r0.0 -d\n");
+		fprintf(stdout,"INFO: with sndlist and datafile entries \n");
+		fprintf(stdout,"INFO:       ex2.wav            22\n");
+		fprintf(stdout,"INFO:       ff3.wav            99\n");
+		fprintf(stdout,"INFO: and parameter column 9: gives\n");
+		fprintf(stdout,"INFO: filter varibank 2 ex2.wav ex2_b0 filt0.txt 10 2 22 -h36 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 ex2.wav ex2_b1 filt1.txt 20 2 22 -h38 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 ex2.wav ex2_b2 filt2.txt 30 2 22 -h40 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 ff3.wav in1_b0 filt0.txt 10 2 99 -h36 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 ff3.wav in1_b1 filt1.txt 20 2 99 -h38 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 ff3.wav in1_b2 filt2.txt 30 2 99 -h40 -r0.0 -d\n");
+		fprintf(stdout,"INFO: \n");
+  		fprintf(stdout,"INFO: 2) MANY PARAMS.\n");
+		fprintf(stdout,"INFO:       a) EXISTING BATCHFILE CAN OPERATE ON DIFFERENT SOUNDFILES.\n");
+		fprintf(stdout,"INFO:       b) SOUNDFILES IN ORIG BATCHFILE REPLACED BY CHOSEN FILES, AND USING NEW PARAMS.\n");
+		fprintf(stdout,"INFO:             TAKING EACH LINE IN TURN.\n");
+		fprintf(stdout,"INFO: e.g. Batchfile\n");
+		fprintf(stdout,"INFO: filter varibank 2 in1.wav in1_a filt0.txt 10 2 14 -h36 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 in0.wav in0_b filt1.txt 20 2 17 -h38 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 in7.wav in7_c filt2.txt 30 2 11 -h40 -r0.0 -d\n");
+		fprintf(stdout,"INFO: e.g. and same Params as above, gives...\n");
+		fprintf(stdout,"INFO: filter varibank 2 ex2.wav ex2_b filt0.txt 10 2 22 -h36 -r0.0 -d\n");
+		fprintf(stdout,"INFO: filter varibank 2 ff3.wav ff3_b filt1.txt 20 2 99 -h38 -r0.0 -d\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: COLUMN NUMBER OF INFILE, IN BATCHFILE.\n");
+		fprintf(stdout,"INFO: COLUMN NUMBER OF OUTFILE, IN BATCHFILE.\n");
+		fprintf(stdout,"INFO: COLUMN NUMBER OF PARAM TO BE REPLACED, IN BATCHFILE.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(MIX_MODEL):
+		fprintf(stdout,"INFO: SUBSTITUTE NEW SOUNDFILES IN EXISTING MIXFILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1st FILE MUST BE AN EXISTING MIXFILE.\n");
+		fprintf(stdout,"INFO: OTHER FILES ARE SOUNDFILES.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THERE MUST BE ONE SOUNDFILE FOR EACH MIXFILE LINE.\n");
+		fprintf(stdout,"INFO: CHANNEL-CNT OF SOUND MUST CORRESPOND TO CHANNEL-CNT ON CORERSPONDING MIXFILE LINE.\n");
+		break;
+	case(CYCINBETWEEN):
+		fprintf(stdout,"INFO: CREATE NEW FILES INTERMEDIATE BETWEEN 2 GIVEN FILES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: FILES ARE INTERPOLATED, ATTEMPTING TO KEEP ZER-CROSSINGS PEGGED.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NUMBER OF INTERMEDIATE FILES.\n");
+		fprintf(stdout,"INFO: HIGH FREQUENCY CUTOFF.\n");
+		break;
+	case(ENVSYN):
+		fprintf(stdout,"INFO: CREATE ENVELOPE WITH REPEATING PATTERN, IN BINARY ENVELOPE FILE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE ....is the resolution of the envelope (smaller window gives finer resolution) .\n");
+		fprintf(stdout,"INFO: .........................Window size is in MILLIseconds.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DURATION OF OUTFILE.......The duration (in secs) of the file you want to generate.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: DURATION OF REPEATING UNIT......Duration (in secs) of the repeating units. This can vary over time.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START POINT WITHIN FIRST UNIT......0 starts at beginning of unit, 1 at the very end.\n");
+		fprintf(stdout,"INFO: ......................................values in between start within the unit.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: HEIGHT OF ENVELOPE TROUGH......Lowest value reached by the envelope units (can vary over time).\n");
+		fprintf(stdout,"INFO: ........................................(Does not apply to USER DEFINED envelopes).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: EXPONENT OF ENVELOPE RISE OR DECAY......can vary over time.(Does not apply to USER DEFINED envelopes).\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: in USER-DEFINED MODE\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Required data is a textfile of time/val(0-1) pairs defining an envelope, where time units are arbitrary\n");
+		fprintf(stdout,"INFO: as the envelope is stretched to each unit duration.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(P_BINTOBRK):
+		fprintf(stdout,"INFO: CONVERT BINARY PITCH DATA TO PITCH DATA TEXTFILE.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: Pitch data is written to textfile as frequency values.\n");
+		break;
+	case(RRRR_EXTEND):
+		fprintf(stdout,"INFO: EXTEND ITERATIVE SOUNDS.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ATTEMPT TO 'TIME-STRETCH' NATURAL ITERATIVE SOUNDS (LIKE ROLLED 'rrr' IN SPEECH) IN A PLAUSIBLE WAY.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS IN MODE 1 ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: START OF SECTION TO BE EXTENDED ................ time of start of the iterated material in the source.\n");
+		fprintf(stdout,"INFO: END OF SECTION TO BE EXTENDED ................... time of end of the iterated material in the source.\n");
+		fprintf(stdout,"INFO: ANTICIPATED NO OF SEGMENTS TO FIND IN SRC... Estimate how many iterations you hear in marked area.\n");
+		fprintf(stdout,"INFO: APPROX RANGE OF ITERATIVE SOUND (OCTAVES)\n");
+		fprintf(stdout,"INFO:                      A guesstimate of the pitch-range of the iteration\n");
+		fprintf(stdout,"INFO:                      This is the pitch range of the (low_frq) iteration, and NOT the resonant frequency.\n");
+		fprintf(stdout,"INFO:                      e.g. for a rolled 'rrr' it is the frq of the 'rrr' itself (even if unvoiced)\n");
+		fprintf(stdout,"INFO:                      and not the pitch of any sung note (if the 'rrr' is voiced).\n");
+		fprintf(stdout,"INFO: TIMESTRETCH OF SECTION ........................... How much to time-stretch the marked material.\n");
+		fprintf(stdout,"INFO: MAX ADJACENT OCCURENCES OF ANY SEG IN OUTPUT\n");
+		fprintf(stdout,"INFO:                      The iterated material is extended by reusing the individual segments in a randomised pattern.\n");
+		fprintf(stdout,"INFO:                      In this pattern, segment A may occur next to an identical copy of segment A, or not.\n");
+		fprintf(stdout,"INFO:                      This parameter specifies how many adjacent copies of any segment you are prepared to allow.\n");
+		fprintf(stdout,"INFO: AMPLITUDE SCATTER\n");
+		fprintf(stdout,"INFO:                      The iterated segments may vary in amplitude.\n");
+		fprintf(stdout,"INFO:                      0 retains original amplitude: N produces random amplitudes between orig and (1-N) * orig.\n");
+		fprintf(stdout,"INFO: PITCH SCATTER\n");
+		fprintf(stdout,"INFO:                      The iterated segments may vary in pitch.\n");;
+		fprintf(stdout,"INFO:                      0 retains original pitch: N produces random pitchshift between N and -N semitones.\n");
+		fprintf(stdout,"INFO: KEEP EXTENDED ITERATE ONLY....................... If flag is set, rest of file is not retained.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS MODE 2 ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN THIS MODE THE PROCESS ATTEMPTS TO LOCATE THE (FIRST) OCCURENCE OF THE ITERATIVE.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: Hence there is no 'START..' or 'END OF SECTION TO BE EXTENDED'\n");
+		fprintf(stdout,"INFO: and 'ANTICIPATED NO OF SEGMENTS TO FIND' is replaced by ...\n");
+		fprintf(stdout,"INFO:           MINUMUM NO OF SEGMENTS TO FIND\n");
+		fprintf(stdout,"INFO:           APPROX SIZE OF GRANULE_(MS) and\n");
+		fprintf(stdout,"INFO:           GATE LEVEL BELOW WHICH SIGNAL ENVELOPE IGNORED\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: You can also cause the time-stretched iterate to ritardando to a specified speed, using...\n");
+		fprintf(stdout,"INFO: TIME IN EXTENDED ITERATIVE BEFORE RITARNDO\n");
+		fprintf(stdout,"INFO: EVENT SEPARATION IN FULLY SLOWED ITERATIVE and\n");
+		fprintf(stdout,"INFO: TIME IN EXTENDED ITERATIVE WHERE RIT ENDS\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: And.....\n");
+		fprintf(stdout,"INFO: NUMBER OF ITERATED ITEMS TO SKIP BEFORE USING ITEMS TO CREATE OUTPUT.\n");
+		fprintf(stdout,"INFO: allows you to play through first N iterate-items before using the ensuing material for time-extension.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: IN MODE 3 ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PROCESS EDITS THE SOUND INTO ITS START, THE ITERATE-UNITS AND THE END\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(SSSS_EXTEND):
+		fprintf(stdout,"INFO: FIND AND TIME-STRETCH (FIRST) NOISE COMPONENT IN A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: OUTPUT DURATION............................. Duration of output file.\n");
+		fprintf(stdout,"INFO: MIN FRQ (HZ) JUDGED TO REPRESENT NOISE ..... Lowest signal 'frequency' (Hz) viewed as noise.\n");
+		fprintf(stdout,"INFO: MINIMUM NOISE DURATION (MS)................. Minimum acceptable duration of usable block of noise in source signal.\n");
+		fprintf(stdout,"INFO: MAXIMUM NOISE DURATION (SECS)............... Maximum acceptable duration of usable block of noise in source signal.\n");
+		fprintf(stdout,"INFO: KEEP EXTENDED NOISE ONLY.................... Kepp ONLY the extended noise: Otherwise, keep whole src with extended noise.\n");
+		break;
+	case(HOUSE_GATE2):
+		fprintf(stdout,"INFO: SUPPRESS GLITCHES\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: THIS PROGRAM ATTEMPTS TO CUT SHORT GLITCHES OUT OF SOUNDS.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: MAX GLITCH DURATION (MS) .... maximum duration of event recognisable as a glitch.\n");
+		fprintf(stdout,"INFO: MIN GLITCH SEPARATION (MS) ...minimum time signal must fall below threshold on either side of glitch.\n");
+		fprintf(stdout,"INFO: GATING LEVEL AT GLITCH EDGE...maxmimum signal level at edges of glitch.\n");
+		fprintf(stdout,"INFO: SPLICE LENGTH (MS).............must be less than half the minimum glitch-separation.\n");
+		fprintf(stdout,"INFO: SEARCH WINDOW (MS).............size of window where average signal level is calculated.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: SEE DETAILS...................If selected,will list size and position of each (possible) glitch found.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: 1) Zero-length splices can be used if Gating-level is set to 0. In other cases they will produce clicks.\n");
+		fprintf(stdout,"INFO: 2) Use larger windows to remove larger features.\n");
+		fprintf(stdout,"INFO: 3) Very short windows may mistake parts of the waveform for 'silence' and also miss larger features.\n");
+		break;
+	case(GRAIN_ASSESS):
+		fprintf(stdout,"INFO: ASSESS GATE LEVEL TO RETRIEVE MAXIMUM NUMBER OF GRAINS IN A SOUND.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(ZCROSS_RATIO):
+		fprintf(stdout,"INFO: FIND PROPORTION OF ZERO CROSSINGS IN FILE BETWEEN SPECIFIED TIMES.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	case(GREV):
+		fprintf(stdout,"INFO: LOCATE AND MANIPULATE 'GRAINS', USING ENVELOPE TROUGHS AND ZERO-CROSSING.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: This process locates elements of a sound by searching for troughs in the envelope.\n");
+		fprintf(stdout,"INFO: It does not need a clear attack to recognise a 'grain' in a sound, and is\n");
+		fprintf(stdout,"INFO: more appropriate for e.g. separating syllables in speech.\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: MODES ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+ 		fprintf(stdout,"INFO: REVERSE ....... Reverse the order of the (grouped) grains.\n");
+		fprintf(stdout,"INFO: REPEAT ......... Repeat each of the (grouped) grains.\n");
+		fprintf(stdout,"INFO: DELETE ......... Delete a proportion of the (grouped) grains.\n");
+		fprintf(stdout,"INFO: OMIT ............. Replace a proportion of the (grouped) grains with silence.\n");
+		fprintf(stdout,"INFO: TIME STRETCH .. Time stretch the output, without timestretching the grains.\n");
+		fprintf(stdout,"INFO: GET ..................... Get the times of the grains to a textfile.\n");
+		fprintf(stdout,"INFO: PUT ..................... Reposition grains at times suppied in textfile.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (MS) .... This determines vthe size of grains that might be found..\n");
+		fprintf(stdout,"INFO: DEPTH OF TROUGHS AS PROPORTION OF PEAK HEIGHT .... ee,g, with value .5, troughs between peaks\n");
+		fprintf(stdout,"INFO:                    which do not fall to half the peak-height, are ignored\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN TIME STRETCH MODE -----------.\n");    
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ........ TIME STRETCH RATIO (which may be greater [slow down] or less [speed up] than 1, and may vary over time.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN ALL OTHER MODES -----------.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ........ NO OF GRAINS GROUPED AS ONE UNIT ... operations are carried out on the unit,\n");
+		fprintf(stdout,"INFO:                    which might be single grains, and may vary over time\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN DELETE & OMIT MODES -----------.\n");    
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NO OF UNITS TO KEEP | OUT OF ......... e.g. keep 3 out of 7\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN REPEAT MODE -----------.\n");    
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: NO OF UNIT REPETITIONS ............. Number of times each unit is repeated, which can vary over time.\n");
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: IN PUT  MODE-----------.\n");    
+		fprintf(stdout,"INFO: \n");
+		fprintf(stdout,"INFO: ........ GRAIN-TIMINGS is a textfile of the times where the grains are to be repositioned.\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	default:
+		fprintf(stdout,"ERROR: Unknown PROCESS\n");
+		fprintf(stdout,"INFO: \n");
+		break;
+	}
+	return 0;
+}
+
+

dev/misc/tkusage_other.c

@@ -0,0 +1,6519 @@
+/*
+ * Copyright (c) 1983-2020 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 <standalone.h>
+#include <string.h>
+#include <speccon.h>
+#include <science.h>
+
+#define RRRR_EXTEND (345)
+#define SEMITONES_PER_OCTAVE (12)
+
+static void RoomReverbFormat(void);
+const char* cdp_version = "6.1.0";
+
+/******************************** TKUSAGE_OTHER ********************************/
+
+int main(int argc, char *argv[])
+{
+    int process, mode;
+    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if(argc!=3) {
+        fprintf(stdout,"ERROR: Error in usage program tkusage_other\n");
+        return -1;
+    }
+    if(sscanf(argv[1],"%d",&process)!=1) {
+        fprintf(stdout,"ERROR: Failed to read process number in tkusage_other\n");
+        return -1;
+    }
+    if(sscanf(argv[2],"%d",&mode)!=1) {
+        fprintf(stdout,"ERROR: Failed to read process number in tkusage_other\n");
+        return -1;
+    }
+    switch(process) {
+    case(TAPDELAY):
+        fprintf(stdout,"INFO: STEREO MULTI-TAPPED DELAY WITH SPATIAL POSITIONING OF DELAYS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DELAY TIMES AMPS (& POSITIONS). A Text Datafile.\n");
+        fprintf(stdout,"INFO:       Each line has either 2 values (TIME , AMPLITUDE of one delay).\n");
+        fprintf(stdout,"INFO:                    or 3 values (third value specifies spatial POSITION of this delay in the stereo space).\n");
+        fprintf(stdout,"INFO:       TIMES (seconds) must be increasing. Duplicate times are ignored.\n");
+        fprintf(stdout,"INFO:       A zero time (no delay) overrides the mix parameter,\n");
+        fprintf(stdout,"INFO:       and determines the level and pan of the (effectively mono) input.\n");
+        fprintf(stdout,"INFO:       AMP values must be in the range 0.0 to 1.0\n");
+        fprintf(stdout,"INFO:       Empty lines and lines starting with a semi-colon (e.g. comments) are permitted.\n");
+        fprintf(stdout,"INFO:       If a Position value is used in any line, outfile will be stereo.\n");
+        fprintf(stdout,"INFO:       POSITION values are nominally in the range -1 to +1:     0 = centre.\n");
+        fprintf(stdout,"INFO:       If all position values are 0, the output will be mono.\n");
+        fprintf(stdout,"INFO:       Values beyond these limits result in attenuation according to the\n");
+        fprintf(stdout,"INFO:       inverse-square law, to suggest distance beyond the speakers.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT GAIN ...........Gain applied to output signal.\n");
+        fprintf(stdout,"INFO: FEEDBACK ..............Proportion of output signal fed back into input.\n");
+        fprintf(stdout,"INFO:                                       (Negative values invert phase of feedback).\n");
+        fprintf(stdout,"INFO: SOURCE SIGNAL IN MIX...Proportion of original src sound mixed with the delay-output.\n");
+        fprintf(stdout,"INFO: DECAY TAIL DURATION....Time allowed for delays to decay to zero.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(RMRESP):
+        fprintf(stdout,"INFO: GENERATE ROOM RESPONSE DATA SUITABLE FOR USE WITH REVERB PROGRAMS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: LIVENESS...................... degree of reflection from each surface.\n");
+        fprintf(stdout,"INFO: NUMBER OF REFLECTIONS......... number of reflections from each surface.\n");
+        fprintf(stdout,"INFO:            (WARNING: high values will create extremely long data files!).\n");
+        fprintf(stdout,"INFO: ROOM LENGTH, WIDTH, HEIGHT.... The size of the room, in metres.\n");
+        fprintf(stdout,"INFO: SRC POSITION, LENGTHWAYS, WIDTHWAYS & HEIGHT within the room, in metres.\n");;
+        fprintf(stdout,"INFO: LISTENER POSITION LENGTHWAYS, WIDTHWAYS, & HEIGHT within the room, in metres.\n");;
+        fprintf(stdout,"INFO: PEAK AMPLITUDE OF DATA\n");
+        fprintf(stdout,"INFO: REFLECTION TIME RESOLUTION (MS).\n");;
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT is a text datafile suitable for use with MULTIPLE-DELAYS, REVERB or ROOM REVERB processes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB: The first output time is non-zero.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(RMVERB):
+        fprintf(stdout,"INFO: MULTI-CHANNEL REVERB WITH ROOM SIMULATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: An OPTIONAL Text Datafile. (Enter '0' to use preset values instead)......\n");
+        RoomReverbFormat();
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ROOM SIZE......................1 small, 2 medium, 3 large.\n");
+        fprintf(stdout,"INFO: DENSE REVERB GAIN..............level of the dense reverberation.\n");
+        fprintf(stdout,"INFO: SOURCE SIGNAL IN MIX...........Proportion of original src sound mixed with the delay-output.\n");
+        fprintf(stdout,"INFO: FEEDBACK ......................Proportion of output signal fed back into input.\n");
+        fprintf(stdout,"INFO: AIR-ABSORPTION FILTER CUTOFF...Cutoff frq (Hz) of low pass filter modelling air absorption.\n");
+        fprintf(stdout,"INFO:                                       (typically 2500Hz for Large room, 4200Hz for small: set to ZERO for NO absorption).\n");
+        fprintf(stdout,"INFO: LOWPASS REVERB-INPUT CUTOFF....Cutoff frq (Hz) of low pass filter on input to reverb.\n");
+        fprintf(stdout,"INFO:                                       (set to ZERO for NO filtering of input).\n");
+        fprintf(stdout,"INFO: DECAY TAIL DURATION............Time allowed for delays to decay to zero.\n");
+        fprintf(stdout,"INFO: LOWPASS INPUT CUTOFF...........Cutoff frq (Hz) of low pass filter on source.\n");
+        fprintf(stdout,"INFO: HIGHPASS INPUT CUTOFF..........Cutoff frq (Hz) of high pass filter on source.\n");
+        fprintf(stdout,"INFO: REVERB PREDELAY (MS)...........Force delay to start at specified time.\n");
+        fprintf(stdout,"INFO: NUMBER OF OUTPUT CHANNELS......Defaults to stereo.\n");
+        fprintf(stdout,"INFO: DOUBLE AIR-ABSORPTION.........(Reduces reverb time: Increase Feedback to compensate).\n");
+        fprintf(stdout,"INFO: FLOATING POINT OUTPUT FILE.....or not.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MIXMULTI):
+        fprintf(stdout,"INFO: MULTI-CHANNEL MIXING FOR UP TO 64-CHANNELS, WITH CHANNEL CROSS-THREADING.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MIXING STARTTIME...starttime in mix (to start mixing later than zero).\n");
+        fprintf(stdout,"INFO: MIXING ENDTIME.....endtime in mix (to stop mix before its true end).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Note that the START and END params intended for mix TESTING purposes only.\n");
+        fprintf(stdout,"INFO: If you want to keep output from such a testmix, you should TOPNTAIL it.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ATTENUATION.......reduce the mix level, if necessary.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MIXFILE FORMAT FOR MULTICHANNEL MIXING:\n");
+        fprintf(stdout,"INFO: The first line indicates the number of output channels.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The ensuing lines have the following format   e.g.\n");
+        fprintf(stdout,"INFO: snd1.wav 0.0 4  1:1 .5 2:2 .5 3:3 .5 4:4 .5\n");
+        fprintf(stdout,"INFO: snd2.wav 2.0 4  1:1 .25 2:1 .25 3:1 .25 4:1 .25\n");
+        fprintf(stdout,"INFO: snd3.wav 2.0 16 2:3 .25 4:1 .25\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Each line consists of:\n");
+        fprintf(stdout,"INFO: 1)  Name of a soundfile\n");
+        fprintf(stdout,"INFO: 2)  Entry time of that sound in the mix\n");
+        fprintf(stdout,"INFO: 3)  Channel count of the input sound\n");
+        fprintf(stdout,"INFO: 4)  A ROUTING CODE for the input channels, followed by a level for that routing.\n");
+        fprintf(stdout,"INFO: The code consists of a number indicating the input channel, a colon, and\n");
+        fprintf(stdout,"INFO: a number indicating the output channel in the final mix.\n");
+        fprintf(stdout,"INFO: In line 1 (1:1 2:2 3:3 4:4) each input channel goes to the corresponding output channel\n");
+        fprintf(stdout,"INFO: In line 2 (1:1 2:1 3:1 4:1) all input channels are mixed into channel 1 of the output\n");
+        fprintf(stdout,"INFO: In line 3 (2:3 4:1) channels 2 & 4 ONLY of input, are routed to chans 3 & 1 of the output\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: So the input channels can be threaded to any output channel desired.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ANALJOIN):
+        fprintf(stdout,"INFO: SPLICE TOGETHER A SEQUENCE OF ANALYSIS FILES.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NO PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PTOBRK):
+        fprintf(stdout,"INFO: CONVERT BINARY PITCH DATA TO BRKPNT FILE, RETAINING NO-PITCH MARKERS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: TIME, IN MS, THAT ANY STRETCH OF PITCH-DATA MUST PERSIST, TO BE VALID.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_STRETCH):
+        fprintf(stdout,"INFO: TIME-STRETCH A SOUND USING PITCH-SYNCHRONOUS ENVELOPED GRAINS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO: 2) STRETCH FACTOR\n");
+        fprintf(stdout,"INFO: 3) NUMBER OF GRAINS PER BLOCK: Block preserved as-is during process.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Timestretching alters pitch: twice as long, down an octave.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_DUPL):
+        fprintf(stdout,"INFO: DUPLICATE PITCH-SYNCHRONOUS ENVELOPED GRAINS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) NUMBER OF DUPLICATIONS.\n");
+        fprintf(stdout,"INFO: 3) NUMBER OF GRAINS PER BLOCK: Block preserved as-is during process.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_DEL):
+        fprintf(stdout,"INFO: DELETE PITCH-SYNCHRONOUS ENVELOPED GRAINS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) ONE IN HOW MANY BLOCKS TO KEEP.\n");
+        fprintf(stdout,"INFO: 3) NUMBER OF GRAINS PER BLOCK: Block preserved as-is during process.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_STRFILL):
+        fprintf(stdout,"INFO: TIME-STRETCH A SOUND USING PITCH-SYNCHRONOUS ENVELOPED GRAINS, AND GRAIN DUPLICATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) STRETCH FACTOR\n");
+        fprintf(stdout,"INFO: 3) NUMBER OF GRAINS PER BLOCK: Block preserved as-is during process.\n");
+        fprintf(stdout,"INFO: 4) TRANSPOSITION IN SEMITONES:\n");
+        fprintf(stdout,"INFO: Only certain harmonics-related transpositions work.\n");
+        fprintf(stdout,"INFO: and these interact in strange ways with the time-stretch parameter,");
+        fprintf(stdout,"INFO: sometimes producing octaves.\n");
+        fprintf(stdout,"INFO:         e.g. with a time-stretch of 2, these transpositions work...\n");
+        fprintf(stdout,"INFO:         -12 (octave down), 12 (octave up)  24 (2 octaves up).\n");
+        fprintf(stdout,"INFO:         7 (major 5th), 16 (octave + major 3rd) 19 (octave + 5th)  22 (octave + minor 7th).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_FREEZE):
+        fprintf(stdout,"INFO: GRAB ONE OR MORE PITCH-SYNCHRONISED GRAINS AND USE TO CONSTRUCT A NEW SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) TIME IN SOURCE WHERE GRAIN(S) GRABBED.\n");
+        fprintf(stdout,"INFO: 3) DURATION OF FILE TO BE CREATED.\n");
+        fprintf(stdout,"INFO:       Duration oz ZERO will cause a single (block of) grain(s) to be grabbed,\n");
+        fprintf(stdout,"INFO: 4) NUMBER OF GRAINS TO GRAB: IF more than 1, this set is used as a block.\n");
+        fprintf(stdout,"INFO: 5) DENSITY (PITCH TRANSPOSITION)\n");
+        fprintf(stdout,"INFO:       Density 2      Grains overlap so there are always 2 grains playing at once.\n");
+        fprintf(stdout,"INFO:       Density 3      Grains overlap so there are always 3 grains playing at once.\n");
+        fprintf(stdout,"INFO:       Density 0.5    One grain followed by one gap, of same duration.\n");
+        fprintf(stdout,"INFO:       Density 0.25   One grain followed by a gap of three times the duration.\n");
+        fprintf(stdout,"INFO:       With a single (or very few) grain(s), Density can be equivalent to transposition ratio.\n");
+        fprintf(stdout,"INFO:       For pitched grains, the fundamental is transposed, but not the spectrum.\n");
+        fprintf(stdout,"INFO:       Very high fixed densities produce a file with just 2 thumps (only).\n");
+        fprintf(stdout,"INFO:       Glissandos through densities above c 2 produce pitch steps rather than a smooth glide.\n");
+        fprintf(stdout,"INFO: 6) SPECTRAL TRANSPOSITION: transposes the spectrum but not the fundamental.\n");
+        fprintf(stdout,"INFO:       The particular way in which Density and Spectral Transpositions operate\n");
+        fprintf(stdout,"INFO:       depends on the size of segments (no of grains) you choose,\n");
+        fprintf(stdout,"INFO:       and the particular nature of the grains (pitched, noisy etc.).\n");
+        fprintf(stdout,"INFO: 7) RANDOMISATION of the position of the output grain(blocks).\n");
+        fprintf(stdout,"INFO:       Randomisation adds noise to any clearly-pitched grain-source.\n");
+        fprintf(stdout,"INFO: 8) OVERALL GAIN (If density is > 1.0, gain may need to be reduced).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_CHOP):
+        fprintf(stdout,"INFO: REMOVE PITCH-SYNCHRONOUD GRAINS FROM A FILE, AT SPECIFIED TIMES,\n");
+        fprintf(stdout,"INFO: AND KEEP THE REMAINING SEPARATED PARTS OF THE SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) TIME - GRAIN-COUNT FILE.\n");
+        fprintf(stdout,"INFO:       Each pair specifies time at which grains are to be found\n");
+        fprintf(stdout,"INFO:       and how many grains to omit between the cut sections.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Outputs are the sections of sound left behind once these grains are taken out.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_INTERP):
+        fprintf(stdout,"INFO: INTERPOLATE BETWEEN PITCH-SYNCHRONOUS GRAINS,\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) Sustain Duration of first grain.\n");
+        fprintf(stdout,"INFO: 2) Duration of Interpolation.\n");
+        fprintf(stdout,"INFO: 3) Sustain Duration of final grain.\n");
+        fprintf(stdout,"INFO: 4) VIBRATO FREQUENCY.\n");
+        fprintf(stdout,"INFO: 5) VIBRATO DEPTH.\n");
+        fprintf(stdout,"INFO: 6) TREMOLO FREQUENCY.\n");
+        fprintf(stdout,"INFO: 7) TREMOLO DEPTH.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB This process assumes that the input files are single pitch-synchronous grains.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_FEATURES):
+        fprintf(stdout,"INFO: ADD NEW FEATURES TO SOUND ANALYSED INTO PITCH-SYNCHRONOUS GRAINS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) PITCH SHIFTING IS ACCOMPANIED BY TIMEWARPING.\n");
+        fprintf(stdout,"INFO:       If the pitch goes up, the sound gets shorter, if down, longer.\n");
+        fprintf(stdout,"INFO: 2) PITCH SHIFTING IS ACCOMPANIED BY PITCH_DIVISION.\n");
+        fprintf(stdout,"INFO:       Results in 2 pitches, the highest at the specified transposition.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  NUMBER OF GRAINS PER BLOCK: Block preserved as-is during process.\n");
+        fprintf(stdout,"INFO: 3)  TRANSPOSITION (semitones).\n");
+        fprintf(stdout,"INFO: 4)  VIBRATO FREQUENCY.\n");
+        fprintf(stdout,"INFO: 5)  VIBRATO DEPTH (semitones).\n");
+        fprintf(stdout,"INFO: 6)  SPECTRAL TRANSPOSITION (semitones).\n");
+        fprintf(stdout,"INFO: 7)  HOARSENESS smaller values (c.0.04) are most effective.\n");
+        fprintf(stdout,"INFO: 8)  ATTENUATION.\n");
+        fprintf(stdout,"INFO: 9)  FOF-STRETCHING:    N.B. This TURNS OFF spectral transposition.\n");
+        fprintf(stdout,"INFO: 10) SUBHARMONIC NUMBER: Divides pitch-frequency to produce subharmonic. Must be at least 2.\n");
+        fprintf(stdout,"INFO: 11) SUBHARMONIC LEVEL:  Level of any subharmonic introduced.\n");
+        fprintf(stdout,"INFO: 12) ALTERNATIVE ALGORITHM FOR FOF_STRETCH.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_SYNTH):
+        fprintf(stdout,"INFO: USE VOCAL FOFS AS CONTOUR ON SYNTHESIZED SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WITH A FIXED BAND OF OSCILLATORS.\n");
+        fprintf(stdout,"INFO:       Data file is exactly like that for a User-defined Filterbank.\n");
+        fprintf(stdout,"INFO: 1)    BANDS AS FRQ (HZ):..Filter-pitches as frq in Hz.....paired with an amplitude.\n");
+        fprintf(stdout,"INFO: 2)    BANDS AS MIDI:......Filter-pitches as MIDI values.....paired with an amplitude.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WITH A TIME-VARYING BANK OF OSCILLATORS.\n");
+        fprintf(stdout,"INFO:       Data file is exactly like that for a User-defined Time-varying Filterbank.\n");
+        fprintf(stdout,"INFO: 3)    BANDS AS FRQ (HZ):..Filter-pitches as frq in Hz.\n");
+        fprintf(stdout,"INFO: 4)    BANDS AS MIDI:......Filter-pitches as MIDI values.\n");
+        fprintf(stdout,"INFO:       For full details, see 'User-defined Time-varying Filterbank' information.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 5) WITH NOISE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  TABLE OF FREQUENCIES AND AMPLITUDES, DEFINING A BANK OF OSCILLATORS.\n");
+        fprintf(stdout,"INFO: 2)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 3)  DEPTH OF FOF CONTOURING (1 TOTAL .... 0, NONE AT ALL).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_IMPOSE):
+        fprintf(stdout,"INFO: IMPOSE VOCAL FOFS IN 1ST SOUND ON A 2ND INPUT SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  DEPTH OF FOF CONTOURING (1 TOTAL .... 0, NONE AT ALL).\n");
+        fprintf(stdout,"INFO: 3)  WINDOW SIZE (mS) FOR ENVELOPE TRACKING 2ND INPUT SOUND.\n");
+        fprintf(stdout,"INFO: 4)  GATE LEVEL (dB) BELOW WHICH 2ND INPUT SIGNAL IS TO BE IGNORED.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_SPLIT):
+        fprintf(stdout,"INFO: SPLIT VOCAL SOUND INTO SUBHARMONICS AND UPWARD-TRANSPOSED FEATURES.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  SUBHARMONIC NUMBER (DIVIDES VOICE FREQUENCY).\n");
+        fprintf(stdout,"INFO: 3)  UPWARD TRANSPOSITION (SEMITONES).\n");
+        fprintf(stdout,"INFO: 4)  SUPPRESSION OF UPWARD-TRANSPOSED COMPONENTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_SPACE):
+        fprintf(stdout,"INFO: SEPARATE FOFS OF A MONO VOCAL SOUND IN STEREO SPACE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  SUBHARMONIC NUMBER (DIVIDES VOICE FREQUENCY).\n");
+        fprintf(stdout,"INFO: 3)  SPATIAL SEPARATION.\n");
+        fprintf(stdout,"INFO:           0  NO SEPARATION.\n");
+        fprintf(stdout,"INFO:           1  SPLITS ALTERNATELY TO FULL RIGHT/LEFT.\n");
+        fprintf(stdout,"INFO:           -1 SPLITS ALTERNATELY TO FULL LEFT/RIGHT.\n");
+        fprintf(stdout,"INFO: 4)  LEFT/RIGHT RELATIVE LEVEL.\n");
+        fprintf(stdout,"INFO:           RL = 1.0  LEFT & RIGHT LEVELS EQUAL.\n");
+        fprintf(stdout,"INFO:           RL > 1.0  LEFT SIGNAL DIVIDED BY RL. BIAS TO RIGHT\n");
+        fprintf(stdout,"INFO:           RL < 1.0  RIGHT SIGNAL MULTIPLIED BY RL. BIAS TO LEFT\n");
+        fprintf(stdout,"INFO: 5)  SUPPRESS HIGH COMPONENTS.\n");
+        fprintf(stdout,"INFO:           0 = NONE.\n");
+        fprintf(stdout,"INFO:           1 = COMPLETE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_INTERLEAVE):
+        fprintf(stdout,"INFO: INTERLEAVE FOFS OF 2 SOUNDS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE FOR 1ST SND, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  PITCH BREAKPOINT FILE FOR 2ND SND, SIMILARLY.\n");
+        fprintf(stdout,"INFO: 3)  NO OF FOFS TREATED AS A UNIT FOR THE PROCESS.\n");
+        fprintf(stdout,"INFO: 4)  PITCH BIAS.\n");
+        fprintf(stdout,"INFO:           0  NO BIAS.\n");
+        fprintf(stdout,"INFO:           1  PITCH FORCED TOWARDS THAT OF 1ST SND.\n");
+        fprintf(stdout,"INFO:           -1 PITCH FORCED TOWARDS THAT OF 2ND SND.\n");
+        fprintf(stdout,"INFO: 5)  RELATIVE LEVEL.\n");
+        fprintf(stdout,"INFO:           RL = 1.0  1ST & 2ND SOUNDS OF EQUAL LEVEL.\n");
+        fprintf(stdout,"INFO:           RL > 1.0  2ND SOUND LEVEL DIVIDED BY RL. BIAS TO 1ST\n");
+        fprintf(stdout,"INFO:           RL < 1.0  1ST SOUND LEVEL MULTIPLIED BY RL. BIAS TO 2ND\n");
+        fprintf(stdout,"INFO: 6)  RELATIVE WEIGHT.\n");
+        fprintf(stdout,"INFO:           RW = 1.0  1ST & 2ND SOUNDS ALTERNATE.\n");
+        fprintf(stdout,"INFO:           RL > 1.0  1ST SOUND OCCURS RL TIMES MORE THAN 2ND\n");
+        fprintf(stdout,"INFO:           RL < 1.0  2ND SOUND OCCURS 1/RL TIMES MORE THAN 1ST\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_REPLACE):
+        fprintf(stdout,"INFO: COMBINE FOFS OF 1ST SOUND WITH PITCH OF 2ND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE FOR 1ST SND, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  PITCH BREAKPOINT FILE FOR 2ND SND, SIMILARLY.\n");
+        fprintf(stdout,"INFO: 3)  NO OF FOFS TREATED AS A UNIT FOR THE PROCESS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_EXTEND):
+        fprintf(stdout,"INFO: EXTEND A SOUND BY FREEZING IT AT A SPECIFIED TIME, USING A PITCH-SYNCD GRAIN.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:        Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2)  TIME IN SOURCE WHERE GRAIN(S) GRABBED.\n");
+        fprintf(stdout,"INFO: 3)  DURATION OF TOTAL FILE ONCE IT IS STRETCHED.\n");
+        fprintf(stdout,"INFO: 4)  NUMBER OF GRAINS TO GRAB: IF more than 1, this set is used as a block.\n");
+        fprintf(stdout,"INFO: 5)  VIBRATO FREQUENCY.\n");
+        fprintf(stdout,"INFO: 6)  VIBRATO DEPTH (semitones).\n");
+        fprintf(stdout,"INFO: 7)  GRAIN PITCH TRANSPOSITION (semitones).\n");
+        fprintf(stdout,"INFO:        In any brkpntfiles used here, zero time refers to start of \n");
+        fprintf(stdout,"INFO:        bring expanded, and NOT (necessarily) to start of sound.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 8)  SMOOTH FOFS.\n");
+        fprintf(stdout,"INFO:        Imposes a smoothing window on the extracted FOF(s)\n");
+        fprintf(stdout,"INFO:        attempting to remove any high frequency buzz effects.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_EXTEND2):
+        fprintf(stdout,"INFO: EXTEND A SOUND BY FREEZING IT AT A SPECIFIED TIME, USING A PITCH-SYNCD GRAIN.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) TIME AT WHICH GRAIN STARTS.\n");
+        fprintf(stdout,"INFO: 2) TIME AT WHICH GRAIN ENDS.\n");
+        fprintf(stdout,"INFO: 3) DURATION OF TOTAL FILE ONCE IT IS STRETCHED.\n");
+        fprintf(stdout,"INFO: 4)  VIBRATO FREQUENCY.\n");
+        fprintf(stdout,"INFO: 5)  VIBRATO DEPTH (semitones).\n");
+        fprintf(stdout,"INFO: 6)  NUDGE: GRAIN-TIMES MOVED FORWARD OR BACK BY 'NUDGE' ZERO-CROSSINGS.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_LOCATE):
+        fprintf(stdout,"INFO: LOCATE EXACT TIME OF START OF GRAIN, NEAREST TO A GIVEN TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_CUT):
+        fprintf(stdout,"INFO: CUT SOUND AT GRAIN START NEAREST TO SPECIFIED TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) KEEP SOUND BEFORE SPECIFIED GRAIN-TIME.\n");
+        fprintf(stdout,"INFO: 2) KEEP SOUND AT AND AFTER SPECIFIED GRAIN-TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 2) TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ONEFORM_GET):
+        fprintf(stdout,"INFO: EXTRACT FORMANT AT A SPECIFIED TIME, FROM A FORMANT FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) TIME AT WHICH TO EXTRACT FORMANT.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ONEFORM_PUT):
+        fprintf(stdout,"INFO: IMPOSE ON SPECTRUM IN AN ANALYSIS FILE\n");
+        fprintf(stdout,"INFO: THE SPECTRAL ENVELOPE IN A SINGLE-FORMANT FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: REPLACE FORMANTS......New formants REPLACE existing formant envelope.\n");
+        fprintf(stdout,"INFO: SUPERIMPOSE FORMANTS..New formants IMPOSED ON TOP OF existing formants.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: LOW FRQ LIMIT...frq, below which spectrum is set to zero.\n");
+        fprintf(stdout,"INFO: HIGH FRQ LIMIT..frq, above which spectrum is set to zero.\n");
+        fprintf(stdout,"INFO: GAIN............adjustment to spectrum loudness (normally < 1.0).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ONEFORM_COMBINE):
+        fprintf(stdout,"INFO: GENERATE SPECTRUM FROM BINARY-PITCHFILE & SINGLE-FORMANT-DATA.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: outfile is analysis file which must be resynthesized to hear.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(NEWGATE):
+        fprintf(stdout,"INFO: GATE A SIGNAL TO ZERO WHERE IT FALLS BELOW A CERTAIN LEVEL.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: GATE LEVEL...in decibels.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPEC_REMOVE):
+        fprintf(stdout,"INFO: REMOVE SPECIFIC PITCH (AREA) FROM A SPECTRUM, OR REMOVE COMPONENTS NOT OF PITCH (AREA).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: 1) REMOVE PITCH.\n");
+        fprintf(stdout,"INFO: 2) REMOVE NON_PITCH.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MINIMUM PITCH (MIDI).\n");
+        fprintf(stdout,"INFO: MAXIMUM PITCH (MIDI).\n");
+        fprintf(stdout,"INFO: MODE 1) FREQUENCY ABOVE WHICH HARMONICS ARE NOT REMOVED (HZ).\n");
+        fprintf(stdout,"INFO: MODE 2) FREQUENCY ABOVE WHICH HARMONICS ARE NOT RETAINED (HZ).\n");
+        fprintf(stdout,"INFO: ATENUATION OF SPECIFIED COMPONENTS.\n");
+        fprintf(stdout,"INFO:          (1 = full attenuation, 0 = no attenuation).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Process removes all components, and their harmonics, in the given pitch range,\n");
+        fprintf(stdout,"INFO: as far as the given frequency limit.\n");
+        fprintf(stdout,"INFO: (Or, mode 2, removes all components which are NOT in the pitch range or that of its harmonics)\n");
+        fprintf(stdout,"INFO: as far as the given frequency limit.\n");
+        fprintf(stdout,"INFO: Pitch range of an octave or more will remove (retain) all spectral components\n");
+        fprintf(stdout,"INFO: between the lower pitch and the upper frequency limit\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PREFIXSIL):
+        fprintf(stdout,"INFO: ADD SILENCE AT START OF SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION of silence to add.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(STRANS):
+        fprintf(stdout,"INFO: CHANGE SPEED & PITCH OF MULTICHANNEL SOURCE SOUND, OR CREATE VIBRATO.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) SPEED CHANGE...............also changing sound pitch.\n");
+        fprintf(stdout,"INFO: 2) SPEED CHANGE IN SEMITONES..speed shift given in semitones.\n");
+        fprintf(stdout,"INFO:    For BOTH these modes, brkpnt times are infiletimes, unless flagged as outfiletimes.\n");
+        fprintf(stdout,"INFO: 3) ACCELERATE SOURCE TO GIVEN SPEED..speed shift given as multiplier.\n");
+        fprintf(stdout,"INFO: 4) VIBRATO THE SOURCE....with given speed and depth (possibly time-varying).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1. Speed change as a speed multiplier.\n");
+        fprintf(stdout,"INFO: MODE 2. Speed change in semitones.\n");
+        fprintf(stdout,"INFO: MODE 3\n");
+        fprintf(stdout,"INFO:      ACCELERATION as speed multiplier at the goal time.\n");
+        fprintf(stdout,"INFO:      GOAL TIME is speed at which 'acceleration' speed is achieved.\n");
+        fprintf(stdout,"INFO:      START TIME is time in source where acceleration begins.\n");
+        fprintf(stdout,"INFO: MODE 4\n");
+        fprintf(stdout,"INFO:      VIBRATO FREQUENCY is rate of vibrato, in Hz (can vary over time).\n");
+        fprintf(stdout,"INFO:      VIBRATO DEPTH is depth of vibrato, in semitones (can vary over time).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PSOW_REINF):
+        fprintf(stdout,"INFO: REINFORCE HARMONICS OR ADD INHARMONIC CONSTITUENTS IN SOUND WITH (VOCAL) FOFS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) REINFORCE HARMONICS.\n");
+        fprintf(stdout,"INFO: 2) ADD INHARMONIC ELEMENTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  TABLE OF HARMONIC NUMBERS AND AMPLITUDES.\n");
+        fprintf(stdout,"INFO:         These define which harmonics are added to the original source, (range 2 to 256)\n");
+        fprintf(stdout,"INFO:         and what their relative-levels are (src assumed to be at level 1.0) (range >0  to 16).\n");
+        fprintf(stdout,"INFO:         The output is scaled down in level, if clipping might occur.\n");
+        fprintf(stdout,"INFO:         In MODE 2, these 'harmonics' can be FRACTIONAL.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 2)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in some places).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In MODE 1\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DON'T DUPLICATE HARMONICS : FOFs corresponding to higher harmonics which\n");
+        fprintf(stdout,"INFO: coincide with FOFs corresponding to lower harmonics, are omitted.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In MODE 1\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DELAY OF HARMONICS: mS delay applied (progressively) to harmonics.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In MODE 2\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WEIGTH : Determines how long inharmonic constituents are sustained.\n");
+        fprintf(stdout,"INFO: In some circumstances very high weights may cause the memory to overflow.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PARTIALS_HARM):
+        fprintf(stdout,"INFO: EXTRACT RELATIVE AMPLITUDES OF PARTIALS IN A PITCHED SOURCE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) SINGLE-WINDOW ANALYSIS FILE -> FRQ DATA.\n");
+        fprintf(stdout,"INFO: 2) SINGLE-WINDOW ANALYSIS FILE -> MIDI DATA.\n");
+        fprintf(stdout,"INFO: 3) MULTI-WINDOW ANALYSIS FILE -> FRQ DATA.\n");
+        fprintf(stdout,"INFO: 4) MULTI-WINDOW ANALYSIS FILE -> MIDI DATA.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  FUNDAMENTAL FREQUENCY:  Fundamental frequency of the window.\n");
+        fprintf(stdout,"INFO: 2)  THRESHOLD AMPLITUDE:  Relative level below which partials are ignored.\n");
+        fprintf(stdout,"INFO: 3)  TIME OF WINDOW:  (Modes 3 & 4 only) Time, in analysis file, where partials to be found.\n");
+        fprintf(stdout,"INFO: 4)  OUTPUT IN VARIPARTIALS FILTER FORMAT:  Outputs data in file-format for varipartials filter.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input file is clearly pitched (at least in the relevant place).\n");
+        break;
+    case(SPECROSS):
+        fprintf(stdout,"INFO: INTERPOLATE PARTIALS OF PITCHED SRC2 TOWARDS THOSE OF PITCHED SRC 1,\n");
+        fprintf(stdout,"INFO: RETAINING THE DURATION OF SRC2, AND THE ATTACK LOCATION OF SRC1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: IN-TUNE RANGE:  Semitone range within which harmonics 'in tune'.\n");
+        fprintf(stdout,"INFO: MIN WINDOWS TO CONFIRM PITCH:   Minimum number of adjacent windows that must be pitched,\n");
+        fprintf(stdout,"INFO:                  for a pitch-value to be registered.\n");
+        fprintf(stdout,"INFO: SIGNAL TO NOISE RATIO:  Signal to noise ratio, in decibels.\n");
+        fprintf(stdout,"INFO:                  Windows which fall at or below this level, relative to the maximum level in the sound,\n");
+        fprintf(stdout,"INFO:                  are assumed to be noise, & any detected pitch is ignored.\n");
+        fprintf(stdout,"INFO: VALID HARMONICS COUNT:  Number of the 8 loudest peaks in spectrum which must be harmonics\n");
+        fprintf(stdout,"INFO:                  to confirm that the sound is pitched: Default 5.\n");
+        fprintf(stdout,"INFO: LOW PITCH LIMIT:  Lowest acceptable frequency (Hz) at which a pitch value is acceptable.\n");
+        fprintf(stdout,"INFO: HIGH PITCH LIMIT:  Highest acceptable frequency (Hz) at which a pitch value is acceptable.\n");
+        fprintf(stdout,"INFO: PARTIAL THRESHOLD AMPLITUDE:  The threshold amplitude is measured relative to the loudest partial in the window.\n");
+        fprintf(stdout,"INFO:                  Any (possible) partial data which falls below this level is ignored.\n");
+        fprintf(stdout,"INFO: OUTPUT LEVEL:  Level of the output spectrum. Vary only if reapplying src1 to several src2s,\n");
+        fprintf(stdout,"INFO:                  when the relative levels of the src2s are important.\n");
+        fprintf(stdout,"INFO: SPECTRAL_INTERPOLATION:  Degree of interpolation between Src2 and Src1.\n");
+        fprintf(stdout,"INFO:                  Zero gives the original (cleaned) src 2, 1 gives src1 only.\n");
+        fprintf(stdout,"INFO:                  The degree of interpolation may vary (with time) through the sound.\n");
+        fprintf(stdout,"INFO:                  Times in any breakpoint file will be scaled to the duration of Src1.\n");
+        fprintf(stdout,"INFO: RETAIN FILE2 CONTOUR UNDER FILE1 CONTOUR so amplitude fluctuations of File1 still apparent at max interpolation.\n");
+        fprintf(stdout,"INFO: EXTEND 1ST STABLE PITCH OF FILE1 TO START so very start of File 1 is assumed to be pitched.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Assumes the input files are clearly pitched (at least in the relevant place).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: A typical application would use a (relatively) stable-pitched source for Src1,\n");
+        fprintf(stdout,"INFO: while Src2 might vary in pitch (e.g. a speaking voice), but this is not essential.\n");
+        break;
+    case(LUCIER_GETF):
+        fprintf(stdout,"INFO: EXTRACT ROOM-RESONANCE FROM A RECORDING AND CREATE A FILTER-DATA FILE FOR 'FILTER VARIBANK'.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MIN ROOM DIMENSION (METRES):  Enter ZERO to ignore roomsize.\n");
+        fprintf(stdout,"INFO: ROLLOFF INTERVAL: Interval (in semitones) over which resonance fades to zero, above the max resonance frq dictated by room dimensions.\n");
+        fprintf(stdout,"INFO: LOW_FRQ_CUTOFF:      Ignore resonances below this frequency.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Longer recordings give better results.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(LUCIER_GET):
+        fprintf(stdout,"INFO: EXTRACT ROOM-RESONANCE FROM A RECORDING AND CREATE A CORRESPONDING ANALYSIS DATA FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MIN ROOM DIMENSION (METRES):  Enter ZERO to ignore roomsize.\n");
+        fprintf(stdout,"INFO: ROLLOFF INTERVAL: Interval (in semitones) over which resonance fades to zero, above the max resonance frq dictated by room dimensions.\n");
+        fprintf(stdout,"INFO: RESOLVE LOW FRQS: Attempt to resolve low frequency resonances more accurately.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(LUCIER_PUT):
+        fprintf(stdout,"INFO: IMPOSE ROOM-RESONANCE FROM A RECORDING (EXTRACTED USING 'LUCIER GET') ONTO AN ANALYSIS FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RESONANCE COUNT:      Number of times the room resonance is (cumulatively) added to the sound.\n");
+        fprintf(stdout,"INFO: OCTAVE DUPLICATION ROLLOFF:  If NOT set to zero (default), room resonance is duplicated at higher octaves,\n");
+        fprintf(stdout,"INFO:          with resonance level multiplied (cumulatively) by this attenuation from 8va to 8va.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(LUCIER_DEL):
+        fprintf(stdout,"INFO: ATTEMPT TO REMOVE ROOM-RESONANCE (EXTRACTED USING 'LUCIER GET') FROM A RECORDING.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SUPPRESSION:   Degree of suppression of room acoustic.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECLEAN):
+        fprintf(stdout,"INFO: REMOVE PERSISTENT NOISE FROM SPECTRUM, BY COMPARISON WITH AN EXTRACT OF THE NOISE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PERSISTANCE (mS):   Time for which signal in a channel must exceed threshold defined by noise input before it is allowed to pass.\n");
+        fprintf(stdout,"INFO: NOISE PREGAIN:          Threshold level for passing clean signal is level of noise signal times this pregain.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECTRACT):
+        fprintf(stdout,"INFO: REMOVE PERSISTENT NOISE FROM SPECTRUM, BY SUBTRACTING AN EXTRACT OF THE NOISE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PERSISTANCE (mS):   Time for which signal in a channel must exceed threshold defined by noise input before it is allowed to pass.\n");
+        fprintf(stdout,"INFO: NOISE PREGAIN:          Threshold level for passing clean signal is level of noise signal times this pregain.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The noise-signal level is also subtracted from any signal exceeding the threshold.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PHASE):
+        fprintf(stdout,"INFO: INVERT PHASE, OR ENHANCE STEREO IMAGE BY PHASE CANCELLATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) INVERT  PHASE OF MONO OR STEREO SIGNAL.\n");
+        fprintf(stdout,"INFO: 2) ENHANCE STEREO IMAGE, BY PHASE CANCELLATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PHASE TRANSFER: (Mode 2 only) Amount of phase-inverted other-channel used to enhance stereo.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(BRKTOPI):
+        fprintf(stdout,"INFO: CONVERT TEXT PITCH-DATA TO BINARY PITCH DATA.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Pitch data is written to a default format binary file.\n");
+        break;
+    case(SPECSLICE):
+        fprintf(stdout,"INFO: SALAMI-SLICE SPECTRUM INTO (INTERLEAVED) FREQUENCY BANDS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) SLICE SPECTRUM BY ANALYSIS CHANNELS.\n");
+        fprintf(stdout,"INFO: 2) SLICE SPECTRUM BY FREQUENCY BANDS.\n");
+        fprintf(stdout,"INFO: 3) SLICE SPECTRUM BY PITCH BANDS.\n");
+        fprintf(stdout,"INFO: 4) SLICE SPECTRUM BY HARMONICS OF EXTRACTED PITCH.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER_OF_SLICES : with 3 slices (and 1 channel per slice) Slice-1 = chans 1,4,7...etc   Slice-2 = chans 2,4,8.etc Slice-3 = chans 3,6,9.etc\n");
+        fprintf(stdout,"INFO: ANALYSIS_CHANNEL_GROUPING : with 3 slices and grouping 2   Slice-1 = chans 1-2,7-8,13-14...etc   Slice-2 = chans 3-4,9-10..etc Slice-3 = chans 5-6,11-12..etc\n");
+        fprintf(stdout,"INFO: SLICE_BANDWIDTH: width of slices in Hz: with Hz 100 and 2 slices: Slice-1 = 0-100Hz + 200-300Hz + 400-500Hz..etc Slice-2 = 100-200Hz + 300-400Hz ..etc\n");
+        fprintf(stdout,"INFO: SLICE_WIDTH_IN_SEMITONES: width of slices in semitones.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(FOFEX_EX):
+        fprintf(stdout,"INFO: EXTRACT AND ORGANISE FOFS IN A SOUND IN ORDER TO RE-USE THEM.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)   EXTRACT ALL FOF(GROUP)S SUBJECT TO EXCLUSIONS, TO SPECIAL FOF-STORAGE SOUNDFILE.\n");     
+        fprintf(stdout,"INFO: 2)   EXTRACT SINGLE FOF(GROUP) AT SPECIFIED TIME.\n");     
+        fprintf(stdout,"INFO: 3)   EXTRACT ALL FOF(GROUP)S SUBJECT TO EXCLUSIONS, TO SEPARATE SOUNDFILES.\n");     
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES 1 & 3\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  LIST OF SECTIONS OF THE SOURCE (AS PAIRS OF SAMPLETIMES) FROM WHICH ~NO~ FOFS ARE TO BE TAKEN.\n");
+        fprintf(stdout,"INFO:           IF THERE ARE NO SUCH AREAS, ENTER THE PARAMETER VALUE \"0\"\n");
+        fprintf(stdout,"INFO: 2)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES,\n");
+        fprintf(stdout,"INFO:     AND DERIVED FROM THE INPUT SOUNDFILE.\n");
+        fprintf(stdout,"INFO:       Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 3)  A dB VALUE: FOFS WHICH ARE LESS THAN THIS LEVEL BELOW THE MAX FOF LEVEL ARE REJECTED.\n");
+        fprintf(stdout,"INFO:       N.B. A value of ZERO, RETAINS ALL FOFS.\n");
+        fprintf(stdout,"INFO: 4)  GROUPED FOFS: Extracts FOFs in (originally adjacent) pairs, triples, etc.\n");
+        fprintf(stdout,"INFO: 5)  NO FOF WINDOWING: Cosine shaping is normally applied to starts and ends of FOFs. Set this flag for NO windowing.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: IN MODE 1: OUTPUT IS A SPECIAL SOUNDFILE CONTAINING A BANK OF FOFS,\n");
+        fprintf(stdout,"INFO:            AND A TEXTFILE PROVIDING INFORMATION ABOUT THE 'FOFBANK'\n");
+        fprintf(stdout,"INFO:            THESE CAN BE USED WITH 'FOF reconstruct'\n");
+        fprintf(stdout,"INFO: IN MODE 3: OUTPUT IS A SET OF SOUNDFILES EACH CONTAINING A SINGLE (GROUP OF) FOF(S).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 2\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PITCH BREAKPOINT FILE, AS ABOVE\n");
+        fprintf(stdout,"INFO: 2)  TIME IN FILE AT WHICH TO EXTRACT FOF(GROUP).\n");
+        fprintf(stdout,"INFO: 3)  GROUPED FOFS: EXTRACT A GROUP OF N FOFs.\n");
+        fprintf(stdout,"INFO: 4)  NO FOF WINDOWING: AS ABOVE.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(FOFEX_CO):
+        fprintf(stdout,"INFO: USE A BANK OF FOFS EXTRACTED WITH 'FOF extract' TO SYNTHESIZE A NEW SOUND OVER A PITCHLINE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: INPUT FILE----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MUST BE A BANK OF FOFS DERIVED FROM A SOUND USING 'FOF extract'\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)   Use 1 FOF.\n");     
+        fprintf(stdout,"INFO: 2)   All FOFs superimposed to make output FOF.\n");
+        fprintf(stdout,"INFO: 3)   Low FOFs superimposed to make output FOF.\n");
+        fprintf(stdout,"INFO: 4)   Midrange FOFs superimposed to make output FOF.\n");
+        fprintf(stdout,"INFO: 5)   High FOFs superimposed to make output FOF.\n");
+        fprintf(stdout,"INFO: 6)   2 FOFs whose balance varies with pitch.\n");
+        fprintf(stdout,"INFO: 7)   3 FOFs whose balance varies with pitch and level.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  TEXTFILE DERIVED FROM 'FOF extract' WHEN YOU CREATED THE (INPUT) FOFBANK.\n");
+        fprintf(stdout,"INFO: 2)  PITCH BREAKPOINT FILE, POSSIBLY CONTAINING 'NO-SIGNAL' MARKERS AT SPECIFIC TIMES.\n");
+        fprintf(stdout,"INFO:          (But no NO-PITCH markers). Extract the pitch to a binary file, then do the conversion to text.\n");
+        fprintf(stdout,"INFO: 3)  LOUDNESS CONTOUR BREAKPOINT DATA, AS TEXT.\n");
+        fprintf(stdout,"INFO: 4)  OVERALL GAIN (FOFS may overlap one another).\n");
+        fprintf(stdout,"INFO: 5)  THE FOF(S) TO BE USED (their number in the FOFBANK file, counting from 1) - USE \"SOUND VIEW\"\n");
+        fprintf(stdout,"INFO: 6)  EQUALISE FOF LEVELS: Adjusts all FOFs to same level before synthesizing output.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(GREV_EXTEND):
+        fprintf(stdout,"INFO: LOCATE AND EXTEND 'GRAINS', USING ENVELOPE TROUGHS AND ZERO-CROSSING.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: This process locates elements of a sound by searching for troughs in the envelope.\n");
+        fprintf(stdout,"INFO: and extends the segment in a coherent way.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (MS) .... This determines the size of grains that might be found..\n");
+        fprintf(stdout,"INFO: DEPTH OF TROUGHS AS PROPORTION OF PEAK HEIGHT .... e.g. with value .5, troughs between peaks\n");
+        fprintf(stdout,"INFO:                    which do not fall to half the peak-height, are ignored\n");
+        fprintf(stdout,"INFO: EXTEND_BY_HOW_MUCH .... How much time to add to file, by extending specified grain area\n");
+        fprintf(stdout,"INFO: TIME_WHERE_GRAINS_START\n");
+        fprintf(stdout,"INFO: TIME_WHERE_GRAINS_END\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PEAKFIND):
+        fprintf(stdout,"INFO: LIST TIMES OF PEAKS IN A SOUNDFILE (ESPECIALLY FOR SPEECH).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Locates prominent peaks, separated by troughs, and save a list of their timings.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (MS) .... This determines the width of peaks that might be found..\n");
+        fprintf(stdout,"INFO: THRESHOLD .... any window falling entirely below this level is assumed to contain no peaks.\n");
+        fprintf(stdout,"INFO: Peaks must have a level greater than the  threshold, and be separated by signal lower than the threshold.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: If \"threshold\" is set to ZERO, program searches for threshold values appropriate to the local level,\n");
+        fprintf(stdout,"INFO: by finding the local maximum in %d windows around the immediate window\n",LOCALMAX_WINDOW);
+        fprintf(stdout,"INFO: and then divides this by a factor of %d\n",LOCALPEAK_DECIMATE);
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CONSTRICT):
+        fprintf(stdout,"INFO: SHRINK THE DURATION OF ANY ZERO-LEVEL SEGMENTS IN A SOUND, BY A GIVEN PERCENTAGE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Works only with sounds having segments of (completely) zero level.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PERCENTAGE DECIMATION .... Percentage of zero-level segments to delete\n");
+        fprintf(stdout,"INFO: Values greater than 100 cause the separated segments to be overlaid.\n");
+        fprintf(stdout,"INFO: e.g. 102 overlays very slightly, 200 overlays completely.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(EXPDECAY):
+        fprintf(stdout,"INFO: CURTAIL SOUND USING A TRUE EXPONENTIAL ENVELOPE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DECAY START TIME\n");
+        fprintf(stdout,"INFO: DECAY END TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PEAKCHOP):
+        fprintf(stdout,"INFO: ISOLATE PEAKS IN SOURCE, AND PLAY THEM BACK AT A SPECIFIED TEMPO.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  PLAY BACK PEAKS AT SPECIFIED TEMPO\n");
+        fprintf(stdout,"INFO: 2)  OUTPUT PEAK-ISOLATING ENVELOPE\n");
+        fprintf(stdout,"INFO: 3)  PLAY BACK PEAKS IN SPECIFIED RHYTHMIC CELLS AT SPECIFIED TEMPO\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RHYTHM CELL .... rhythm-cell speficied in integers = relative durations of rhythmic units.\n");
+        fprintf(stdout,"INFO:                                           Rhythmic units DIVIDE beat, so e.g. \"3 1 2\" becomes \"1/2 1/6 1/3\".\n");
+        fprintf(stdout,"INFO: WINDOW SIZE (MS) .... windowsize (in mS) for creating envelope.\n");
+        fprintf(stdout,"INFO: PEAK WIDTH (MS).... width of retained peaks (in mS).\n");
+        fprintf(stdout,"INFO: RISE TIME (MS).... time for signal to rise to (and fall from) the retained peaks.\n");
+        fprintf(stdout,"INFO: TEMPO .... tempo of resulting output as MM (events per minute).\n");
+        fprintf(stdout,"INFO: GAIN .... where tempo and peakwidth combine to make events overlap, may be necessary to reduce gain.\n");
+        fprintf(stdout,"INFO: TEMPO SCATTER ....randomisation of output times (0-1)\n");
+        fprintf(stdout,"INFO: GATE ....level (relative to maximum signal level) below which peaks are ignored (0-1)\n");
+        fprintf(stdout,"INFO: LEVELLING .... force peakevent levels towards level of maximum event.\n");
+        fprintf(stdout,"INFO: CENTRING ....centring of envelope on peak (0-1): 0 = at peak at envelope start; 1 = peak at envelope end.\n");
+        fprintf(stdout,"INFO: REPETITION .... repeat peakevents in the source.\n");
+        fprintf(stdout,"INFO: SKIP BY .... after using a peakevent, miss out the next 'skip by' peakevents.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MCHANPAN):
+        fprintf(stdout,"INFO: PAN A FILE OVER MORE THAN 2 OUTPUT CHANNELS.\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: MODE 1:  MOVE MONO SOUND AROUND A MULTICHANNEL SPACE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PANNING DATA .... is a file containing value triples : time  pan-position  pantype\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         PAN-POSITION vals lie between (channel) 1 and a max no-of-channels >= 3.\n");
+            fprintf(stdout,"INFO:         positions between 0 and 1 are also possible (see below).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         PANTYPE values can be\n");
+            fprintf(stdout,"INFO:         0  = direct pan: pan from 1 to 4 goes directly between lspkrs 1->4\n");
+            fprintf(stdout,"INFO:         1  = clockwise rotation: pan from 1 to 4 goes through intermediate lspkrs 1->2->3->4\n");
+            fprintf(stdout,"INFO:          (assuming lspks are arranged with numbering increasing in a clockwise direction).\n");
+            fprintf(stdout,"INFO:         -1 = anticlockwise rotation: pan from 1 to 4 (with 8 lspkrs) goes 1->8->7->6->5->4\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         Direct pans must start at a single loudspeaker, so position vals must be integers (and NOT 0).\n");
+            fprintf(stdout,"INFO:         Rotations can start and stop anywhere, so position values can be fractional,\n");
+            fprintf(stdout,"INFO:         and values between 0 & 1 are positions between maximum lspkr (e.g. 8) and lspkr 1\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE ..... This should not be less than the maximum channel number in the panning data.\n");
+            fprintf(stdout,"INFO:         but it can be greater.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FOCUS ......... Degree to which positioned sound is focused in the loudspeaker.\n");
+            fprintf(stdout,"INFO: If focus = 1.0, position set to (e.g.) '2' puts all the signal in lspkr 2.\n");
+            fprintf(stdout,"INFO: If focus = 0.9, position '2' puts 90%% of the signal in lspkr 2\n");
+            fprintf(stdout,"INFO: and the remainder in the 2 adjacent lspkrs (1 and 3).\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: MODE 2:  SWITCH (SILENCE-SEPARATED) MONO EVENTS IN SOUND BETWEEN SPECIFIED CHANNELS OF OUTPUT.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: OUT-CHANNEL SEQUENCE .... is a file containing a list of output channels.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         Each output channel in the list will be visited, in turn.\n");
+            fprintf(stdout,"INFO:         If the end of the list is reached, the sequence wraps back to the start of the list.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE ..... This should not be less than the maximum channel number in the switching data.\n");
+            fprintf(stdout,"INFO:         but it can be greater.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FOCUS ......... Degree to which positioned sound is focused in the loudspeaker.\n");
+            fprintf(stdout,"INFO: If focus = 1.0, position set to (e.g.) '2' puts all the signal in lspkr 2.\n");
+            fprintf(stdout,"INFO: If focus = 0.9, position '2' puts 90%% of the signal in lspkr 2\n");
+            fprintf(stdout,"INFO: and the remainder in the 2 adjacent lspkrs (1 and 3).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM DURATION OF SILENCES ..... minimum duration (mS) of consecutive zero-samples\n");
+            fprintf(stdout,"INFO:          to constitute a silent 'gap' between peak-events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: MODE 3:  SPREAD SUCCESSIVE (SILENCE-SEPARATED) MONO EVENTS ON DIFFERENT NUMBERS OF CHANNELS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Events are spread over specified output channels.\n");
+            fprintf(stdout,"INFO: If the centre, width or depth of the spread are changing in time,\n");
+            fprintf(stdout,"INFO: the placement of events changes only at the onset of a new event in the input.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CENTRE OF SPREAD ....... Channel from which spreading radiates.\n");
+            fprintf(stdout,"INFO: CHANNEL SPREAD ......... Total Number of channels over which spreading extends.\n");
+            fprintf(stdout,"INFO: DEPTH OF SPREAD FRONT .. Number of channels (on each side) activated behind spreading front.\n");
+            fprintf(stdout,"INFO: LEVEL ROLLOFF WITH ADDED CHANNELS .... Level compensation for addition of new output channels.\n");
+            fprintf(stdout,"INFO:                       0, No rolloff, all channels go up to full level as they are added.\n");
+            fprintf(stdout,"INFO:                       1, Full rolloff, level falls to 1/N for N channels of output.\n");
+            fprintf(stdout,"INFO:                       Intermediate values are possible.\n");
+            fprintf(stdout,"INFO: MINIMUM DURATION OF SILENCES ..... minimum duration (mS) of consecutive zero-samples\n");
+            fprintf(stdout,"INFO:          to constitute a silent 'gap' between peak-events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CENTRE, SPREAD and DEPTH can vary over time.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: MODE 4:  SPREAD SOUND GRADUALLY OVER DIFFERENT NUMBERS OF CHANNELS (MONO OR STEREO INPUT).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Events are spread over specified output channels.\n");
+            fprintf(stdout,"INFO: If the centre, width or depth of the spread are changing in time,\n");
+            fprintf(stdout,"INFO: the placement of events changes continuously.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CENTRE OF SPREAD ....... Channel from which spreading radiates (must be an integer).\n");
+            fprintf(stdout,"INFO: CHANNEL SPREAD ......... Total Number of channels over which spreading extends.\n");
+            fprintf(stdout,"INFO: DEPTH OF SPREAD FRONT .. Number of channels (on each side) activated behind spreading front.\n");
+            fprintf(stdout,"INFO: LEVEL ROLLOFF WITH ADDED CHANNELS .... Level compensation for addition of new output channels.\n");
+            fprintf(stdout,"INFO:                       0, No rolloff, all channels go up to full level as they are added.\n");
+            fprintf(stdout,"INFO:                       1, Full rolloff, level falls to 1/N for N channels of output.\n");
+            fprintf(stdout,"INFO:                       Intermediate values are possible.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CENTRE AND SPREAD can vary continuously over time.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(4):
+            fprintf(stdout,"INFO: MODE 5:  ANTIPHONALLY SWAP (SILENCE-SEPARATED) EVENTS IN SOUND BETWEEN TWO SETS OF OUTPUT-CHANNELS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Events are switched between one set of output channels and another.\n");
+            fprintf(stdout,"INFO: Event switching occurs only at the onset of a new event.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ANTIPHONAL CHANNEL SETS ..... two strings of letters, with separator ('-')\n");
+            fprintf(stdout,"INFO:          representing the 2 sets of output channels to alternate between.\n");
+            fprintf(stdout,"INFO:          e.g. abcd-efgh = antiphony between output channels 1,2,3,4 and output channels 5,6,7,8.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE ..... This should not be less than the maximum channel number in the antiphony data,\n");
+            fprintf(stdout,"INFO:         but it can be greater.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM DURATION OF SILENCES ..... minimum duration (mS) of consecutive zero-samples\n");
+            fprintf(stdout,"INFO:          to constitute a silent 'gap' between peak-events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(5):
+            fprintf(stdout,"INFO: MODE 6:  ANTIPHONALLY SWITCH BETWEEN TWO SETS OF OUTPUT-CHANNELS, USING 1 OR MORE SOUNDS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Sound output is switched between one set of output channels and another.\n");
+            fprintf(stdout,"INFO: Event switching occurs at specified times and, if several files are input, the next sound in the input list is used.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ANTIPHONAL CHANNEL SETS ..... two strings of letters, with separator ('-')\n");
+            fprintf(stdout,"INFO:          representing the 2 sets of output channels to alternate between.\n");
+            fprintf(stdout,"INFO:          e.g. abcd-efgh = antiphony between output channels 1,2,3,4 and output channels 5,6,7,8.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE ..... This should not be less than the maximum channel number in the antiphony data,\n");
+            fprintf(stdout,"INFO:         but it can be greater.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ANTIPHONY_TIMESTEP ..... Timestep before the output switches to the next set of output channels.\n");
+            fprintf(stdout,"INFO:                       Can vary through time.\n");
+            fprintf(stdout,"INFO: SILENT GAP BETWEEN ANTIPHONAL EVENTS ... Silence separating antiphonal events (if any).\n");
+            fprintf(stdout,"INFO:                       Can vary through time.\n");
+            fprintf(stdout,"INFO:                       Cannot be equal to or less than the minimum antiphony_timestep.\n");
+            fprintf(stdout,"INFO: SPLICELENGTH (mS) ...... Length of splices fading in and out the antiphonal events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM DURATION OF SILENCES ..... minimum duration (mS) of consecutive zero-samples\n");
+            fprintf(stdout,"INFO:          to constitute a silent 'gap' between peak-events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(6):
+            fprintf(stdout,"INFO: MODE 7:  PAN FROM ONE CHANNEL CONFIGURATION TO ANOTHER, PASSING \"THROUGH the CENTRE\".\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PANNING DATA .... is a file containing a list of lines, each having : time  pan-positions\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         TIME value must increase, from one entry to the next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         PAN-POSITIONS is a list of ALL the output channels in any order.\n");
+            fprintf(stdout,"INFO:         Input channels 1 to N are mapped, in order, to the channels in your list.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         On moving from one list to the next, every input channel spreads outwards until\n");
+            fprintf(stdout,"INFO:         it feeds every output channel, then gradually focuses into its next output-channel position.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:         To force all inputs to feed all outputs at the start of the sound, at the end of the sound,\n");
+            fprintf(stdout,"INFO:         or at any point during the sound, enter a map of zeros (one zero for every input channel)\n");
+            fprintf(stdout,"INFO:         at the starttime, and at the endtime, of the desired period.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: LEVEL ROLLOFF WITH ADDED CHANNELS .... Level compensation for addition of new output channels.\n");
+            fprintf(stdout,"INFO:                       0, No rolloff, all channels go up to full level as they are added.\n");
+            fprintf(stdout,"INFO:                       1, Full rolloff, level falls to 1/N for N channels of output.\n");
+            fprintf(stdout,"INFO:                       Intermediate values are possible.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(7):
+            fprintf(stdout,"INFO: MODE 8:  PAN A PROCESS ROUND A MULTICHANNEL FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The input multichannel sound remains where it is.\n");
+            fprintf(stdout,"INFO: The processing itself progresses around the output space in the manner you define.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CENTRE OF PROCESSING  ....... Channel where processing is located.\n");
+            fprintf(stdout,"INFO: CHANNEL SPREAD OF PROCESSING .....Total Number of channels over which processing spreads.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(8):
+            fprintf(stdout,"INFO: MODE 9:  ROTATE MONO SOUND AROUND MULTICHANNEL SPACE, SPECIFYING (POSSIBLY VARYING) SPEED.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE ..... This should not be less than the maximum channel number in the panning data.\n");
+            fprintf(stdout,"INFO:         but it can be greater.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: START CHANNEL ...... Channel in which sound starts out.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPEED (CYCLES PER SEC) ...... Speed of rotation.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FOCUS ......... Degree to which positioned sound is focused in the loudspeaker.\n");
+            fprintf(stdout,"INFO: If focus = 1.0, position set to (e.g.) '2' puts all the signal in lspkr 2.\n");
+            fprintf(stdout,"INFO: If focus = 0.9, position '2' puts 90%% of the signal in lspkr 2\n");
+            fprintf(stdout,"INFO: and the remainder in the 2 adjacent lspkrs (1 and 3).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ANTICLOCKWISE ...... Force rotation to be anticlockwise (default: clockwise).\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(9):
+            fprintf(stdout,"INFO: MODE 10:  SWITCH (SILENCE-SEPARATED) MONO EVENTS IN SOUND BETWEEN RANDOMLY PERMUTED CHANNELS OF OUTPUT.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS IN OUTPUT FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FOCUS ......... Degree to which positioned sound is focused in the loudspeaker.\n");
+            fprintf(stdout,"INFO: If focus = 1.0, position set to (e.g.) '2' puts all the signal in lspkr 2.\n");
+            fprintf(stdout,"INFO: If focus = 0.9, position '2' puts 90%% of the signal in lspkr 2\n");
+            fprintf(stdout,"INFO: and the remainder in the 2 adjacent lspkrs (1 and 3).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM DURATION OF SILENCES ..... minimum duration (mS) of consecutive zero-samples\n");
+            fprintf(stdout,"INFO:          to constitute a silent 'gap' between events in source-sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EVENT GROUP SIZE ......... number of events at any channel, before switching to next.\n");
+            fprintf(stdout,"INFO:          Can vary through time.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NO STEPS TO ADJACENT CHANNELS.......Reject moving to an adjacent output channel.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RANDOMLY VARY GROUP SIZE.......number of events at any channel, before switching to next,\n");
+            fprintf(stdout,"INFO:          can vary randomly from specified size down to just 1.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        }
+        break;
+    case(TEX_MCHAN):
+        fprintf(stdout,"INFO: TEXTURE MADE FROM ONE OR SEVERAL INPUT SOUND FILES, TO MANY OUTPUT CHANNELS\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: HARMONIC TYPES OF TEXTURE------------------------------------------------------\n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Textures are specified WITHIN A (possibly varying) RANGE OF PITCHES\n");
+        fprintf(stdout,"INFO: and within that range, the chosen pitches may be\n");
+        fprintf(stdout,"INFO: entirely RANDOM, on a HARMONIC SET (using pitches given),\n");
+        fprintf(stdout,"INFO: on a HARMONIC FIELD (uses 8va transpositions of pitches given),\n");
+        fprintf(stdout,"INFO: or on HARMONIC SETS, OR FIELDS, WHICH CHANGE THROUGH TIME.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: First note (only) of motifs are guaranteed to be on a harmonic set(field) note\n");
+        fprintf(stdout,"INFO: except in MOTIFS IN HF, where motifs notes are forced onto set (field) notes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: PARAMETERS FOR TEXTURE---------------------------------------------------------\n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (** starred items CANNOT VARY in time)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT DURATION...........**.(min) duration of outfile\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------- TIMING PARAMETERS -----------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: EVENT PACKING ...............(average) time between event onsets.\n");
+        fprintf(stdout,"INFO: SKIPTIME BETWEEN GROUP,MOTIF ONSETS..(average) time between group,motif onsets.\n");
+        fprintf(stdout,"INFO: EVENT SCATTER................randomisation of event, group or motif onsets.\n");
+        fprintf(stdout,"INFO: TIME GRID UNIT...............minstep(MS) quantised timegrid (for event starttimes)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------- SOUND PARAMETERS -----------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1ST SND-IN-LIST TO USE,LAST..1st,last snd to use,from listed input sounds.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------- LOUDNESS PARAMETERS -----------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MIN EVENT GAIN, MAX..........min & max level of input events\n");
+        fprintf(stdout,"INFO: MIN EVENT SUSTAIN, MAX.......min & max sustain-time of events.\n");
+        fprintf(stdout,"INFO: OVERALL ATTENUATION..........overall attenuation of the output\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------- PITCH PARAMETERS -----------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MIN PITCH, MAX...............min & max pitch(MIDI): (gives transposition of input)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------- SPATIAL PARAMETERS -----------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SPATIAL POSITION.............centre of output sound-image.\n");
+        fprintf(stdout,"INFO: SPATIAL SPREAD...............spatial-spread of texture events (0 to all-outchans).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: If spatial spread is set to ZERO ....\n");
+        fprintf(stdout,"INFO: With MONO sources, output is distributed randomly over all output channels\n");
+        fprintf(stdout,"INFO: with no events in positions BETWEEN output channels (all events IN single loudspeakers).\n");
+        fprintf(stdout,"INFO: With STEREO sources, each stereo event is assigned to a random pair of output channels,\n");
+        fprintf(stdout,"INFO: and these pairs are randomly permuted, so all channels used before any channel visited a 2nd time.\n");
+        fprintf(stdout,"INFO: With panning sources, this produces a set of random pan-motions using all channels equally.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------- OTHER PARAMETERS -----------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SEED.........................same seed-number: reproducible output (0: not so)\n");
+        fprintf(stdout,"INFO: PLAY ALL OF INSOUND..........always play whole input-sound (ignoring dur vals).\n");
+        fprintf(stdout,"INFO: PLAY FILES CYCLICALLY........play sounds in input order (always uses ALL input sounds).\n");
+        fprintf(stdout,"INFO: RANDOMLY PERMUTE EACH CYCLE..permute order of sounds, in each complete cycle.\n");
+        fprintf(stdout,"INFO: FIXED POSITIONS..............infiles set at fixed positions in output.\n");
+        fprintf(stdout,"INFO:          This option only functions if the output channel count > 2\n");
+        fprintf(stdout,"INFO:          and output positions are located on stereo-images formed by alternate lspkrs\n");
+        fprintf(stdout,"INFO:          (i.e. stereo 1-3, stereo 2-4, stereo 3-5 etc)\n");
+        fprintf(stdout,"INFO:          In this case, \"SPATIAL POSITION\" is read as an offset of the placement of output positions\n");
+        fprintf(stdout,"INFO:          With no offset, first sounds entered are on the channels 1-3 stereo image.\n");
+        fprintf(stdout,"INFO:          With offset of 1 first sounds entered are on the channels 2-4 stereo image, and so on\n");
+        fprintf(stdout,"INFO:          \"SPATIAL SPREAD\" is read as a randomisation of these positions\n");
+        fprintf(stdout,"INFO:          with a range 0 to 1 (entered values above 1 are truncated to 1).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: NOTEDATA IS A TEXTFILE CONTAINING-----------------------------------------------\n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: LINE 1: list of (possibly fictional) MIDI pitch of each input snd.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Then, where  harmonic sets or harmonic fields are required,\n");
+        fprintf(stdout,"INFO: each subsequent group of lines specifies a NOTELIST\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: NOTELISTS HAVE THE FOLLOWING FORMAT---------------------------------------------\n");
+        fprintf(stdout,"INFO: --------------------------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: first line:  #N\n");
+        fprintf(stdout,"INFO: other lines: time(SECS)     infile_no      pitch(MIDI)      amp(MIDI)     dur(SECS)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: where N = number of notes (and therefore lines) in notelist to follow,\n");
+        fprintf(stdout,"INFO: and times in notelist must never decrease.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (The amp(MIDI) and dur(SECS) params are now redundant, but need to be included).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MANYSIL):
+        fprintf(stdout,"INFO: INSERT SEVERAL SILENCES IN A SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SILENCE LOCATION & DURATION .....time/duration value pairs, being the times in the sound to insert the silences,\n");
+        fprintf(stdout,"INFO:                                 and the durations of the inserted silences..\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH .... length of splices, in mS.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(RETIME):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: MODE 1:  RETIME USER-IDENTIFIED PEAKS IN SOUND, PLACING THEM AT REGULAR BEATS AT SPECIFIED MM.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: LOCATIONS OF BEATS .....list of times of events corresponding to beats, in original sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: METRONOME MARK OR BEAT DURATION .... indicating required output tempo.\n");
+            fprintf(stdout,"INFO:        (Marked events in source will be placed at regular beats at this MM in output)\n");
+            fprintf(stdout,"INFO:        Values between 20 and 400 are interpreted as MM\n");
+            fprintf(stdout,"INFO:        Values below 1.0 are interpreted as beat duration\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: MODE 2:  RETIME EVENTS IN ANY SOUND, USING RETIMING DATA.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RETIMING DATA .....which consists of.\n");
+            fprintf(stdout,"INFO:      (a) MM of rhythm of accents in original sound.\n");
+            fprintf(stdout,"INFO:      (b) Time, in the outfile, of the first accented event.\n");
+            fprintf(stdout,"INFO:      (c) Two columns of (increasing) time-data. \n");
+            fprintf(stdout,"INFO:             (1) The true position of the attacks in the original sound.\n");
+            fprintf(stdout,"INFO:             (2) The ideal(ised) position of those attacks.\n");
+            fprintf(stdout,"INFO:                    NB time of first-accented event must equal a time in this 2nd list.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:      This Data can be generated AUTOMATICALLY from the 'rcode' property in a properties file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: METRONOME MARK OR BEAT DURATION .... indicating required OUTPUT tempo.\n");
+            fprintf(stdout,"INFO:       Values between 20 and 400 are interpreted as MM\n");
+            fprintf(stdout,"INFO:       Values below 1.0 are interpreted as beat duration\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PEAKWIDTH (mS) .... ..width to which peak events will be cut, in output.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPLICE LENGTH (mS) .... risetime to events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: MODE 3:  SHORTEN (SILENCE-SEPARATED) EVENTS IN A SOUND, USING PEAKWIDTH DATA.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: OUTPUT PEAKWIDTH .............. width (in mS) of peaks required in output sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: OUTPUT SPLICE LENGTH .... ...time (in mS) for splice cutoff of events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ORIGINAL SPLICE LENGTH .. time (in mS) of splices at end of events in original data.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: MODE 4:  RETIME (SILENCE-SEPARATED) EVENTS IN SOUND, PLACING THEM AT REGULAR BEATS AT SPECIFIED MM.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: METRONOME MARK OR BEAT DURATION .... indicating required output tempo.\n");
+            fprintf(stdout,"INFO:       (Marked events in source will be placed at regular beats at this MM in output)\n");
+            fprintf(stdout,"INFO:       Values between 20 and 400 are interpreted as MM\n");
+            fprintf(stdout,"INFO:       Values below 1.0 are interpreted as beat duration\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PREGAIN .... Gain applied to input\n");
+            fprintf(stdout,"INFO:       possibly set less than 1.0 where existing grains overlap in output.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(4):
+            fprintf(stdout,"INFO: MODE 5:  RETIME (SILENCE-SEPARATED) EVENTS IN SOUND, CHANGING THEIR TIMING BY A GIVEN FACTOR.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TEMPO-CHANGE FACTOR .... increases or decreases tempo of events.\n");
+            fprintf(stdout,"INFO:       Factor may vary over time.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TEMPO-CHANGE STARTS AFTER .... Events not moved before this time.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TEMPO-CHANGE ENDS BEFORE .... Events not moved after this time.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SYNCHRONISATION TIME .... .. Time of event in input which will sync with its copy in output.\n");
+            fprintf(stdout,"INFO:                    Time should be WITHIN the desired event. Zero implies sync at 1st event.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(5):
+            fprintf(stdout,"INFO: MODE 6:  REPOSITION (SILENCE-SEPARATED) EVENTS AT SPECIFIED BEATS, AT SPECIFIED TEMPO.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: BEAT LOCATIONS OF EVENTS .... positioning of output events, counted as beats.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: METRONOME MARK OR BEAT DURATION .... indicating required output tempo.\n");
+            fprintf(stdout,"INFO:       Values between 20 and 1000 are interpreted as MM\n");
+            fprintf(stdout,"INFO:       Values below 1.0 are interpreted as beat duration\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIME OF FIRST SOUNDING EVENT IN OUTPUT .... in seconds.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:       between peak events.\n");
+            fprintf(stdout,"INFO: PREGAIN .... Applied to output: may be necessary if retimed events overlap one another.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(6):
+            fprintf(stdout,"INFO: MODE 7:  REPOSITION (SILENCE-SEPARATED) EVENTS AT SPECIFIED TIMES.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIME LOCATIONS OF EVENTS .... positioning of output events, indicated in seconds.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIME OF FIRST SOUNDING EVENT IN OUTPUT .... in seconds.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:       between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PREGAIN .... Applied to output: may be necessary if retimed events overlap one another.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(7):
+            fprintf(stdout,"INFO: MODE 8:  REPEAT SPECIFIED (SILENCE-SEPARATED) EVENT, WITHIN SOUND, AT SPECIFIED TEMPO.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: METRONOME MARK OR BEAT DURATION .... indicating required output tempo.\n");
+            fprintf(stdout,"INFO:       Values between 20 and 1000 are interpreted as MM\n");
+            fprintf(stdout,"INFO:       Values below 1.0 are interpreted as beat duration\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EVENT LOCATION .... (rough) start-time in file of event to be repeated (must be INSIDE event).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: BEATS IN EVENT .... Number of beats (at specified tempo) within the event to repeat.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EVENT REPETITIONS .... How many times (1 or more) to repeat the event.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(8):
+            fprintf(stdout,"INFO: MODE 9:  MASK (REPLACE BY SILENCE) (SILENCE-SEPARATED) EVENTS, IN A SPECIFIED PATTERN OF 'DELETIONS'.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MASKING PATTERN......sequence of 0s (mask) and 1s (don't mask) describing masking pattern.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:       between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(9):
+            fprintf(stdout,"INFO: MODE 10: EQUALISE LEVELS, OR ACCENT, (SILENCE-SEPARATED) EVENTS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: DEGREE OF LEVEL EQUALISATION .... Range from 0 to 1.\n");
+            fprintf(stdout,"INFO:       1 Boosts level of all events to that of loudest. 0 has no effect.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ACCENT_GROUPING .... If set to ZERO, existing accentuation pattern retained,\n");
+            fprintf(stdout,"INFO:       and quieter events are boosted by \"equalisation\".\n");
+            fprintf(stdout,"INFO:       If set to (e.g.) 3, every 3rd events is accented,\n");
+            fprintf(stdout,"INFO:       (others are set at \"equalisation\" level.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PREGAIN .... Applied to output, only where accent-grouping > 0.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(10):
+            fprintf(stdout,"INFO: MODE 11: REPORT DURATION OF SHORTEST (AND LONGEST) (SILENCE-SEPARATED) EVENT.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM INTER-EVENT SILENCE (mS) .... minimum duration of any silence\n");
+            fprintf(stdout,"INFO:        between peak events.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(11):
+            fprintf(stdout,"INFO: MODE 12: LOCATE START OF SOUND (FIRST NON-ZERO SAMPLE) IN FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: OUTPUT TEXTFILE .... Data can be written to a new file, or to an existing file.\n");
+            fprintf(stdout,"INFO:       The outputfile must have a '.txt' extension, or NO extension.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:       The output data consists of the sound-start-time plus the name of the soundfile.\n");
+            fprintf(stdout,"INFO:       The same file can be used for successive calls to this process:\n");
+            fprintf(stdout,"INFO:       new data will be appended to the end of the file.\n");
+            fprintf(stdout,"INFO:       Hence this process can be applied as a BULK PROCESS on a list of input files.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(12):
+            fprintf(stdout,"INFO: MODE 13: MOVE ALL DATA IN FILE SO FILE PEAK FOUND MOVES TO SPECIFIED TIME.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NEW PEAK TIME ......... Time to which to move peak in file.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(13):
+            fprintf(stdout,"INFO: MODE 14: MOVE ALL DATA IN FILE SO FILE EVENT SPECIFIED MOVES TO SPECIFIED TIME.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NEW PEAK TIME ......... Time to which to move peak in file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ORIGINAL PEAK TIME .... Time of existing peak in file.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        }
+        break;
+    case(HOVER):
+        fprintf(stdout,"INFO: WANDER THROUGH FILE, ZIGZAG READING SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RATE OF HOVER (Hz) .... slow rate read lots of samples forwards, then backwards\n");
+        fprintf(stdout,"INFO:                         fast rate read fewer samples forwards, then backwards\n");
+        fprintf(stdout,"INFO: LOCATION OF HOVERING .. Time in input sound where samples are read.\n");
+        fprintf(stdout,"INFO: RANDOMISATION OF RATE (0-1)\n");
+        fprintf(stdout,"INFO: RANDOMISATION OF LOCATION (0-1)\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH (mS) .... Must by less then 2 divided by max \"rate\" used\n");
+        fprintf(stdout,"INFO: OUTPUT DURATION ....... Total Duration of output file.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MULTIMIX):
+        fprintf(stdout,"INFO: GENERATE MULTI-CHANNEL MIXFILES FROM A LIST OF SOUNDFILES.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  ALL FILES START AT TIME ZERO. OUTPUT CHANNEL COUNT IS MAX INPUT CHANNEL COUNT.\n");
+        fprintf(stdout,"INFO: (2)  EACH FILE STARTS WHERE PREVIOUS FILE ENDS. OUT CHANNEL CNT IS MAX INPUT CHANNEL CNT.\n");
+        fprintf(stdout,"INFO: (3)  EACH FILE STARTS AT A FIXED 'TIMESTEP' AFTER THE PREVIOUS ONE. OUT CHANNEL CNT IS MAX INPUT CHANNEL CNT.\n");
+        fprintf(stdout,"INFO: (4)  STEREO (or mono) SOUND DISTRIBUTED TO NARROW AND WIDE STEREO PAIRS (4 of 8).\n");
+        fprintf(stdout,"INFO: (5)  STEREO (or mono) SOUND DISTRIBUTED OVER AN 8-CHANNEL (PAIR-AT FRONT) SYSTEM.\n");
+        fprintf(stdout,"INFO:          in modes 4 and 5, mono is treated as stereo with same signal in each channel.\n");
+        fprintf(stdout,"INFO: (6)  N MONO SOUNDS SENT, IN ORDER, TO N SEPARATE OUTPUT CHANNELS.\n");
+        fprintf(stdout,"INFO: (7)  MONO SOUNDS SENT, IN ORDER, TO SEPARATE OUTPUT CHANNELS.\n");
+        fprintf(stdout,"INFO:              wrapping back to initial position, if more input files than output channels.\n");
+        fprintf(stdout,"INFO: (8)  ALL FILES START AT TIME ZERO. OUTPUT CHANNEL COUNT SPECIFIED BY PARAMETER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIME STEP BETWEEN ENTRIES ..... (Mode 3).\n");
+        fprintf(stdout,"INFO: RELATIVE LEVEL OF OUTER PAIR .. (Mode 4) Assuming inner pair is at level 1, this is outer pair level.\n");
+        fprintf(stdout,"INFO:                                                           All levels are adjusted to avoid distortion.\n");
+        fprintf(stdout,"INFO: FRONT PAIR LEVEL ........ (Mode 5) Level of stereo signal on front pair of loudspeakers.\n");
+        fprintf(stdout,"INFO: FRONT WIDE PAIR LEVEL ... (Mode 5) Level of stereo signal on front pair of loudspeakers.\n");
+        fprintf(stdout,"INFO: REAR WIDE PAIR LEVEL .... (Mode 5) Level of stereo signal on front pair of loudspeakers.\n");
+        fprintf(stdout,"INFO: REAR PAIR LEVEL ......... (Mode 5) Level of stereo signal on front pair of loudspeakers.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 7:\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT .....No of channels in output file.\n");
+        fprintf(stdout,"INFO: START CHANNEL ........... Output channel to which first input file is sent.\n");
+        fprintf(stdout,"INFO: CHANNEL SKIP ............ Step between output-channel assignment.\n");
+        fprintf(stdout,"INFO:                      SKIP 1    assign to successive channels.\n");
+        fprintf(stdout,"INFO:                      SKIP 2    assign to alternate channels.\n");
+        fprintf(stdout,"INFO:                      SKIP -1   assign to successive channels, counting downwards.\n");
+        fprintf(stdout,"INFO: TIMESTEP ................ Timestep between successive entries in mixfile.\n");
+        break;
+    case(FRAME):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: MODE 1: ROTATE ENTIRE SPATIAL FRAME OF A MULTICHANNEL SOUNDFILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SNAKING SEQUENCE ...... \n");
+            fprintf(stdout,"INFO:       In a clockwise frame rotation, an input channel proceeds on a path around all the lspkrs,\n");
+            fprintf(stdout,"INFO:       e.g. in an 8-chan file, input-chan 1 follows the path 1- 2->3->4->5->6->7->8->1 etc\n");
+            fprintf(stdout,"INFO:       and the other input channels follow it in a \"snake\".\n");
+            fprintf(stdout,"INFO:       This ROTATION-snake is the DEFAULT motion, and you should enter\n");
+            fprintf(stdout,"INFO:       a ZERO for the snaking sequence, to generate a rotation.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:       However, the channels might snake around the lspkrs on a different route\n");
+            fprintf(stdout,"INFO:       e.g. (for an 8-channel file) \"1 3 5 4 6 8 7 2\"\n");
+            fprintf(stdout,"INFO:       and these routes could vary over time.\n");
+            fprintf(stdout,"INFO:       You can specify such alternative routes in a text datafile of \"time : route\" values\n");
+            fprintf(stdout,"INFO:       A line in the datafile for the above route, starting at time zero, would be\n");
+            fprintf(stdout,"INFO:       \"0.0 1 3 5 4 6 8 7 2\"\n");
+            fprintf(stdout,"INFO:       A changed route could be specified at a later time, on the next line\n");
+            fprintf(stdout,"INFO:       e.g. \"1.3327 1 4 6 3 8 5 7 2\"\n");
+            fprintf(stdout,"INFO:       In the datafile, the first time used must be zero, and times must increase.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ROTATION SPEED ........\n");
+            fprintf(stdout,"INFO:       The speed of frame-rotation, in complete-rotations per second. This can vary over time.\n");
+            fprintf(stdout,"INFO:       Positive values give clockwise rotation; negative values, anticlockwise.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SMEAR ........\n");
+            fprintf(stdout,"INFO:       Extent to which signal in any OUTPUT channel bleeds onto its 2 adjacent channels.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: MODE 2: ROTATE ENTIRE SPATIAL FRAME OF SOUNDFILE, ROTATING ODD AND EVEN CHANNELS INDEPENDENTLY.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SNAKING SEQUENCE ...... \n");
+            fprintf(stdout,"INFO:       In a clockwise frame rotation here,\n");
+            fprintf(stdout,"INFO:       an ODD input channel proceeds on a path around all ODD outchannels,\n");
+            fprintf(stdout,"INFO:       e.g. in an 8-chan file, input-chan 1 follows the path 1->3->5->7->1 etc\n");
+            fprintf(stdout,"INFO:       and the other ODD input channels follow it in a \"snake\" around the ODD outchannels,\n");
+            fprintf(stdout,"INFO:       while an EVEN input channel proceeds on a path around all EVEN outchannels,\n");
+            fprintf(stdout,"INFO:       e.g. in an 8-chan file, input-chan 2 follows the path 2->4->6->8->2 etc\n");
+            fprintf(stdout,"INFO:       and the other EVEN input channels follow it in a \"snake\" around the EVEN outchannels.\n");
+            fprintf(stdout,"INFO:       This ROTATION-snake is the DEFAULT motion, and you should enter\n");
+            fprintf(stdout,"INFO:       a ZERO for the snaking sequence, to generate a double rotation.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:       but you can redefine the snaking sequences with a datafile\n");
+            fprintf(stdout,"INFO:       e.g.  the snake \"8 6 5 2 7 3 4 1\" produces one snake around the odd entries\n");
+            fprintf(stdout,"INFO:       i.e. 8 -> 5 -> 7 -> 4 -> 8 etc\n");
+            fprintf(stdout,"INFO:       and a 2nd snake around the even entries\n");
+            fprintf(stdout,"INFO:       i.e. 6 -> 2 -> 3 -> 1 -> 6 etc\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: 1ST ROTATION SPEED ........\n");
+            fprintf(stdout,"INFO:       The speed of frame-rotation for the ODD input channels, in complete-rotations per second. This can vary over time.\n");
+            fprintf(stdout,"INFO:       Positive values give clockwise rotation; negative values, anticlockwise.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: 2ND ROTATION SPEED ........\n");
+            fprintf(stdout,"INFO:       The speed of frame-rotation for the EVEN input channels, in complete-rotations per second. This can vary over time.\n");
+            fprintf(stdout,"INFO:       Positive values give clockwise rotation; negative values, anticlockwise.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SMEAR ........\n");
+            fprintf(stdout,"INFO:       Extent to which signal in any OUTPUT channel bleeds onto its 2 adjacent channels.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: MODE 3:  REORIENTATE THE CHANNELS OF THE INPUT FILE TO (FIXED) NEW POSITIONS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: REORIENTATION ..... a list of ALL the output channels, in some order.\n");
+            fprintf(stdout,"INFO:        Each successive input channel will be sent to the next output channel in the list.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:        For example, the list \"2 4 6 8 1 3 5 7\"  will cause the input channels to be routed\n");
+            fprintf(stdout,"INFO:        1 to 2 : 2 to 4 : 3 to 6 : 4 to 8 : 5 to 1 : 6 to 3 : 7 to 5 : 8 to 7\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: MODE 4:  MIRROR the FRAME OF THE INPUT FILE ABOUT A SPECIFIED AXIS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIRROR PLANE .... Channel number, or Channel-number + 0.5.\n");
+            fprintf(stdout,"INFO:       The output channels are symmetrically mirrored about the channel given \n");
+            fprintf(stdout,"INFO:       or around the midpoint between channels (1.5 is midpoint between 1 and 2).\n");
+            fprintf(stdout,"INFO:       With an N-channel file, N.5 is midpoint between channels N and 1.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(4):
+            fprintf(stdout,"INFO: MODE 5:  RENUMBER the OUTPUT CHANNELS, FROM A RING TO A BILATERAL SCHEMA (OR VICE VERSA).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TO RING FORMAT ....\n");
+            fprintf(stdout,"INFO:       WITHOUT this flag, converts from ring schema to bilateral schema.\n");
+            fprintf(stdout,"INFO:       WITH this flag, converts from bilateral schema to ring schema.\n");;
+            fprintf(stdout,"INFO:               Ring         Bilateral                  Ring               Bilateral\n");
+            fprintf(stdout,"INFO:                 1                 1                          1                      1\n");
+            fprintf(stdout,"INFO:               8   2            2   3                     5   2                 2   3\n");
+            fprintf(stdout,"INFO:              7     3          4     5                     4 3                   4 5\n");
+            fprintf(stdout,"INFO:               6   4            6   7\n");
+            fprintf(stdout,"INFO:                 5                 8\n");
+            fprintf(stdout,"INFO: All multichannel processes assume RING format. If using a bilateral numbering schema\n");
+            fprintf(stdout,"INFO: convert from and to Bilateral format, before and after processing data.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(5):
+            fprintf(stdout,"INFO: MODE 6:  SWAP ANY 2 CHANNEL OF A MLTICHANNEL FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNEL TO SWAP .... The channel to exchange.\n");
+            fprintf(stdout,"INFO: CHANNEL TO SWAP WITH .... The channel to exchange it with.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(6):
+            fprintf(stdout,"INFO: MODE 7:  ADJUST LEVEL IN (OR ENVELOPE) ONLY SPECIFIED CHANNELS OF A MULTICHANNEL FILE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CHANNELS TO MODIFY ....... Either a channel number, or a text file list of channel numbers.\n");
+            fprintf(stdout,"INFO:            Only these channels are modified by the process.\n");
+            fprintf(stdout,"INFO: GAIN OR ENVELOPE ....... The gain, or the time-varying gain in the envelope file\n");
+            fprintf(stdout,"INFO:            to apply to the specified channels.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(7):
+            fprintf(stdout,"INFO: MODE 8:  RENUMBER the OUTPUT CHANNELS, FROM A RING TO BEAST BILATERAL SCHEMA (OR VICE VERSA).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TO RING FORMAT ....\n");
+            fprintf(stdout,"INFO:       WITHOUT this flag, converts from ring schema to BEAST bilateral schema.\n");
+            fprintf(stdout,"INFO:       WITH this flag, converts from BEAST bilateral schema to ring schema.\n");;
+            fprintf(stdout,"INFO:               Ring         Bilateral                  Ring               Bilateral\n");
+            fprintf(stdout,"INFO:                 1                 7                          1                      5\n");
+            fprintf(stdout,"INFO:               8   2            1   2                     5   2                 1   2\n");
+            fprintf(stdout,"INFO:              7     3          3     4                     4 3                   3 4\n");
+            fprintf(stdout,"INFO:               6   4            5   6\n");
+            fprintf(stdout,"INFO:                 5                 8\n");
+            fprintf(stdout,"INFO: All multichannel processes assume RING format. If using a bilateral numbering schema\n");
+            fprintf(stdout,"INFO: convert from and to Bilateral format, before and after processing data.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: \"BEAST\" = Birmingham Electro-Acoustic Sound Theatre sound-diffusion system.\n");
+            break;
+        }
+        break;
+    case(SEARCH):
+        fprintf(stdout,"INFO: FIND THE FIRST REAL SIGNAL IN FILE(S) WHICH START(S) WITH SILENCE.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MCHANREV):
+        fprintf(stdout,"INFO: CREATE MULTICHANNEL ECHO OR REVERBERATION AROUND A SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: INPUT GAIN................Attenuates signal input to stadium.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: LEVEL LOSS WITH DISTANCE..across stadium.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: STADIUM SIZE MULTIPLIER...Multiplies average time between echoes.\n");
+        fprintf(stdout,"INFO: ..........................(Default average echo time = 0.1 secs).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF ECHOS...........Number of stadium echoes produced.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF OUTPUT CHANNELS....Number of channels in output sound.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CENTRE OF SOUND IMAGE........Centre of sound image amongst output channels.\n");
+        fprintf(stdout,"INFO:                      Values from 0, to the total number of output channels.\n");
+        fprintf(stdout,"INFO:                      Values can be fractional. Values below 1, lie between Channel N and channel 1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SPREAD_OF_ECHOS/REVERB.......Spread of echoes/reverb across output channels.\n");
+        fprintf(stdout,"INFO:                      values from 2, to the total number of output channels.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(WRAPPAGE):
+        fprintf(stdout,"INFO: GRANULAR RECONSTITUTION OF ONE OR MORE SOUNDFILES, MOVING AROUND A MULTICHANNEL SPACE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CENTRE OF SPREAD  ............ Channel from which sound radiates.Any number between 0 & last output channel.\n");
+        fprintf(stdout,"INFO:             Values less than 1, represent locations between the last outchan and the 1st.\n");
+        fprintf(stdout,"INFO:             The centre can be moved by supplying a datafile of triples: \"Time   Centre   Direction\"\n");
+        fprintf(stdout,"INFO:             Direction, either 1 (clockwise) or -1 (anticlockwise), is direction of motion from PREVIOUS value.\n");
+        fprintf(stdout,"INFO: OUTPUT CHANNELS ............. Number of channels of MULTICHANNEL OUTPUT (>2).\n");
+        fprintf(stdout,"INFO: CHANNEL SPREAD ............... Total Number of channels over which sound image extends.\n");
+        fprintf(stdout,"INFO: DEPTH OF SPREAD FRONT ..... Number of channels (on each side) activated behind spreading front.\n");
+        fprintf(stdout,"INFO: TIMESHRINK...... ................Speed of advance in infiles, relative to outfile. (>=0)\n");
+        fprintf(stdout,"INFO:              Inverse of timestretch, (& permits infinite timestretch).\n");
+        fprintf(stdout,"INFO: DENSITY...........................Amount of grain overlap (>0 : <1 leaves intergrain silence)\n");
+        fprintf(stdout,"INFO:              Extremely small values will cease to perform predictably.\n");
+        fprintf(stdout,"INFO: GRAINSIZE........................grainsize in MS (must be > 2 * splicelen)\n");
+        fprintf(stdout,"INFO: PITCHSHIFT.......... ............is pitchshift of grains in +|- (fractions of) semitones.\n");
+        fprintf(stdout,"INFO: LOUDNESS RANGE................is range of gain on grains.\n");
+        fprintf(stdout,"INFO:              Use only if amp is to vary (over range &/or through time)\n");
+        fprintf(stdout,"INFO: STARTSPLICE.....................length of startsplices on grains,in MS.\n");
+        fprintf(stdout,"INFO: ENDSPLICE........................length of endsplices on grains,in MS.\n");
+        fprintf(stdout,"INFO: SEARCHRANGE...................for nextgrain, before current 'now' in infile (Default 0 MS).\n");
+        fprintf(stdout,"INFO: SCATTER..........................Randomisation of grain position (Range 0-1).\n");
+        fprintf(stdout,"INFO: OUTPUT LENGTH.................max outfile length (if end of data not reached).\n");
+        fprintf(stdout,"INFO:              Set to zero (Default) for this parameter to be ignored.\n");
+        fprintf(stdout,"INFO:              BUT if TIMESHRINK is ANYWHERE 0: OUTLENGTH must be given.\n");
+        fprintf(stdout,"INFO: EXPONENTIAL SPLICES.........Default, Linear.\n");
+        fprintf(stdout,"INFO: RELATIVE TO OUTPUT TIME..Timeshrink parameters are ALWAYS read relative to time in INPUT file.\n");
+        fprintf(stdout,"INFO:              All other parameters are normally also read relative to time in input file.\n");
+        fprintf(stdout,"INFO:              Set this flag to force those parameters to be read relative to time in OUTPUT file.\n");
+        fprintf(stdout,"INFO: TIMESHRINK LIMIT,DENSITY LIMIT ETC.......allow range of values to be specified\n");
+        fprintf(stdout,"INFO:              for any of these params. e.g. With Density & Density Limit set\n");
+        fprintf(stdout,"INFO:              a random density is generated between these values,\n");
+        fprintf(stdout,"INFO:              while Density & Density Limit can THEMSELVES vary through time.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MCHSTEREO):
+        fprintf(stdout,"INFO: INSERT STEREO FILES INTO A MULTICHANNEL OUTPUT SPACE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: This process allows, for example, stereo outputs from processing the individual channels\n");
+        fprintf(stdout,"INFO: of a multichannel file (e.g. reverberation) to be remixed into the multichannel context,\n");
+        fprintf(stdout,"INFO: at the sample location as their original mono sources.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PREGAIN.......gain applied to stereo inputs before they are mixed to the output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUT CHANNEL ON WHICH STEREO INPUT CENTRED.......either a channel number,\n");
+        fprintf(stdout,"INFO:              or a textfile of channel numbers, one for each stereo inputfile.\n");
+        fprintf(stdout,"INFO:              Each stereo input image will be centred (in turn) at the output positions given,\n");
+        fprintf(stdout,"INFO:              BUT ...\n");
+        fprintf(stdout,"INFO: CENTRE BETWEEN OUTCHANS .... if this flag is set, the output stereo-images are centred\n");
+        fprintf(stdout,"INFO:              to the right of the specified output centre, between the 2 output channels.\n");
+        fprintf(stdout,"INFO:              e.g. Stereo signal sent to output 2, will be centred between output channels 2 & 3.\n");
+        break;
+    case(MTON):
+        fprintf(stdout,"INFO: CONVERT MONO SOURCE TO MULTICHANNEL SOUND, WITH IDENTICAL DATA IN EVERY CHANNEL.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT.......Number of (identical) channels in the output file.\n");
+        break;
+    case(FLUTTER):
+        fprintf(stdout,"INFO: IMPOSE MULTICHANNEL-DISPERSED LOUDNESS FLUTTERING ON A MULTICHANNEL FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CHANNEL SET SEQUENCE ..... The change in loudness occurs first in one set of output channels,\n");
+        fprintf(stdout,"INFO:               then in another, as the fluttering proceeds.\n");
+        fprintf(stdout,"INFO:               Each line contains a list of 1 or more of the output channels\n");
+        fprintf(stdout,"INFO:               forming a 'channel set' which will flutter.\n");
+        fprintf(stdout,"INFO:               The flutter passes from the channels in one set, to the channels in the next,\n");
+        fprintf(stdout,"INFO:               on every pulse of the fluttering. When all the defined channels sets are used up,\n");
+        fprintf(stdout,"INFO:               The sequence begins again at the start (BUT see the 'randomisation' flag, below),\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FLUTTER FREQUENCY (Hz) ...Frequency of loudness fluctuations. May vary over time.\n");
+        fprintf(stdout,"INFO: FLUTTER DEPTH ................... Depth of loudness fluctuations. May vary over time.\n");
+        fprintf(stdout,"INFO:               Depth between 0 and 1 determines the trough level of the flutter cycle.\n");
+        fprintf(stdout,"INFO:               Depth above 1, makes flutter peaks narrower (troughing still at zero).\n");
+        fprintf(stdout,"INFO: GAIN ...................................... Overall gain on the output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANDOMISE CHANNEL-SETS ORDER .... With this flag set, once all channel-sets have been used\n");
+        fprintf(stdout,"INFO:               they are randomly permuted into a different order before the next flutter,\n");
+        fprintf(stdout,"INFO:               and when all sets, in this new order, have been used, they are permuted again\n");
+        fprintf(stdout,"INFO:               and so on. (The sets themselves are not changed by this process).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ABFPAN):
+        fprintf(stdout,"INFO: APPLY FIXED OR ORBITING 1st ORDER B_FORMAT PAN TO A MONO INPUT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: START POSITION ..... 0 is front centre, with values increasing clockwise\n");
+        fprintf(stdout,"INFO:               until we reach centre again at 1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: END POSITION ....... \"N.M\" means \"N\" complete orbits, finishing at position \"M\".\n");
+        fprintf(stdout,"INFO:               positive values give clockwise orbits, negative values anticlockwise orbits.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF B FORMAT OUTPUT CHANNELS .... Either 3 or (default) 4.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT AS STANDARD WAV: AMBISONIC.\n");
+        fprintf(stdout,"INFO: OUTPUT AS STANDARD WAV  ........ (NB You cannot set both of these flags)\n");
+        fprintf(stdout,"INFO:               The default output is a WAVEX B-FORMAT Ambisonic File.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ABFPAN2):
+        fprintf(stdout,"INFO: APPLY FIXED OR ORBITING 2nd ORDER B_FORMAT PAN TO A MONO INPUT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: START POSITION ..... 0 is front centre, with values increasing clockwise\n");
+        fprintf(stdout,"INFO:               until we reach centre again at 1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: END POSITION ....... \"N.M\" means \"N\" complete orbits, finishing at position \"M\".\n");
+        fprintf(stdout,"INFO:               positive values give clockwise orbits, negative values anticlockwise orbits.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PREGAIN .... ... Change the input file amplitude.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: STANDARD WAV (AMBISONIC) OUTPUT ...... default is WAVEX B-FORMAT.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ABFPAN2P):
+        fprintf(stdout,"INFO: APPLY FIXED OR ORBITING 2nd ORDER B_FORMAT PAN TO A MONO INPUT, IN 3-DIMENSIONS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: START POSITION ..... 0 is front centre, with values increasing clockwise\n");
+        fprintf(stdout,"INFO:               until we reach centre again at 1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: END POSITION ....... \"N.M\" means \"N\" complete orbits, finishing at position \"M\".\n");
+        fprintf(stdout,"INFO:               positive values give clockwise orbits, negative values anticlockwise orbits.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PREGAIN .... ... Change the input file amplitude.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: HEIGHT.......... 90 is directly above, -90 directly below.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: STANDARD WAV (AMBISONIC) OUTPUT ...... default is WAVEX B-FORMAT.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CHANNELX):
+        fprintf(stdout,"INFO: EXTRACT CHANNELS FROM A MULTICHANNEL FILE OF ANY FORMAT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: INPUT CHANNELS TO EXTRACT.......... Textfile with a list of input channels to extract.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CHORDER):
+        fprintf(stdout,"INFO: REORDER CHANNELS INSIDE A MULTICHANNEL FILE OF ANY FORMAT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: REORDERING STRING.......... String consisting of (lower-case) letters, with or without zeros.\n");
+        fprintf(stdout,"INFO:               The string cannot contain more than 26 items.\n");
+        fprintf(stdout,"INFO:               For example, for a 4-channel input file, the channels are represented by \"a\",\"b\",\"c\" and \"d\".\n");
+        fprintf(stdout,"INFO:               \"0\" represents a (possible) silent output channel.\n");
+        fprintf(stdout,"INFO:               Ordering strings for this 4-channel file could be.....\n");
+        fprintf(stdout,"INFO:               \"abcd\" same order as the input (input file not altered).\n");
+        fprintf(stdout,"INFO:               \"dcba\" reversed channel-order of the input.\n");
+        fprintf(stdout,"INFO:               \"a00b\" input channel 1 to out-channel 1, input channel 2 to out-channel 4, with 2 silent channels.\n");
+        fprintf(stdout,"INFO:               \"aababc00ddd\" etc (note that channels can be duplicated in the output).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:               For an 8-channel input file, channels are represented by \"a\",\"b\",\"c\",\"d\",\"e\",\"f\",\"g\" and \"h\".\n");
+        fprintf(stdout,"INFO:               and so on.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FORCE A .amb FILENAME EXTENSION (CARE!!)\n");
+        fprintf(stdout,"INFO:               specifying a \".amb\" file extension does NOT automatically produce an ambisonic output file.\n");
+        fprintf(stdout,"INFO:               This can only be guaranteed by the internal structure of the data.\n");
+        fprintf(stdout,"INFO:               Forcing a \".amb\" extension onto non-ambisonic data may cause confusion at a later data!\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: This program permits low level manipulation of the data format of files.\n");
+        fprintf(stdout,"INFO: With ambisonic or other non-trivial data structures, it should be used WITH CAUTION!!\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(FMDCODE):
+        fprintf(stdout,"INFO: PLAIN MULTI-LAYOUT DECODER FOR AMBISONIC FILES.\n");
+        fprintf(stdout,"INFO: (No shelf filter or NF compensation used).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT LAYOUT.......... This can take one of the following values.\n");
+        fprintf(stdout,"INFO:               1  : *   Mono (= W signal only).\n");
+        fprintf(stdout,"INFO:               2  : *   Stereo (quasi mid/side, = W +- Y) \n");
+        fprintf(stdout,"INFO:               3  :     Square (FL  FR  RR  RL  order)\n");
+        fprintf(stdout,"INFO:               4  : *   Quad   (FL  FR  RL  RR  order)\n");
+        fprintf(stdout,"INFO:               5  :     Pentagon  \n");
+        fprintf(stdout,"INFO:               6  : *   5.0  (WAVEX order)\n");
+        fprintf(stdout,"INFO:               7  : *   5.1  (WAVEX order : silent LFE)\n");
+        fprintf(stdout,"INFO:               8  :     hexagon  \n");
+        fprintf(stdout,"INFO:               9  :     octagon 1 (pair at front)\n");
+        fprintf(stdout,"INFO:               10 :    octagon 2  (single lspkr at front centre)\n");
+        fprintf(stdout,"INFO:               11 :    cube  (as 3 : low/high interleaved)\n");
+        fprintf(stdout,"INFO:               12 : *  cube  (as 4 : low quad followed by high quad)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WRITE WAVEX LSPKR POSITIONS TO HEADER ....... NB only applies to \"*\" layouts above.\n");
+        fprintf(stdout,"INFO: PLAIN WAV OUTFILE FORMAT ...... Default is generic wavex format.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CHXFORMAT):
+        fprintf(stdout,"INFO: SET OR CHANGE THE LOUDSPEAKER POSITION MASK IN A WAVEX FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \nLSPKR_POSITION_MASK ....... Indicates the loudspeaker positions for sound output.");
+        fprintf(stdout,"INFO:               0 : Unsets the loudspeaker mask.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CHXFORMATG):
+        fprintf(stdout,"INFO: CHANGE GUID TYPE FROM WAVEX TO AMBISONIC, UNSETTING THE LSPKR POSITION MASK.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CHXFORMATM):
+        fprintf(stdout,"INFO: SET THE POSSIBLE LOUDSPEAKER POSITION MASK VALUES FOR A WAVEX FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(INTERLX):
+        fprintf(stdout,"INFO: INTERELAVE LIST OF MONO OR STEREO SOUNDS (IN A TEXTFILE) TO A MULTICHANNEL OUTPUT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL FORMAT  ....... Indicates the output soundfile format.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:               0 : Standard (wav, aiff etc.) format.\n");
+        fprintf(stdout,"INFO:               1 : generic WAV_EX (no loudspeaker assignments).\n");
+        fprintf(stdout,"INFO:               2 : WAV_EX mono/stereo/quad (FL  FR  RL  RR). 1,2 or 4 input channels needed.\n");
+        fprintf(stdout,"INFO:               3 : WAV_EX quad surround (L, C, R, S). Four input channels needed.\n");
+        fprintf(stdout,"INFO:               4 : WAV_EX 5.1 format surround. Six input channels needed.\n");
+        fprintf(stdout,"INFO:               5 : WAV_EX Ambisonic B-Format (W,X,Y,Z....). 3,4,5,6,7,8,9,11 or 16 input chans needed.\n");
+        fprintf(stdout,"INFO:               6 : WAV_EX 5.0 surround. Five input channels needed.\n");
+        fprintf(stdout,"INFO:               7 : WAV_EX 7.1 surround. Eight input channels needed.\n");
+        fprintf(stdout,"INFO:               8 : WAV_EX Cube surround. Eight input channels needed.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Input files must match in sample rate, and number of channels, but can have different sample types.\n");
+        fprintf(stdout,"INFO: If Input files are WAVEX, any loudspeaker position information is ignored.\n");
+        fprintf(stdout,"INFO: The same input file can be listed several times, if required to send to several output channels.\n");
+        break;
+    case(COPYSFX):
+        fprintf(stdout,"INFO: COPY SOUNDFILE, CHANGING THE FORMAT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SAMPLE TYPE  ....... Indicates the output sample type.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:               0 : Retain sample type of input file.\n");
+        fprintf(stdout,"INFO:               1 : 16 bit integer (short).\n");
+        fprintf(stdout,"INFO:               2 : 32 bit integer (long).\n");
+        fprintf(stdout,"INFO:               3 : 32 bit floating-point.\n");
+        fprintf(stdout,"INFO:               4 : 24 bit integer (packed).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTFILE FORMAT  ....... Indicates the output soundfile format.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:               -1 : Retain format of input file.\n");
+        fprintf(stdout,"INFO:               0 : Standard wav format.\n");
+        fprintf(stdout,"INFO:               1 : generic WAV_EX (no loudspeaker assignments).\n");
+        fprintf(stdout,"INFO:               2 : WAV_EX mono/stereo/quad (FL  FR  RL  RR). 1,2 or 4 input channels needed.\n");
+        fprintf(stdout,"INFO:               3 : WAV_EX quad surround (L, C, R, S). Four input channels needed.\n");
+        fprintf(stdout,"INFO:               4 : WAV_EX 5.1 format surround. Six input channels needed.\n");
+        fprintf(stdout,"INFO:               5 : WAV_EX Ambisonic B-Format (W,X,Y,Z....). 3,4,5,6,7,8,9,11 or 16 input chans needed.\n");
+        fprintf(stdout,"INFO:               6 : WAV_EX 5.0 surround. Five input channels needed.\n");
+        fprintf(stdout,"INFO:               7 : WAV_EX 7.1 surround. Eight input channels needed.\n");
+        fprintf(stdout,"INFO:               8 : WAV_EX Cube surround. Eight input channels needed.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ADD TDPF DITHER TO 16 BIT OUTFILE .... improving quality of low level signals.\n");
+        fprintf(stdout,"INFO: WRITE MINIMAL HEADER (NO PEAKDATA) ... header gets no information about peaks in the output file.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(NJOINCH):
+        fprintf(stdout,"INFO: CHECK COMPATIBLITY OF FILES FOR CONCATENATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CD COMPATIBLE FILES ONLY .... All files must have sample-rate 44100\n");
+        fprintf(stdout,"INFO:               and must be at least 4 seconds in duration. \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: All files must match in sample-rate and number of channels,\n");
+        fprintf(stdout,"INFO: but may have different sample types (e.g. 16-bit, 32-bit etc.)\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(NJOIN):
+        fprintf(stdout,"INFO: CONCATENATE FILES e.g. FOR C.D. COMPILATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SILENCE BETWEEN FILES ...... silence separating the files in concatenated output.\n");
+        fprintf(stdout,"INFO:               To eliminate silence BEFORE 1st file in output, enter a NEGATIVE value.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CD COMPATIBLE FILES ONLY .... All files must have sample-rate 44100\n");
+        fprintf(stdout,"INFO:               and must be at least 4 seconds in duration. \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT A TEXTFILE OF CUES .... Output extra file, with cue points in compilation. \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: All files must match in sample-rate and number of channels,\n");
+        fprintf(stdout,"INFO: but may have different sample types (e.g. 16-bit, 32-bit etc.)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The output sample format is taken from the file with the highest precision.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(NMIX):
+        fprintf(stdout,"INFO: MIX TWO FILES OF THE SAME FORMAT.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Any format is accepted, so long as both files have the same format.\n");
+        fprintf(stdout,"INFO: Formats may be wav, aiff, WAVEX, Ambisonic, etc.\n");
+        fprintf(stdout,"INFO: (WAVEX files must have the same loudspeaker layout).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Files may have different sample types (16bit, 32bit etc.)\n");
+        fprintf(stdout,"INFO: and (unless \"Float Output\" flag is set) output takes the sample-type of the FIRST file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: START TIME OF 2nd FILE .... First file starts at zero; 2nd file starts at time specified here.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: APPLY DITHER TO 16bit OUTPUT .... Enhance quality of low level signal (only with 16bit output).\n");
+        fprintf(stdout,"INFO: FLOAT OUTPUT ......................... Force 32bit floating point output type.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(RMSINFO):
+        fprintf(stdout,"INFO: REPORT RMS AND AVERAGE POWER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Scans the file (between the times specified) and reports the loudness in various forms.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Output is a table of values showing, for each channel,\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1) the RMS loudness, as amplitude(0-1) and in dB\n");
+        fprintf(stdout,"INFO: 2) the average loudness (power) as amplitude(0-1) and in dB\n");
+        fprintf(stdout,"INFO: 3) the NET DC loudness as amplitude(0-1) and in dB\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SFEXPROPS):
+        fprintf(stdout,"INFO: DISPLAY PROPERTIES OF WAVEX FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: These include\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The File Format.\n");
+        fprintf(stdout,"INFO: The loudspeaker configuration.\n");
+        fprintf(stdout,"INFO: The loudspeaker positions (if specified).\n");
+        fprintf(stdout,"INFO: Creation date of the file.\n");
+        fprintf(stdout,"INFO: Sample Rate.\n");
+        fprintf(stdout,"INFO: Channel Count.\n");
+        fprintf(stdout,"INFO: Sample Type (16-bit,32-bit etc.)\n");
+        fprintf(stdout,"INFO: Duration.\n");
+        fprintf(stdout,"INFO: Peak data information for each channel.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SETHARES):
+        fprintf(stdout,"INFO: EXTRACT PEAKS FROM ANALYSIS DATA.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  LIST (TIME-VARYING) PEAKS\n");
+        fprintf(stdout,"INFO:              List peaks in each window - windows may have different numbers of peaks.\n");
+        fprintf(stdout,"INFO: (2)  STREAM MAXIMUM NUMBER OF PEAKS.\n");
+        fprintf(stdout,"INFO:              Number of streams = maximum number of peaks in any one window in the file.\n");
+        fprintf(stdout,"INFO:              Where a window has insufficient peaks to fill all the streams\n");
+        fprintf(stdout,"INFO:              a zero-amplitude peak, at an estimated frequency , is set in the stream for that window.\n");
+        fprintf(stdout,"INFO:              In this process, all peaks are retained.\n");
+        fprintf(stdout,"INFO: (3)  STREAM MOST PROMINENT PEAKS.\n");
+        fprintf(stdout,"INFO:              This process assumes that the spectrum is relatively stable.\n");
+        fprintf(stdout,"INFO:              The peaks at every semitone interval in every window are counted.\n");
+        fprintf(stdout,"INFO:              This determines the weighting of each pitch among the peaks in the entire file.\n");
+        fprintf(stdout,"INFO:              The most prominent pitches are chosen as the stream-centres.\n");
+        fprintf(stdout,"INFO:              Time-varying pitch/amp data is then assigned to these streams.\n");
+        fprintf(stdout,"INFO:              In this process, some peaks may be discarded.\n");
+        fprintf(stdout,"INFO: (4)  OUTPUT AVERAGE PITCHES.\n");
+        fprintf(stdout,"INFO:              This process assumes that the spectrum is relatively stable.\n");
+        fprintf(stdout,"INFO:              Streams are calculated as in Mode 3, and an average value calculated for each stream.\n");
+        fprintf(stdout,"INFO:              The output data does not vary in time.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SEARCH WINDOW SIZE (SEMITONES) .... semitone width of subwindow used to search for local peaks in spectrum.\n");
+        fprintf(stdout,"INFO: PEAKING RATIO .............................. a peak is defined as a channel whose amplitude\n");
+        fprintf(stdout,"INFO:              exceeds the median amplitude of all the channels in the subwindow, by this factor.\n");
+        fprintf(stdout,"INFO: AMPLITUDE FLOOR .......................... peak must also exceed a floor value to be retained.\n");
+        fprintf(stdout,"INFO:             Entered value is first multiplied by the maximum channel amplitude found in the file.\n");
+        fprintf(stdout,"INFO: LOW PITCH LIMIT ............................ Minimum frequency to accept as a peak.\n");
+        fprintf(stdout,"INFO: HIGH PITCH LIMIT ............................ Maximum frequency to accept as a peak.\n");
+        fprintf(stdout,"INFO: IN-TUNE RANGE (SEMITONES) ............. range within which harmonics accepted as in tune.\n");
+        fprintf(stdout,"INFO:             If NON-ZERO, peaks which are harmonics of other peaks are not retained.\n");
+        fprintf(stdout,"INFO:             If set to zero, ALL peaks are retained.\n");
+        fprintf(stdout,"INFO: NO AMPLITUDES ............................. Discard the amplitude information.\n");
+        fprintf(stdout,"INFO:             NB: If the output is in \"FILTER FORMAT\", all amplitudes are set to 1.0.\n");
+        fprintf(stdout,"INFO: MIDI OUTPUT ................................. Frequency data output as MIDI values.\n");
+        fprintf(stdout,"INFO: QUANTISE TO QUARTERTONES ........... Quantise frqs to tempered-scale quartertone.\n");
+        fprintf(stdout,"INFO: MARK ZEROS ................................. Mark windows which have NO peaks.\n");
+        fprintf(stdout,"INFO:             If set, peak-free areas are marked by (timed) zeros in the output data.\n");
+        fprintf(stdout,"INFO: FILTER FORMAT ............................. Output data in filter varibank format.\n");
+        fprintf(stdout,"INFO:             This overrides the \"MARK ZEROS\" flag.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MCHSHRED):
+        fprintf(stdout,"INFO: MULTICHANNEL SOUND SHREDDING.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  SHRED MONO FILE TO N OUTPUT CHANNELS\n");
+        fprintf(stdout,"INFO: (2)  SHRED MULTICHANNEL FILE\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Cut file into segments, rearrange the segments: Repeat the process on the output.\n");
+        fprintf(stdout,"INFO: The output chunks are also sent to a randomly permuted sequence of output channels.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF SHREDS. ...number of repeats of shredding process.\n");
+        fprintf(stdout,"INFO: AVERAGE CHUNKLENGTH..average length of chunks to cut & permute.\n");
+        fprintf(stdout,"INFO: CUT SCATTER..........randomisation of cuts (0 to K): default 1.\n");
+        fprintf(stdout,"INFO: .....................where K = total number of chunks (snd-duration/chunklen).\n");
+        fprintf(stdout,"INFO: .....................If scatter = 0: sound is reordered without shredding.\n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL CNT...For Mode 1 only.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MCHZIG):
+        fprintf(stdout,"INFO: READ BACK AND FORTH INSIDE SOUNDFILE, WITH RANDOM PANS\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  RANDOM ZIGZAGS\n");
+        fprintf(stdout,"INFO: (2)  ZIGZAG BETWEEN USER SPECIFIED TIMES\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In mode USER SPECIFIED\n");
+        fprintf(stdout,"INFO: Required data is textfile containing sequence of times to zigzag (and pan) between.\n");
+        fprintf(stdout,"INFO: Each step-between-times must be > (3 * splicelen).\n");
+        fprintf(stdout,"INFO: Successive zigsteps moving in same (time-)direction are concatenated.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ZIGZAGGING START TIME..... Start time of the area of the infile where zigzagging will happen.\n");
+        fprintf(stdout,"INFO: ZIGZAGGING END TIME ........ End time of the area of the infile where zigzagging will happen.\n");
+        fprintf(stdout,"INFO: MIN DURATION OUTFILE ...... output will be at least this long.\n");
+        fprintf(stdout,"INFO: MIN ZIG LENGTH ............... in \"Random\" mode, minimum duration of any zig or zag.\n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL CNT\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH (MS)\n");
+        fprintf(stdout,"INFO: MAX ZIG LENGTH ............... in \"Random\" mode, maximum duration of any zig or zag.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANDOM SEED..a number to generate a replicable random sequence. (>0)\n");
+        fprintf(stdout,"INFO: .............enter same number on next program run, to get same outfile.\n");
+        fprintf(stdout,"INFO: .............(Default: (0) random sequence is different every time).\n");
+        fprintf(stdout,"INFO: NO PANS BETWEEN ADJACENT CHANNELS.......Reject zigs between adjacent output channels.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MCHITER):
+        fprintf(stdout,"INFO: ITERATE INPUT SOUND IN FLUID MANNER, DISTRIBUTING TO MANY CHANNELS\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ****  WARNING: Do NOT use with large files. ****\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DELAY..................(average) delay between iterations. Default:infile dur.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANDOMISATION OF DELAY.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PITCH SCATTER..........max of random pitchshift of each iteration: semitones\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AMPLITUDE SCATTER......max of random amp-reduction on each iteration.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PROGRESSIVE FADE.......(average) amplitude reduction between iterations.\n");
+        fprintf(stdout,"INFO:                        A small value is a small amplitude reduction.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OVERALL GAIN...........(special) value 0, gives best guess for no distortion.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SEED RANDOM GENERATOR..same number produces identical output on rerun,\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECSPHINX):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: IMPOSE CHANNEL AMPLITUDES OF FILE2 ON CHANNEL FRQS OF FILE 1\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: AMPLITUDE BALANCE..... Proportion of File1 Channel-amplitudes retained.\n");
+            fprintf(stdout,"INFO: FREQUENCY BALANCE..... Proportion of File2 Channel-frequencies retained in output spectrum.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: MULTIPLY CHANNEL AMPLITUDES OF TWO SPECTRA\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Note that the spectral FREQUENCIES of the FIRST input are always retained.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: BIAS ....... If NON-zero, a proportion of the (channel-by-channel) amplitude of original signal is added to the output.\n");
+            fprintf(stdout,"INFO:                        If less than 1, a proportion of the 1st input signal is added to the multiplied output.\n");
+            fprintf(stdout,"INFO:                        If greater than 1, a proportion of the 2nd input signal is added to the multiplied output.\n");
+            fprintf(stdout,"INFO:                        Ratio of original to multiplied signal, in the output = abs(bias)/(1.0 - abs(bias))\n");
+            fprintf(stdout,"INFO:                        where \"abs(bias)\" is the absolute (unsigned) value of \"bias\"\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GAIN ....... Overall gain on output.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: CARVE SPECTRUM OF FILE 1 WITH FORMANT ENVELOPE OF FILE 2\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: If file 2 is continuous, it's continuity is largely retained.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CARVE DEPTH ............ How deeply does the spectral envelope of File 2 bite into the spectrum of File 1. (Range 0 to 1). Time-variable.\n");
+            fprintf(stdout,"INFO: OUTPUT GAIN ............ Overall gain on output.\n");
+            fprintf(stdout,"INFO: CUTOFF FREQUENCY ... Where in the spectrum does the carving stop (Range 0 - nyquist). Zero value leaves the 1st sound unchanged.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: USE LOUDNESS ENVELOPE OF 2nd SPECTRUM ... The loudness contour of the 1st sound affects that of the output.\n");
+            fprintf(stdout,"INFO:                                                                                 Default, the loudness contour of the 1st sound is largely unaffected.\n");
+            break;
+        }
+        break;
+    case(SUPERACCU):
+        fprintf(stdout,"INFO: SUSTAIN EACH SPECTRAL BAND, UNTIL LOUDER DATA APPEARS IN THAT BAND\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: This process is similar to \"FOCUS ACCUMULATE\"\n");
+        fprintf(stdout,"INFO: but at the file end, any decaying channels are retained until they decay to zero.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  SUSTAIN (AND POSSIBLY GLISS) LOUDEST PARTIALS.\n");
+        fprintf(stdout,"INFO: (2)  AS (1) BUT TUNE (START OF) SUSTAINED PARTIALS TO TEMPERED SCALE.\n");
+        fprintf(stdout,"INFO: (3)  AS (1) BUT TUNE (START OF) SUSTAINED PARTIALS TO NEAREST OF SPECIFIED FREQUENCIES.\n");
+        fprintf(stdout,"INFO:             (HARMONIC SET GIVEN IN INPUT DATA FILE).\n");
+        fprintf(stdout,"INFO: (4)  AS (1) BUT TUNE (START OF) SUSTAINED PARTIALS TO NEAREST OF SPECIFIED FREQUENCIES OR THEIR 8vas\n");
+        fprintf(stdout,"INFO:             (HARMONIC FIELD GIVEN IN INPUT DATA FILE).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DECAY RATE....sutained channel data decays by DECAYRATE per sec.\n");
+        fprintf(stdout,"INFO: GLISS RATE....sutained channel data glisses at GLISRATE 8vas per sec.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TUNING....forces the (start) frq of sustained partials to one of the specified frequencies.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: REASSIGN CHANNELS .... glissing data is moved into more appropriate channel\n");
+        fprintf(stdout,"INFO:                        if it strays beond the channel frq limits.\n");
+        fprintf(stdout,"INFO:                        (can cause sustained glissandi to persist for longer.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PARTITION):
+        fprintf(stdout,"INFO: PARTITION MONO SOUND FILE INTO DISJUNCT BLOCKS, ASSIGNING EVERY Nth BLOCK TO ONE OF N OUTPUT FILES\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: For input file \"abcdefghijklmno....\" and 3 output files\n");
+        fprintf(stdout,"INFO: (where \"a\",\"b\" etc are successive blocks), we produce\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Outfile1 \"a--d--g--j--m--...\n");
+        fprintf(stdout,"INFO: Outfile2 \"-b--e--h--k--n-...\n");
+        fprintf(stdout,"INFO: Outfile3 \"--c--f--i--l--o...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: where \"--\" is silence replacing the missing blocks\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  BLOCKS DEFINED BY THE COUNT OF THE WAVESETS THEY CONTAIN.\n");
+        fprintf(stdout,"INFO: (2)  BLOCKS DEFINED BY THEIR DURATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: GRID COUNT ..... is the number of output files to generate.\n");
+        fprintf(stdout,"INFO: WAVESET COUNT PER GRID BLOCK (Mode 1) ..... is the number of wavesets in each Block in the output files.\n");
+        fprintf(stdout,"INFO: DURATION OF GRID BLOCKS (Mode 2) ..... is the duration (in seconds) of each Block.\n");
+        fprintf(stdout,"INFO: RANDOMISATION OF DURATION (Mode 2) ..... is the randomisation of that duration (Range 0 -1).\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH (Mode 2) ..... is the duration of the splices used to cut the blocks, in milliseconds.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECGRIDS):
+        fprintf(stdout,"INFO: PARTITION SPECTRUM INTO PARTS, OVER A GRID\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTFILECNT    Number of output spectral files.\n");
+        fprintf(stdout,"INFO: CHANGROUPING  Number of adjacent channels per group in the output spectra.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The product of the 2 parameters must be a divisor of the channel count.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: If the input file has 16 channels \"abcdefghijklmnop\"\n");
+        fprintf(stdout,"INFO: With 2 outfiles and changrouping 1\n");
+        fprintf(stdout,"INFO: The outfiles contain \"a-c-e-g-i-k-m-o\" and \"b-d-f-h-j-l-n-p\" respectively.\n");
+        fprintf(stdout,"INFO: With 2 outfiles and changrouping 2\n");
+        fprintf(stdout,"INFO: The outfiles contain \"ab-ef-ij-mn\" and \"cd-gh-kl-op\".\n");
+        fprintf(stdout,"INFO: With 2 outfiles and changrouping 4\n");
+        fprintf(stdout,"INFO: The outfiles contain \"abcd-ijkl\" and \"efgh-mnop\".\n");
+        fprintf(stdout,"INFO: With 2 outfiles and changrouping 8\n");
+        fprintf(stdout,"INFO: The outfiles contain \"abcdefgh\" and \"mnopijkl\".\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: With 4 outfiles and changrouping 1\n");
+        fprintf(stdout,"INFO: The outfiles contain \"a-e-i-m\" \"b-f-j-n\" \"c-g-k-o\" and \"d-h-l-p\".\n");
+        fprintf(stdout,"INFO: With 4 outfiles and changrouping 2\n");
+        fprintf(stdout,"INFO: With changrouping 2 and 4 outfiles\n");
+        fprintf(stdout,"INFO: The outfiles contain \"ab-ij\" \"cd-kl\" \"ef-mn\" and \"gh-op\".\n");
+        fprintf(stdout,"INFO: With 4 outfiles and changrouping 4\n");
+        fprintf(stdout,"INFO: The outfiles contain \"abcd\" \"efgh\" \"ijkl\" and \"mnop\".\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(GLISTEN):
+        fprintf(stdout,"INFO: RANDOM PARTITION THE SPECTRUM INTO BINS AND PLAY THESE BACK IN ORDER\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: All the channels of the spectrum are partitioned into N mutually exclusive sets\n");
+        fprintf(stdout,"INFO: with channels assigned at random to each set. These sets form 1 complete group.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Then channels in the first set are played, for a given number of windows,\n");
+        fprintf(stdout,"INFO: at which point channels in the 2nd set are played, and so on.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (As this happens, we are progressing through the original spectrum at the original rate.\n");
+        fprintf(stdout,"INFO: The process determines merely which channels are used - the others being zeroed).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Once all N sets are exhausted, a new group is made by random partition, and so on.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: GROUP DIVISIONS ..... Number of sets to divide analysis-channels into\n");
+        fprintf(stdout,"INFO:                     (e.g. with value 4, process partitions channels randomly\n");
+        fprintf(stdout,"INFO:                     among 4 sets with [totalchans/4] channels per set).\n");
+        fprintf(stdout,"INFO:                     NB Must be an exact divisior of the channel count.\n");
+        fprintf(stdout,"INFO: WINDOW LENGTH .......  Number of windows for which each channel-set persists\n");
+        fprintf(stdout,"INFO:                     before we switch to next set-of-channels (Range 1-1024)\n");
+        fprintf(stdout,"INFO: PITCHSHIFT ............. Maximum +- range of random pitch shifting of each set\n");
+        fprintf(stdout,"INFO:                     (Range 0 to 12.0  semitones)\n");
+        fprintf(stdout,"INFO: WINDOWLENGTH RANDOMISE ... Randomisation of Window length to use (between 1 and value set)\n");
+        fprintf(stdout,"INFO: GROUPDIVIDE RANDOMISE ..... Randomise number of channels in each set in a group\n");
+        fprintf(stdout,"INFO:                     Without randomisation, each set-in-a-group has an equal number of channels.\n");
+        fprintf(stdout,"INFO:                     With randomisation, a group has sets of different sizes.\n");
+        break;
+    case(TUNEVARY):
+        fprintf(stdout,"INFO: REPLACE SPECTRAL FRQS BY HARMONICS OF SPECIFIED PITCH(ES), POSSIBLY IN MOTION\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Data required a time-changing template of MIDI pitch-values\n");
+        fprintf(stdout,"INFO: Each line must start with a time, in seconds,\n");
+        fprintf(stdout,"INFO: and be followed by (possibly fractional) MIDI values (range 0 - 127).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Times must start at zero and increase from line to line.\n");
+        fprintf(stdout,"INFO: Lines must have equal numbers of entries,\n");
+        fprintf(stdout,"INFO: but duplicated MIDI values can be used on any line.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOCUS..........degree of focusing of partial pitches onto template.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CLARITY........degree to which non-template partials are suppressed.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TRACE..........number of (window_by_window) most prominent channels\n");
+        fprintf(stdout,"INFO: ...............to be replaced by template frqs. (default, all channels)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: LOW FRQ LIMIT..frqs below this are ignored.\n");
+        fprintf(stdout,"INFO: \n");
+    case(ISOLATE):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: ISOLATE, IN PLACE, SINGLE SPECIFIED SEGMENT(S) OF A SOURCE, TO DISTINCT OUTFILES\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Specified segments are cut from the input file to distinct output files\n");
+            fprintf(stdout,"INFO: but the segments retain silent preambles\n");
+            fprintf(stdout,"INFO: so they occur at SAME TIME in the outfiles, as in the input file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Process concludes by generating a file of all material left over after segment removal.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The original file is reconstructible by mixing all these components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CUT SEGMENT TIMES .....The datafile is a list of time-pairs,\n");
+            fprintf(stdout,"INFO:           being the start and end times of segments to be cut.\n");
+            fprintf(stdout,"INFO:           These should be in time order, and must not overlap one another.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           If 2 cuts abutt each other, or are so close that the end and start splices overlap,\n");
+            fprintf(stdout,"INFO:           the end of the first cut will be moved back, and the start of 2nd cut moved forward\n");
+            fprintf(stdout,"INFO:           so that they overlap by a single splicelength.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           On the Loom, the \"Sound View\" window allows cut-segments to be marked\n");
+            fprintf(stdout,"INFO:           on a graphic of the input file waveform.\n");
+            fprintf(stdout,"INFO:           Input segments are sorted into order and checked for overlap.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPLICELEN ............ Length of the splices in mS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EXTEND END-SILENCES TO ENDTIME OF SOURCE forces all output files to be the same length.\n");
+            fprintf(stdout,"INFO: REVERSE SEGMENT OUTPUT outputs the segmented data backwards-in-time.\n");
+            fprintf(stdout,"INFO:            This is useful if the segments are to be INVERSE-PROCESSED.\n");
+            fprintf(stdout,"INFO:            i.e. a time-reversed file is processed and the process-output re-reversed, restoring the original time-direction.\n");
+            fprintf(stdout,"INFO:            This might be useful where a process generates a tail of sound after the end of the original source  e.g. reverb\n");
+            fprintf(stdout,"INFO:            Reverse-processing in this way causes the 'tail' to PRECEDE the source in the final output.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:            NB If all outputs are the same length in \"ISOLATE\", the reversed files can be processed\n");
+            fprintf(stdout,"INFO:            then rejoined with the remnant file using \"REJOIN\", WITHOUT needing to re-reverse them first.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: ISOLATE, IN PLACE, SETS OF SPECIFIED SEGMENT(S) OF A SOURCE, TO DISTINCT OUTFILES\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Specified sets of isolated segments are cut from the input file.\n");
+            fprintf(stdout,"INFO: Each output file has a different set of isolated segments of the source.\n");
+            fprintf(stdout,"INFO: The files have silent preambles so that events occur at SAME TIME in the outfiles\n");
+            fprintf(stdout,"INFO: as in the source file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The original file is reconstructible by mixing all these components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CUT SEGMENT TIMES ...... Each line of the datafile has a list of time-pairs,\n");
+            fprintf(stdout,"INFO:           the start & end times of segments to be cut for that particular output file.\n");
+            fprintf(stdout,"INFO:           These should be in time order, in each line.\n");
+            fprintf(stdout,"INFO:           None of segments (in any of the lines) must overlap one another.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           If 2 cuts abutt each other, or are so close that the end and start splices overlap,\n");
+            fprintf(stdout,"INFO:           the end of the first cut will be moved back, and the start of 2nd cut moved forward\n");
+            fprintf(stdout,"INFO:           so that they overlap by a single splicelength.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           On the Loom, the \"Sound View\" window allows cut-segments to be marked\n");
+            fprintf(stdout,"INFO:           on a graphic of the input file waveform.\n");
+            fprintf(stdout,"INFO:           Marked segments which succeed each other in time are placed on the same line.\n");
+            fprintf(stdout,"INFO:           (assumed to be part of the data for the same output file).\n");
+            fprintf(stdout,"INFO:           If a new marked segment preceeds (in time) a previous marked segment,\n");
+            fprintf(stdout,"INFO:           a new data line is initiated for a 2nd output file, and so on.\n");
+            fprintf(stdout,"INFO:           Input segments are also checked for overlap.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPLICELEN ............ Length of the splices in mS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EXTEND END-SILENCES TO ENDTIME OF SOURCE forces all output files to be the same length.\n");
+            fprintf(stdout,"INFO: REVERSE SEGMENT OUTPUT outputs the segmented data backwards-in-time.\n");
+            fprintf(stdout,"INFO:            This is useful if the segments are to be INVERSE-PROCESSED.\n");
+            fprintf(stdout,"INFO:            i.e. a time-reversed file is processed and the process-output re-reversed, restoring the original time-direction.\n");
+            fprintf(stdout,"INFO:            This might be useful where a process generates a tail of sound after the end of the original source  e.g. reverb\n");
+            fprintf(stdout,"INFO:            Reverse-processing in this way causes the 'tail' to PRECEDE the source in the final output.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:            NB If all outputs are the same length in \"ISOLATE\", the reversed files can be processed\n");
+            fprintf(stdout,"INFO:            then rejoined with the remnant file using \"REJOIN\", WITHOUT needing to re-reverse them first.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: ISOLATE, IN PLACE, SEVERAL SEGMENT(S) OF A SOURCE, TO A SINGLE OUTFILE\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Specified segments are cut from the input file and placed in the same output file.\n");
+            fprintf(stdout,"INFO: but the segments retain silent surrounds\n");
+            fprintf(stdout,"INFO: so they occur at SAME TIME in the outfiles, as in the input file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Segment starts and ends are located using threshold-on and threshold-off parameters.\n");
+            fprintf(stdout,"INFO: If a segment-length is set, only the initial part (length specified) of each segment is retained.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Process concludes by generating a file of all material left over after segment removal.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The original file is reconstructible by mixing both these components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: THRESHOLD ON .......... dB level at which a segment is triggered to  be cut.\n");
+            fprintf(stdout,"INFO: THRESHOLD OFF ......... dB level at which a cut segment is triggered to end.\n");
+            fprintf(stdout,"INFO: MINIMUM SEGMENT LENGTH.. Minimum Duration in mS which segment must have, to be accepted.\n");
+            fprintf(stdout,"INFO: SEGMENT RETAIN LENGTH .. Duration in mS of (start-)portion of segments to retain.\n");
+            fprintf(stdout,"INFO:                     If segment length is set to zero, the complete segments are retained.\n");
+            fprintf(stdout,"INFO: SPLICELEN ............ Length of the splices in mS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EXTEND END-SILENCES TO ENDTIME OF SOURCE forces all output files to be the same length.\n");
+            fprintf(stdout,"INFO: REVERSE SEGMENT OUTPUT outputs the segmented data backwards-in-time.\n");
+            fprintf(stdout,"INFO:            This is useful if the segments are to be INVERSE-PROCESSED.\n");
+            fprintf(stdout,"INFO:            i.e. a time-reversed file is processed and the process-output re-reversed, restoring the original time-direction.\n");
+            fprintf(stdout,"INFO:            This might be useful where a process generates a tail of sound after the end of the original source  e.g. reverb\n");
+            fprintf(stdout,"INFO:            Reverse-processing in this way causes the 'tail' to PRECEDE the source in the final output.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:            NB If all outputs are the same length in \"ISOLATE\", the reversed files can be processed\n");
+            fprintf(stdout,"INFO:            then rejoined with the remnant file using \"REJOIN\", WITHOUT needing to re-reverse them first.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: ISOLATE, IN PLACE, ALL THE SLICED UP SEGMENT(S) OF A SOUNDFILE\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The source is segmented into successive adjacent segments, written to distinct output files.\n");
+            fprintf(stdout,"INFO: The files have silent preambles so that events occur at SAME TIME in the outfiles\n");
+            fprintf(stdout,"INFO: as in the source file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The original file is reconstructible by mixing all these components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SLICE TIMES ...... Datafile contains a list of (increasing) times where the source is to be cut.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           On the Loom, the \"Sound View\" window allows cut-times to be marked\n");
+            fprintf(stdout,"INFO:           on a graphic of the input file waveform.\n");
+            fprintf(stdout,"INFO:           Cut-times are sorted into ascending order.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPLICELEN ............ Length of the splices in mS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EXTEND END-SILENCES TO ENDTIME OF SOURCE forces all output files to be the same length.\n");
+            fprintf(stdout,"INFO: REVERSE SEGMENT OUTPUT outputs the segmented data backwards-in-time.\n");
+            fprintf(stdout,"INFO:            This is useful if the segments are to be INVERSE-PROCESSED.\n");
+            fprintf(stdout,"INFO:            i.e. a time-reversed file is processed and the process-output re-reversed, restoring the original time-direction.\n");
+            fprintf(stdout,"INFO:            This might be useful where a process generates a tail of sound after the end of the original source  e.g. reverb\n");
+            fprintf(stdout,"INFO:            Reverse-processing in this way causes the 'tail' to PRECEDE the source in the final output.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:            NB If all outputs are the same length in \"ISOLATE\", the reversed files can be processed using \"REJOIN\",\n");
+            fprintf(stdout,"INFO:            WITHOUT needing to re-reverse them first.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(4):
+            fprintf(stdout,"INFO: ISOLATE, IN PLACE, ALL THE SLICED UP SEGMENT(S) OF A SOUNDFILE, WITH SLIGHT OVERLAPS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The source is segmented into successive adjacent segments, written to distinct output files.\n");
+            fprintf(stdout,"INFO: The files have silent preambles so that events occur at SAME TIME in the outfiles\n");
+            fprintf(stdout,"INFO: as in the source file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The cut segments are made to overlap slightly (good for isolating speech syllables).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The original file is reconstructible by mixing all these components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SLICE TIMES ...... Datafile contains a list of (increasing) times where the source is to be cut.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           On the Loom, the \"Sound View\" window allows cut-times to be marked\n");
+            fprintf(stdout,"INFO:           on a graphic of the input file waveform.\n");
+            fprintf(stdout,"INFO:           Cut-times are sorted into ascending order.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPLICELEN ............ Length of the splices in mS\n");
+            fprintf(stdout,"INFO: DOVETAIL  ............ Length of segment overlaps in mS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EXTEND END-SILENCES TO ENDTIME OF SOURCE forces all output files to be the same length.\n");
+            fprintf(stdout,"INFO: REVERSE SEGMENT OUTPUT outputs the segmented data backwards-in-time.\n");
+            fprintf(stdout,"INFO:            This is useful if the segments are to be INVERSE-PROCESSED.\n");
+            fprintf(stdout,"INFO:            i.e. a time-reversed file is processed and the process-output re-reversed, restoring the original time-direction.\n");
+            fprintf(stdout,"INFO:            This might be useful where a process generates a tail of sound after the end of the original source  e.g. reverb\n");
+            fprintf(stdout,"INFO:            Reverse-processing in this way causes the 'tail' to PRECEDE the source in the final output.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:            NB If all outputs are the same length in \"ISOLATE\", the reversed files can be processed using \"REJOIN\",\n");
+            fprintf(stdout,"INFO:            WITHOUT needing to re-reverse them first.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        }
+        break;
+    case(REJOIN):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: REMIX SEGMENT-FILES ORIGINATING IN THE \"ISOLATE\" PROCESS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Process assumes the source files are semgents cut from a source, using \"ISOLATE\"\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The (possibly processed) files are here remixed together\n");
+            fprintf(stdout,"INFO: returning segments to their original timings in the source.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: If the segments were originally REVERSED by the isolate process\n");
+            fprintf(stdout,"INFO: setting \"REVERSE SEGMENTS\" here will automatically re-reverse the (possibly processed) segments\n");
+            fprintf(stdout,"INFO: before mixing them.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GAIN ....... Changes the output level (Range 0 - 1).\n");
+            fprintf(stdout,"INFO:             (Note that output level is automatically turned down if output clips).\n");
+            fprintf(stdout,"INFO: \n");
+            break;      
+        case(1):
+            fprintf(stdout,"INFO: REMIX SEGMENT-FILES ORIGINATING IN THE \"ISOLATE\" PROCESS, WITH THE REMNANT FILE\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Process assumes the source files are segments cut from a source, using \"ISOLATE\"\n");
+            fprintf(stdout,"INFO: PLUS the remnant file, which must be LAST in the list of input files.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The (possibly processed) files are here remixed together\n");
+            fprintf(stdout,"INFO: returning segments to their original timings in the source.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: If the segments were originally REVERSED by the isolate process\n");
+            fprintf(stdout,"INFO: setting \"REVERSE SEGMENTS\" here will automatically re-reverse the (possibly processed) segments\n");
+            fprintf(stdout,"INFO: before mixing them with the remnant file.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GAIN ....... Changes the output level (Range 0 - 1).\n");
+            fprintf(stdout,"INFO:             (Note that output level is automatically turned down if output clips).\n");
+            fprintf(stdout,"INFO: \n");
+            break;      
+        }
+        break;
+    case(PANORAMA):
+        fprintf(stdout,"INFO: CREATE PANORAMA OF INPUT FILES, SPREADING ACROSS MULTICHANNEL SURROUND SPACE\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Loudspeakers assumed to be effectively surrounding the listening area from the front outwards.\n");
+        fprintf(stdout,"INFO: Input sounds distributed in order from leftmost to rightmost position\n");
+        fprintf(stdout,"INFO: (with a 360 degree spread specified, 180 is assumed to be the rightmost position).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES ----------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  SPECIFY THE NUMBER OF LOUDSPEAKERS, AND THE TOTAL ANGULAR WIDTH ( >= 190 degrees )\n");
+        fprintf(stdout,"INFO: 2)  LIST OF LOUDSPEAKER POSITIONS, IN A FILE (TOTAL ANGULAR WIDTH >= 190 degrees)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS -------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1:\n");
+        fprintf(stdout,"INFO:       NO. OF LOUDSPEAKERS ........ Assumed equally spaced.\n");
+        fprintf(stdout,"INFO:       TOTAL ANGULAR WIDTH OF LSPKRS ......(190 - 360).\n");
+        fprintf(stdout,"INFO:                       The loudspeaker array is assumed to be symmetrical around its centre-line.\n");
+        fprintf(stdout,"INFO: MODE 2:\n");
+        fprintf(stdout,"INFO:       LOUDSPEAKER POSITIONS ....... A textfile list of the angular positions of the loudspeakers.\n");
+        fprintf(stdout,"INFO:           positions to the right of centre lie between 0 (front) and 180 (rear)\n");
+        fprintf(stdout,"INFO:           positions to the left of centre lie between >180 (rear) and 360(=0) (front)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ANGULAR WIDTH OF SOUND IMAGE .......... (0 - 360 degrees).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ANGULAR OFFSET OF SOUND IMAGE ...... angle between centre-line of sounds and centre-line of loudspeakers.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SOUND CONFIGURATION ........ Distribution of output sounds within the sound image angle.\n");
+        fprintf(stdout,"INFO:          1: sounds are equally spaced\n");
+        fprintf(stdout,"INFO:          2: two sounds are equally spaced, followed by a gap, etc.\n");
+        fprintf(stdout,"INFO:          3: three sounds are equally spaced, followed by a gap, etc.\n");
+        fprintf(stdout,"INFO:          and so on\n");
+        fprintf(stdout,"INFO:          Must be a divisor of the number of input sounds used.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANDOMISATION ............... Randomisation of sound positions (0-1).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FRONT-PAIR LSPKRS ....... If the angular width of the loudspeakers is 360 degrees.\n");
+        fprintf(stdout,"INFO:          The speaker orientation is ambiguous.\n");
+        fprintf(stdout,"INFO:          Default assumes that there is a single loudspeaker at centre front.\n");
+        fprintf(stdout,"INFO:          Setting this flag forces a pair of lspkrs, symmetrically placed to each side of centre-front.\n");
+        fprintf(stdout,"INFO:          (The flag is IGNORED if TOTAL ANGULAR WIDTH OF LSPKRS is less than 360 degrees )\n");
+        fprintf(stdout,"INFO: FRONT-PAIR SOUND IMAGES ....... The same logic applied to the SOUND positions\n");
+        fprintf(stdout,"INFO:          (ignored if the ANGULAR WIDTH OF SOUND IMAGE is less than 360 degrees )\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(TREMOLO):
+        fprintf(stdout,"INFO: TREMOLO A SOUND, WITH ADJUSTABLE PEAK-WIDTH\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FRQWISE....Interpolate linearly between frqs in any frq brktable (default).\n");
+        fprintf(stdout,"INFO: PITCHWISE..Interpolate logarithmically (like pitch). (Care with zero frqs).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TREMOLO FREQUENCY..is frequency of the tremolo vibration itself.\n");
+        fprintf(stdout,"INFO: TREMOLO DEPTH......amplitude depth of tremolo.\n");
+        fprintf(stdout,"INFO: OVERALL GAIN.......Overall signal gain, or envelope.\n");
+        fprintf(stdout,"INFO: PEAK NARROWING ....Tremolo peaks can be made narrower.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ECHO):
+        fprintf(stdout,"INFO: REPEATEDLY ECHO A SOUND\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DELAY...................must be greater than the sound duration.\n");
+        fprintf(stdout,"INFO:               (use the \"DELAY\" program otherwise).\n");
+        fprintf(stdout,"INFO: ATTENUATION.............change in level from one echo to the next.\n");
+        fprintf(stdout,"INFO: MAXIMUM DURATION....... maximum duration of output (output may be shorter).\n");
+        fprintf(stdout,"INFO: RANDOMISATION ......... Randomisation of echo times.\n");
+        fprintf(stdout,"INFO: CUTOFF LEVEL .......... Level below which output signal is cut off.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PACKET):
+        fprintf(stdout,"INFO: CREATE AN ENVELOPED SOUND-PACKET, CUT AND SHAPED FROM A SOURCE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOUND....Use signal minima around the specified location in the source, to determine where to cut a packet.\n");
+        fprintf(stdout,"INFO: FORCED...Cut a packet at the specified location in the source.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PACKET LOCATION IN SOURCE ........ Time in source around which packet is to be cut.\n");
+        fprintf(stdout,"INFO:                    A single time value or a textfile list of times.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION ......... Duration (of forced packet) or minimum-duration (of found packet) in mS.\n");
+        fprintf(stdout,"INFO:                    (Must be less than half the source duration).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NARROWING ........ Narrowing of the packet envelope, which is normally cosinusoidal.\n");
+        fprintf(stdout,"INFO:                    Values below 1.0 broaden the packet.\n");
+        fprintf(stdout,"INFO:                    Values very close to zero may produce clicks (square-wave envelope).\n");
+        fprintf(stdout,"INFO:                    High vals with short packets may produce click-impulses or silence.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CENTRING ........  Centring of the peak of the packet envelope.\n");
+        fprintf(stdout,"INFO:                    0  gives a peak at centre: -ve values move the peak towards the start of packet\n");
+        fprintf(stdout,"INFO:                    +ve values move the peak towards the end of the packet.\n");
+        fprintf(stdout,"INFO:                    If the packet content has varying level, the true peak position may not correspond\n");
+        fprintf(stdout,"INFO:                    to the envelope peak position, unless the \"-f\" flag is used.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NORMALISE ........ Normalise the packet level.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: EXPAND ........... Packet wave maxima(minima) are forced up(down) to the envelope contour of the packet.\n");
+        fprintf(stdout,"INFO:                    (default, the packet envelope is simply imposed on the existing signal).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SHAVE SILENCE..... Remove leading or trailing silence in resultant packet.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SYNTHESIZER):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: SYNTHESIZE COMPLEX TONES\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Creates tones with any number of partials which may vary through time in frequency and level.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECTRUM DATA ..... A textfile Listing of partial ratios and relative levels, against time.\n");
+            fprintf(stdout,"INFO:                     Data is a text file of lines of data and every line must have the same number of entries.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     The 1ST ENTRY on each line is a time. Times must start at zero and increase.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All EVEN NUMBERED entries are partial numbers\n");
+            fprintf(stdout,"INFO:                     For synthesizing tones, the first partial number on each line must be 1.\n");
+            fprintf(stdout,"INFO:                     Partial numbers must increase through a line.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All other ODD NUMBERED entries are partial levels and may have any numeric value.\n");
+            fprintf(stdout,"INFO:                     -ve values invert the phase of the partial.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SAMPLE_RATE ....... Sample rate of the synthesized sound.\n");
+            fprintf(stdout,"INFO: DURATION .......... Total Duration of the synthesized sound.\n");
+            fprintf(stdout,"INFO: FREQUENCY ......... Fundamental frequency of the synthesized sound (possibly time-varying).\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: SYNTHESIZE PACKET_STREAMS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Creates a stream of wave-packets, which may vary in content through time.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECTRUM DATA ..... A textfile Listing of partial ratios and relative levels, against time.\n");
+            fprintf(stdout,"INFO:                     Data is a text file of lines of data and every line must have the same number of entries.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     The 1ST ENTRY on each line is a time. Times must start at zero and increase.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All EVEN NUMBERED entries are partial numbers\n");
+            fprintf(stdout,"INFO:                     For synthesizing tones, the first partial number on each line must be 1.\n");
+            fprintf(stdout,"INFO:                     Partial numbers must increase through a line.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All other ODD NUMBERED entries are partial levels and may have any numeric value.\n");
+            fprintf(stdout,"INFO:                     -ve values invert the phase of the partial.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SAMPLE_RATE ....... Sample rate of the synthesized sound.\n");
+            fprintf(stdout,"INFO: DURATION .......... Total Duration of the synthesized sound.\n");
+            fprintf(stdout,"INFO: FREQUENCY ......... Fundamental frequency of the synthesized sound (possibly time-varying).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NARROWING ......... Narrowing of the packet envelope, which is normally cosinusoidal.\n");
+            fprintf(stdout,"INFO:                     Values below 1.0 broaden the packet.\n");
+            fprintf(stdout,"INFO:                     Values very close to zero may produce clicks (square-wave envelope).\n");
+            fprintf(stdout,"INFO:                     High vals with high frequencies may produce click-impulses or silence.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CENTRING .........  Centring of the peak of the packet envelope.\n");
+            fprintf(stdout,"INFO:                     0 gives a peak at centre: -ve values move the peak towards the start of packet\n");
+            fprintf(stdout,"INFO:                     +ve values move the peak towards the end of the packet.\n");
+            fprintf(stdout,"INFO:                     If the packet content has varying level, the true peak position may not correspond\n");
+            fprintf(stdout,"INFO:                     to the envelope peak position.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: STATIONARY PACKET PARAMS .......\n");
+            fprintf(stdout,"INFO:                     With this flag set, packet parameters are set at the outset of a packet,\n");
+            fprintf(stdout,"INFO:                     and remain the same until its end.\n");
+            fprintf(stdout,"INFO:                     With no flag set, frq and level parameters of partials continue to vary WITHIN the packets.\n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: SYNTHESIZE GLISTENING SOUNDS\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Creates a distribution of partials-components of spectrum (which may vary through time), varying in time and space.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECTRUM DATA ..... A textfile Listing of partial ratios and relative levels, against time.\n");
+            fprintf(stdout,"INFO:                     Data is a text file of lines of data and every line must have the same number of entries.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     The 1ST ENTRY on each line is a time. Times must start at zero and increase.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All EVEN NUMBERED entries are partial numbers\n");
+            fprintf(stdout,"INFO:                     For synthesizing tones, the first partial number on each line must be 1.\n");
+            fprintf(stdout,"INFO:                     Partial numbers must increase through a line.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All other ODD NUMBERED entries are partial levels and may have any numeric value.\n");
+            fprintf(stdout,"INFO:                     -ve values invert the phase of the partial.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SAMPLE_RATE ....... Sample rate of the synthesized sound.\n");
+            fprintf(stdout,"INFO: DURATION ............ Total Duration of the synthesized sound.\n");
+            fprintf(stdout,"INFO: FREQUENCY ......... Fundamental frequency of the synthesized sound (possibly time-varying).\n");
+            fprintf(stdout,"INFO: CHANNEL COUNT ... Number of output channels.\n");
+            fprintf(stdout,"INFO: MAX OCTAVE TRANSPOSITION.. Maximum transposition of spectral components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIMESTEP ............ Average timestep between changes in partials-content of output.\n");
+            fprintf(stdout,"INFO: RISETIME ............ Time taken to attain max octave transposition range, at start of sound.\n");
+            fprintf(stdout,"INFO: FALLTIME ............ Time taken to return to minimal range.\n");
+            fprintf(stdout,"INFO: STEADY STATE ...... Time spent in minimal range at end of sound.\n");
+            fprintf(stdout,"INFO: FROM FUNDAMENTAL  Initial rise in number of partials is from fundamental only.\n");
+            fprintf(stdout,"INFO: TO FUNDAMENTAL .... Final \"steady state\" gradually contracts to using fundamental only.\n");
+            fprintf(stdout,"INFO: SPLICETIME (mS).... Length of fade-in/out times of components in output sound, in milliseconds.\n");
+            fprintf(stdout,"INFO: PARTIALS IN PLAY . Number of partials used in any segment: If set to zero, number of partials used is random.\n");
+            fprintf(stdout,"INFO: MAXCHANGE PARTIALS .. As far as possible, always change partials used, from one segment to the next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPATIALISE ............ Distribute components in space.\n");
+            fprintf(stdout,"INFO: EMERGENCE CHANNEL .. If spatial image emerges from a single channel, to fill the space, this is the channel.\n");
+            fprintf(stdout,"INFO: EMERGENCE TIME .... If spatial image emerges from a single channel, time taken to fully emerge.\n");
+            fprintf(stdout,"INFO: CONVERGENCE CHANNEL .. If spatial image converges to a single channel at end of sound, this is the channel.\n");
+            fprintf(stdout,"INFO: CONVERGENCE TIME . If spatial image converges to a single channel, time taken to fully converge.\n");
+            fprintf(stdout,"INFO: JUMP .................. Use same spatial position for all partials in a segment.\n");
+            fprintf(stdout,"INFO: ROTATION SPEED .... Rotation speed for Special Space Type 3 (only).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECIAL SPACE TYPE  (8-channel files only) .... Special types of spatialisation.\n");
+            fprintf(stdout,"INFO:    1:  Left-Right Rand ........... Alternate Left and Right sides, random positions.\n");
+            fprintf(stdout,"INFO:    2:  Front-Back Rand .......... Alternate Front and back areas of space , random positions.\n");
+            fprintf(stdout,"INFO:    3:  Rotate ...................... (Requires a positive or negative rotation speed).\n");               
+            fprintf(stdout,"INFO:    4:  Superspace1 ............... Single channel positions only.\n");
+            fprintf(stdout,"INFO:    5:  Superspace2 ............... Single channels and channel-pairs only.\n");
+            fprintf(stdout,"INFO:    6:  Superspace3 ............... Single channels and channel-pairs and channel-triples only.\n");
+            fprintf(stdout,"INFO:    7:  Superspace4 ............... Single channels, channel-pairs, channel-triples, square, diamond and all-positions.\n");
+            fprintf(stdout,"INFO:    8:  Left-Right Alternate ....... Alternate Left and Right sides, using all channels of each.\n");
+            fprintf(stdout,"INFO:    9:  Back-Front Alternate ...... Alternate Back and Front areas, using all channels of each.\n");
+            fprintf(stdout,"INFO:    10: Frameswitch ............... Alternate Between Square and Diamond 4-sets.\n");
+            fprintf(stdout,"INFO:    11: Triangle Rotate 1 ......... Rotate a triple of alternate channels, clockwise.\n");
+            fprintf(stdout,"INFO:    12: Triangle AntiRotate 1 ..... Rotate a triple of alternate channels, anticlockwise.\n");
+            fprintf(stdout,"INFO:    13: Triangle Rotate 2 ......... Rotate a channel and the pair opposite, clockwise.\n");
+            fprintf(stdout,"INFO:    14: Triangle AntiRotate 2 ..... Rotate a channel and the pair opposite, anticlockwise.\n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: SYNTHESIZE FRACTALLY-ARRAYED SEQUENCES OF SPIKES\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Creates waveform with fractal distribution of spikes.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SAMPLE_RATE ....... Sample rate of the synthesized sound.\n");
+            fprintf(stdout,"INFO: DURATION ............ Total Duration of the synthesized sound.\n");
+            fprintf(stdout,"INFO: FREQUENCY ......... Fundamental frequency of the synthesized sound (possibly time-varying).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Shape of waveform is \"ON OFF ON OFF TAIL\" where ...\n");
+            fprintf(stdout,"INFO:       \"ON\" segments contain signal, and are of same duration.\n");
+            fprintf(stdout,"INFO:       \"OFF\" segments contain NO signal, and are of same duration.\n");
+            fprintf(stdout,"INFO:       \"TAIL\" (can be zero length) is additional silence at waveform end.\n");
+            fprintf(stdout,"INFO: The \"ON\" segments are then themselves divided in similar proportions, the resulting smaller \"ON\" segments similarly, and so on,\n");
+            fprintf(stdout,"INFO: producing a  fractal distribution.\n");
+            fprintf(stdout,"INFO: Signal spikes are then placed in the \"ON\" segments.\n");
+            fprintf(stdout,"INFO: Spikes alternate from +ve to -ve at the specified level of fractalisation.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SAMPLES IN SPIKE ATTACK ... Number of samples in the spike attack (can be zero).\n");
+            fprintf(stdout,"INFO: SLOPE OF SPIKE ATTACK ..... Slope of attack : 1 = linear  : >1 rises slowly-then-faster  : <1 rises fast-then-slower.\n");
+            fprintf(stdout,"INFO: SAMPLES IN SPIKE DECAY .... Number of samples in the spike decay (can be zero).\n");
+            fprintf(stdout,"INFO: SLOPE OF SPIKE DECAY ...... Slope of decay : 1 = linear  : >1 falls fast-then-slower  : <1 falls slowly-then-faster.\n");
+            fprintf(stdout,"INFO: RATIO ONSEG TO ONOFF GROUPLENGTH ............ Determines relative size of \"ON\" and \"OFF\" segments.\n");
+            fprintf(stdout,"INFO: RATIO ONOFFONOFF GROUPLENGTH TO WAVECYCLE LENGTH ............ \n");
+            fprintf(stdout,"INFO:             Determines relative size of the 4 (\"ON\",\"OFF\",\"ON\",\"OFF\") segments group, and the total wavecycle length.\n");
+            fprintf(stdout,"INFO: RANDOMISATION OF SPIKES ............ Degree of time-randomisation of the spikes.\n");
+            fprintf(stdout,"INFO: FRACTALISATION LEVEL FOR SPIKES TO FLIP POS TO NEG ...... Level of fractalisation at which spikes flip from +ve to -ve.\n");
+            break;
+        }
+        break;
+    case(TAN_ONE):
+        fprintf(stdout,"INFO: PLAY REPETITIONS OF MONO SOUND ON TANGENT PATH TO AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: loudspeaker array is numbered clockwise, starting with \"1\" at front-centre.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Different modes have different tangent styles...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FAR TANGENT  .... For focus at speaker 1, starts along line at right-angles to speaker 2.\n");
+        fprintf(stdout,"INFO: NEAR TANGENT .... For focus at speaker 1, starts along line formed by speakers 2 and 3.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION ....... Duration of output file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: EVENT COUNT ... Count of the events in the tangent stream (Single and Two src modes only).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MAXIMUM ANGLE .. (Far Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Max angle of rotation of the motion lies between 3rd pair (  i.e. between  90 to 135 degrees).\n");
+        fprintf(stdout,"INFO:                       (lsprks 3-4 in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SKEW  ....... .. (Near Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Skew is the ratio (0-1) of time spent between the last pair & the penultimate pair of lspkrs.\n");
+        fprintf(stdout,"INFO:                       (lspkr pairs 3-4 and 2-3, in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DECIMATION ..... Loudness decimation on passing from one event to the next.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOCUS POSITION .. Loudpseaker at which the motion ends (approaching motion) or begins (receding motion).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: JITTER ..........  Randomisation of event timings (0-1, default 0) Can vary over time.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DRAG ........... (Far Tangent Modes) Slows the pan-motion acceleration.\n");
+        fprintf(stdout,"INFO:                  Smaller values make stream proceed more slowly to (or from) the focus position.\n");
+        fprintf(stdout,"INFO:                  For approaching motion, 0.5 avoids the arrival being too fast to tell.\n");
+        fprintf(stdout,"INFO:                  For receding motion, 1.0, makes the initial motion rapid.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RECEDE ........  Sounds Recede (default, sounds approach).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AT LEFT .......  Motion is to or from the left of the focal lspkr (default: motion is to or from the right).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Note that in the part of the stream closest to the focal lspkr,\n");
+        fprintf(stdout,"INFO: the SAME final (approaching)  or initial (receding) event is repeated, at fixed level.\n");
+        fprintf(stdout,"INFO: These repeated events are ADDITIONAL to the event-count.\n");
+        break;
+    case(TAN_TWO):
+        fprintf(stdout,"INFO: PLAY REPETITIONS OF TWO MERGED MONO SOUNDS ON TANGENT PATH TO AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: loudspeaker array is numbered clockwise, starting with \"1\" at front-centre.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The two sources are superimposed along the tangent path, beginning with only the 1st sound\n");
+        fprintf(stdout,"INFO: and gradually mixing in more of the 2nd sound from one event to the next.\n");
+        fprintf(stdout,"INFO: If one input is a filtered version of the other, this suggest it might be more distant.\n");
+        fprintf(stdout,"INFO: Hence for approaching motion the filterd sound should be first,\n");
+        fprintf(stdout,"INFO: whereas for receding motion the filtered sound should be second.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Different modes have different tangent styles...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FAR TANGENT  .... For focus at speaker 1, starts along line at right-angles to speaker 2.\n");
+        fprintf(stdout,"INFO: NEAR TANGENT .... For focus at speaker 1, starts along line formed by speakers 2 and 3.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION ....... Duration of output file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: EVENT COUNT ... Count of the events in the tangent stream (Single and Two src modes only).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MAXIMUM ANGLE .. (Far Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Max angle of rotation of the motion lies between 3rd pair (  i.e. between  90 to 135 degrees).\n");
+        fprintf(stdout,"INFO:                       (lsprks 3-4 in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SKEW  ....... .. (Near Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Skew is the ratio (0-1) of time spent between the last pair & the penultimate pair of lspkrs.\n");
+        fprintf(stdout,"INFO:                       (lspkr pairs 3-4 and 2-3, in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DECIMATION ..... Loudness decimation on passing from one event to the next.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: BALANCE ACCUMULATOR ... Progressive accumulation of 2nd sound in the mix.\n");
+        fprintf(stdout,"INFO:                  For an accumulation value of 0.33, succeesive mix would be [1.0 : 0.0] [0.66 : 0.33] [0.44 : 0.56] etc.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOCUS POSITION .. Loudpseaker at which the motion ends (approaching motion) or begins (receding motion).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: JITTER ..........  Randomisation of event timings (0-1, default 0) Can vary over time.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DRAG ........... (Far Tangent Modes) Slows the pan-motion acceleration.\n");
+        fprintf(stdout,"INFO:                  Smaller values make stream proceed more slowly to (or from) the focus position.\n");
+        fprintf(stdout,"INFO:                  For approaching motion, 0.5 avoids the arrival being too fast to tell.\n");
+        fprintf(stdout,"INFO:                  For receding motion, 1.0, makes the initial motion rapid.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RECEDE ........  Sounds Recede (default, sounds approach).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AT LEFT .......  Motion is to or from the left of the focal lspkr (default: motion is to or from the right).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Note that in the part of the stream closest to the focal lspkr,\n");
+        fprintf(stdout,"INFO: the SAME final (approaching)  or initial (receding) event is repeated, at fixed level.\n");
+        fprintf(stdout,"INFO: These repeated events are ADDITIONAL to the event-count, and there are no balance changes here.\n");
+        break;
+    case(TAN_SEQ):
+        fprintf(stdout,"INFO: PLAY SEQUENCE OF MONO SOUNDS ON TANGENT PATH TO AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: loudspeaker array is numbered clockwise, starting with \"1\" at front-centre.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Different modes have different tangent styles...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FAR TANGENT  .... For focus at speaker 1, starts along line at right-angles to speaker 2.\n");
+        fprintf(stdout,"INFO: NEAR TANGENT .... For focus at speaker 1, starts along line formed by speakers 2 and 3.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION ....... Duration of output file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MAXIMUM ANGLE .. (Far Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Max angle of rotation of the motion lies between 3rd pair (  i.e. between  90 to 135 degrees).\n");
+        fprintf(stdout,"INFO:                       (lsprks 3-4 in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SKEW  ....... .. (Near Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Skew is the ratio (0-1) of time spent between the last pair & the penultimate pair of lspkrs.\n");
+        fprintf(stdout,"INFO:                       (lspkr pairs 3-4 and 2-3, in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DECIMATION ..... Loudness decimation on passing from one event to the next.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOCUS POSITION .. Loudpseaker at which the motion ends (approaching motion) or begins (receding motion).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: JITTER ..........  Randomisation of event timings (0-1, default 0) Can vary over time.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DRAG ........... (Far Tangent Modes) Slows the pan-motion acceleration.\n");
+        fprintf(stdout,"INFO:                  Smaller values make stream proceed more slowly to (or from) the focus position.\n");
+        fprintf(stdout,"INFO:                  For approaching motion, 0.5 avoids the arrival being too fast to tell.\n");
+        fprintf(stdout,"INFO:                  For receding motion, 1.0, makes the initial motion rapid.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RECEDE ........  Sounds Recede (default, sounds approach).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AT LEFT .......  Motion is to or from the left of the focal lspkr (default: motion is to or from the right).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Note that in the part of the stream closest to the focal lspkr,\n");
+        fprintf(stdout,"INFO: the SAME final (approaching) or initial (receding) event is repeated, at fixed level\n");
+        fprintf(stdout,"INFO: and these events are ADDED to the input events.\n");
+        break;
+    case(TAN_LIST):
+        fprintf(stdout,"INFO: PLAY SEQUENCE OF MONO SOUNDS (IN A TEXTFILE LIST OF SOUNDS) ON TANGENT PATH TO AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: loudspeaker array is numbered clockwise, starting with \"1\" at front-centre.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Different modes have different tangent styles...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FAR TANGENT  .... For focus at speaker 1, starts along line at right-angles to speaker 2.\n");
+        fprintf(stdout,"INFO: NEAR TANGENT .... For focus at speaker 1, starts along line formed by speakers 2 and 3.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION ....... Duration of output file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MAXIMUM ANGLE .. (Far Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Max angle of rotation of the motion lies between 3rd pair (  i.e. between  90 to 135 degrees).\n");
+        fprintf(stdout,"INFO:                       (lsprks 3-4 in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SKEW  ....... .. (Near Tangent Modes) The motion lies between 3 lspkr pairs (e.g. 1-2, 2-3, 3-4)\n");
+        fprintf(stdout,"INFO:                       Skew is the ratio (0-1) of time spent between the last pair & the penultimate pair of lspkrs.\n");
+        fprintf(stdout,"INFO:                       (lspkr pairs 3-4 and 2-3, in the example)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DECIMATION ..... Loudness decimation on passing from one event to the next.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOCUS POSITION .. Loudpseaker at which the motion ends (approaching motion) or begins (receding motion).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: JITTER ..........  Randomisation of event timings (0-1, default 0) Can vary over time.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DRAG ........... Slows the pan-motion acceleration.\n");
+        fprintf(stdout,"INFO:                  Smaller values make stream proceed more slowly to (or from) the focus position.\n");
+        fprintf(stdout,"INFO:                  For approaching motion, 0.5 avoids the arrival being too fast to tell.\n");
+        fprintf(stdout,"INFO:                  For receding motion, 1.0, makes the initial motion rapid.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RECEDE ........  Sounds Recede (default, sounds approach).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AT LEFT .......  Motion is to or from the left of the focal lspkr (default: motion is to or from the right).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Note that in the part of the stream closest to the focal lspkr,\n");
+        fprintf(stdout,"INFO: the SAME final (approaching) or initial (receding) event is repeated, at fixed level.\n");
+        fprintf(stdout,"INFO: and these repeated events are ADDED to the input events.\n");
+        break;
+    case(SPECTWIN):
+        fprintf(stdout,"INFO: INTERBREED THE SPECTRAL CONTENT OF TWO DIFFERENT SOUNDS\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Spectral envelope may be drawn over the local-maxima of the channel-levels (Formant Envelope)\n");
+        fprintf(stdout,"INFO: or simply follow the amplitude changes from one channel to the next (Absolute Envelope)\n");
+        fprintf(stdout,"info: Spectral envelops are interbred as follows ....\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FORMANTS SND 1 WITH FORMANTS SND 2.\n");
+        fprintf(stdout,"INFO: FORMANTS SND 1 WITH ABSOLUTE SND 2.\n");
+        fprintf(stdout,"INFO: ABSOLUTE SND 1 WITH FORMANTS SND 2.\n");
+        fprintf(stdout,"INFO: ABSOLUTE SND 1 WITH ABSOLUTE SND 2.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FREQUENCY INTERPOLATION .... Dominance of spectral frequencies of 2nd input file.\n");
+        fprintf(stdout,"INFO:            Values > 0 move channel frequencies from those of file 1 towards those of file 2.\n");
+        fprintf(stdout,"INFO: ENVELOPE INTERPOLATION ..... Dominance of spectral envelope of 2nd input file.\n");
+        fprintf(stdout,"INFO:            Values > 0 move the envelope from that of file 1 towards that of file 2.\n");
+        fprintf(stdout,"INFO:            Note that when Formant and Absolute envelopes are combined,\n");
+        fprintf(stdout,"INFO:            the formant peaks are moved onto the absolute envelope,\n");
+        fprintf(stdout,"INFO:            with all other channels moving proportionately.\n");
+        fprintf(stdout,"INFO: SPECTRAL DUPLICATIONS .... Adds transposed copies to spectrum 1, before proceeding.\n");
+        fprintf(stdout,"INFO: DUPLICATION INTERVAL .... Transposition from one duplication to next, in semitones.\n");
+        fprintf(stdout,"INFO: DUPLICATION ROLLOFF ....  Level change in passing to next higher duplication.\n");
+        break;
+    case(TRANSIT):
+        fprintf(stdout,"INFO:  CREATE MULTICHANNEL MIX WHICH POSITIONS REPETITIONS OF A MONO SOUND\n");
+        fprintf(stdout,"INFO:          ON TANGENT PATH TO AND FROM AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Loudspeakers assumed to be equidistant in a ring, and numbered clockwise.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         GLANCING                EDGEWISE                  CROSSING                   CLOSE                   CENTRAL\n");
+        fprintf(stdout,"INFO:           ---O->>            ->>--O---O->>                       O                          O      O                          O\n");
+        fprintf(stdout,"INFO:       O              O                                           ->>--O-------O->>                                           O              O\n");
+        fprintf(stdout,"INFO:                                       O                  O                                    ->>-O--------------O->>\n");
+        fprintf(stdout,"INFO:     O                  O                                              O                  O                                  ->>-O---------------O->>\n");
+        fprintf(stdout,"INFO:                                       O                  O                                            O                  O\n");
+        fprintf(stdout,"INFO:       O              O                                                  O              O                                              O              O\n");
+        fprintf(stdout,"INFO:               O                            O      O                            O                          O      O                          O\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  FOCUS ............ Centre of motion. Integer for odd modes, 1.5 ; 2.5 etc for even modes.\n");
+        fprintf(stdout,"INFO:  DURATION ......... Duration of motion from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO:  REPETITIONS ...... Count of events from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Total duration and number of repetitions will be double these values, as the mix approaches and then recedes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MAXIMUM RANGE .... (Modes 1-4) Maximum angle from centreline reached ( < 90).\n");
+        fprintf(stdout,"INFO:                                 (Mode 5) Maximum distance from centre, where centre-to-loudspeaker distance is 1.\n");
+        fprintf(stdout,"INFO:  DECIMATION ....... Gain multiplier (>0 <1) on passing from one event to the next, away from the focus.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  To extend the motion further (which increases the duration and the number of repetitions)....\n");
+        fprintf(stdout,"INFO:  the (gain) decimation can be modified with these 4 parameters ... \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  THRESHOLD FOR EXTENSION.. Value of (decimated) gain at which gain the decimation starts to increase.\n");
+        fprintf(stdout,"INFO:  DECIMATION MAXIMUM ......... Maximum level of decimation after it starts to increase (> DECIMATION).\n");
+        fprintf(stdout,"INFO:  FINAL GAIN ....................... Decimated gain at which the event concludes ( < THRESHOLD).\n");
+        fprintf(stdout,"INFO:  MAXIMUM DURATION .......... Maximum duration of motion from centre to edge (in case FINAL GAIN is never reached) ( >= DURATION).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  LEFTWARDS FROM FOCUS .... Motion towards left of focal position (Default: motion towards right).\n");
+        break;
+    case(TRANSITF):
+        fprintf(stdout,"INFO:  CREATE MULTICHANNEL MIX WHICH POSITIONS REPETITIONS OF A PAIR OF MONO SOUNDS\n");
+        fprintf(stdout,"INFO:               ON TANGENT PATH TO AND FROM AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  The 2nd sound is gradually mixed in to the first as distance from focus increases.\n");
+        fprintf(stdout,"INFO:  If 2nd sound is a filtered version of the first, this may suggest greater distance.\n");
+        fprintf(stdout,"INFO:  Loudspeakers assumed to be equidistant in a ring, and numbered clockwise.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         GLANCING                EDGEWISE                  CROSSING                   CLOSE                   CENTRAL\n");
+        fprintf(stdout,"INFO:           ---O->>            ->>--O---O->>                       O                          O      O                          O\n");
+        fprintf(stdout,"INFO:       O              O                                           ->>--O-------O->>                                           O              O\n");
+        fprintf(stdout,"INFO:                                       O                  O                                    ->>-O--------------O->>\n");
+        fprintf(stdout,"INFO:     O                  O                                              O                  O                                  ->>-O---------------O->>\n");
+        fprintf(stdout,"INFO:                                       O                  O                                            O                  O\n");
+        fprintf(stdout,"INFO:       O              O                                                  O              O                                              O              O\n");
+        fprintf(stdout,"INFO:               O                            O      O                            O                          O      O                          O\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  FOCUS ............ Centre of motion. Integer for odd modes, 1.5 ; 2.5 etc for even modes.\n");
+        fprintf(stdout,"INFO:  DURATION ......... Duration of motion from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO:  REPETITIONS ...... Count of events from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Total duration and number of repetitions will be double these values, as the mix approaches and then recedes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MAXIMUM RANGE .... (Modes 1-4) Maximum angle from centreline reached ( < 90).\n");
+        fprintf(stdout,"INFO:                                 (Mode 5) Maximum distance from centre, where centre-to-loudspeaker distance is 1.\n");
+        fprintf(stdout,"INFO:  DECIMATION ....... Gain multiplier (>0 <1) on passing from one event to the next, away from the focus.\n");
+        fprintf(stdout,"INFO:  BALANCE DECIMATION ..Proportion of 2nd sound mixed into first as sound becomes more distant from focus.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  To extend the motion further (which increases the duration and the number of repetitions)....\n");
+        fprintf(stdout,"INFO:  the (gain) decimation can be modified with these 4 parameters ... \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  THRESHOLD FOR EXTENSION.. Value of (decimated) gain at which gain the decimation starts to increase.\n");
+        fprintf(stdout,"INFO:  DECIMATION MAXIMUM ......... Maximum level of decimation after it starts to increase (> DECIMATION).\n");
+        fprintf(stdout,"INFO:  FINAL GAIN ....................... Decimated gain at which the event concludes ( < THRESHOLD).\n");
+        fprintf(stdout,"INFO:  MAXIMUM DURATION .......... Maximum duration of motion from centre to edge (in case FINAL GAIN is never reached) ( >= DURATION).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  LEFTWARDS FROM FOCUS .... Motion towards left of focal position (Default: motion towards right).\n");
+        break;
+    case(TRANSITD):
+        fprintf(stdout,"INFO:  CREATE MULTICHANNEL MIX WHICH POSITIONS REPETITIONS OF A MONO SOUND\n");
+        fprintf(stdout,"INFO:        ON TANGENT PATH TO AND FROM AN 8-CHANNEL RING OF LSPKRS,\n");
+        fprintf(stdout,"INFO:                      SHIFTING TO 2nd SOUND ON PASSING FOCUS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  The 2nd sound replaces the first once the focus of the motion is passed.\n");
+        fprintf(stdout,"INFO:  If the 2nd sound is a pitch-shifted version of the 1st, this may suggest doppler-shift.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Additional sounds may be input, to place at the centre point of the mix (near the focus)\n");
+        fprintf(stdout,"INFO:  suggesting gradual changes in pitch at the doppler-shift moment.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Loudspeakers assumed to be equidistant in a ring, and numbered clockwise.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         GLANCING                EDGEWISE                  CROSSING                   CLOSE                   CENTRAL\n");
+        fprintf(stdout,"INFO:           ---O->>            ->>--O---O->>                       O                          O      O                          O\n");
+        fprintf(stdout,"INFO:       O              O                                           ->>--O-------O->>                                           O              O\n");
+        fprintf(stdout,"INFO:                                       O                  O                                    ->>-O--------------O->>\n");
+        fprintf(stdout,"INFO:     O                  O                                              O                  O                                  ->>-O---------------O->>\n");
+        fprintf(stdout,"INFO:                                       O                  O                                            O                  O\n");
+        fprintf(stdout,"INFO:       O              O                                                  O              O                                              O              O\n");
+        fprintf(stdout,"INFO:               O                            O      O                            O                          O      O                          O\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  FOCUS ............ Centre of motion. Integer for odd modes, 1.5 ; 2.5 etc for even modes.\n");
+        fprintf(stdout,"INFO:  DURATION ......... Duration of motion from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO:  REPETITIONS ...... Count of events from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Total duration and number of repetitions will be double these values, as the mix approaches and then recedes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MAXIMUM RANGE .... (Modes 1-4) Maximum angle from centreline reached ( < 90).\n");
+        fprintf(stdout,"INFO:                                 (Mode 5) Maximum distance from centre, where centre-to-loudspeaker distance is 1.\n");
+        fprintf(stdout,"INFO:  DECIMATION ....... Gain multiplier (>0 <1) on passing from one event to the next, away from the focus.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  To extend the motion further (which increases the duration and the number of repetitions)....\n");
+        fprintf(stdout,"INFO:  the (gain) decimation can be modified with these 4 parameters ... \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  THRESHOLD FOR EXTENSION.. Value of (decimated) gain at which gain the decimation starts to increase.\n");
+        fprintf(stdout,"INFO:  DECIMATION MAXIMUM ......... Maximum level of decimation after it starts to increase (> DECIMATION).\n");
+        fprintf(stdout,"INFO:  FINAL GAIN ....................... Decimated gain at which the event concludes ( < THRESHOLD).\n");
+        fprintf(stdout,"INFO:  MAXIMUM DURATION .......... Maximum duration of motion from centre to edge (in case FINAL GAIN is never reached) ( >= DURATION).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  LEFTWARDS FROM FOCUS .... Motion towards left of focal position (Default: motion towards right).\n");
+        break;
+    case(TRANSITFD):
+        fprintf(stdout,"INFO:  CREATE MULTICHANNEL MIX WHICH POSITIONS REPETITIONS OF A PAIR OF MONO SOUNDS\n");
+        fprintf(stdout,"INFO:        ON TANGENT PATH TO AND FROM AN 8-CHANNEL RING OF LSPKRS,\n");
+        fprintf(stdout,"INFO:                      SHIFTING TO 2nd PAIR ON PASSING FOCUS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  The 2nd sound is gradually mixed in to the first as distance from focus increases.\n");
+        fprintf(stdout,"INFO:  If 2nd sound is a filtered version of the first, this may suggest greater distance.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  The 3rd sound replaces the first once the focus of the motion is passed.\n");
+        fprintf(stdout,"INFO:  If the 3rd sound is a pitch-shifted version of the 1st, this may suggest doppler-shift.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  The 4th sound is gradually mixed in to the 3rd, as with sounds 1 and 2.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Additional sounds may be input, to place at the centre point of the mix (near the focus)\n");
+        fprintf(stdout,"INFO:  suggesting gradual changes in pitch at the doppler-shift moment.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Loudspeakers assumed to be equidistant in a ring, and numbered clockwise.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         GLANCING                EDGEWISE                  CROSSING                   CLOSE                   CENTRAL\n");
+        fprintf(stdout,"INFO:           ---O->>            ->>--O---O->>                       O                          O      O                          O\n");
+        fprintf(stdout,"INFO:       O              O                                           ->>--O-------O->>                                           O              O\n");
+        fprintf(stdout,"INFO:                                       O                  O                                    ->>-O--------------O->>\n");
+        fprintf(stdout,"INFO:     O                  O                                              O                  O                                  ->>-O---------------O->>\n");
+        fprintf(stdout,"INFO:                                       O                  O                                            O                  O\n");
+        fprintf(stdout,"INFO:       O              O                                                  O              O                                              O              O\n");
+        fprintf(stdout,"INFO:               O                            O      O                            O                          O      O                          O\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  FOCUS ............ Centre of motion. Integer for odd modes, 1.5 ; 2.5 etc for even modes.\n");
+        fprintf(stdout,"INFO:  DURATION ......... Duration of motion from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO:  REPETITIONS ...... Count of events from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Total duration and number of repetitions will be double these values, as the mix approaches and then recedes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MAXIMUM RANGE .... (Modes 1-4) Maximum angle from centreline reached ( < 90).\n");
+        fprintf(stdout,"INFO:                                 (Mode 5) Maximum distance from centre, where centre-to-loudspeaker distance is 1.\n");
+        fprintf(stdout,"INFO:  DECIMATION ....... Gain multiplier (>0 <1) on passing from one event to the next, away from the focus.\n");
+        fprintf(stdout,"INFO:  BALANCE DECIMATION ..Proportion of 2nd(4th) sound mixed into 1st(3rd) as sound becomes more distant from focus.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  To extend the motion further (which increases the duration and the number of repetitions)....\n");
+        fprintf(stdout,"INFO:  the (gain) decimation can be modified with these 4 parameters ... \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  THRESHOLD FOR EXTENSION.. Value of (decimated) gain at which gain the decimation starts to increase.\n");
+        fprintf(stdout,"INFO:  DECIMATION MAXIMUM ......... Maximum level of decimation after it starts to increase (> DECIMATION).\n");
+        fprintf(stdout,"INFO:  FINAL GAIN ....................... Decimated gain at which the event concludes ( < THRESHOLD).\n");
+        fprintf(stdout,"INFO:  MAXIMUM DURATION .......... Maximum duration of motion from centre to edge (in case FINAL GAIN is never reached) ( >= DURATION).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  LEFTWARDS FROM FOCUS .... Motion towards left of focal position (Default: motion towards right).\n");
+        break;
+    case(TRANSITS):
+        fprintf(stdout,"INFO:  CREATE MULTICHANNEL MIX WHICH POSITIONS A SEQUENCE OF MONO SOUND\n");
+        fprintf(stdout,"INFO:          ON TANGENT PATH TO AND FROM AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Loudspeakers assumed to be equidistant in a ring, and numbered clockwise.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         GLANCING                EDGEWISE                  CROSSING                   CLOSE                   CENTRAL\n");
+        fprintf(stdout,"INFO:           ---O->>            ->>--O---O->>                       O                          O      O                          O\n");
+        fprintf(stdout,"INFO:       O              O                                           ->>--O-------O->>                                           O              O\n");
+        fprintf(stdout,"INFO:                                       O                  O                                    ->>-O--------------O->>\n");
+        fprintf(stdout,"INFO:     O                  O                                              O                  O                                  ->>-O---------------O->>\n");
+        fprintf(stdout,"INFO:                                       O                  O                                            O                  O\n");
+        fprintf(stdout,"INFO:       O              O                                                  O              O                                              O              O\n");
+        fprintf(stdout,"INFO:               O                            O      O                            O                          O      O                          O\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  FOCUS ............ Centre of motion. Integer for odd modes, 1.5 ; 2.5 etc for even modes.\n");
+        fprintf(stdout,"INFO:  DURATION ......... Duration of motion from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Total duration will be double this value, as the mix approaches and then recedes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MAXIMUM RANGE .... (Modes 1-4) Maximum angle from centreline reached ( < 90).\n");
+        fprintf(stdout,"INFO:                                 (Mode 5) Maximum distance from centre, where centre-to-loudspeaker distance is 1.\n");
+        fprintf(stdout,"INFO:  DECIMATION ....... Gain multiplier (>0 <1) on passing from one event to the next, away from the focus.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  LEFTWARDS FROM FOCUS .... Motion towards left of focal position (Default: motion towards right).\n");
+        break;
+    case(TRANSITL):
+        fprintf(stdout,"INFO:  CREATE MULTICHANNEL MIX WHICH POSITIONS A SEQUENCE OF MONO SOUND LISTED IN A TEXTFILE\n");
+        fprintf(stdout,"INFO:          ON TANGENT PATH TO AND FROM AN 8-CHANNEL RING OF LSPKRS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Loudspeakers assumed to be equidistant in a ring, and numbered clockwise.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         GLANCING                EDGEWISE                  CROSSING                   CLOSE                   CENTRAL\n");
+        fprintf(stdout,"INFO:           ---O->>            ->>--O---O->>                       O                          O      O                          O\n");
+        fprintf(stdout,"INFO:       O              O                                           ->>--O-------O->>                                           O              O\n");
+        fprintf(stdout,"INFO:                                       O                  O                                    ->>-O--------------O->>\n");
+        fprintf(stdout,"INFO:     O                  O                                              O                  O                                  ->>-O---------------O->>\n");
+        fprintf(stdout,"INFO:                                       O                  O                                            O                  O\n");
+        fprintf(stdout,"INFO:       O              O                                                  O              O                                              O              O\n");
+        fprintf(stdout,"INFO:               O                            O      O                            O                          O      O                          O\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  FOCUS ............ Centre of motion. Integer for odd modes, 1.5 ; 2.5 etc for even modes.\n");
+        fprintf(stdout,"INFO:  DURATION ......... Duration of motion from centre to edge (ONLY).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  Total duration will be double this value, as the mix approaches and then recedes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  MAXIMUM RANGE .... (Modes 1-4) Maximum angle from centreline reached ( < 90).\n");
+        fprintf(stdout,"INFO:                                 (Mode 5) Maximum distance from centre, where centre-to-loudspeaker distance is 1.\n");
+        fprintf(stdout,"INFO:  DECIMATION ....... Gain multiplier (>0 <1) on passing from one event to the next, away from the focus.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  LEFTWARDS FROM FOCUS .... Motion towards left of focal position (Default: motion towards right).\n");
+        break;
+    case(CANTOR):
+        fprintf(stdout,"INFO:  GRADUALLY INSERT HOLES INTO A SOURCE, IN THE MANNER OF A CANTOR SET\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:  A hole is gradually cut in the middle of the source sound, dividing into two parts.\n");
+        fprintf(stdout,"INFO:  Then holes are cut in these two parts, and so on.\n");
+        fprintf(stdout,"INFO:  The output is a set of versions of the source, with more and more holes.\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO:  MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO:  MODE 1 .... Holesize proportional to size of segment they cut.\n");
+        fprintf(stdout,"INFO:  MODE 2 .... Holesize is fixed.\n");
+        fprintf(stdout,"INFO:  MODE 3 .... Holes generated by  superimposed layers of sinusoindal envelope-shapng..\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO:  In Modes 1 & 2\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO:  HOLE SIZE ........ Percentage of the input sound (or sound segment) taken up by the hole.\n");
+        fprintf(stdout,"INFO:  DIG DEPTH ........ Depth of each cut (as a fraction of 1) as hole is gradually created.\n");
+        fprintf(stdout,"INFO:  TRIGGER DEPTH .... Depth of hole at which next pair of holes start to be dug.\n");
+        fprintf(stdout,"INFO:  SPLICE LENGTH .... Splice length in milliseconds.\n");
+        fprintf(stdout,"INFO:  MAXIMUM DURATION.. Maximum total duration of all the output sounds.\n");
+        fprintf(stdout,"INFO:  EXTEND TO LIMIT .. Proceed with hole digging even when there are not enough samples left to create splices.\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO:  In Modes 3\n");
+        fprintf(stdout,"INFO:  \n");
+        fprintf(stdout,"INFO:  MNIMUM HOLE LEVEL .. Level of signal at base of holes.\n");
+        fprintf(stdout,"INFO:  DIG DEPTH .......... Number of repetitions for hole to reach its maximum depth.\n");
+        fprintf(stdout,"INFO:  LAYER COUNT ........ Number of enveloping layers used.\n");
+        fprintf(stdout,"INFO:  LAYER DECIMATION ... Relative depth at which each layer is imposed.\n");
+        fprintf(stdout,"INFO:  MAXIMUM DURATION.... Maximum total duration of all the output sounds.\n");
+        break;
+    case(SHRINK):
+        switch(mode) {
+        case(0):
+        case(1):
+        case(2):
+        case(3):
+            switch(mode) {
+            case(0):
+                fprintf(stdout,"INFO:  REPEAT A SOUND, SHRINKING IT, BY REMOVING ITS END, AS THE REPETITIONS PROCEEDS.\n");
+                break;
+            case(1):
+                fprintf(stdout,"INFO:  REPEAT A SOUND, SHRINKING IT AROUND ITS MIDPOINT AS THE REPETITIONS PROCEEDS.\n");
+                break;
+            case(2):
+                fprintf(stdout,"INFO:  REPEAT A SOUND, SHRINKING IT, BY REMOVING ITS BEGINNING, AS THE REPETITIONS PROCEEDS.\n");
+                break;
+            case(3):
+                fprintf(stdout,"INFO:  REPEAT A SOUND, SHRINKING IT AROUND A SPECIFIED TIME, AS THE REPETITIONS PROCEEDS.\n");
+                break;
+            }
+            fprintf(stdout,"INFO:  \n");
+            fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+            fprintf(stdout,"INFO:  \n");
+            if(mode == 3)
+                fprintf(stdout,"INFO:  CENTRE OF SHRINKAGE.. Time around which shrinkage takes place.\n");
+            fprintf(stdout,"INFO:  SOUND SHRINKAGE ..... Shortening factor of sound from one repeat to the next.\n");
+            fprintf(stdout,"INFO:                                                Shrinkage stops once events become too short for the splices.\n");
+            fprintf(stdout,"INFO:  EVENT GAP ........... Initial timestep between output events (>= input sound duration).\n");
+            fprintf(stdout,"INFO:  TIME CONTRACTION .....Shortening of time between placement of sounds in output stream.\n");
+            fprintf(stdout,"INFO:                                                1.0 = events equally spaced, < 1.0 events become closer\n");
+            fprintf(stdout,"INFO:                                                Events cannot overlap, so the minimum value of \"contraction\" = value of \"sound shrinkage\".\n");
+            fprintf(stdout,"INFO:  DURATION ............ (Minimum) duration of the output.\n");
+            fprintf(stdout,"INFO:  SPLICE LENGTH ....... Length of splices, in millseconds.\n");
+            fprintf(stdout,"INFO:  MINIMUM EVENT DURATION ....... When sound duration reaches this minimum, shrinkage stops and events thereafter are of equal length.\n");
+            fprintf(stdout,"INFO:  MINIMUM EVENT SEPARATION ..... When event separation reaches this minimum, contraction stops and events thereafter are equally spaced in time.\n");
+            fprintf(stdout,"INFO:  EVENT TIME RANDOMISATION ..... Randomisation of entry times of events.\n");
+            fprintf(stdout,"INFO:  EQUALISE EVENT LEVELS ........ Force the (maximum) level of all output events to that of the input event (if possible).\n");
+            fprintf(stdout,"INFO:  REVERSE SEGMENTS ............. Output events are each reversed, but remain in the same time order.\n");
+            break;
+        case(4):
+        case(5):
+            switch(mode) {
+            case(4):
+                fprintf(stdout,"INFO:  IN A SOUND, SHRINK EVENTS CENTRED ROUND DETECTABLE PEAKS.\n");
+                break;
+            case(5):
+                fprintf(stdout,"INFO:  IN A SOUND, SHRINK EVENTS CENTRED ROUND USER-SPECIFIED PEAKS.\n");
+                break;
+            }
+            fprintf(stdout,"INFO:  \n");
+            fprintf(stdout,"INFO: PARAMETERS---------------------------------------------------------------\n");
+            fprintf(stdout,"INFO:  \n");
+            if(mode == 5)
+                fprintf(stdout,"INFO:  PEAK TIMES .......... A textfile listing the times of peaks in the input sound file.\n");
+            fprintf(stdout,"INFO:  SOUND SHRINKAGE ..... Shortening factor of sound from one repeat to the next.\n");
+            fprintf(stdout,"INFO:                                                Shrinkage stops once events become too short for the splices.\n");
+            if(mode == 4)
+                fprintf(stdout,"INFO:  WINDOW SIZE ......... Size of window for peak detection (in milliSeconds).\n");
+            else
+                fprintf(stdout,"INFO:  WINDOW SIZE ......... Size of window for minima detection (in milliSeconds).\n");
+            fprintf(stdout,"INFO:  TIME CONTRACTION .....Shortening of time between placement of sounds in output stream.\n");
+            fprintf(stdout,"INFO:                                                1.0 = events equally spaced, < 1.0 events become closer\n");
+            fprintf(stdout,"INFO:                                                Events cannot overlap, so the minimum value of \"contraction\" = value of \"sound shrinkage\".\n");
+            fprintf(stdout,"INFO:  SHRINKAGE START...... Time at which shrinking begins.\n");
+            fprintf(stdout,"INFO:  SPLICE LENGTH ....... Length of splices, in millseconds.\n");
+            fprintf(stdout,"INFO:  MINIMUM EVENT DURATION ....... When sound duration reaches this minimum, shrinkage stops.\n");
+            fprintf(stdout,"INFO:  MINIMUM EVENT SEPARATION ..... When event separation reaches this minimum, contraction stops.\n");
+            fprintf(stdout,"INFO:  EVENT TIME RANDOMISATION ..... Randomisation of entry times of events.\n");
+            fprintf(stdout,"INFO:  \n");
+            fprintf(stdout,"INFO:  MINIMUM LENGTH FOR SQUEEZE START.....\n");
+            fprintf(stdout,"INFO:                                 Minimum source-segment length before sound squeezing can begin (for the \"SQUEEZE EVENLY\" option)\n");
+            fprintf(stdout,"INFO:  INPUT GATE .......... Input level (relative to the maximum level of the source) below which source-peaks are ignored.\n");
+            if(mode == 4)
+                fprintf(stdout,"INFO:  SKEW ................ Where, in the found source-segment, the sound is cut. e.g. 0 = at start  :  0.5 = in the middle  :  1 = at end.\n");
+            fprintf(stdout,"INFO:  \n");
+            fprintf(stdout,"INFO:  EQUALISE EVENT LEVELS ........ Force the (maximum) level of all output events to that of the input event (if possible).\n");
+            fprintf(stdout,"INFO:  REVERSE SEGMENTS ............. Output events are each reversed, but remain in the same time order.\n");
+            fprintf(stdout,"INFO:                        Mixing the output, then reversing the resultant sound produces an 'Expansion' of events,\n");
+            fprintf(stdout,"INFO:                        opposite to the 'Shrinkage/Contraction'.\n");
+            fprintf(stdout,"INFO:                        Note that the mixed sequence can be developed (each sound processed) to produce new, related sequences\n");
+            fprintf(stdout,"INFO:                        which can be mixed using the same mix times as in the original.\n");
+            fprintf(stdout,"INFO:                        If sounds processing involves any time-extension, start-times in the mix for the reversed segments will be altered.\n");
+            fprintf(stdout,"INFO:                        Hence, with this flag set, an additional file is output listing the gaps between sound-ENDS in any mix\n");
+            fprintf(stdout,"INFO:                        of the processed events.\n");
+            fprintf(stdout,"INFO:  SQUEEZE EVENLY ............... If \"shrinkage\" > 0, sounds shorten in a regular manner.\n");
+            fprintf(stdout,"INFO:                                                                If \"contraction\" > 0, output accelerates in a regular manner.\n");
+            fprintf(stdout,"INFO:  OUTPUT GATE .................. Omit any too-quiet events, once a fixed end tempo has been reached.\n");
+            break;
+        }
+        break;
+    case(NEWTEX):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: GRANULATE SOURCE SOUND OVER TIME AND SPACE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Granulate several streams from a SINGLE source, where the source can be transposed.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TRANSPOSITION DATA ..... A textfile Listing of transposition ratios and relative levels, against time.\n");
+            fprintf(stdout,"INFO:                     Data is a text file of lines of data and every line must have the same number of entries.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     The 1ST ENTRY on each line is a time. Times must start at zero and increase.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All EVEN NUMBERED entries are transpositions, and these must increase through a line.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                     All other ODD NUMBERED entries are loudness levels for those transposition, between -1 and 1.\n");
+            fprintf(stdout,"INFO:                     -ve values invert the phase of the source.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: DURATION ............ Total Duration of the output sound.\n");
+            fprintf(stdout,"INFO: CHANNEL COUNT ... Number of output channels.\n");
+            fprintf(stdout,"INFO: OCTAVE TRANSPOSITION.. Current range of additional octave transpositions of the original components.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIMESTEP ............ Average timestep between changes in stream-content of output.\n");
+            fprintf(stdout,"INFO: SPLICETIME (mS).... Length of fade-in/out times of components in output sound, in milliseconds.\n");
+            fprintf(stdout,"INFO: STREAMS IN PLAY . Number of streams used in any segment: If set to ZERO, number of streams used is random.\n");
+            fprintf(stdout,"INFO: MAXCHANGE COMPONENTS  As far as possible, always change components used, from one segment to the next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EMERGENCE CHANNEL .. If spatial image emerges from a single channel, to fill the space, this is the channel.\n");
+            fprintf(stdout,"INFO: EMERGENCE TIME .... If spatial image emerges from a single channel, time taken to fully emerge.\n");
+            fprintf(stdout,"INFO: CONVERGENCE CHANNEL .. If spatial image converges to a single channel at end of sound, this is the channel.\n");
+            fprintf(stdout,"INFO: CONVERGENCE TIME . If spatial image converges to a single channel, time taken to fully converge.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Note that Emergence always works but, because of the nature of the algorithm, Convergence is only a tendency\n");
+            fprintf(stdout,"INFO: and the signal may not all converge to the specified convergence channel.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: For NO EMERGENCE or NO CONVERGENCE, set the relevant values to ZERO.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: JUMP .................. Use same spatial position for all components in a segment.\n");
+            fprintf(stdout,"INFO: ROTATION SPEED .... Rotation speed for Special Space Type 3 (only).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECIAL SPACE TYPE  (8-channel files only) .... Special types of spatialisation.\n");
+            fprintf(stdout,"INFO:    1:  Left-Right Rand ........... Alternate Left and Right sides, random positions.\n");
+            fprintf(stdout,"INFO:    2:  Front-Back Rand .......... Alternate Front and back areas of space , random positions.\n");
+            fprintf(stdout,"INFO:    3:  Rotate ...................... (Requires a positive or negative rotation speed).\n");
+            fprintf(stdout,"INFO:    4:  Superspace1 ............... Single channel positions only.\n");
+            fprintf(stdout,"INFO:    5:  Superspace2 ............... Single channels and channel-pairs only.\n");
+            fprintf(stdout,"INFO:    6:  Superspace3 ............... Single channels and channel-pairs and channel-triples only.\n");
+            fprintf(stdout,"INFO:    7:  Superspace4 ............... Single channels, channel-pairs, channel-triples, square, diamond and all-positions.\n");
+            fprintf(stdout,"INFO:    8:  Left-Right Alternate ....... Alternate Left and Right sides, using all channels of each.\n");
+            fprintf(stdout,"INFO:    9:  Back-Front Alternate ...... Alternate Back and Front areas, using all channels of each.\n");
+            fprintf(stdout,"INFO:    10: Frameswitch ............... Alternate Between Square and Diamond 4-sets.\n");
+            fprintf(stdout,"INFO:    11: Triangle Rotate 1 ......... Rotate a triple of alternate channels, clockwise.\n");
+            fprintf(stdout,"INFO:    12: Triangle AntiRotate 1 ..... Rotate a triple of alternate channels, anticlockwise.\n");
+            fprintf(stdout,"INFO:    13: Triangle Rotate 2 ......... Rotate a channel and the pair opposite, clockwise.\n");
+            fprintf(stdout,"INFO:    14: Triangle AntiRotate 2 ..... Rotate a channel and the pair opposite, anticlockwise.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: GRANULATE SEVERAL SOURCE SOUNDS OVER TIME AND SPACE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Granulate a group of sounds, where the sources are not transposed.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: DURATION ............ Total Duration of the output sound.\n");
+            fprintf(stdout,"INFO: CHANNEL COUNT ... Number of output channels.\n");
+            fprintf(stdout,"INFO: MAX SOURCE DUPLICATION...... Maximum number of simultaneous streams of any one source.\n");
+            fprintf(stdout,"INFO: DELAY ................. Time delay between duplicated streams.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIMESTEP ............ Average timestep between changes in stream-content of output.\n");
+            fprintf(stdout,"INFO: SPLICETIME (mS).... Length of fade-in/out times of components in output sound, in milliseconds.\n");
+            fprintf(stdout,"INFO: STREAMS IN PLAY . Number of streams used in any segment: If set to ZERO, number of streams used is random.\n");
+            fprintf(stdout,"INFO: MAXCHANGE COMPONENTS  As far as possible, always change components used, from one segment to the next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EMERGENCE CHANNEL .. If spatial image emerges from a single channel, to fill the space, this is the channel.\n");
+            fprintf(stdout,"INFO: EMERGENCE TIME .... If spatial image emerges from a single channel, time taken to fully emerge.\n");
+            fprintf(stdout,"INFO: CONVERGENCE CHANNEL .. If spatial image converges to a single channel at end of sound, this is the channel.\n");
+            fprintf(stdout,"INFO: CONVERGENCE TIME . If spatial image converges to a single channel, time taken to fully converge.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Note that Emergence always works but, because of the nature of the algorithm, Convergence is only a tendency\n");
+            fprintf(stdout,"INFO: and the signal may not all converge to the specified convergence channel.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: For NO EMERGENCE or NO CONVERGENCE, set the relevant values to ZERO.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: JUMP .................. Use same spatial position for all components in a segment.\n");
+            fprintf(stdout,"INFO: ROTATION SPEED .... Rotation speed for Special Space Type 3 (only).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECIAL SPACE TYPE  (8-channel files only) .... Special types of spatialisation.\n");
+            fprintf(stdout,"INFO:    1:  Left-Right Rand ........... Alternate Left and Right sides, random positions.\n");
+            fprintf(stdout,"INFO:    2:  Front-Back Rand .......... Alternate Front and back areas of space , random positions.\n");
+            fprintf(stdout,"INFO:    3:  Rotate ...................... (Requires a positive or negative rotation speed).\n");
+            fprintf(stdout,"INFO:    4:  Superspace1 ............... Single channel positions only.\n");
+            fprintf(stdout,"INFO:    5:  Superspace2 ............... Single channels and channel-pairs only.\n");
+            fprintf(stdout,"INFO:    6:  Superspace3 ............... Single channels and channel-pairs and channel-triples only.\n");
+            fprintf(stdout,"INFO:    7:  Superspace4 ............... Single channels, channel-pairs, channel-triples, square, diamond and all-positions.\n");
+            fprintf(stdout,"INFO:    8:  Left-Right Alternate ....... Alternate Left and Right sides, using all channels of each.\n");
+            fprintf(stdout,"INFO:    9:  Back-Front Alternate ...... Alternate Back and Front areas, using all channels of each.\n");
+            fprintf(stdout,"INFO:    10: Frameswitch ............... Alternate Between Square and Diamond 4-sets.\n");
+            fprintf(stdout,"INFO:    11: Triangle Rotate 1 ......... Rotate a triple of alternate channels, clockwise.\n");
+            fprintf(stdout,"INFO:    12: Triangle AntiRotate 1 ..... Rotate a triple of alternate channels, anticlockwise.\n");
+            fprintf(stdout,"INFO:    13: Triangle Rotate 2 ......... Rotate a channel and the pair opposite, clockwise.\n");
+            fprintf(stdout,"INFO:    14: Triangle AntiRotate 2 ..... Rotate a channel and the pair opposite, anticlockwise.\n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: GRANULATE SOURCE SOUND(S) OVER TIME AND SPACE, WITH DRUNKEN WALK THROUGH SOURCE(S).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The sources are not transposed.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: DURATION ............ Total Duration of the output sound.\n");
+            fprintf(stdout,"INFO: CHANNEL COUNT ... Number of output channels.\n");
+            fprintf(stdout,"INFO: MAX SOURCE DUPLICATION...... Maximum number of simultaneous streams of any one source.\n");
+            fprintf(stdout,"INFO: LOCUS ................................. Time around which (next) source-read begins.\n");
+            fprintf(stdout,"INFO: AMBITUS ............................ Area around locus within which next source-segment read may start.\n");
+            fprintf(stdout,"INFO: DRUNK STEP ..................... Maximum size of random leap in source between start of this read and start of next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIMESTEP ............ Average timestep in output between changes in stream-content.\n");
+            fprintf(stdout,"INFO: SPLICETIME (mS).... Length of fade-in/out times of components in output sound, in milliseconds.\n");
+            fprintf(stdout,"INFO: STREAMS IN PLAY . Number of streams used in any segment: If set to ZERO, number of streams used is random.\n");
+            fprintf(stdout,"INFO: MAXCHANGE COMPONENTS  As far as possible, always change components used, from one segment to the next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: EMERGENCE CHANNEL .. If spatial image emerges from a single channel, to fill the space, this is the channel.\n");
+            fprintf(stdout,"INFO: EMERGENCE TIME .... If spatial image emerges from a single channel, time taken to fully emerge.\n");
+            fprintf(stdout,"INFO: CONVERGENCE CHANNEL .. If spatial image converges to a single channel at end of sound, this is the channel.\n");
+            fprintf(stdout,"INFO: CONVERGENCE TIME . If spatial image converges to a single channel, time taken to fully converge.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Note that Emergence always works but, because of the nature of the algorithm, Convergence is only a tendency\n");
+            fprintf(stdout,"INFO: and the signal may not all converge to the specified convergence channel.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: For NO EMERGENCE or NO CONVERGENCE, set the relevant values to ZERO.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: JUMP .................. Use same spatial position for all components in a segment.\n");
+            fprintf(stdout,"INFO: ROTATION SPEED .... Rotation speed for Special Space Type 3 (only).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SPECIAL SPACE TYPE  (8-channel files only) .... Special types of spatialisation.\n");
+            fprintf(stdout,"INFO:    1:  Left-Right Rand ........... Alternate Left and Right sides, random positions.\n");
+            fprintf(stdout,"INFO:    2:  Front-Back Rand .......... Alternate Front and back areas of space , random positions.\n");
+            fprintf(stdout,"INFO:    3:  Rotate ...................... (Requires a positive or negative rotation speed).\n");
+            fprintf(stdout,"INFO:    4:  Superspace1 ............... Single channel positions only.\n");
+            fprintf(stdout,"INFO:    5:  Superspace2 ............... Single channels and channel-pairs only.\n");
+            fprintf(stdout,"INFO:    6:  Superspace3 ............... Single channels, channel-pairs and triangles only.\n");
+            fprintf(stdout,"INFO:    7:  Superspace4 ............... Single channels, channel-pairs, triangles, square, diamond and all-positions.\n");
+            fprintf(stdout,"INFO:    8:  Left-Right Alternate ....... Alternate Left and Right sides, using all channels of each.\n");
+            fprintf(stdout,"INFO:    9:  Back-Front Alternate ...... Alternate Back and Front areas, using all channels of each.\n");
+            fprintf(stdout,"INFO:    10: Frameswitch ............... Alternate Between Square and Diamond 4-sets.\n");
+            fprintf(stdout,"INFO:    11: Triangle Rotate 1 ......... Rotate a triple of alternate channels, clockwise, speed determined by \"Timestep\".\n");
+            fprintf(stdout,"INFO:    12: Triangle AntiRotate 1 ..... Rotate a triple of alternate channels, anticlockwise, speed determined by \"Timestep\".\n");
+            fprintf(stdout,"INFO:    13: Triangle Rotate 2 ......... Rotate a channel and the pair opposite, clockwise, speed determined by \"Timestep\".\n");
+            fprintf(stdout,"INFO:    14: Triangle AntiRotate 2 ..... Rotate a channel and the pair opposite, anticlockwise, speed determined by \"Timestep\".\n");
+            break;
+        }
+        break;
+    case(CERACU):
+        fprintf(stdout,"INFO: SUPERIMPOSE DIFFERENT CYCLIC REPETITIONS OF A SOUND, UNTIL THE CYCLES RESYNCHRONISE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The source sound repeats at regular time-intervals.\n");
+        fprintf(stdout,"INFO: There are 2 or more streams of such repetition, each with a different repetition time-interval.\n");
+        fprintf(stdout,"INFO: A \"complete-cycle\" takes us from one point where all the streams are in sync to the next point where this is the case.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CYCLE COUNT DATA ................... A list of integers.\n");
+        fprintf(stdout,"INFO:                                    The number of items in the list determines the number of simultaneous cycle-streams.\n");
+        fprintf(stdout,"INFO:                                    The values entered determined how many repeats there are in each stream before all streams resynchronise.\n");
+        fprintf(stdout,"INFO: SHORTEST REPEAT TIME .............. Time before the first repeat in the fastest cycle. If set to ZERO, assumed to be duration of input file.\n");
+        fprintf(stdout,"INFO:                                    NB With many prime-number cycles, the \"Shortest Repeat Time\" may be adjusted upwards (sometimes considerably!)\n");
+        fprintf(stdout,"INFO:                                    to allow all the repeating cycles to fit into a cycle with the correct number of repeats.\n");
+        fprintf(stdout,"INFO:                                    (The minimum output duration, in samples, cannot be less than the Lowest Common Multiple of all the cycle-counts,\n");
+        fprintf(stdout,"INFO:                                    and the cyclecnts will all be factors of this duration).\n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT ............ Number of output channels.\n");
+        fprintf(stdout,"INFO: MINIMUM OUTPUT DURATION......... Minimum duration of the output. If set to ZERO, assumed to be one complete-cycle.\n");
+        fprintf(stdout,"INFO:                                    Process always outputs a WHOLE NUMBER of complete-cycles\n");
+        fprintf(stdout,"INFO:                                    and this output will be equal to or longer in duration than the output duration specified.\n");
+        fprintf(stdout,"INFO: OVERRIDE LENGTH LIMIT ............. Force output to continue until a complete cycle is generated, no matter how long this may take.\n");
+        fprintf(stdout,"INFO:                                    A warning will be given after 1 hour of output(!).\n");
+        fprintf(stdout,"INFO:                                    No guarantee can be given that the program will not crash for extremely long durations.\n");
+        fprintf(stdout,"INFO: ECHO DELAY ................................. An optional echo of the entire output can be added. To avoid this echo, set parameter to ZERO.\n");
+        fprintf(stdout,"INFO:                                    The echo delay should not be greater than the \"Shortest Repeat Time\" BUT\n");
+        fprintf(stdout,"INFO:                                    the \"Shortest Repeat Time\" may be recalculated (see program output) to accomodate\n");
+        fprintf(stdout,"INFO: ECHO SPATIAL OFFSET ................ Any optional echo can be offset to a different channel.\n");
+        fprintf(stdout,"INFO:                                    1 offset it 1 channel to the right, -1 offsets it 1 chyannel to the left, and so on.\n");
+        fprintf(stdout,"INFO: LINEAR OUTPUT ARRAY ................ If output > stereo, loudspeaker array assumed to be in surround (circling the audience).\n");
+        fprintf(stdout,"INFO:                                    But if this flag is set, the array is assumed to be linear (reaching from a leftmost to a rightmost point).\n");
+        break;
+    case(MADRID):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: REPEAT SOUND(S) WITH SPATIALISED ACCENTUATIONS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The source sounds repeat, with several superimposed copies played at different spatial locations.\n");
+            fprintf(stdout,"INFO: By randomly deleting events from these streams spatial relocations and accents are produced.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: OUTPUT DURATION ....................... Maximum Duration of output.\n");
+            fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT ............... Number of channels in the output sound.\n");
+            fprintf(stdout,"INFO: NUMBER OF STREAMS .................... Number of spatially distinct streams.\n");
+            fprintf(stdout,"INFO: DELETION FACTOR ........................ Proportion of events to delete.\n");
+            fprintf(stdout,"INFO:                                                        Values between 0 and 1 delete that proportion of events in the various streams.\n");
+            fprintf(stdout,"INFO:                                                        For values greater than 1, the proportion of events at a single location increases.\n");
+            fprintf(stdout,"INFO: and, if you \"ALLOW GAPS IN OUTPUT\", the proportion of empty events also increases.\n");
+            fprintf(stdout,"INFO: EVENT TIME STEP .......................... Time-step between event repetitions.\n");
+            fprintf(stdout,"INFO: EVENT TIME RANDOMISATION .......... Randomisation of time-step between event repetitions.\n");
+            fprintf(stdout,"INFO: DELETION SEED VALUE .................... If the process is run a 2nd time, with the SAME parameters,\n");
+            fprintf(stdout,"INFO:                                                        If the seed value is set to the same POSITIVE value, deletions will be the same.\n");
+            fprintf(stdout,"INFO:                                                        If set to zero however, deletions will always be different, even when all other parameters are the same.\n");
+            fprintf(stdout,"INFO: ALLOW GAPS IN OUTPUT ................. Some repeptition points may have NO sound at all.\n");
+            fprintf(stdout,"INFO: LINEAR OUTPUT ARRAY .................. If output > stereo, loudspeaker array assumed to be in surround (circling the audience).\n");
+            fprintf(stdout,"INFO:                                                        But if this flag is set, the array is assumed to be linear (reaching from a leftmost to a rightmost point).\n");
+            fprintf(stdout,"INFO: RANDOMLY_PERMUTE_INFILE_ORDER . Randomly permuter order of input files, and play 1 of each in this order before creating the next order permutation.\n");
+            fprintf(stdout,"INFO: RANDOMLY_SELECT_INFILE .............. Randomly select the next input file to use, independently of any previous selection.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: You cannot use BOTH Random Permutation AND Random Selection.\n");
+            fprintf(stdout,"INFO: Neither of these flags is operational where there is only ONE input sound.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: SEQUENCE SOUND(S) WITH SPATIALISED ACCENTUATIONS.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The source sounds follow each other in a defined sequence\n");
+            fprintf(stdout,"INFO: with several superimposed copies played at different spatial locations.\n");
+            fprintf(stdout,"INFO: By randomly deleting events from these streams spatial relocations and accents are produced.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEQUENCE DATA ........................ Textfile of integers between 1 and the number of input files.\n");
+            fprintf(stdout,"INFO:                                                        The sequence of numbers in this file determines the sequence of input files used in the output.\n");
+            fprintf(stdout,"INFO: OUTPUT DURATION ....................... Maximum Duration of output.\n");
+            fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT ............... Number of channels in the output sound.\n");
+            fprintf(stdout,"INFO: NUMBER OF STREAMS .................... Number of spatially distinct streams.\n");
+            fprintf(stdout,"INFO: DELETION FACTOR ........................ Proportion of events to delete.\n");
+            fprintf(stdout,"INFO:                                                        Values between 0 and 1 delete that proportion of events in the various streams.\n");
+            fprintf(stdout,"INFO:                                                        For values greater than 1, the proportion of events at a single location increases.\n");
+            fprintf(stdout,"INFO: and, if you \"ALLOW GAPS IN OUTPUT\", the proportion of empty events also increases.\n");
+            fprintf(stdout,"INFO: EVENT TIME STEP .......................... Time-step between event repetitions.\n");
+            fprintf(stdout,"INFO: EVENT TIME RANDOMISATION .......... Randomisation of time-step between event repetitions.\n");
+            fprintf(stdout,"INFO: DELETION SEED VALUE .................... If the process is run a 2nd time, with the SAME parameters,\n");
+            fprintf(stdout,"INFO:                                                        If the seed value is set to the same POSITIVE value, deletions will be the same.\n");
+            fprintf(stdout,"INFO:                                                        If set to zero however, deletions will always be different, even when all other parameters are the same.\n");
+            fprintf(stdout,"INFO: ALLOW GAPS IN OUTPUT ................. Some repeptition points may have NO sound at all.\n");
+            fprintf(stdout,"INFO: LINEAR OUTPUT ARRAY .................. If output > stereo, loudspeaker array assumed to be in surround (circling the audience).\n");
+            fprintf(stdout,"INFO:                                                        But if this flag is set, the array is assumed to be linear (reaching from a leftmost to a rightmost point).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: You cannot use BOTH Random Permutation AND Random Selection.\n");
+            fprintf(stdout,"INFO: Neither of these flags is operational where there is only ONE input sound.\n");
+            break;
+        }
+        break;
+    case(SHIFTER):
+        fprintf(stdout,"INFO: GENERATE A SERIES OF SIMULTANEOUS REPETITION STREAMS WHERE THE RHYTHMIC PULSE SHIFTS FROM ONE TO THE OTHER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The source sound repeats regularly in (specified) cycles.\n");
+        fprintf(stdout,"INFO: The tempi of the cycles is arranged so that the streams resynchronise after a set number of repetitions.\n");
+        fprintf(stdout,"INFO: e.g. 11,12,13 would set up 3 streams which repeat the sound 11,12 and 13 times, respectively, before the streams resynchronise.\n");
+        fprintf(stdout,"INFO: The focus may shift from one stream to another (by loudness emphasis), as the output sound evolves.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CYCLE DATA ................................. Textfile list of at least 2 different integers with values  >= 2.\n");
+        fprintf(stdout,"INFO:                                                        In Mode 2, the number of entries should equal the number of input sound-sources.\n");
+        fprintf(stdout,"INFO:                                                        These numbers represent the count of repetitions in each output stream before the streams resynchronise.\n");
+        fprintf(stdout,"INFO: CYCLE DURATION ........................ Duration from one streams-synchronisation-point to the next.\n");
+        fprintf(stdout,"INFO:                                                        Cycle duration and cycle data together determine the tempi of the different streams.\n");
+        fprintf(stdout,"INFO: MIN OUTPUT DURATION ................ Minimum Duration of the output.\n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT ............. Number of channels in the output sound. The cycles play at fixed locations distributed over the output array.\n");
+        fprintf(stdout,"INFO: MINIMUM BEAT DIVISION .............. Smallest integer subdivision of the beat: a multiple of 2 or 3, and greater than 4.\n");
+        fprintf(stdout,"INFO:                                                        This determines the quantisation of the entry-times in the various streams.\n");
+        fprintf(stdout,"INFO: LINGER CYCLES .......................... Number of cycles for which the focus is on any one cycle.\n");
+        fprintf(stdout,"INFO: TRANSITION CYCLES .................... Number of cycles during which the focus moves from one cycle to another.\n");
+        fprintf(stdout,"INFO:                                                        The sum of Linger cycles and Transition cycles must be >= 1.\n");
+        fprintf(stdout,"INFO: FOCUS LEVEL BOOST .................... If the standard stream level is \"L\", the focus stream is increased in level by \"L\" times \"FOCUS LEVEL BOOST\".\n");
+        fprintf(stdout,"INFO: LINEAR OUTPUT ARRAY .................. If output > stereo, loudspeaker array assumed to be in surround (circling the audience).\n");
+        fprintf(stdout,"INFO:                                                        But if this flag is set, the array is assumed to be linear (reaching from a leftmost to a rightmost point).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In standard operation, focus shifts to each of the listed cycles in the order they appear in the data file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: READ BACK AND FORTH_THROUGH FOCUS .. Focus shifts gradually to the end of the data list, then back gradually towards the start, and so on.\n");
+        fprintf(stdout,"INFO: RANDOMLY PERMUTE FOCUS ........... The cycle to focus on is determined by a random permutation of the order of the cycles.\n");
+        fprintf(stdout,"INFO:                                                        Once all the cycles have been used, a new permutation is made.\n");
+        fprintf(stdout,"INFO: You cannot use both Back-and-Forth AND Random focus shift.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(FRACTURE):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: MONO SOUND GRADUALLY FRACTURES INTO ELEMENTS DISTRIBUTED IN SPACE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stderr,"INFO: The source is cut into fragments which are enveloped and possibly transpose-stacked\n");
+            fprintf(stderr,"INFO: and these fragments are distributed in space.\n");
+            fprintf(stderr,"INFO: Stacks are synchronised at the envelope peak of the fragment.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ENVELOPE SERIES ......... A text datafile of lines consisting of a time and 7 pairs of envelope data.\n");
+            fprintf(stdout,"INFO:                                                       The times are abslute times and must start at 0 and advance.\"\n");
+            fprintf(stdout,"INFO:                                                       Each pair of the 7 consists of an \"etime\" and a level value.\n");
+            fprintf(stdout,"INFO:                                                       Etimes are RELATIVE times within the envelope.\n");
+            fprintf(stdout,"INFO:                                                       In Each line they must start at 0, end at 1, and advance.\n");
+            fprintf(stdout,"INFO:                                                       Levels values should lie between 0 and 1. The first and last values MUST be zero, and the maximum value MUST be 1.0.\n");
+            fprintf(stdout,"INFO:                                                       Envelopes to use at a specific time are derived by interpolating between the given envelopes\n");
+            fprintf(stdout,"INFO:                                                       and subsequently modifying their depth (how close to zero they cut - see below).\n");
+            fprintf(stdout,"INFO: OUTPUT CHANNELS ......... The number of channels in the output file (2-16).\n");
+            fprintf(stdout,"INFO: NUMBER OF SPATIAL STREAMS .. The number of spatial positions to which the resulting fragments are allotted ( >=4 ).\n");
+            fprintf(stdout,"INFO: PULSE DURATION ............ The average time between each SET of fragments (one in each stream).\n");
+            fprintf(stdout,"INFO: DEPTH AND STACK ........... Between 0 and 1 this parameter controls how deeply the envelopes cut into the source.\n");
+            fprintf(stdout,"INFO:                                                       With depth 1 the envelope cuts down to zero (as in the input envelope data).\n");
+            fprintf(stdout,"INFO:                                                       With depth 0.75 the envelope cuts 3/4 of the way to zero.\n");
+            fprintf(stdout,"INFO:                                                       With depth 0 the envelope has NO EFFECT on the source.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                                                       Once the depth value exceeds 1, a STACK value is derived, being the depth minus 1.\n");
+            fprintf(stdout,"INFO:                                                       Stacking adds transposed copies to the fragment, synchronised around the envelope peak.\n");
+            fprintf(stdout,"INFO:                                                       With a Depth of 2, the Stack value is 1: The 1st transposed element is added at full level,\n");
+            fprintf(stdout,"INFO:                                                       With a Depth of 1.5, the Stack value is .5: the transposed element is added at 1/2 level,\n");
+            fprintf(stdout,"INFO:                                                       With a Depth of 2.5, the Stack value is 1.5: The first element is added at full level, the 2nd at 1/2 level\n");
+            fprintf(stdout,"INFO:                                                       and so on.\n");
+            fprintf(stdout,"INFO: STACKING INTERVAL ........ Interval of (upward) transposition in the stack, in semitones (0-12).\n");
+            fprintf(stdout,"INFO:                                                       The (Default) zero value is read as an octave (12). Zeros MUST NOT BE USED in stack brkpoint files.\n");
+            fprintf(stdout,"INFO: READ RANDOMISATION .... Randomisation of the fragment read-time in the source. Range 0-1.\n");
+            fprintf(stdout,"INFO: PULSE RANDOMISATION ... Randomisation of the pulse duration. Range 0-1.\n");
+            fprintf(stdout,"INFO:                                                       In both cases, maximum random scatter scatters within range +- half the duration of the fragment.\n");
+            fprintf(stdout,"INFO: STREAM DISPERSAL ........ Scattering of the output timings amongst different streams.\n");
+            fprintf(stdout,"INFO:                                                       If pulse(+randomisation) generates a timing \"P\",\n");
+            fprintf(stdout,"INFO:                                                       With Dispersal 0 : all fragments start at \"P\".\n");
+            fprintf(stdout,"INFO:                                                       With Dispersal 1 : fragments are scattered within a range of +- half the duration of the fragment.\n");
+            fprintf(stdout,"INFO:                                                       Intermediate values scattered fragment start-times to various extents around the time \"W\".\n");
+            fprintf(stdout,"INFO: LEVEL RANDOMISATION .... Randomisation of the levels of the fragments. Range  0 - 1.\n");
+            fprintf(stdout,"INFO:                                                       With value 0: All fragments are at full level. Value 1 produces random levels between 0 & full level.\n");
+            fprintf(stdout,"INFO: ENVELOPE RANDOMISATION .. Randomisation of the choice of source envelope.\n");
+            fprintf(stdout,"INFO:                                                       This is a time-range between 0 and \"now\".\n");
+            fprintf(stdout,"INFO:                                                       If set (>0) the time in the envelope data file at which the envelope is selected\n");
+            fprintf(stdout,"INFO:                                                       is set randomly between \"now\" and \"now minus time-range\".\n");
+            fprintf(stdout,"INFO: STACK RANDOMISATION .. Randomisation of the stacking depth.\n");
+            fprintf(stdout,"INFO:                                                       If set to zero, stacking depth is determined completely by the depth parameter (S = D - 1).\n");
+            fprintf(stdout,"INFO:                                                       If set to one, stacking depth is selected at random between 0 and the given value.\n");
+            fprintf(stdout,"INFO:                                                       Intermediate values give intermediate random-selection ranges.\n");
+            fprintf(stdout,"INFO: PITCH RANDOMISATION IN CENTS .. Randomisation of the transposition of the fragments.\n");
+            fprintf(stdout,"INFO:                                                       If set to \"P\", Fragments are randomly transposed in pitch between +P and -P.\n");
+            fprintf(stdout,"INFO: RANDOM SEED .............. If the seed value is set as ZERO, and randomising parameters are used,\n");
+            fprintf(stdout,"INFO:                                                       running the process again with IDENTICAL parameters will produce DIFFERENT output (due to the the variable randomisation).\n");
+            fprintf(stdout,"INFO:                                                       With a POSITIVE seed value, re-running the process with IDENTICAL randomising parameters produces IDENTICAL (randomised) output.\n");
+            fprintf(stdout,"INFO: MINIMUM FRAGMENT DURATION .... Minimum duration of any fragment in any stream.\n");
+            fprintf(stdout,"INFO: MAXIMUM FRAGMENT DURATION ... Maximum duration of any fragment in any stream.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PERMIT SHORT STACKS ... Normally, very sort events are not stacked (to prevent clipping). Setting this flag allows short events to be stacked.\n");
+            fprintf(stdout,"INFO: LINEAR OUTPUT ARRAY ... If output > stereo, loudspeaker array assumed to be in surround (circling the audience).\n");
+            fprintf(stdout,"INFO:                                                        But if this flag is set, the array is assumed to be linear (reaching from a leftmost to a rightmost point).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NB Stacking, and the read, level & pitch randomisations ARE NOT ACTIVATED if the depth is less than 1.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: MONO SOUND GRADUALLY FRACTURES INTO ELEMENTS DISTRIBUTED IN STEREO, THEN STEREO-IMAGE POSITIONED IN MULTICHANNEL SPACE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stderr,"INFO: The source is cut into fragments which are enveloped and possibly transpose-stacked\n");
+            fprintf(stderr,"INFO: and these fragments are distributed in space.\n");
+            fprintf(stderr,"INFO: Stacks are synchronised at the envelope peak of the fragment.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The stereo \"front\" is then positioned in multichannel space.\n");
+            fprintf(stdout,"INFO: If the front moves it must always move forwards.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ENVELOPE SERIES ......... A text datafile of lines consisting of a time and 7 pairs of envelope data.\n");
+            fprintf(stdout,"INFO:                                                       The times are abslute times and must start at 0 and advance.\"\n");
+            fprintf(stdout,"INFO:                                                       Each pair of the 7 consists of an \"etime\" and a level value.\n");
+            fprintf(stdout,"INFO:                                                       Etimes are RELATIVE times within the envelope.\n");
+            fprintf(stdout,"INFO:                                                       In Each line they must start at 0, end at 1, and advance.\n");
+            fprintf(stdout,"INFO:                                                       Levels values should lie between 0 and 1. The first and last values MUST be zero, and the maximum value MUST be 1.0.\n");
+            fprintf(stdout,"INFO:                                                       Envelopes to use at a specific time are derived by interpolating between the given envelopes\n");
+            fprintf(stdout,"INFO:                                                       and subsequently modifying their depth (how close to zero they cut - see below).\n");
+            fprintf(stdout,"INFO: OUTPUT CHANNELS ......... The number of channels in the output file (2-16).\n");
+            fprintf(stdout,"INFO: NUMBER OF SPATIAL STREAMS .. The number of spatial positions to which the resulting fragments are allotted ( >=4 ).\n");
+            fprintf(stdout,"INFO: PULSE DURATION ............ The average time between each SET of fragments (one in each stream).\n");
+            fprintf(stdout,"INFO: DEPTH AND STACK ........... Between 0 and 1 this parameter controls how deeply the envelopes cut into the source.\n");
+            fprintf(stdout,"INFO:                                                       With depth 1 the envelope cuts down to zero (as in the input envelope data).\n");
+            fprintf(stdout,"INFO:                                                       With depth 0.75 the envelope cuts 3/4 of the way to zero.\n");
+            fprintf(stdout,"INFO:                                                       With depth 0 the envelope has NO EFFECT on the source.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                                                       Once the depth value exceeds 1, a STACK value is derived, being the depth minus 1.\n");
+            fprintf(stdout,"INFO:                                                       Stacking adds transposed copies to the fragment, synchronised around the envelope peak.\n");
+            fprintf(stdout,"INFO:                                                       With a Depth of 2, the Stack value is 1: The 1st transposed element is added at full level,\n");
+            fprintf(stdout,"INFO:                                                       With a Depth of 1.5, the Stack value is .5: the transposed element is added at 1/2 level,\n");
+            fprintf(stdout,"INFO:                                                       With a Depth of 2.5, the Stack value is 1.5: The first element is added at full level, the 2nd at 1/2 level\n");
+            fprintf(stdout,"INFO:                                                       and so on.\n");
+            fprintf(stdout,"INFO: STACKING INTERVAL ........ Interval of (upward) transposition in the stack, in semitones (0-12).\n");
+            fprintf(stdout,"INFO:                                                       The (Default) zero value is read as an octave (12). Zeros MUST NOT BE USED in stack brkpoint files.\n");
+            fprintf(stdout,"INFO: CENTRE OF IMAGE .......... Channel from which stereo image radiates (must be an integer).\n");
+            fprintf(stdout,"INFO: FRONT POSITION ............ Position of stereo image in surround-space.\n");
+            fprintf(stdout,"INFO:                                                       1 : front at centre lspkr.     -1: front at lspkr opposite to centre      0 : front at midline of surround-space.\n");
+            fprintf(stdout,"INFO:                                                       2 : front infinitely far away in direction of centre lspkr.     -(2+(depth*2)) : front infinitely far away in direction opposite to centre lspkr.\n");
+            fprintf(stdout,"INFO: DEPTH BEHIND FRONT ...... Fraction of total channels activated behind spreading front.\n");
+            fprintf(stdout,"INFO: LEVEL ROLLOFF WITH ADDED CHANNELS .... Level compensation for addition of new output channels.\n");
+            fprintf(stdout,"INFO:                                                       0, No rolloff, all channels play at full-current-level as they are added.\n");
+            fprintf(stdout,"INFO:                                                       1, Full rolloff, levels fall to 1/N of full-current-level when Nth channels is added.\n");
+            fprintf(stdout,"INFO:                                                       Intermediate values are possible.\n");
+            fprintf(stdout,"INFO: READ RANDOMISATION .... Randomisation of the fragment read-time in the source. Range 0-1.\n");
+            fprintf(stdout,"INFO: PULSE RANDOMISATION ... Randomisation of the pulse duration. Range 0-1.\n");
+            fprintf(stdout,"INFO:                                                       In both cases, maximum random scatter scatters within range +- half the duration of the fragment.\n");
+            fprintf(stdout,"INFO: STREAM DISPERSAL ........ Scattering of the output timings amongst different streams.\n");
+            fprintf(stdout,"INFO:                                                       If pulse(+randomisation) generates a timing \"P\",\n");
+            fprintf(stdout,"INFO:                                                       With Dispersal 0 : all fragments start at \"P\".\n");
+            fprintf(stdout,"INFO:                                                       With Dispersal 1 : fragments are scattered within a range of +- half the duration of the fragment.\n");
+            fprintf(stdout,"INFO:                                                       Intermediate values scattered fragment start-times to various extents around the time \"W\".\n");
+            fprintf(stdout,"INFO: LEVEL RANDOMISATION .... Randomisation of the levels of the fragments. Range  0 - 1.\n");
+            fprintf(stdout,"INFO:                                                       With value 0: All fragments are at full level. Value 1 produces random levels between 0 & full level.\n");
+            fprintf(stdout,"INFO: ENVELOPE RANDOMISATION .. Randomisation of the choice of source envelope.\n");
+            fprintf(stdout,"INFO:                                                       This is a time-range between 0 and \"now\".\n");
+            fprintf(stdout,"INFO:                                                       If set (>0) the time in the envelope data file at which the envelope is selected\n");
+            fprintf(stdout,"INFO:                                                       is set randomly between \"now\" and \"now minus time-range\".\n");
+            fprintf(stdout,"INFO: STACK RANDOMISATION .. Randomisation of the stacking depth.\n");
+            fprintf(stdout,"INFO:                                                       If set to zero, stacking depth is determined completely by the depth parameter (S = D - 1).\n");
+            fprintf(stdout,"INFO:                                                       If set to one, stacking depth is selected at random between 0 and the given value.\n");
+            fprintf(stdout,"INFO:                                                       Intermediate values give intermediate random-selection ranges.\n");
+            fprintf(stdout,"INFO: PITCH RANDOMISATION IN CENTS .. Randomisation of the transposition of the fragments.\n");
+            fprintf(stdout,"INFO:                                                       If set to \"P\", Fragments are randomly transposed in pitch between +P and -P.\n");
+            fprintf(stdout,"INFO: RANDOM SEED .............. If the seed value is set as ZERO, and randomising parameters are used,\n");
+            fprintf(stdout,"INFO:                                                       running the process again with IDENTICAL parameters will produce DIFFERENT output (due to the the variable randomisation).\n");
+            fprintf(stdout,"INFO:                                                       With a POSITIVE seed value, re-running the process with IDENTICAL randomising parameters produces IDENTICAL (randomised) output.\n");
+            fprintf(stdout,"INFO: MINIMUM FRAGMENT DURATION .... Minimum duration of any fragment in any stream.\n");
+            fprintf(stdout,"INFO: MAXIMUM FRAGMENT DURATION ... Maximum duration of any fragment in any stream.\n");
+            fprintf(stdout,"INFO: ATTENUATION FACTOR .......... Rapidity of attenuation of level of front, with distance from ring,\n");
+            fprintf(stdout,"INFO:                                                       or during intrinsic fade-out of sound which doesn't recede into far distance.\n");
+            fprintf(stdout,"INFO:                                                       1 = linear fade.\n");
+            fprintf(stdout,"INFO: SUBTEND ZERO POINT ......... Point at which image becomes mono as it retreats from circle, or ceases being mono as it approaches the circle of loudspeakers.\n");
+            fprintf(stdout,"INFO:                                                       Ratio of the required-distance(time)-to-the-subtend-zero-point to the total-distance(time)-to-infinity.\n");
+            fprintf(stdout,"INFO: CONTRACTION FACTOR ...... Rate of contraction of image :  1 = linear.\n");
+            fprintf(stdout,"INFO: MAX FILTER POINT ............ Point at which image becomes entirely lo-pass filtered as it retreats from circle, or begins to de-filter as it approaches the circle of loudspeakers.\n");
+            fprintf(stdout,"INFO:                                                       Ratio of the required-distance(time)-to-the-max-filter-point to the total-distance(time)-to-infinity.\n");
+            fprintf(stdout,"INFO: FILTER MIX FACTOR ............ Rate of replacement by filtered image :  1 = linear.\n");
+            fprintf(stdout,"INFO: FILTER LOPASS FREQUENCY.. Low-pass cut-off frequency of distance-filter.\n");
+            fprintf(stdout,"INFO: FADE IN ........................... Proportion of total duration over which event fades in from zero (independently of any fade associated with distance).\n");
+            fprintf(stdout,"INFO: FADE OUT ......................... Proportion of total duration over which event decays to zero (independently of any fade associated with distance).\n");
+            fprintf(stdout,"INFO: OVERALL GAIN ................. Overall gain: rare possibility that very rapid contraction with very low attenuation rate may cause overload in mixing to mono.\n");
+            fprintf(stdout,"INFO:                                                       In case of overload, turn down inputs with \"Overall Gain\".\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PERMIT SHORT STACKS ... Normally, very sort events are not stacked (to prevent clipping). Setting this flag allows short events to be stacked.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NB The stacking, level and repitching parameters DO NOT KICK IN until the depth reaches 1.\n");
+            break;
+        }
+        break;
+    case(SUBTRACT):
+        fprintf(stdout,"INFO: SUBTRACTS A MONO FILE FROM (1 CHANNEL OF) ANOTHER FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The first file can have any number of channels.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CHANNEL TO SUBTRACT .......... The number ( 1 - N ) of any channel in the 2nd file. (Setting to ZERO subtracts channel 1).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPEKLINE):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: CREATING SPECTRUM FROM SPECTRAL LINES TEXT DATA.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ANALYSIS CHANNELS .......................... Number of channels in output spectral file (multiple of 2).\n");
+            fprintf(stdout,"INFO: SOUND SAMPLING RATE ...................... Sampling rate of sound which will eventually be generated.\n");
+            fprintf(stdout,"INFO: OUTPUT DURATION .............................. Duration of output spectrum.\n");
+            fprintf(stdout,"INFO: NO OF ADDED HARMONICS .................. Number of harmonics to add to basic input spctrum.\n");
+            fprintf(stdout,"INFO: HARMONICS ROLLOFF(dB).................... Rolloff (in dB) proceeding from one harmonic to the next.\n");
+            fprintf(stdout,"INFO: FOOT OF INPUT DATA ........................ Minimum value in input to be represented in output spectrum ( less or equal to min data value).\n");
+            fprintf(stdout,"INFO: CEILING OF INPUT DATA ..................   Maximum value in input to be represented in output spectrum ( breater than or equal to max data value).\n");
+            fprintf(stdout,"INFO: FOOT OF SPECTRUM IN OUTPUT ........  Frequency of minimum value represented in output spectrum.\n");
+            fprintf(stdout,"INFO: CEILING OF SPECTRUM IN OUTPUT .. Frequency of maximum value represented in output spectrum.\n");
+            fprintf(stdout,"INFO: OVERALL GAIN .................................... Attenuation of output spectrum.\n");
+            fprintf(stdout,"INFO: SPECTRAL WARP .................................. If NOT set to 1.0, warpa the shape of the output spectrum .... \n");
+            fprintf(stdout,"INFO:                               Warp greater than 1 causes spectrum to be squeezed into the lower frequencies.\n");
+            fprintf(stdout,"INFO:                               Warp less than 1 causes spectrum to be squeezed into the higher frequencies.\n");
+            fprintf(stdout,"INFO: AMPLITUDE RANGE FLATTENING ........ If NOT set to 1.0 changes range of amplitudes of spectral lines.... \n");
+            fprintf(stdout,"INFO:                               As value increases, amplitude range is increasingly flattened.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: CREATING FILTER DATA FILE FROM SPECTRAL LINES TEXT DATA.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SOUND SAMPLING RATE ...................... Sampling rate of sound which will eventually be generated.\n");
+            fprintf(stdout,"INFO: OUTPUT DURATION .............................. Duration of output spectrum.\n");
+            fprintf(stdout,"INFO: FOOT OF INPUT DATA ........................ Minimum value in input to be represented in output spectrum ( less or equal to min data value).\n");
+            fprintf(stdout,"INFO: CEILING OF INPUT DATA ..................   Maximum value in input to be represented in output spectrum ( breater than or equal to max data value).\n");
+            fprintf(stdout,"INFO: FOOT OF SPECTRUM IN OUTPUT ........  Frequency of minimum value represented in output spectrum.\n");
+            fprintf(stdout,"INFO: CEILING OF SPECTRUM IN OUTPUT .. Frequency of maximum value represented in output spectrum.\n");
+            fprintf(stdout,"INFO: SPECTRAL WARP .................................. If NOT set to 1.0, warpa the shape of the output spectrum .... \n");
+            fprintf(stdout,"INFO:                               Warp greater than 1 causes spectrum to be squeezed into the lower frequencies.\n");
+            fprintf(stdout,"INFO:                               Warp less than 1 causes spectrum to be squeezed into the higher frequencies.\n");
+            fprintf(stdout,"INFO: AMPLITUDE RANGE FLATTENING ........ If NOT set to 1.0 changes range of amplitudes of spectral lines.... \n");
+            fprintf(stdout,"INFO:                               As value increases, amplitude range is increasingly flattened.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        }
+        break;
+    case(SPECMORPH):
+        switch(mode) {
+        case(6):
+            fprintf(stdout,"INFO: MORPH, IN STEPS, BETWEEN TWO DISSIMILAR SPECTRA.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Spectral peaks of 2 files are matched and, at each output step, move away from 1st and closer to 2nd.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NUMBER OF PEAKS TO MAP ..................... Number of peaks to look for.\n");
+            fprintf(stdout,"INFO: NUMBER OF INTERMEDIATE FILES ... Number of output files with peaks in between the 1st and 2nd input files.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RETAIN LOUDNESS ENVELOPE OF 1st SND The loudness contour of the 1st sound is retained, even as its spectrum is changed.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: INTERP PEAKS ONLY .................... Retain file1 content of all non-peak channels.\n");
+            fprintf(stdout,"INFO:                                   (In default case, non-peak channels interpolate towards file2 values).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: INTERP PEAK FREQUENCIES ONLY .. Amplitudes of peak channels are determined by peak amplitudes of sound 1 only.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        default:
+            fprintf(stdout,"INFO: MORPH BETWEEN TWO DISSIMILAR SPECTRA.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Spectral peaks are matched, and pitch-glide towards one another.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Modes 1 and 2: Calculate the channels of the spectral peaks as an average over the whole sound.\n");
+            fprintf(stdout,"INFO: Modes 3 and 4: Calculate the channels of the spectral peaks on a window by window basis.\n");
+            fprintf(stdout,"INFO: Modes 5 and 6: Uses harmonic field of the average peaks in the 2nd sound to tune the spectrum of the 1st.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: 2nd FILE ENTRY TIME ........... Entry of 2nd sound may be delayed (but morph can only begin oce it has entered).\n");
+            fprintf(stdout,"INFO: INTERPOLATION START ........ Start time of the morph.\n");
+            fprintf(stdout,"INFO: INTERPOLATION END ........... End time of the morph.\n");
+            fprintf(stdout,"INFO: INTERPOLATION EXPONENT ... Determines the shape of the interpolation.\n");
+            fprintf(stdout,"INFO:                      In modes 1 and 3\n");
+            fprintf(stdout,"INFO:                                   exponent 1 gives a linear interpolation.\n");
+            fprintf(stdout,"INFO:                                   exponent more than 1 interpolates slower at the start and faster at the end.\n");
+            fprintf(stdout,"INFO:                                   exponent less than 1 interpolates faster at the start and slower at the end.\n");
+            fprintf(stdout,"INFO:                      In modes 2 and 4\n");
+            fprintf(stdout,"INFO:                                   exponent 1 gives a cosinusiodal interpolation.\n");
+            fprintf(stdout,"INFO:                                   exponent more than 1 forces the cosinusiodal transition towards the midpoint-time.\n");
+            fprintf(stdout,"INFO:                                   exponent less than 1 speeds up the initial and final interpolation-rate.\n");
+            fprintf(stdout,"INFO:                                   exponent .85 approaches the linear case.\n");
+            fprintf(stdout,"INFO:                                   Below .85 the interpolation lingers longer around its half-way point.\n");
+            fprintf(stdout,"INFO: NUMBER OF PEAKS TO MAP ..................... Number of peaks to look for.\n");
+            fprintf(stdout,"INFO: RANDOMISATION OF GOAL PEAK FRQ ... Randomisation of goal peak-frequencies (can vary over time).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RETAIN LOUDNESS ENVELOPE OF 1st SND The loudness contour of the 1st sound is retained, even as its spectrum morphs.\n");
+            fprintf(stdout,"INFO:                                   In this case, output will cease once the 1st sound ends.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: INTERP PEAKS ONLY .................... Retain file1 content of all non-peak channels.\n");
+            fprintf(stdout,"INFO:                                   (In default case, non-peak channels interpolate towards file2 values).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: INTERP PEAK FREQUENCIES ONLY .. Peak channel amplitudes are determined by 1st sound peak amplitudes only.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        }
+        break;
+    case(SPECMORPH2):
+        fprintf(stdout,"INFO: EXTRACT OR MORPH SPECTRAL PEAKS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Spectral peaks are made to glide to new values.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Mode 1:  Extract average frequencies of the peaks  (in order of decreasing prominence).\n");
+        fprintf(stdout,"INFO: Mode 2: Uses peak-frequencies specified in textfile (in order of decreasing prominence) to gradually tune the spectrum.\n");
+        fprintf(stdout,"INFO: Mode 3: Ditto, using cosinusoidal morph.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF PEAKS TO LOOK FOR ..... Number of peaks to look for.\n");
+        fprintf(stdout,"INFO: INTERPOLATION START ........ Start time of the morph.\n");
+        fprintf(stdout,"INFO: INTERPOLATION END ........... End time of the morph.\n");
+        fprintf(stdout,"INFO: INTERPOLATION EXPONENT ... Determines the shape of the interpolation.\n");
+        fprintf(stdout,"INFO:                      In modes 1 and 3\n");
+        fprintf(stdout,"INFO:                                   exponent 1 gives a linear interpolation.\n");
+        fprintf(stdout,"INFO:                                   exponent more than 1 interpolates slower at the start and faster at the end.\n");
+        fprintf(stdout,"INFO:                                   exponent less than 1 interpolates faster at the start and slower at the end.\n");
+        fprintf(stdout,"INFO:                      In modes 2 and 4\n");
+        fprintf(stdout,"INFO:                                   exponent 1 gives a cosinusiodal interpolation.\n");
+        fprintf(stdout,"INFO:                                   exponent more than 1 forces the cosinusiodal transition towards the midpoint-time.\n");
+        fprintf(stdout,"INFO:                                   exponent less than 1 speeds up the initial and final interpolation-rate.\n");
+        fprintf(stdout,"INFO:                                   exponent .85 approaches the linear case.\n");
+        fprintf(stdout,"INFO:                                   Below .85 the interpolation lingers longer around its half-way point.\n");
+        fprintf(stdout,"INFO: RANDOMISATION OF GOAL PEAK FRQ ... Randomisation of goal peak-frequencies (can vary over time).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(NEWDELAY):
+        fprintf(stdout,"INFO: DELAY WITH FEEDBACK, GENERATING PITCHED OUTPUT.\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: Pitch a sound using delay with feedback.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIDI PITCH .................. MIDI pitch generated by delayed feedback\n");
+            fprintf(stdout,"INFO: DELAYED SIGNAL IN MIX .. Level of delayed signal in the output\n");
+            fprintf(stdout,"INFO: FEEDBACK................... Feedback level (Feedback generates pitch effect)\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: Pitch the start portion (HEAD) of a sound using delay with feedback.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIDI PITCH ....................................................... MIDI pitch to be generated.\n");
+            fprintf(stdout,"INFO: HEAD DURATION ................................................ Duration of Head portion of sound.\n");
+            fprintf(stdout,"INFO: FACTOR BY WHICH HEAD DURATION EXTENDED .......... Repeats of Head cause the resulting pitched-head to be longer than original by this factor.\n");
+            fprintf(stdout,"INFO: DELAY RANDOMISATION ....................................... More randomisation of delay causes pitch to be more gritty or unclear.\n");
+            fprintf(stdout,"INFO: MAX OF LEVEL DIP IN EXTENDED HEAD (A FACTOR) ....... Extended Head can dip in level in its middle. Factor 1 = no dip, factor 3 = dip to 1/3 level.\n");
+            fprintf(stdout,"INFO: POSITION OF MAX DIP AS FRACTION OF HEAD LENGTH .. Any dip in level reaches its lowest point at this fraction of the extended head's duration.\n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        }
+        break;
+    case(FILTRAGE):
+        fprintf(stdout,"INFO: GENERATE RANDOM FILTER-SETTINGS FOR VARIBANK FILTER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Mode 1: Make fixed-values filter.\n");
+        fprintf(stdout,"INFO: Mode 2: Make time-varying filter.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION ...................... Duration of filter.\n");
+        fprintf(stdout,"INFO: NUMBER OF FILTERS .......... Number of separate pitch-streams defined in output filter data.\n");
+        fprintf(stdout,"INFO: MIN MIDIPITCH OF FILTERS .. Minimum MIDI pitch in any specified pitchstream.\n");
+        fprintf(stdout,"INFO: MAX MIDIPITCH OF FILTERS .. Maximum MIDI pitch in any specified pitchstream\n");
+        fprintf(stdout,"INFO: PITCH DISTRIBUTION ........ 1 gives linear pitch-distribution,\n");
+        fprintf(stdout,"INFO:                                           greater than 1 squeezes pitches towards lower values.\n");
+        fprintf(stdout,"INFO:                                           less than 1 squeezes pitches towards higher values.\n");
+        fprintf(stdout,"INFO: PITCH RANDOMISATION ......... Randomisation of pitches. 1 gives maximum randomisation.\n");
+        fprintf(stdout,"INFO: MINIMUM FILTER AMPLITUDE ... Filters will vary in amplitude between thhis MINIMUM, and the max value of 1.0\n");
+        fprintf(stdout,"INFO: AMPLITUDE RANDOMISATION .. Randomisation of amplitudes.\n");
+        fprintf(stdout,"INFO: AMPLITUDE DISTRIBUTION ...... 0 gives random amplitudes.\n");
+        fprintf(stdout,"INFO:                                           1 gives increasing amplitude with pitch.\n");
+        fprintf(stdout,"INFO:                                           -1 gives decreasing amplitude with pitch.\n");
+        fprintf(stdout,"INFO:                                           Intermediate values give increasing degrees of randomisation, as zero is approached.\n");
+        if(mode == 1) {
+            fprintf(stdout,"INFO: TIMESTEP BETWEEN FILTER SETS .. (Average) timestep between each pitch-set specification, for time-changing filters,\n");
+            fprintf(stdout,"INFO: RANDOMISATION OF TIMESTEP ........ Randomisation of timesteps.\n");
+        }
+        fprintf(stdout,"INFO: RANDOM SEED .................... If seed value is NOT zero, random values used in process will be reproduced on next pass with SAME parameters.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ITERLINE):
+    case(ITERLINEF):
+        if(process == ITERLINE)
+            fprintf(stdout,"INFO: EXTEND SOURCE BY ITERATION, FOLLOWING A DEFINED TRANSPOSITION LINE.\n");
+        else {
+            fprintf(stdout,"INFO: EXTEND BY ITERATION A SET OF SOUNDS WHICH ARE TRANSPOSITIONS OF A SOURCE, FOLLOWING A DEFINED TRANSPOSITION LINE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The aim here is to effect a line which changes in pitch without altering the formant character of a source.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: There must be 25 input files, being semitone transpositions of an original source.\n");
+            fprintf(stdout,"INFO: The first 12 sounds are transpositions downward by 12 semitones, 11 semitones, 10 semitones etc\n");
+            fprintf(stdout,"INFO: File 13 is the original, untransposed source.\n");
+            fprintf(stdout,"INFO: Files 14-25 are transpositions upwards by 1 semitone, 2 semitones, 3 semitones etc\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: The transpositions should be duration and formant preserving.\n");
+            fprintf(stdout,"INFO: \n");
+        }
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Mode 1: Interpolate timewise between transposition values.\n");
+        fprintf(stdout,"INFO: Mode 2: Step between transposition values.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TRANSPOSITION DATA.....Textfile of pairs of time/transposition values. Times must start at 0, and increase.\n");
+        fprintf(stdout,"INFO:                                       Transposition valueds are in (possibly fractional) semitones, in range +- 24 (2 octaves up or down)\n");
+        fprintf(stdout,"INFO: DELAY..................(average) delay between iterations.\n");
+        fprintf(stdout,"INFO: PITCH SCATTER..........max of randomisation of pitchshift of each iteration: (possibly fractional) semitones.\n");
+        fprintf(stdout,"INFO: AMPLITUDE SCATTER......max of random amp-reduction on each iteration.\n");
+        fprintf(stdout,"INFO: OVERALL GAIN...........(special) value 0, gives best guess for no distortion.\n");
+        fprintf(stdout,"INFO: SEED RANDOM GENERATOR..same number produces identical output on rerun,\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECRAND):
+        fprintf(stdout,"INFO: TIME-RANDOMISE SPECTRAL DATA.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANDOMISATION TIMESCALE .......... Timescale over which spectral data are randomised.\n");
+        fprintf(stdout,"INFO: WINDOW GROUPING .................. Spectral windows are grouped into sets of time-adjacent windows, and these sets are time-randomised,\n");
+        fprintf(stdout,"INFO:                                          This parameter determines the number of windows in each set.\n");
+        fprintf(stdout,"INFO:                                          The duration of the window-group cannot exceed (half of) the Randomisation Timescale.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECSQZ):
+        fprintf(stdout,"INFO: SQUEEZE THE FREQUENCY-SECTRUM.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CENTRE FREQUENCY ............. Frequency around which other values are squeezed.\n");
+        fprintf(stdout,"INFO: SQUEEZE FACTOR ............... Contraction of the frequency data range (less than 1).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(HOVER2):
+        fprintf(stdout,"INFO: ZIGZAG READ A SOURCE AT A GIVEN FREQUENCY.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: At any specified location, process searches for nearby zero-crossing,\n");
+        fprintf(stdout,"INFO: then reads forwards from the zero, then back to the zero, producing a wave half-cycle,\n");
+        fprintf(stdout,"INFO: then writes the inversion of those samples, producing symmetrical 2nd-half of wave-cycle.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RATE OF HOVER (Hz) .... slow rate: reads lots of samples forwards, backwards, forwards.\n");
+        fprintf(stdout,"INFO:                         fast rate: reads fewer samples forwards, backwards, forwards.\n");
+        fprintf(stdout,"INFO: LOCATION OF HOVERING .. Time in input sound where samples are read.\n");
+        fprintf(stdout,"INFO: RANDOMISATION OF RATE (0-1)\n");
+        fprintf(stdout,"INFO: RANDOMISATION OF LOCATION (0-1)\n");
+        fprintf(stdout,"INFO: OUTPUT DURATION ....... Total Duration of output file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ADVANCE LOCATIONS STEPWISE ..... If a brkpoint table is used for LOCATION\n");
+        fprintf(stdout,"INFO:                         then the location read at any time-value remains the read-location\n");
+        fprintf(stdout,"INFO:                         until a new time-value in the file is reached.\n");
+        fprintf(stdout,"INFO:                         (The default read mode is to INTERPOLATE between locations specified at the time-values in the file).\n");
+        fprintf(stdout,"INFO: NORMALISE OUTPUT ..... Normalise the level of all wavecycles generated.\n");
+        break;
+    case(SELFSIM):
+        fprintf(stdout,"INFO: MAKE SPECTRUM MORE SELF-SIMILAR.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SELF SIMILARITY INDEX ............. Number of similar windows to replace.\n");
+        fprintf(stdout,"INFO:                         Value 1 uses loudest window to replace the most similar window.\n");
+        fprintf(stdout,"INFO:                         then the next loudest window to replace window most similar to it\n");
+        fprintf(stdout,"INFO:                         and so on, with appropriate overall-loudness scaling.\n");
+        fprintf(stdout,"INFO:                         With value 2, loudest windows replaces the TWO windows most similar to it.\n");
+        fprintf(stdout,"INFO:                         and so on.\n");
+        fprintf(stdout,"INFO:                         If two windows are to be replaced by A, and A first replaces B,\n");
+        fprintf(stdout,"INFO:                         and D is more similar to B, than C is to A, then A replaces D rather than C.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ITERFOF):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: GENERATE PITCHED LINE FROM SMALL SOUND PACKET OR FOF.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Treat source as a wavelength sized FOF, and use transposition data, to guide pitch of output line.\n");
+            fprintf(stdout,"INFO: With any transposition breakpoint file, interpolate between values, so pitch glides from one value to next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE WHOLE EVENT ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEMITONE TRANSPOSITION OF LINE Assumes duration of input = wavelength of the fundamental pitch to be transposed.\n");
+            fprintf(stdout,"INFO: DURATION ............................... (Minimum) duration of the entire output sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE ELELEMTS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEGMENT PITCH RANDOMISATION ... Randomises pitch of individual segments themselves.\n");
+            fprintf(stdout,"INFO: MAX OF RANDOM AMP REDUCTION .. If greater than 0, amplitude of successive segments are randomly reduced\n");
+            fprintf(stdout,"INFO:                                                                          up to a maximum of the value input here.\n");
+            fprintf(stdout,"INFO: TRIMMED DURATION OF ELEMENTS . If elements are to be shortened, this is Duration to trim to\n");
+            fprintf(stdout,"INFO:                                                                          and will be equal to or less than (possibly transposed) source duration.\n");
+            fprintf(stdout,"INFO:                                                                          A ZERO value means the elements are NOT trimmed.\n");
+            fprintf(stdout,"INFO: FADE DURATION OF ELEMENTS ...... Duration of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: FADE SLOPE ............................. Slope of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE LINE ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH ROUGHNESS ....................... Randomisation of instantaneous pitch.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO FREQUENCY .......... Minimum frequency of line vibrato.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO FREQUENCY .......... Maximum frequency of line vibrato. Frequnecy varies at random between min and max.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO DEPTH ................. Minimum depth of line vibrato in semitones.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO DEPTH  ................ Maximum depth of line vibrato. Depth varies at random between min and max.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GENERAL PARAMETERS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RANDOM SEED ......... ............. Setting a particular seed value will produce similar output when same seed applied again.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: GENERATE STEPPED PITCHED LINE FROM SMALL SOUND PACKET OR FOF.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Treat source as a wavelength sized FOF, and use transposition data, to set pitches of output line.\n");
+            fprintf(stdout,"INFO: With any transposition breakpoint file, STEP between values, so that pitch steps from one timed-event to next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE WHOLE EVENT ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEMITONE TRANSPOSITION OF LINE Assumes duration of input = wavelength of the fundamental pitch to be transposed.\n");
+            fprintf(stdout,"INFO: DURATION ............................... (Minimum) duration of the entire output sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE ELELEMTS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEGMENT PITCH RANDOMISATION ... Randomises pitch of individual segments themselves.\n");
+            fprintf(stdout,"INFO: MAX OF RANDOM AMP REDUCTION .. If greater than 0, amplitude of successive segments are randomly reduced\n");
+            fprintf(stdout,"INFO:                                                                          up to a maximum of the value input here.\n");
+            fprintf(stdout,"INFO: TRIMMED DURATION OF ELEMENTS . If elements are to be shortened, this is Duration to trim to\n");
+            fprintf(stdout,"INFO:                                                                          and will be equal to or less than (possibly transposed) source duration.\n");
+            fprintf(stdout,"INFO:                                                                          A ZERO value means the elements are NOT trimmed.\n");
+            fprintf(stdout,"INFO: FADE DURATION OF ELEMENTS ...... Duration of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: FADE SLOPE ............................. Slope of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE LINE ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH ROUGHNESS ....................... Randomisation of instantaneous pitch.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO FREQUENCY .......... Minimum frequency of line vibrato.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO FREQUENCY .......... Maximum frequency of line vibrato. Frequnecy varies at random between min and max.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO DEPTH ................. Minimum depth of line vibrato in semitones.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO DEPTH  ................ Maximum depth of line vibrato. Depth varies at random between min and max.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS FOR ANY DISTINCT PITCHES ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIN LEVEL NOTES ..................... Minimum note loudness.\n");
+            fprintf(stdout,"INFO: MAX LEVEL NOTES ..................... Maximum note loudness. Notes vary in loudness between min and max\n");
+            fprintf(stdout,"INFO: NOTE INFADE DURATION ............ Duration of any fade-in of notes.\n");
+            fprintf(stdout,"INFO: NOTE OUTFADE DURATION ......... Duration of any fade-out of notes.\n");
+            fprintf(stdout,"INFO: GAP BETWEEN NOTES ................. Relative length of any gap between notes, as proportion of note duration.\n");
+            fprintf(stdout,"INFO: PORTAMENTO TYPE ................... 0 = none  :  1 = rising  :  -1 = falling  :  2 = randomly rising or falling.\n");
+            fprintf(stdout,"INFO: PORTAMENTO INTERVAL ............. Interval rise(fall) of any portamento, in semitones, attained only by the start-time of next note.\n");
+            fprintf(stdout,"INFO:                                                            (If there are gaps between notes, maximum interval will not be reached).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GENERAL PARAMETERS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RANDOM SEED ......... ............. Setting a particular seed value will produce similar output when same seed applied again.\n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: GENERATE PITCHED LINE FROM INPUT SOUND.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIDI-pitch data determines pitch of output line.\n");
+            fprintf(stdout,"INFO: With any pitch breakpoint file, interpolate between timed values, so that pitch glides from one timed-event to next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE WHOLE EVENT ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIDI-PITCH OF LINE ...................\n");
+            fprintf(stdout,"INFO: DURATION ............................... (Minimum) duration of the entire output sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE ELELEMTS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEGMENT PITCH RANDOMISATION ... Randomises pitch of individual segments themselves.\n");
+            fprintf(stdout,"INFO: MAX OF RANDOM AMP REDUCTION .. If greater than 0, amplitude of successive segments are randomly reduced\n");
+            fprintf(stdout,"INFO:                                                                          up to a maximum of the value input here.\n");
+            fprintf(stdout,"INFO: TRIMMED DURATION OF ELEMENTS . If elements are to be shortened, this is Duration to trim to\n");
+            fprintf(stdout,"INFO:                                                                          and will be equal to or less than (possibly transposed) source duration.\n");
+            fprintf(stdout,"INFO:                                                                          A ZERO value means the elements are NOT trimmed.\n");
+            fprintf(stdout,"INFO: FADE DURATION OF ELEMENTS ...... Duration of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: FADE SLOPE ............................. Slope of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                                                            (If there are gaps between notes, maximum interval will not be reached).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE LINE ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH ROUGHNESS ....................... Randomisation of instantaneous pitch.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO FREQUENCY .......... Minimum frequency of line vibrato.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO FREQUENCY .......... Maximum frequency of line vibrato. Frequnecy varies at random between min and max.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO DEPTH ................. Minimum depth of line vibrato in semitones.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO DEPTH  ................ Maximum depth of line vibrato. Depth varies at random between min and max.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GENERAL PARAMETERS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RANDOM SEED ......... ............. Setting a particular seed value will produce similar output when same seed applied again.\n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: GENERATE STEP-PITCHED LINE FROM INPUT SOUND.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIDI-pitch data determines pitches of output line.\n");
+            fprintf(stdout,"INFO: With any pitch breakpoint file, step between timed values, so pitch steps from one timed-event to next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE WHOLE EVENT ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIDI-PITCHES OF LINE ...............\n");
+            fprintf(stdout,"INFO: DURATION ............................... (Minimum) duration of the entire output sound.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE ELELEMTS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEGMENT PITCH RANDOMISATION ... Randomises pitch of individual segments themselves.\n");
+            fprintf(stdout,"INFO: MAX OF RANDOM AMP REDUCTION .. If greater than 0, amplitude of successive segments are randomly reduced\n");
+            fprintf(stdout,"INFO:                                                                          up to a maximum of the value input here.\n");
+            fprintf(stdout,"INFO: TRIMMED DURATION OF ELEMENTS . If elements are to be shortened, this is Duration to trim to\n");
+            fprintf(stdout,"INFO:                                                                          and will be equal to or less than (possibly transposed) source duration.\n");
+            fprintf(stdout,"INFO:                                                                          A ZERO value means the elements are NOT trimmed.\n");
+            fprintf(stdout,"INFO: FADE DURATION OF ELEMENTS ...... Duration of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: FADE SLOPE ............................. Slope of any fade on end of elements.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS OF THE LINE ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH ROUGHNESS ....................... Randomisation of instantaneous pitch.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO FREQUENCY .......... Minimum frequency of line vibrato.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO FREQUENCY .......... Maximum frequency of line vibrato. Frequnecy varies at random between min and max.\n");
+            fprintf(stdout,"INFO: MIN VIBRATO DEPTH ................. Minimum depth of line vibrato in semitones.\n");
+            fprintf(stdout,"INFO: MAX VIBRATO DEPTH  ................ Maximum depth of line vibrato. Depth varies at random between min and max.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS FOR ANY DISTINCT PITCHES (Modes 2 and 4) ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MIN LEVEL NOTES ..................... Minimum note loudness.\n");
+            fprintf(stdout,"INFO: MAX LEVEL NOTES ..................... Maximum note loudness. Notes vary in loudness between min and max\n");
+            fprintf(stdout,"INFO: NOTE INFADE DURATION ............ Duration of any fade-in of notes.\n");
+            fprintf(stdout,"INFO: NOTE OUTFADE DURATION ......... Duration of any fade-out of notes.\n");
+            fprintf(stdout,"INFO: GAP BETWEEN NOTES ................. Relative length of any gap between notes, as proportion of note duration.\n");
+            fprintf(stdout,"INFO: PORTAMENTO TYPE ................... 0 = none  :  1 = rising  :  -1 = falling  :  2 = randomly rising or falling.\n");
+            fprintf(stdout,"INFO: PORTAMENTO INTERVAL ............. Interval rise(fall) of any portamento, in semitones, attained only by the start-time of next note.\n");
+            fprintf(stdout,"INFO:                                                            (If there are gaps between notes, maximum interval will not be reached).\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GENERAL PARAMETERS ----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RANDOM SEED ......... ............. Setting a particular seed value will produce similar output when same seed applied again.\n");
+            break;
+        }
+        break;
+    case(PULSER):
+    case(PULSER2):
+    case(PULSER3):
+        switch(mode) {
+        case(0):
+            switch(process) {
+            case(PULSER):
+                fprintf(stdout,"INFO: CREATE A STREAM OF PITCHED PACKETS FROM A MONO SOURCE.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: (NB: Only the spectral brightness of the source is reflected in the output sound.)\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                break;
+            case(PULSER2):
+                fprintf(stdout,"INFO: CREATE A STREAM OF PITCHED PACKETS FROM MONO SOURCES.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: (NB: Only the spectral brightness of the sources is reflected in the output sound.)\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                break;
+            case(PULSER3):
+                fprintf(stdout,"INFO: CREATE A STREAM OF SYNTHESIZED PACKETS FROM PARTIAL-NUMBER DATA.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARTIAL NUMBERS AND LEVELS ......... Textfile list of paired items: Each pair is a partial number and a level.\n");
+                fprintf(stdout,"INFO:                                                                                  Partial number range 1 - 64 (can be fractional) : level range -1 to 1.\n");
+                break;
+            }
+            fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+            fprintf(stdout,"INFO: MIDI PITCH ................................. Midi pitch of output packets.\n");
+            break;
+        case(1):
+            switch(process) {
+            case(PULSER):
+                fprintf(stdout,"INFO: CREATE A STREAM OF PACKETS FROM A MONO SOURCE, USING THE START OF THE SOURCE ONLY.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+                break;
+            case(PULSER2):
+                fprintf(stdout,"INFO: CREATE A STREAM OF PACKETS FROM MONO SOURCES, USING THE START OF THE SOURCES ONLY.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+                break;
+            case(PULSER3):
+                fprintf(stdout,"INFO: CREATE A STREAM OF SYNTHESIZED PACKETS WHOSE SPECTRA CHANGE WITH TIME.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARTIAL NUMBERS AND LEVELS ......... Textfile is of list of lines of format \"Time  partialno level [partialno2 level2 ......]\"\n");
+                fprintf(stdout,"INFO:                                                                                  Partial number range 1 - 64 (can be fractional) : level range -1 to 1.\n");
+                fprintf(stdout,"INFO:                                                                                  Timers must start at zero, and increase.\n");
+                fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+                fprintf(stdout,"INFO: MIDI PITCH ................................. Midi pitch of output packets.\n");
+                break;
+            }
+            break;
+        case(2):
+            switch(process) {
+            case(PULSER):
+                fprintf(stdout,"INFO: CREATE A STREAM OF PACKETS FROM A MONO SOURCE, SELECTING RANDOM CHUNKS FROM INSIDE THE SOURCE.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+                fprintf(stdout,"INFO: LSPKR SELECTION ...................... ZERO   ~~OR~~   SPATIALISATION DATA FOR AN 8-CHANNEL OUPUT.\n");
+                fprintf(stdout,"INFO:                                                                                  With ZERO, Sound Output is MONO or (if WIDTH > 0) STEREO.\n");
+                fprintf(stdout,"INFO:                                                                                  SPATIALISATION DATA is either ......\n");
+                fprintf(stdout,"INFO:                                                                                              (1) a string of channel numbers indicating which of 8 ouput channels to use.\n");
+                fprintf(stdout,"INFO:                                                                                              (2) A textfile with a time and a spacedata-string on each line, times increasing from one line to next.\n");
+                fprintf(stdout,"INFO:                                                                                                      The number of channels used (as well as the channel selection) may change with time.\n");
+                break;
+            case(PULSER2):
+                fprintf(stdout,"INFO: CREATE A STREAM OF PACKETS FROM MONO SOURCES, SELECTING RANDOM CHUNKS FROM INSIDE THE SOURCES.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+                fprintf(stdout,"INFO: LSPKR SELECTION ...................... ZERO   ~~OR~~   SPATIALISATION DATA FOR AN 8-CHANNEL OUPUT.\n");
+                fprintf(stdout,"INFO:                                                                                  With ZERO, Sound Output is MONO or (if WIDTH > 0) STEREO.\n");
+                fprintf(stdout,"INFO:                                                                                  SPATIALISATION DATA is either ......\n");
+                fprintf(stdout,"INFO:                                                                                              (1) a string of channel numbers indicating which of 8 ouput channels to use.\n");
+                fprintf(stdout,"INFO:                                                                                              (2) A textfile with a time and a spacedata-string on each line, times increasing from one line to next.\n");
+                fprintf(stdout,"INFO:                                                                                                      The number of channels used (as well as the channel selection) may change with time.\n");
+                break;
+            case(PULSER3):
+                fprintf(stdout,"INFO: CREATE A STREAM OF SYNTHESIZED PACKETS WHOSE SPECTRA CHANGE AT RANDOM.\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+                fprintf(stdout,"INFO: \n");
+                fprintf(stdout,"INFO: PARTIAL NUMBERS AND LEVELS ......... Textfile is of list of lines of format \"Time  partialno level [partialno2 level2 ......]\"\n");
+                fprintf(stdout,"INFO:                                                                                  Partial number range 1 - 64 (can be fractional) : level range -1 to 1.\n");
+                fprintf(stdout,"INFO:                                                                                  Timers must start at zero, and increase.\n");
+                fprintf(stdout,"INFO:                                                                                  Lines are read in RANDOM order (TIMES ARE IGNORED).\n");
+                fprintf(stdout,"INFO: DURATION .................................. Duration of output.\n");
+                fprintf(stdout,"INFO: MIDI PITCH ................................. Midi pitch of output packets.\n");
+                break;
+            }
+            break;
+        }
+        fprintf(stdout,"INFO: RISE-TIME MINIMUM/MAXIMUM ......... Minimum and maximum duration of risetime of packets.\n");
+        fprintf(stdout,"INFO: SUSTAIN-TIME MINIMUM/MAXIMUM .. Minimum and maximum duration of sustain time of packets.\n");
+        fprintf(stdout,"INFO: DECAY-TIME MINIMUM/MAXIMUM ...... Minimum and maximum duration of decaytime of packets.\n");
+        fprintf(stdout,"INFO:                                                                                  Actual rise, sustain and decay times are set at random, between the limits given.\n");
+        fprintf(stdout,"INFO: TIME STEP BETWEEN PACKETS .......... Timestep between packets in output stream.\n");
+        fprintf(stdout,"INFO: PACKET TIME RANDOMISATION ........ Randomisation of timestep between packets.\n");
+        fprintf(stdout,"INFO: SLOPE OF ATTACK,SLOPE OF DECAY .. 1 is linear : greater than 1 is steep : less than 1 is less steep.\n");
+        fprintf(stdout,"INFO: PITCH SCATTER (SEMITONES) .......... Random scattering of packet pitches.\n");
+        fprintf(stdout,"INFO: AMPLITUDE SCATTER ..................... Random scattering of packet amplitudes.\n");
+        fprintf(stdout,"INFO: OCTAVIATION ............................. Redundant parameter : no longer in use.\n");
+        fprintf(stdout,"INFO: PACKET PITCH BEND ...................... Bending of pitches of packets.\n");
+        fprintf(stdout,"INFO: RANDOM SEED ............................. Setting a particular seed value will produce similar output when same seed applied again.\n");
+        if(process != PULSER3 && mode == 2) {
+            fprintf(stdout,"INFO: SPATIAL WIDTH ............................. With LSPKR SELECTION SET TO ZERO, Width is spatial spread of placement of output segments in stereo panorama.\n");
+            fprintf(stdout,"INFO:                                                                                  A width of ZERO produces a MONO output.\n");
+            fprintf(stdout,"INFO:                                                                                  With LSPKR SELECTION NOT ZERO Width is spatial spread around the selected output loudspeakers.\n");
+            fprintf(stdout,"INFO:                                                                                  A width of ZERO produces a loudspeaker-centric output.\n");
+        }
+        if(process == PULSER2) {
+            fprintf(stdout,"INFO: TOTALLY RANDOM SRC SEQUENCE .... Source sound to produce next packet is chosen totally at random.\n");
+            fprintf(stdout,"INFO:                                                                                  Default:  all srcs are used once, in a random order, before proceeding to the next random ordering.\n");
+        } else if(process == PULSER3) {
+            fprintf(stdout,"INFO: SAMPLING RATE ............................ Sampling rate of sythesized output.\n");
+            fprintf(stdout,"INFO: PARTIAL COUNT ............................ Number of partials actually activated (time-variable).\n");
+            fprintf(stdout,"INFO:                                                                                  Fractional values can be used: e.g. 2.4 means use 1st and 2nd partials, and 3rd partial attenuated by 0.4.\n");
+        }
+        fprintf(stdout,"INFO: \n");
+        if(process == PULSER && mode == 2)
+            fprintf(stdout,"INFO: All parameters except DURATION, RISE/DECAY limits, and SEED can vary through time.\n");
+        else if(process == PULSER3)
+            fprintf(stdout,"INFO: All parameters except DURATION, RISE/SUSTAIN/DECAY limits, SEED and SAMPLE RATE can vary through time.\n");
+        else
+            fprintf(stdout,"INFO: All parameters except DURATION, RISE/SUSTAIN/DECAY limits, and SEED can vary through time.\n");
+        break;
+    case(CHIRIKOV):
+        fprintf(stdout,"INFO: GENERATE SOUND OR PITCHLINE BASED ON CHIRIKOV STANDARD MAP, OR CIRCULAR MAP.\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(0):    fprintf(stdout,"INFO: GENERATE SOUND BASED ON ITERATION OF CHIRIKOV STANDARD MAP.\n");      break;
+        case(1):    fprintf(stdout,"INFO: GENERATE PITCH LINE BASED ON ITERATION OF CHIRIKOV STANDARD MAP.\n"); break;
+        case(2):    fprintf(stdout,"INFO: GENERATE SOUND BASED ON ITERATION OF CIRCULAR MAP.\n");               break;
+        case(3):    fprintf(stdout,"INFO: GENERATE PITCH LINE BASED ON ITERATION OF CIRCULAR MAP.\n");          break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(0):    
+        case(1):    fprintf(stdout,"INFO: DURATION .................... Duration of the output sound.\n");  break;
+        case(2):
+        case(3):    fprintf(stdout,"INFO: DURATION .................... Duration of the output breakpoint file.\n");    break;
+        }
+        fprintf(stdout,"INFO: FREQUENCY ................... Frequency of the forcing oscillation (can vary through time).\n");
+        fprintf(stdout,"INFO: DAMPING ..................... Damping coeeficient (can vary through time).\n");
+        switch(mode) {
+        case(0):    
+        case(1):    
+            fprintf(stdout,"INFO: SAMPLE RATE .......... Sampling rate of the synthesized sound.\n");   
+            fprintf(stdout,"INFO: SPLICE LENGTH (mS) ... Splice length (in milliseconds) of the onset and end of the output sound.\n"); 
+            break;
+        case(2):    
+        case(3):    
+            fprintf(stdout,"INFO: MINIMUM_MIDI PITCH .. Bottom of MIDI pitch range of output data.\n"); 
+            fprintf(stdout,"INFO: MAXIMUM_MIDI PITCH .. Top of MIDI pitch range of output data.\n");    
+            fprintf(stdout,"INFO: TIME STEP ....................... Time step between entries in output brkpoint file.\n"); 
+            fprintf(stdout,"INFO: TIME RANDOMISATION .. Randomisation of times in output brkpoint file.\n");    
+            break;
+        }
+        break;
+    case(MULTIOSC):
+        fprintf(stdout,"INFO: GENERATE INTERACTING OSCILLATORS.\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(0):    fprintf(stdout,"INFO: OSCILLATION OF OSCILLATION.\n");                               break;
+        case(1):    fprintf(stdout,"INFO: OSCILLATION OF OSCILLATION OF OSCILLATION.\n");                break;
+        case(2):    fprintf(stdout,"INFO: OSCILLATION OF OSCILLATION OF OSCILLATION OF OSCILLATION.\n"); break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION .................... Duration of the output sound.\n");
+        fprintf(stdout,"INFO: FREQUENCY ................... Oscillator frequency.\n");
+        fprintf(stdout,"INFO: FREQUENCY TWO................ Frequency of oscillation of oscillation.\n");
+        fprintf(stdout,"INFO: AMPLITUDE TWO................ Amplitude of oscillation of oscillation.\n");
+        if(mode >= 1) {
+            fprintf(stdout,"INFO: FREQUENCY THREE................ Frequency of oscillation of oscillation of oscillation.\n");
+            fprintf(stdout,"INFO: AMPLITUDE THREE................ Amplitude of oscillation of oscillation of oscillation.\n");
+        }
+        if(mode == 2) {
+            fprintf(stdout,"INFO: FREQUENCY FOUR................ Frequency of oscillation of oscillation of oscillation of oscillation.\n");
+            fprintf(stdout,"INFO: AMPLITUDE FOUR................ Amplitude of oscillation of oscillation of oscillation of oscillation.\n");
+        }
+        fprintf(stdout,"INFO: SAMPLE RATE .......... Sampling rate of the synthesized sound.\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH (mS) ... Splice length (in milliseconds) of the onset and end of the output sound.\n");
+        break;
+    case(SYNFILT):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: GENERATE BAND OF FILTERED NOISE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: REQUIRED DATAFILE-------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIMELIST OF PITCHES OF FILTS .... a textfile of lines with time-pitch pairs on each line. \n");
+            fprintf(stdout,"INFO: \n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: GENERATE BAND OF MULTIPITCHED FILTERED NOISE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: REQUIRED DATAFILE-------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TIMELIST OF PICHS&AMPS OF FILTS .... a textfile with lines of data for filter bands at successive times.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Each line contains the following items\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:           Time   Pitch1 Amp1   [Pitch2 Amp2    etc....].\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Where pitch and Amp values must be paired: and any number of pairs can be used in a line,\n");
+            fprintf(stdout,"INFO: BUT each line must have SAME number of pairs on it.\n");
+            fprintf(stdout,"INFO: Amp values may be numeric, or dB values (e.g. -4.1dB).\n");
+            fprintf(stdout,"INFO: (To eliminate a band in any line(s), set its amplitude to 0.0).\n");
+            break;
+        }
+        fprintf(stdout,"INFO: Time values (in secs) must be in ascending order (and >=0.0), with the maximum time being greater than 0.03 seconds.\n");
+        fprintf(stdout,"INFO: Pitch vals are MIDI values (but may be fractional).\n");
+        fprintf(stdout,"INFO: (Comment-lines may be used: start these with ';').\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OTHER PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SAMPLE RATE ............. Sample rate of output sound.\n");
+        fprintf(stdout,"INFO: CHANNEL COUNT ......... Mono or stereo output.\n");
+        fprintf(stdout,"INFO: FILTER Q .................. Q (tightness) of filter.\n");
+        fprintf(stdout,"INFO: NUMBER OF HARMONICS.. No of harmonics (of each pitch) to use: Default 1.\n");
+        fprintf(stdout,"INFO:                                                Very high harmonics of high pitches may be too high to calculate. (check with Max Harmonic button)\n");
+        fprintf(stdout,"INFO:                                                No-of-pitches times no-of-harmonics determines program speed.\n");
+        fprintf(stdout,"INFO: ROLL OFF................. Level drop (in dB) from one harmonic to next.\n");
+        fprintf(stdout,"INFO: RANDOM SEED .......... Any set value gives reproducible output.\n");
+        fprintf(stdout,"INFO: DOUBLE FILTERING .... More sharply defined filter frequencies.\n");
+        fprintf(stdout,"INFO: DROP OUT ON OVERFLOW   The filter is designed to adjust its internal level to prevent numerical overflow from\n");
+        fprintf(stdout,"INFO:                                                setting this flag will cause the filter to stop calculating if any overflow is detected.\n");
+        fprintf(stdout,"INFO:                                                The filter gain can then be turned down, and the filter launched again.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB: USING VERY LARGE NUMBERS OF HARMONICS MAY PRODUCE NUMERICAL INSTABILITY (OUTPUT WILL FAIL)\n");
+        fprintf(stdout,"INFO: NB: USING RAPID PITCH SHIFTS AT THE SOUND'S END (ESPECIALLY WITH LOW PITCH & FEW HARMONICS) MAY GIVE TAIL ARTEFACTS.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(STRANDS):
+        switch(mode) {
+        case(0):
+        case(2):
+            fprintf(stdout,"INFO: GENERATE PITCHBAND DATA EXHIBITING  LAMINAR,  TAYLOR_COUETTE, AND  TURBULENT  FLOW.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: GENERATE PITCHBANDED SOUND EXHIBITING  LAMINAR,  TAYLOR_COUETTE, AND  TURBULENT  FLOW.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Generates pitch threads distributed over a specified range, which can \"flow\" in the following ways ....\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:         (a)  LAMINAR FLOW (threads do not cross).\n");
+        fprintf(stdout,"INFO:         (b)  TWISTED FLOW (threads are grouped in pitch-adjacent bands, and the threads in each band cycle around one another).\n");
+        fprintf(stdout,"INFO:         (c)  TWISTED FLOW WITH WAVY BOUNDARIES.\n");
+        fprintf(stdout,"INFO:         (d)  BANDED FLOW WITH TURBULENCE (threads cross indiscriminately within the bands).\n");
+        fprintf(stdout,"INFO:         (e)  TURBULENT FLOW (threads cross indiscriminately across the entire range).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Transitions to (and from) twisting, and to (and from) turbulence are managed by the process, and timed by the input parameters supplied.\n");
+        fprintf(stdout,"INFO: \n");
+        if(mode==0) {
+            fprintf(stdout,"INFO: Data is output as a set of time-pitch breakkpoint files which define the pitch-evolution of each stream.\n");
+            fprintf(stdout,"INFO: (Level data may also be output: see the \"3D\" option below).\n");
+            fprintf(stdout,"INFO: \n");
+        }
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        if(mode==2)
+            fprintf(stdout,"INFO: THREADCOUNT IN EACH BAND ........... Number of pitch-threads in each band, listed in a textfile.\n");
+        switch(mode) {
+        case(0):
+        fprintf(stdout,"INFO: DURATION .................................. Duration of the output data.\n");
+        break;
+        case(1):
+        fprintf(stdout,"INFO: DURATION .................................. Duration of the output sound.\n");
+        break;
+        }
+        fprintf(stdout,"INFO: NUMBER OF BANDS ........................ Number of pitch-bands in the output.\n");
+        if(mode != 2)
+            fprintf(stdout,"INFO: NUMBER OF THREADS PER BAND ........ Number of pitch-threads in each band.\n");
+        fprintf(stdout,"INFO: TIMESTEP BETWEEN OUTPUT VALUES .. Timestep (in mS) between the pitch-data values in the output.\n");
+        fprintf(stdout,"INFO: BOTTOM OF PITCH RANGE ................ Lowest pitch of all output.\n");
+        fprintf(stdout,"INFO: TOP OF PITCH RANGE ..................... Highest pitch of all output.\n");
+        fprintf(stdout,"INFO: FREQUENCY OF BAND ROTATION ....... Rate (in Hz) at which the pitches twist aroud one another within the bands.\n");
+        fprintf(stdout,"INFO:                                     (1)  If two successive times in the input data have ZERO frequency,\n");
+        fprintf(stdout,"INFO:                                               the flow between those times is LAMINAR.\n");
+        fprintf(stdout,"INFO:                                     (2)  If two successive times have NON-ZERO freqency,\n");
+        fprintf(stdout,"INFO:                                               the flow between those times is TWISTED.\n");
+        fprintf(stdout,"INFO:                                     (3)  If two successive times have zero and non-zero freqencies,\n");
+        fprintf(stdout,"INFO:                                               the flow gradually changes between laminar and twisted.\n");
+        fprintf(stdout,"INFO: RANDOM DIVERSITY OF BAND FREQUENCIES\n");
+        fprintf(stdout,"INFO:                                     (1) With LAMINAR FLOW : Amount of random divergence of thread pitches from steady pitch.\n");
+        fprintf(stdout,"INFO:                                     (2) With TWISTED FLOW : Amount of random divergence of twist of individual bands\n");
+        fprintf(stdout,"INFO:                                               from the specified twist frequency.\n");
+        fprintf(stdout,"INFO: RANDOM WARPING OF THREAD OSCILLATIONS\n");     
+        fprintf(stdout,"INFO:                                     (1) With LAMINAR FLOW : If the flow is 3D (see below),\n");
+        fprintf(stdout,"INFO:                                               amount of scattering of the loudness random of each stream.\n");
+        fprintf(stdout,"INFO:                                               (If the flow is NOT 3D, this parameter is ignored during laminar flow).\n");
+        fprintf(stdout,"INFO:                                     (2) With TWISTED FLOW : Random timewarp (acceleration or decelleration)\n");
+        fprintf(stdout,"INFO:                                               of the twisting of individual threads in the same band.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: BAND BOUNDARY WAVINESS ............ Amount that the band-boundaries wander away from fixed pitches.\n" );
+        fprintf(stdout,"INFO: WAVINESS MIN FREQUENCY ............. Minimum rate of oscillation of the band boundaries.\n");
+        fprintf(stdout,"INFO: WAVINESS MAX FREQUENCY ............ Maximum rate of oscillation of the band boundaries.\n");
+        fprintf(stdout,"INFO:                                     Actual oscillation rates are selected at random (for each band boundary) between these limits.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TURBULENCE ............................... Turbulence destroys the laminar or twisting pattern of the threads.\n");
+        fprintf(stdout,"INFO:                                     Value ZERO creates no turbulence.\n"); 
+        fprintf(stdout,"INFO:                                     Values UP TO 1.0 create increasingly turbulent paths WITHIN the  band boundaries.\n");
+        fprintf(stdout,"INFO:                                     Values BETWEEN 1.0 and 2.0 create increasingly turbulent paths over the entire pitch-range.\n");
+        fprintf(stdout,"INFO:                                     Note that turbulence can ONLY be non-zero when the flow is (fully) twisted.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SEED ..................................... Seed for random generators in process. Set same side on 2 runs to get identical randomisation.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MINIMUM PITCH INTERVAL BETWEEN BANDS Minimum pitch-interval separating the pitch-bands.\n");
+        fprintf(stdout,"INFO: MINIMUM PITCH WIDTH OF BANDS ...... Minimum width of bands (especially when subjected to wavyiness).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ROTATION IN 3D ........................... 2 more tranches of values are created to control 3d asepcts of the flow.\n");
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO:                                     The 1st tranche can be used to generate relative level values for the streams,\n");
+            fprintf(stdout,"INFO:                                     or to control the number of partials in the stream with changes in pitch.\n");
+            fprintf(stdout,"INFO:                                     The 2nd tranche can be used to control the level of a modified version of the source\n");
+            fprintf(stdout,"INFO:                                     (e.g. reverbd or filtered), in a mix with the unmodified source.\n");
+            fprintf(stdout,"INFO:                                     BOTH processes might indicate the instantaneous distance of each stream from the listener.\n");
+            fprintf(stdout,"INFO:                                     This data output as 2 FURTHER sets of textfiles, AFTER all pitch data files have been output.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO:                                     This data is used to modify the relative level of the streams in the output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT BANDS SEQUENTIALLY ......... Outputs each band separately, in sequence, rather than all superimposed.\n");
+        fprintf(stdout,"INFO: \n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(REFOCUS):
+        fprintf(stdout,"INFO: GENERATE ENVELOPES TO CHANGE THE FOCUS (LOUDNESS) BETWEEN CO-EXISTING SOUNDS (e.g. IN A SET OF SOUNDS TO BE MIXED).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  Randomly permute which band is currently in focus.\n");
+        fprintf(stdout,"INFO: 2)  Bring bands into focus consecutively in 'rising' sequences, starting at the lowest, rising to the highest.\n");
+        fprintf(stdout,"INFO: 3)  Bring bands into focus consecutively in 'falling' sequences, starting at the highest, falling to the lowest.\n");
+        fprintf(stdout,"INFO: 4)  Bring bands into focus in a rising/falling/rising... cycle, starting at the lowest.\n");
+        fprintf(stdout,"INFO: 5)  Bring bands into focus in a falling/rising/falling.. cycle, starting at the highest.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DURATION .................................. Duration of output envelope files.\n");
+        fprintf(stdout,"INFO: NUMBER OF BANDS ........................ Number of sounds to envelope.\n");
+        fprintf(stdout,"INFO: FOCUSING RATIO .......................... Ratio of loudness of in-focus sound to out of focus sounds.\n");
+        fprintf(stdout,"INFO: TIMESTEP TO NEXT REFOCUS............. Time between refocusings.\n");
+        fprintf(stdout,"INFO: TIMESTEP RANDOMISATION .............. Randomisation of this these times.\n");
+        fprintf(stdout,"INFO: OFFSET BEFORE REFOCUSING BEGINS .. Refocusing does not start until after the \"offset\" time\n");
+        fprintf(stdout,"INFO: TIME AT WHICH REFOCUSING ENDS ..... Refocusing ends at this time, unless it is set to zero.\n");
+        fprintf(stdout,"INFO: NO FOCUS ON EXTREMAL BAND .......... The upper (1) or lower (-1) band gets no special focus.\n");
+        fprintf(stdout,"INFO: RANDOM SEED .............................. Seend for random value generation: identical seed gives identical output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT IS A SET OF ENVELOPE TEXTFILES which can be used to modify the levels of the sounds in the set of sounds.\n");
+        break;
+    case(CHANPHASE):
+        fprintf(stdout,"INFO: INVERT THE PHASE OF A SPECIFIED CHANNEL OF AN INPUT FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CHANNEL TO INVERT  .................................. Channel whose phase is to be inverted.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SILEND):
+        fprintf(stdout,"INFO: PAD END OF SOUND WITH EXTRA SILENCE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1: ................. Duration of silence to add.\n");
+        fprintf(stdout,"INFO: MODE 2: ................. Total Duration of new output sound (must be greater than duration of input sound).\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECULATE):
+        fprintf(stdout,"INFO: SYSTEMATICALLY PERMUTE CHANNELS OF ANALYSIS FILE, PRODUCING MANY OUTPUT FILES.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Analysis channels are permuted pairwise, in the manner of a \"Plain Bob\" bell-ringing sequence.\n");
+        fprintf(stdout,"INFO: After each permutation, a new file is output.\n");
+        fprintf(stdout,"INFO: The process conclude once the permutations have cycled the channels round to their original order\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MINIMUM FREQUENCY: ................. Frq of lowest analysis channel to permute.\n");
+        fprintf(stdout,"INFO: MAXIMUM FREQUENCY: ................. Frq of highest analysis channel to permute.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MASK OTHER CHANNELS: .............. Zero any spectral information outside range of frequencies defined by Min and Max above.\n");
+        break;
+    case(SPECTUNE):
+        fprintf(stdout,"INFO: FIND MOST PROMINENT PITCH IN INPUT FILE, THEN RETUNE THE FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: On retuning, the entire file is transposed by the same amount,\n");
+        fprintf(stdout,"INFO: and such that the most prominent pitch moves to the tuning pitch.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1)  Tune to the nearest tempered pitch.\n");
+        fprintf(stdout,"INFO: 2)  Tune to the nearest of the pitches listed in the \"tuning\" file.\n");
+        fprintf(stdout,"INFO: 3)  Tune to the nearest pitch, or it's octave equivalents, listed in the \"tuning\" file.\n");
+        fprintf(stdout,"INFO: 4)  Report the pitch found : no sound output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: VALID HARMONICS COUNT ................ how many of the loudest peaks in the spectral window\n");
+        fprintf(stdout,"INFO: ...................................... must be harmonics to confirm that the window is pitched. (default %d)\n",ST_ACCEPTABLE_MATCH);
+        fprintf(stdout,"INFO: MINIMUM MIDI PITCH ...................... MIDI value of the LOWEST acceptable pitch. (default 4)\n");
+        fprintf(stdout,"INFO: MAXIMUM MIDI PITCH ...................... MIDI value of the HIGHEST acceptable pitch. (default 127)\n");
+        fprintf(stdout,"INFO: START TIME FOR PITCH SEARCH .... Time in source at which pitch-search begins (default: 0.0).\n");
+        fprintf(stdout,"INFO: END TIME FOR PITCH SEARCH ......... Time in source at which pitch-search ends (default: end-of-file)..\n");
+        fprintf(stdout,"INFO: IN-TUNE RANGE (SEMIT) ................. semitone-range within which harmonics accepted as in tune (default %d)\n",ST_ACCEPTABLE_MATCH);
+        fprintf(stdout,"INFO: MIN WINDOWS TO CONFIRM PITCH .. minimum number of adjacent windows that must be pitched\n");
+        fprintf(stdout,"INFO: ............................... for pitch-value to be registered. (default %d)\n",BLIPLEN);
+        fprintf(stdout,"INFO: SIGNAL TO NOISE RATIO (dB) ...... in decibels (default %.1lf)\n",SILENCE_RATIO);
+        fprintf(stdout,"INFO: ................................. Windows whose level falls this far below the maximum window level in the sound\n");
+        fprintf(stdout,"INFO: ................................. are assumed to be noise, & any detected pitch is assumed spurious.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: IGNORE PITCHED-WINDOW RELATIVE-LOUDNESS  ......\n");
+        fprintf(stdout,"INFO:                               Assign window-pitches to 1/8thsemitone bins, and count occurences in bins.\n");
+        fprintf(stdout,"INFO:                               Default, Weight the count with the window loudnesses.\n");
+        fprintf(stdout,"INFO: SMOOTH PITCH-CONTOUR ..........................................\n");
+        fprintf(stdout,"INFO:                               Smooth pitch-contour data before assessing most prominent pitch.\n");
+        fprintf(stdout,"INFO:                               Default, no smoothing.\n");
+        fprintf(stdout,"INFO: FORMANT ENVELOPE NOT PRESERVED (Modes 1 to 3 only)............ \n");
+        fprintf(stdout,"INFO:                               If flag set, transposition ignores the original formant envelope.\n");
+        fprintf(stdout,"INFO:                               Default, transposition preserves original formant envelope.\n");
+        break;
+    case(REPAIR):
+        fprintf(stdout,"INFO: REASSEMBLE A SET OF MULTICHANNEL FILES FROM INDIVIDUAL MONO-CHANNEL SOURCES.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT  ................ how many channels in the output sound (2, 4, 5, 7, 8, 16 only)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  The number of (mono) input files must be a multiple of the \"OUTPUT CHANNEL COUNT\"\n");
+        fprintf(stdout,"INFO: (2)  All files destined to be channel-1s in the output should be listed first;\n");
+        fprintf(stdout,"INFO:           All files destined to be channel-2s in the output should be listed next;\n");
+        fprintf(stdout,"INFO:           and so on.\n");
+        fprintf(stdout,"INFO: (3)  For any one output file, its mono file sources must all be the same length,\n");
+        fprintf(stdout,"INFO:           (but output files need not be the same length).\n");
+        break;
+    case(DISTSHIFT):
+        fprintf(stdout,"INFO: DISTORT BY TIME-SHIFTING (GROUPS OF) HALF-WAVESETS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: A half-waveset is defined as the samples between one zero-crossing and the next.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Alternate (groups of) half-wavesets are time-shifted with respect to their partners.\n");
+        fprintf(stdout,"INFO: (2)  Alternate (groups of) half-wavesets are swapped.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WAVESET GROUP SIZE  ................ Number of wavesets in the waveset-groups which are operated on.\n");
+        fprintf(stdout,"INFO:            1 corresponds to a single half-waveset\n");
+        fprintf(stdout,"INFO:            2 corresponds to a complete waveset and a single half-waveset\n");
+        fprintf(stdout,"INFO:            3 corresponds to 2 complete wavesets and a single half-waveset\n");
+        fprintf(stdout,"INFO:            ETC.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WAVESET SHIFT (MODE 1 ONLY).... Number of waveset(group)s by which the signal is shifted.\n");
+        break;
+    case(QUIRK):
+        fprintf(stdout,"INFO: DISTORT BY RAISING SAMPLE-VALUES TO A POWER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1: Rescales values differently within each half-waveset, scaling values within noramlised range of\n");
+        fprintf(stdout,"INFO:              zero to max (for +ve half-waveset) or zero to min (for -ve half-waveset)\n");
+        fprintf(stdout,"INFO:              and hence retianing the maximum (minimum) excursion of each half-waveset.\n");
+        fprintf(stdout,"INFO: MODE 2: Rescales values within noramlised range of (absolute) maximum sample in file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: POWER FACTOR ................ Factor by which each sample is scaled.\n");
+        fprintf(stdout,"INFO:            > 1 exaggerates waveform contour.\n");
+        fprintf(stdout,"INFO:            < 1 smooths waveform contour.\n");
+        break;
+    case(ROTOR):
+        fprintf(stdout,"INFO: GENERATING CYCLING PITCH-SPEED SETS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Generates sequence of pitch-sets : sets expand-contract in range, and accel-rit in speed.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Sound is generated from an input soundfile and an input envelope (text)file of time-value pairs.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The input soundfile is read as a wavecycle table.\n");
+        fprintf(stdout,"INFO: and should start and end at zero level, and the start and end must both rise, or both fall.\n");
+        fprintf(stdout,"INFO: Dovetailing (fading the start and end) can be used to trim the edges of the source.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The envelope file is used to envelope the output events.\n");
+        fprintf(stdout,"INFO: The duration of the envelope determines the duration of all the events.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: There are 3 ways to specifiy the time-gap between the pitch-sets.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1: Timestep from start of one set to start of next is determined by your input parameter.\n");
+        fprintf(stdout,"INFO: MODE 2: Timestep from last event of first set, to first event of next\n");
+        fprintf(stdout,"INFO:              is determined by the last timestep between the elements in the previous set.\n");
+        fprintf(stdout,"INFO: MODE 3: First element of new set overlays the last element of the previous set.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: COUNT OF NOTES PER SET................................... Number of events in each set.\n");
+        fprintf(stdout,"INFO: MIN MIDI PITCH/MAX MIDI PITCH...................... Minimum and Maximum (MIDI) pitch when set has maximal pitch-range.\n");
+        fprintf(stdout,"INFO: MAX DURATION SLOWEST BEAT............................ Timestep between elements of sets when at slowest speed.\n");
+        fprintf(stdout,"INFO: NUMBER OF SETS PER PITCH CYCLE .................. How many sets before the pitch-sequence returns to its original form.\n");
+        fprintf(stdout,"INFO: NUMBER OF SETS PER SPEED CYCLE .................. How many sets before the sequence returns to its original speed.\n"); 
+        fprintf(stdout,"INFO: INITIAL PHASE DIFFERENCE BETWEEN CYCLES . Range 0 (in phase) to 1, where -5 is antiphase.\n");
+        fprintf(stdout,"INFO: (MININIMUM) OUTPUT DURATION ........................ (Minimum) duration of output to be generated.\n");
+        fprintf(stdout,"INFO: DOVETAIL DURATION (mS) .................................. (Optional) dovetails for sommthing onset and tail of source sound.\n");
+        fprintf(stdout,"INFO: TIME STEP BETWEEN WHOLE SETS (Mode 1 only). Timestep from start of one set to the next.\n");
+        break;
+    case(DISTCUT):
+        fprintf(stdout,"INFO: CHOP SOUND INTO SEGMENTS, BY COUNTING WAVESETS, AND IMPOSE A DECAYING-ENVELOPE ON SEGMENTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: A waveset is defined as the samples between one zero-crossing and the next-but-one.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Envelope stretches from start of waveset-group to start of next waveset-group.\n");
+        fprintf(stdout,"INFO:            Groups are therefore abutted and adjacent.\n");
+        fprintf(stdout,"INFO: (2)  Envelope length (in wavesets) and step to start of next envelope group are independent.\n");
+        fprintf(stdout,"INFO:            Groups may therefore overlap or be separated by intervening wavesets.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CYCLE COUNT ................. Number of wavesets in the waveset-groups which are enveloped.\n");
+        fprintf(stdout,"INFO: CYCLE STEP ................... Number of wavesets from start of one group to start of next.\n");
+        fprintf(stdout,"INFO:                                      In Mode 1, this is the same as the cycle_count.\n");
+        fprintf(stdout,"INFO: DECAY EXPONENT ........... Defines the decay shape of the envelope.\n");
+        fprintf(stdout,"INFO:         1 = Linear  :  >1  Decays more quickly initially  :  <1 Decays more sloly initially.\n");
+        fprintf(stdout,"INFO: CUTOFF (dB) ................. Segments whose maximum level falls below MINUS this (dB) value, are not retained.\n");
+        break;
+    case(ENVCUT):
+        fprintf(stdout,"INFO: CHOP SOUND INTO SEGMENTS, AND IMPOSE A DECAYING-ENVELOPE ON SEGMENTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Envelope stretches to time where next envelopes begins.\n");
+        fprintf(stdout,"INFO:            Cut segments are therefore abutted and adjacent.\n");
+        fprintf(stdout,"INFO: (2)  Envelope duration step to start of next enveloped segment are independent.\n");
+        fprintf(stdout,"INFO:            Segments may therefore overlap or be separated from one another within the source.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ENVELOPE DURATION ..... ....... .. Duration of segments which are enveloped.\n");
+        fprintf(stdout,"INFO: TIMESTEP TO NEXT SEGMENT .. TImestep from start of one enveloped segment to start of next.\n");
+        fprintf(stdout,"INFO:                                      In Mode 1, this is the same as the Envelope Duration.\n");
+        fprintf(stdout,"INFO: ATTACK DURATION (mS) ........... Defines the rise-time of the envelope, in Milliseconds.\n");
+        fprintf(stdout,"INFO: DECAY EXPONENT ........... Defines the decay shape of the envelope.\n");
+        fprintf(stdout,"INFO:         1 = Linear  :  >1  Decays more quickly initially  :  <1 Decays more sloly initially.\n");
+        fprintf(stdout,"INFO: CUTOFF (dB) ................. Segments whose maximum level falls below MINUS this (dB) value, are not retained.\n");
+        break;
+    case(SPECFOLD):
+        fprintf(stdout,"INFO: PERMUTE SPECTRAL CHANNELS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Fold the spectrum.\n");
+        fprintf(stdout,"INFO:         A group of consecutive channels to fold is selected.\n");
+        fprintf(stdout,"INFO:         Channels in the group are split into 2 equal sets  (e.g. 1-to-8 and 9-to-16.\n");
+        fprintf(stdout,"INFO:         Values in the 1st set are moved to alternate channels (e.g. 1-->2  2-->4  3-->6  etc.\n");
+        fprintf(stdout,"INFO:         Values in the 2nd set are assigned to the remaining channels, in descending order.(e.g. 5-->7  6-->5  7-->3  etc.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (2)  Invert the spectrum.\n");
+        fprintf(stdout,"INFO: (3)  Randomise the spectrum.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CHANNEL WHERE PROCESSING STARTS .. The number of the first channel in the folded groups.\n");
+        fprintf(stdout,"INFO: CHANNELS TO PROCESS .......................... Number of channels to process.\n");
+        fprintf(stdout,"INFO: (MODE 1) NUMBER OF FOLDINGS .......... Number of times to repreat the folding process.\n");
+        fprintf(stdout,"INFO: (MODE 3) RANDOM SEED ........................ Same seed value produces exactly the same random permutation.\n");
+        fprintf(stdout,"INFO: AMPLITUDES ONLY .................................. Process only the channel amplitude information.\n");
+        break;
+    case(BROWNIAN):
+        fprintf(stdout,"INFO: CREATE BROWNIAN MOTION IN PITCH AND SPACE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Use the source sound as a wavetable to generate the output pitches.\n");
+        fprintf(stdout,"INFO: (2)  Use the whole source sound to generate individual events, by transposition.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The pitch of successive events wander in both pitch and space.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT ................. Number of channels in the output file (1-16).\n");
+        fprintf(stdout,"INFO: (MAX) OUTPUT DURATION ................. (Maximum) duration of the output file.\n");
+        fprintf(stdout,"INFO: EVENT ATTACK DURATION ................ Rise time of events (Mode 1 only).\n");
+        fprintf(stdout,"INFO: EVENT DECAY DURATION .................. Decay time of events (Mode 1 only).\n");
+        fprintf(stdout,"INFO: BOTTOM OF PITCHRANGE (MIDI) ........ Bottom of pitch range (MIDI).\n");
+        fprintf(stdout,"INFO: TOP OF PITCHRANGE (MIDI) ............. Top of pitch range (MIDI).\n");
+        fprintf(stdout,"INFO: STARTING PITCH (MIDI) ................... Initial pitch (MIDI).\n");
+        fprintf(stdout,"INFO: START POSITION ............................ Initial spatial position amongst output channels (numbering channels 1 - N).\n");
+        fprintf(stdout,"INFO: MAX PITCH STEP (SEMITONES) .......... Maximum pitch step between events.\n");
+        fprintf(stdout,"INFO: MAX SPACE STEP ............................ Max spatial step between events (fraction of distance between channels).\n");
+        fprintf(stdout,"INFO:                                                                      START POSITION and SPACE STEP are ignored if the output is specified MONO.\n");
+        fprintf(stdout,"INFO: AVERAGE TIMESTEP BETWEEN EVENTS.. (Average) Time between events.\n");
+        fprintf(stdout,"INFO: RANDOM SEED ............................... (Integer) Seed value (Gives a reproducible random sequence).\n");
+        fprintf(stdout,"INFO: MAX AMPLITUDE STEP(dB) ................. Max loudness step between events, in dB (default = 0: max = 96dB).\n");
+        fprintf(stdout,"INFO: MINIMUM AMPLITUDE(dB) ................... Min loudness (only comes into play if \"AMPLITUDE STEP\" is greater than zero).\n");
+        fprintf(stdout,"INFO:                                                                      If min > zero, and varying amplitude reaches -min dB,\n");
+        fprintf(stdout,"INFO:                                                                       amplitude values are \"reflected\" back from this minimum boundary.\n");
+        fprintf(stdout,"INFO:                                                                      If set to zero, NO amplitude minimum is set and\n");
+        fprintf(stdout,"INFO:                                                                      if varying amplitude reaches -96dB, the sounds stream terminates.\n");
+        fprintf(stdout,"INFO: ATTACK SLOPE ................................ Slope of the attack (mode 1 only)\n");
+        fprintf(stdout,"INFO:                                                                      values < 1 rise fast, then more slowly  : values > 1 rise slowly, then faster.\n");
+        fprintf(stdout,"INFO: DECAY SLOPE .................................. Slope of the decay (mode 1 only).\n");
+        fprintf(stdout,"INFO:                                                                      values < 1 fall slowly, then faster  : values > 1 fall fast, then more slowly.\n");
+        fprintf(stdout,"INFO: LINEAR LSPKR_ARRAY ...................... Output channels fed to \"linear\" array of loudspeakers.\n");
+        fprintf(stdout,"INFO:                                                                      Default: loudspeaker array encircles the listener.\n");
+        break;
+    case(SPIN):
+        fprintf(stdout,"INFO: ROTATE A WIDE STEREO-IMAGE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Rotate around the same 2 stereo channels, with possible doppler-shift.\n");
+        fprintf(stdout,"INFO: (2)  Rotate around central channel (with possible doppler-shift) with stereo image spread to channels on left and right of this.\n");
+        fprintf(stdout,"INFO: (3)  As mode 2, with image squeezing at centre i.e. when the spinning image crosses the centre ....\n");
+        fprintf(stdout,"INFO:               MODE 3 uses ONLY the central channel to project the stereo-at-centre image.\n");
+        fprintf(stdout,"INFO:               whereas MODE 2 also uses contributions from the outer channels to project the stereo-at-centre image.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ROTATION_RATE(CYCLES PER SEC) ........... Number of complete rotations per second (can vary through time).\n");
+        fprintf(stdout,"INFO:                                                                            Positive values rotate clockwise (as viewed from above).\n");
+        fprintf(stdout,"INFO:                                                                            Negative values rotate anticlockwise.\n");
+        fprintf(stdout,"INFO: DIFFERENTIAL BETWEEN FRONT AND REAR .. As the edges cross the centre, edge \"at front\" is amplified by this factor\n");
+        fprintf(stdout,"INFO:                                                                            while edge at rear is attenuated by this factor.\n");
+        fprintf(stdout,"INFO: ATTENUATION AT CENTRE ...................... Attenuates BOTH edges as they cross the centre.\n");
+        fprintf(stdout,"INFO: MAX DOPPLER PITCHSHIFT(SEMITONES) ...... Maximum pitchshift (up and down) due to motion-dependent doppler-shift.\n");
+        fprintf(stdout,"INFO: EXPAND BUFFERS BY .............................. For large doppler-shift, more memory may be needed for calculations.\n");
+        fprintf(stdout,"INFO:                                                                            Memory may be expanded here by some integer factor.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In Modes 2 and 3 .....\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTFILE CHANNEL COUNT ...................... Channel count of the output file. \n");
+        fprintf(stdout,"INFO: CENTRE CHANNEL OF IMAGE ................... Channel number, in output file, which is at the output image centre.\n");
+        fprintf(stdout,"INFO: MIN LEVEL ON CENTRE CHAN  .................. Minimum level of mono-condensed signal on centre channel.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In Mode 2 only .....\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MAX BOOST ON CENTRE CHAN  ................ Maximum amplification of (mono-condensed) signal on centre channel.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPINQ):
+        fprintf(stdout,"INFO: ROTATE A DOUBLE STEREO-IMAGE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Takes two stereo inputs and rotates them  around central channel with stereo image spread to channels on left and right of this.\n");
+        fprintf(stdout,"INFO: The two inputs are initially wrapped around one another.\n");
+        fprintf(stdout,"INFO: i.e. if the channels of File 1 are \"1L\" and \"1R\", and of File 2, \"2L\" and \"2R\", with central channel \"C\"\n");
+        fprintf(stdout,"INFO: then the initial placement is  2L   1L   C   1R   2R\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Rotate around central channel (with possible doppler-shift) with stereo image spread to channels on left and right of this.\n");
+        fprintf(stdout,"INFO: (2)  As mode 1, with image squeezing at centre i.e. when the spinning image crosses the centre ....\n");
+        fprintf(stdout,"INFO:               MODE 2 uses ONLY the central channel to project the stereo-at-centre image.\n");
+        fprintf(stdout,"INFO:               whereas MODE 1 also uses contributions from the outer channels to project the stereo-at-centre image.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ROTATION_RATE(CYCLES PER SEC) ........... Number of complete rotations per second (can vary through time).\n");
+        fprintf(stdout,"INFO:                                                                            Positive values rotate clockwise (as viewed from above).\n");
+        fprintf(stdout,"INFO:                                                                            Negative values rotate anticlockwise.\n");
+        fprintf(stdout,"INFO: DIFFERENTIAL BETWEEN FRONT AND REAR .. As the edges cross the centre, edge \"at front\" is amplified by this factor\n");
+        fprintf(stdout,"INFO:                                                                            while edge at rear is attenuated by this factor.\n");
+        fprintf(stdout,"INFO: ATTENUATION AT CENTRE ...................... Attenuates BOTH edges as they cross the centre.\n");
+        fprintf(stdout,"INFO: OUTFILE CHANNEL COUNT ...................... Channel count of the output file. \n");
+        fprintf(stdout,"INFO: CENTRE CHANNEL OF IMAGE ................... Channel number, in output file, which is at the output image centre.\n");
+        fprintf(stdout,"INFO: MAX DOPPLER PITCHSHIFT(SEMITONES) ...... Maximum pitchshift (up and down) due to motion-dependent doppler-shift.\n");
+        fprintf(stdout,"INFO: EXPAND BUFFERS BY .............................. For large doppler-shift, more memory may be needed for calculations.\n");
+        fprintf(stdout,"INFO:                                                                            Memory may be expanded here by some integer factor.\n");
+        fprintf(stdout,"INFO: MIN LEVEL ON CENTRE CHAN  .................. Minimum level of mono-condensed signal on centre channel.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: In Mode 2 only .....\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MAX BOOST ON CENTRE CHAN  ................ Maximum amplification of (mono-condensed) signal on centre channel.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CRUMBLE):
+        fprintf(stdout,"INFO: DISINTEGRATE A MONO SOURCE OVER A MULTICHANNEL SPACE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Project a MONO source on all channels of a multichannel output, then segment it,\n");
+        fprintf(stdout,"INFO: and distribute the segments over smaller and smaller groups of channels\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Over an 8-channel space.\n");
+        fprintf(stdout,"INFO: (2)  Over a 16-channel space.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: START TIME ............................ Time in source at which disintegration starts.\n");
+        fprintf(stdout,"INFO: DURATION OF HALF SPLITS .......... Duration of section where signal splits into 2 images.\n");
+        fprintf(stdout,"INFO: DURATION OF QUARTER SPLITS .... Duration of section where signal split into 4 images.\n");
+        fprintf(stdout,"INFO: DURATION OF EIGHTH SPLITS ....... (Mode 2 only) Duration of section where signal split into 8 images.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The sum of the \"Start Time\" and all these \"Duration\"s cannot exceed the duration of the input sound.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ORIENTATION ......................... When the input image first splits onto 2 images on 2 blocks of adjacent chans.\n");
+        fprintf(stdout,"INFO:                                                                                The first block starts at channel \"ORIENTATION\" and uses channels clockwise of this.\n");
+        fprintf(stdout,"INFO:                                                                                The 2nd block uses the remaining channels.\n");
+        fprintf(stdout,"INFO: SEGMENT SIZE ........................ The (average) duration of the cut segments (can vary ober time).\n");
+        fprintf(stdout,"INFO: SIZE RANDOMISATION ..............  Range 0 - 1. Maximum value(1) modifies size randomly between (size/2) and (3*size)./2\n");
+        fprintf(stdout,"INFO: INPUT SCATTER ...................... Random scatering of the start-time in the source at which the next segment is cut. (Range 0 - 1)\n");
+        fprintf(stdout,"INFO:                                                                                The cut-time in the source always advances.\n");
+        fprintf(stdout,"INFO:                                                                                With no scatter, the timestep step to the next cut-time equals the duration of the current segment.\n");
+        fprintf(stdout,"INFO:                                                                                With max input-scatter(1) timestep is a random value between 0 and the current segment duration.\n");
+        fprintf(stdout,"INFO: OUTPUT SCATTER .................... Random scatering of the time-placement of the segment in the output stream. (Range 0 - 1)\n");
+        fprintf(stdout,"INFO:                                                                                Time-placement in the output stream always advances.\n");
+        fprintf(stdout,"INFO:                                                                                With no scatter, the step to the next output-time equals the duration of the current segment.\n");
+        fprintf(stdout,"INFO:                                                                                With max output-scatter(1) timestep is a random value between 0 and the current segment duration.\n");
+        fprintf(stdout,"INFO: OUTPUT TIMESTRETCH .............. Stretching of time-placement of segments in the output stream. (Range 1 - 64)\n");
+        fprintf(stdout,"INFO:                                                                                The timestep in the output stream to the next segment-placement, is multiplied by the timestretch.\n");
+        fprintf(stdout,"INFO:                                                                                Where output-timestretch is greater than 1, silent gaps should appear in the output.\n");
+        fprintf(stdout,"INFO: PITCH SCATTER ...................... Maximum transposition (up or down) of the output segments,\n");
+        fprintf(stdout,"INFO:                                                                                For example, a value of 3 produces a random transposition anywhere between 3 semitones up and 3 semitones down.\n");
+        fprintf(stdout,"INFO: SEED ................................... The same seed value produces identical output on successive process runs.\n");
+        fprintf(stdout,"INFO: SPLICELENGTH(mS) ................. Length, in milliseconds, of splices which cut segments from source.\n");
+        fprintf(stdout,"INFO: LENGTH OF EXPONENTIAL TAIL(mS) Length, in milliseconds, of any (exponentially decaying) tail on the cut segments.\n");
+        fprintf(stdout,"INFO: MAXIMIM DURATION ................ If output duration exceeds this limit, curtail it (set to zero for no curtailment).\n");
+        break;
+    case(TESSELATE):
+        fprintf(stdout,"INFO: CREATE REPEATING PATTERN WITH SHIFTS IN SPACE AND TIME, USING ONE OR MORE MONO SOURCES.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The mono source is repeated one (set of) channels, but delays between repeats are different on a different (set of) channel(s).\n");
+        fprintf(stdout,"INFO: The standard-delay is the \"Repeat Cycle Duration\".\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The change in the delay, as you pass from one (set of) channel(s) to the next, is specified by an integer, the \"Cycle Index\".\n");
+        fprintf(stdout,"INFO: With 4 output channels, and a Cycle Index of 60,\n");
+        fprintf(stdout,"INFO: If Channel A has standard-delay,\n");
+        fprintf(stdout,"INFO: then the associated channels have standard-delay * (1 + 1/60)\n");
+        fprintf(stdout,"INFO: so that\n");
+        fprintf(stdout,"INFO: after 60 repetitions, channel(s) B resynchronises with channel(s) A\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Several sources can be input, and time-offset (Time Stagger), so the N sources (initially) form a rhythmic phrase.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Different sources can have different cycle-indeces.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TESSELATION DATA .......................... A textfile consisting of 2 lines of data.\n");
+        fprintf(stdout,"INFO:                                   Each line must contain one entry for each input file.\n");
+        fprintf(stdout,"INFO:                                   Line 1 - indicates the \"Cycle Index\" for the associated source.\n");
+        fprintf(stdout,"INFO:                                   Line 2 - indicates the \"Time Stagger\" of the associated source.\n");
+        fprintf(stdout,"INFO:                                                 One item should have stagger zero.\n");
+        fprintf(stdout,"INFO:                                                 The other items should have different staggers\n");
+        fprintf(stdout,"INFO:                                                 indicating their timing in the initial rhythmic phrase.\n");
+        fprintf(stdout,"INFO:                                                 No delay should equal or exceed the \"Repeat Cycle Duration\".\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL COUNT .................. The number of output channels (2 - 16). This must be an even number of channels.\n");
+        fprintf(stdout,"INFO: REPEAT CYCLE DURATION .................. The standard-(shortest)-delay between repetitions (the \"Repeat Cycle Duration\").\n");
+        fprintf(stdout,"INFO: OUTPUT DURATION .......................... The required duration of the output sound.\n");
+        fprintf(stdout,"INFO: TESSELATION TYPE ........................ Specifies how the channels are paired up.\n");
+        fprintf(stdout,"INFO:                                       0 : Double diamond, all odd-channels play at one delay rate, and all even-channels at the other.\n");
+        fprintf(stdout,"INFO:                                       1 : Channels are paired with the adjacent channel (sound 1 on ch1-paired-with-ch2, sound 2 on ch2-paired-with-ch3, etc.\n");
+        fprintf(stdout,"INFO:                                       2 : Channels are paired with the channel 2 ahead (sound 1 on ch1 paired-with-ch3, sound 2 on ch2-paired-with-ch4, etc.\n");
+        fprintf(stdout,"INFO:                                       3 : Channels are paired with the channel 3 ahead (sound 1 on ch1 paired-with-ch4, sound 2 on ch2-paired-with-ch5, etc.\n");
+        fprintf(stdout,"INFO:                                       and so on.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(PHASOR):
+        fprintf(stdout,"INFO: CREATE GRADUALLY PITCH-SHIFTING COPIES OF SOURCE SOUND, WHICH \"PHASE\" WITH ONE ANOTHER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Each stream pitch-shifts gradually up and down, to a specified max/min pitch-shift, at a rate determined by the frequency of the phasing wave.\n");
+        fprintf(stdout,"INFO: The streams can be distributed over a specified number of output channels, and can be synchronous or time-staggered.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF PHASING STREAMS .......... The number of pitch-shifting streams to be output.\n");
+        fprintf(stdout,"INFO: FREQUENCY OF PHASING WAVE .......... The frequency at which the up-down pitch-shifts happen.\n");
+        fprintf(stdout,"INFO: MAX PHASING SHIFT (SEMITONES) .. The maximum phase shift used (in semitones): other streams have proportionately less phase-shift.\n");
+        fprintf(stdout,"INFO: NUMBER OF OUTPUT CHANNELS .......... Output streams are distributed over this given number of output channels.\n");
+        fprintf(stdout,"INFO: TIME OFFSET OF STREAMS(mS) ........ The start-time of the streams can be staggered by a few milliseconds (default, no stagger).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SOUND-SURROUND ................................ If more than 2 output channels, there output-placement relates to a sound-surround array.\n");
+        fprintf(stdout,"INFO: WARN OF ROUNDING ERRORS .............. Warns of any errors in calculating the phase-shifted stream outputs.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB With time-variable phasing-wave frequency, extreme frequency shifts or reversals may produce anomalous output.\n");
+        break;
+    case(CRYSTAL):
+        fprintf(stdout,"INFO: CREATE SOUND-SET RELATED, IN PITCH, TIME & PROXIMITY, TO VERTICES OF A 3D CRYSTAL, THEN ROTATE CRYSTAL AND RECREATE SOUNDS, ETC..\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Mono input sound (or N input sounds for N vertices) used as sample-read table to generate outputs. Ideal duration 1 sec, but any dur possible.\n");
+        fprintf(stdout,"INFO: Crystal vertices projected onto x, y plane, where x represents pitch, and y represents time. z (depth) determines signal brightness.\n");
+        fprintf(stdout,"INFO: After playing one set of vertices, crystal rotates, around 2 different axes, and process of sound generation is then repeated ...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Mono output.\n");
+        fprintf(stdout,"INFO: (2)  Stereo output (the y-coordinate is further interpreted as a position in the stereo space).\n");
+        fprintf(stdout,"INFO: (3)  Stereo output across 2 channels of an 8-channel multichannel file, but separated by 1 channel.\n");
+        fprintf(stdout,"INFO: (4)  Ditto, stepping clockwise around the channels for each vertex-group generated.\n");
+        fprintf(stdout,"INFO: (5)  Ditto, stepping anticlockwise.\n");
+        fprintf(stdout,"INFO: (6)  Ditto, stepping randomly.\n");
+        fprintf(stdout,"INFO: (7)  Stereo output across 2 adjacent channels of an 8-channel multichannel file, stepping clockwise.\n");
+        fprintf(stdout,"INFO: (8)  Ditto, stepping anticlockwise.\n");
+        fprintf(stdout,"INFO: (9)  Ditto, stepping randomly.\n");
+        fprintf(stdout,"INFO: (10) Stereo output, each vertex-set is output as a separate file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ROTATION SPEED AROUND Z AXIS (CYCS PER SEC) ................ Rotation speed (cycles per second) around z-axis.\n");
+        fprintf(stdout,"INFO: ROTATION SPEED AROUND Y AXIS (CYCS PER SEC) ................ Rotation speed (cycles per second) around y-axis.\n");
+        fprintf(stdout,"INFO: MAXIMUM TIMEWIDTH OF ONE ALL-VERTICES-PLAY .................. Maximum time between first vertex to play, and last, for any playing of one set of vertices.\n");
+        fprintf(stdout,"INFO:                 Actual time between first and last vertices played will depend on crystal orientation.\n");
+        fprintf(stdout,"INFO:                 Maximum timewidth is the maximum value this timewidth can take for all possible orientations of the crystal.\n");
+        fprintf(stdout,"INFO:                 There will be a central time around which the vertices are laid out, sone before and some after this central time.\n");
+        fprintf(stdout,"INFO: TIMESTEP BETWEEN ONE ALL-VERTICES-PLAY AND NEXT .......... Time-step between central-time of one playing-of-a-set-of-vertices, and the next playing.\n");
+        fprintf(stdout,"INFO: TOTAL DURATION OF OUTPUT ........................................................ Minimum output duration.\n");
+        fprintf(stdout,"INFO:                 When \"total duration\" is reached, any vertex-set being played will continue to its end before the output terminates.\n");
+        fprintf(stdout,"INFO: MIN MIDI PITCH OF ANY VERTEX (WHEREVER ROTATED)\n");
+        fprintf(stdout,"INFO: MAX MIDI PITCH OF ANY VERTEX (WHEREVER ROTATED) .......... As vertices are rotated, their pitch will usually change.\n");
+        fprintf(stdout,"INFO:                 These are the minimum and maximum pitch thay any vertex might attain, and will not necessarily be reached by any rotated vertex.\n");
+        fprintf(stdout,"INFO: FRQ OF PASSBAND OF FILTER FOR DISTANCE CUES\n");
+        fprintf(stdout,"INFO: FRQ OF STOPBAND OF FILTER FOR DISTANCE CUES\n");
+        fprintf(stdout,"INFO: MAX ATTENUATION(DB) OF FILTER\n");
+        fprintf(stdout,"INFO: GAIN APPLIED TO SRC BEFORE FILTERING ..................................As vertices recede beyond x-y plane, sound is filtered to indicate distance.\n");
+        fprintf(stdout,"INFO:                 Filtering done by CDP lowpass-filter, for which a passband, a (higher) stopband, an attenuation and a pregain need to be specified.\n");
+        fprintf(stdout,"INFO: CURVE SLOPE FOR MIXING FILT TO UNFILT SND(DEPTH CUE) .. The filtered sound is mixed into the unfiltered, increasingly for greater distance.\n");
+        fprintf(stdout,"INFO:                 The curve slope determines how this mixing differs from a simple linear crossfade.\n");
+        fprintf(stdout,"INFO:                 Values less than one create a more rapid increase in filtering in the initial stages, values greater than one, the opposite.\n");
+        fprintf(stdout,"INFO: CURVE SLOPE FOR MIXING IN OCTAVE-UP-SND(PROXIMITY CUE) As vertices approach in front of the x-y plane, sound is octave-stacked to indicate proximity.\n");
+        fprintf(stdout,"INFO:                 The curve slope determines, similarly, how this mixing differs from a simple linear crossfade.\n");
+        break;
+    case(WAVEFORM):
+        fprintf(stdout,"INFO: CREATE A WAVETABLE SUITABLE FOR USE IN THE \"CRYSTAL\" PROCESS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Mono input sound used to generate a symmetric output table, suitable to use as a waveform for sound-generation.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Specify a time in the source, and a number of half-wavesets to read.\n");
+        fprintf(stdout,"INFO: (2)  Specify a time in the source, and a duration in milliseconds to read.\n");
+        fprintf(stdout,"INFO: (3)  Ditto, then combine the selected sound with a single-cycle sinusoid.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIME OF SAMPLING ...................... Time in the source where sound is to be sampled.\n");
+        fprintf(stdout,"INFO: COUNT OF HALF WAVESETS .......... Number of half-wavesets to read from the source.\n");
+        fprintf(stdout,"INFO: DURATION TO SAMPLE (mS) ........ Duration, in mS, to sample from the source.\n");
+        fprintf(stdout,"INFO: BALANCE WITH SINUSOID ............ Relative level of source and sinusoid in final output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Modes 1 and 2 cut a source segment (at zero-crossings), then abutt the inverted segment to the original, to make a waveform.\n");
+        fprintf(stdout,"INFO: In Mode 3, this abutted waveform is superimposed over a single-cycle sinusoid of the same duration.\n");
+        break;
+    case(DVDWIND):
+        fprintf(stdout,"INFO: SHORTEN SOUND BY READ-THEN-SKIP, READ-THEN-SKIP, ETC.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIME CONTRACTION ............. Time-contraction of the source. Greater than 1. Can vary through time.\n");
+        fprintf(stdout,"INFO: SIZE OF CLIPS(mS) ............ Duration of the retained clips, in mS. Can vary through time.\n");
+        break;
+    case(CASCADE):
+        fprintf(stdout,"INFO: SUCCESSIVE SEGMENTS OF SRC ARE REPEAT-ECHOED, AND ECHO-SETS SUPERIMPOSED ON SRC.\n");
+        fprintf(stdout,"INFO: \n");
+        if(mode < 5) {
+            switch(mode) {
+            case(0):    
+                fprintf(stdout,"INFO: N-chan output :: N-chan input. Every echo is in all N channels.\n");
+                break;
+            case(1):
+                fprintf(stdout,"INFO: Stereo output :: Mono input (going to left of output)   :: Echo-streams pan to right.\n");
+                break;
+            case(2):
+                fprintf(stdout,"INFO: Stereo output :: Mono input (going to centre of output) :: Echo-streams pan alternately to L and R.\n");
+                break;
+            case(3):
+                fprintf(stdout,"INFO: 8-chan output :: Mono input (going initially to Ch 1)   :: Each echo in each stream steps to next channel, clockwise.\n");
+                break;
+            case(4):
+                fprintf(stdout,"INFO: 8-chan output :: Mono input (going initially to Ch 1)   :: Each echo in odd-numbered streams steps to R, even-numbered to L.\n");
+                break;
+            }
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SEGMENT LENGTH .......................... Duration (in secs) of (successive) segments in source; each of which is echoed. Possibly time-varying.\n");
+            fprintf(stdout,"INFO: MAX SEGMENT LENGTH .................... Maximum duration of the segments. If set, \"SEGMENT LENGTH\" treated as a minimum.\n");
+            fprintf(stdout,"INFO:                                                              Actual length is a random value between min and max.\n");
+        } else {
+            switch(mode) {
+            case(5):    
+                fprintf(stdout,"INFO: N-chan output :: N-chan input. Every echo is in all N channels.\n");
+                break;
+            case(6):
+                fprintf(stdout,"INFO: Stereo output :: Mono input (going to left of output)   :: Echo-streams pan to right.\n");
+                break;
+            case(7):
+                fprintf(stdout,"INFO: Stereo output :: Mono input (going to centre of output) :: Echo-streams pan alternately to L and R.\n");
+                break;
+            case(8):
+                fprintf(stdout,"INFO: 8-chan output :: Mono input (going initially to Ch 1)   :: Each echo in each stream steps to next channel, clockwise.\n");
+                break;
+            case(9):
+                fprintf(stdout,"INFO: 8-chan output :: Mono input (going initially to Ch 1)   :: Each echo in odd-numbered streams steps to R, even-numbered to L.\n");
+                break;
+            }
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: CUT_TIMES_IN_SOURCE .................... (Succesive) times at which to cut source, to produce the segments to echo.\n");
+            fprintf(stdout,"INFO: \n");
+        }
+        fprintf(stdout,"INFO: ECHO COUNT ................................... Number of echos of each segment. Possibly time-varying.\n");
+        fprintf(stdout,"INFO: MAX ECHO COUNT ........................... Maximum number of echos. If set, \"ECHO COUNT\" treated as a minimum.\n");
+        fprintf(stdout,"INFO:                                                              Actual count is a random value between min and max.\n");
+        fprintf(stdout,"INFO:                                                              If set to ZERO it is ignored.\n");
+        fprintf(stdout,"INFO: TIME RANDOMISATION OF ECHOS .. Randomisation of echo timings (default zero).\n");
+        fprintf(stdout,"INFO: RANDOM SEED ............................... With same non-zero Seed value, a repeat process-run with same parameters gives identical output.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ECHOS MAY BE SHREDDED (echoed-segment cut into smaller chunks which are then randomly rearraged)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CHUNKS IN ANY SEGMENT SHRED .. Number of chunks into which segment-echo is cut.\n");
+        fprintf(stdout,"INFO: REPEAT SHREDDINGS ....................... Number of repeated shreddings on each segment-echo.\n");
+        fprintf(stdout,"INFO: ALSO SHRED SOURCE ....................... Source is shredded, as well as echos.\n");
+        fprintf(stdout,"INFO: LINEAR DECAY ECHO LEVELS ........ Successice echos, in each echo-set, fall away in level less rapdily.\n");
+        fprintf(stdout,"INFO: NORMALISE LOW LEVEL OUTPUT .... Raise Low level output to near maximum level. (High level output is automatically normalised).\n");
+        break;
+    case(SYNSPLINE):
+        fprintf(stdout,"INFO: SYNTHESIS FROM WAVEFORMS MADE BY SMOOTHLY JOINING RANDOMLY GENERATED POINTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SAMPLE RATE ........................... Sample rate of synthesized sound.\n");
+        fprintf(stdout,"INFO: DURATION .............................. Duration of the output sound.\n");
+        fprintf(stdout,"INFO: FREQUENCY ............................ Fundamental frq of the output (Range 0.001 to 10000 Hz).\n");
+        fprintf(stdout,"INFO: SPLINE COUNT ......................... Number of random points generated within a half-wavecycle. InterpolatION between these create the (next) waveform. (0 -64)\n");
+        fprintf(stdout,"INFO: INTERPOLATION STEPS .............. Number of interpolation steps in which one waveform morph into the next (0 - 4096).\n");
+        fprintf(stdout,"INFO: MAXIMUM SPLINE COUNT ............ Maximum Spline Count. If a non-zero value is entered, at each new vavecycle,\n");
+        fprintf(stdout,"INFO:                                                                     a random number of spline points is generated with value between \"Spline Count\" and this maximum value.\n");
+        fprintf(stdout,"INFO: MAXIMUM INTERPOLATION STEPS .. Maximum number of interpolation steps. If a non-zero value is entered, at each new vavecycle,\n");
+        fprintf(stdout,"INFO:                                                                     a random number of steps is generated with value between \"Interpolation Steps\" and this maximum value.\n");
+        fprintf(stdout,"INFO: MAXIMUM PITCH_DRIFT (SEMITONES)............... Maximum random drift of pitch away away from specified frequency, in semitones. (0 - 12)\n");
+        fprintf(stdout,"INFO: AVERAGE TIME(mS) BETWEEN NEW DRIFT VALS .. New pitch drift value set after approximately this timestep (mS).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NORMALISE ALL WAVECYCLES ...... Normalise every wavecycle (default: cycles retain whatever (maximal)-amplitude is generated\n");
+        fprintf(stdout,"INFO:                                                                     in the waveform generation process).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FREQUENCY, SPLINE COUNT, INTERPOLATION STEPS (and the related maximal parameters) can all vary through time. \n");
+        break;
+    case(FRACTAL):
+        fprintf(stdout,"INFO: CREATE FRACTAL REARRANGEMENT OF SOURCE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF FRACTAL LAYERS .. How many times the source is rearranged : Range 2 to 100.\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH IN mS ............ Length of splices : Range 2 to 50\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB The process magnifies the size of the source, substantially.\n");
+        break;
+    case(FRACSPEC):
+        fprintf(stdout,"INFO: IMPOSE FRACTAL TRANSPOSITION PATTERN ON SPECTRUM.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SEMITONE TRANSPOSITION PATTERN ......................... set of time:semitone-transposition pairs for largest time-scale of fractal pattern,\n");
+        fprintf(stdout,"INFO:                                                                                                      Last time defines duration of pattern, last value ignored.\n");
+        fprintf(stdout,"INFO:                                                                                                      Pattern reproduced at contracted time-scale, on each element of pattern, recursively.\n");
+        fprintf(stdout,"INFO: MAX FRACTALISATION ............................................ Maximum degree of fractalisation (repetition of patterning at smaller and smaller timescales.\n");
+        fprintf(stdout,"INFO: TIME STRETCH OF FRACTAL PATTERN ......................... Timestretch applied to fractal pattern. Must be >= 1. If set to zero, ignored.\n");
+        fprintf(stdout,"INFO: INTERVAL STRETCH OF FRACTAL PATTERN ................... Interval stretch applied to fractal pattern. If set to zero, ignored.\n");
+        fprintf(stdout,"INFO: The previous three parameters can all vary through time. \n");
+        fprintf(stdout,"INFO: SHRINK FRACTAL INTERVALS AS_TIMESCALE SHRINKS ..... e.g. if pattern (at next timescale) shrinks by 1/4, transposition intervals also shrink by 1/4.\n");
+        fprintf(stdout,"INFO: READ BRKPNT DATA IN OUTFILE TIMEFRAME ................. (default : brkpoint data is read in the inputfile timeframe).\n");
+        fprintf(stdout,"INFO: FORMANTS NOT RETAINED ............................................. Simple transposition of spectral components. (Default: attempts to retain formant envelope).\n");
+        break;
+    case(SPLINTER):
+        switch(mode) {
+        case(0):    
+        case(2):    
+            fprintf(stdout,"INFO: CREATE SPLINTERS MERGING INTO SOURCE SOUND.\n");
+            break;
+        case(1):    
+        case(3):    
+            fprintf(stdout,"INFO: CREATE SPLINTERS EMERGING OUT OF SOURCE SOUND.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Creates splinters by repeating, with shrinking, a specific waveset-group in the source.\n");
+        fprintf(stdout,"INFO: The time of and size of this group is specified by you.\n");
+        switch(mode) {
+        case(0): case(2):   
+            fprintf(stdout,"INFO: The derived, shrunk splinters repeat, then expand, eventually merging into the original sound at their origin point.\n");
+            break;
+        case(1): case(3):   
+            fprintf(stdout,"INFO: The original sound plays up to the selected time, then splinters,\n");
+            break;
+        }
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: As they expand, the splinters step downwards in pitch.\n");
+            break;
+        case(1):    
+            fprintf(stdout,"INFO: As they shrink, the splinters step upward in pitch.\n");
+            break;
+        case(2): case(3):   
+            fprintf(stdout,"INFO: As they shrink, the splinters retain the original pitch (roughly).\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIME (BEFORE) WAVESET GROUP ............. Time immediately before start of selected wavesets.\n");
+        fprintf(stdout,"INFO: WAVESET COUNT ............................... Number of wavesets to use to make splinter.\n");
+        fprintf(stdout,"INFO: SHRINKING SPLINTERS COUNT ................ Number of splinter repeats before max shrinking attained.\n"); 
+        fprintf(stdout,"INFO: SHRUNK SPLINTERS COUNT ................... Number of additional max-shrunk splinters before any accel or rit ends.\n");
+        fprintf(stdout,"INFO: SPLINTER PULSE RATE AT ORIG WAVESET .. Pulse rate (in Hz) of the repeating splinters close to their origin in the source.\n");
+        fprintf(stdout,"INFO: GOAL PULSE RATE ............................. Pulse rate (in Hz) of the splinters at max distance from their origin.\n");
+        fprintf(stdout,"INFO: EXTRA SPLINTERS COUNT .................... Number of any additional splinters, at regular pulse, beond the \"maximum\" distance.\n");
+        switch(mode) {
+        case(0): case(2):
+            fprintf(stdout,"INFO: SHRINK CONTOUR ............................. Contour of shrink. 1.0 = linear; >1 expands more rapidly at end; <1  less rapidly at end.\n");
+            break;
+        case(1): case(3):
+            fprintf(stdout,"INFO: SHRINK CONTOUR ............................. Contour of shrink. 1.0 = linear; >1 shrink more rapidly at end; <1  less rapidly at end.\n");
+            break;
+        }
+        switch(mode) {
+        case(0): case(2):
+            fprintf(stdout,"INFO: TIMING CONTOUR ............................. Contour of pulse-rate change. >1 accels or rits more rapidly at end; <1 less rapidly at end.\n");
+            break;
+        case(1): case(3):
+            fprintf(stdout,"INFO: TIMING CONTOUR ............................. Contour of pulse-rate change. >1 accels or rits more rapidly at start; <1 less rapidly at start.\n");
+            break;
+        }
+        switch(mode) {
+        case(0): case(1):   
+            fprintf(stdout,"INFO: FRQ OF SHRUNK WAVESETS ................. Determines final wavelength of wavesets when they are maximally shrunk. Default 6000Hz\n");
+            break;
+        case(2): case(3):   
+            fprintf(stdout,"INFO: DURATION(mS) OF SHRUNK WAVESETS ... The final size (in mS) of the waveset-group when it is maximally shrunk.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: SPLINTER TIMING RANDOMISATION ......... Randomisation of the pulse-rate of the splinters.\n");
+        fprintf(stdout,"INFO: SPLINTER SHRINKING RANDOMISATION .... Randomisation of the shrinkage of the splinters.\n");
+        switch(mode) {
+        case(0): case(2):   
+            fprintf(stdout,"INFO: RETAIN ALL SOURCE SND ..................... Default, source is not heard until the splinters merge into it.\n");
+            break;
+        case(1): case(3):   
+            fprintf(stdout,"INFO: RETAIN ALL SOURCE SND ..................... Default, source is not heard after splinters emerge from it.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: RETAIN NO SOURCE SND ..................... The source sound is entirely suppressed.\n");
+        break;
+    case(REPEATER):
+        fprintf(stdout,"INFO: PLAY THROUGH SOURCE, WITH SPECIFIED ELEMENTS REPEATING THEMSELVES.\n");
+        fprintf(stdout,"INFO:        The Sound-stream pauses for each segment-of-repeats then continues (to the next) ...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 3 : produces decrescendoing, accelerating output, like bouncing object.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: REPEATED SEGMENTS DATA ......................... a textfile of values specifying the segments to be repeated, and the details of the repetition .\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:                         Each line contains 4 values .....\n");
+        fprintf(stdout,"INFO: \n");
+        if(mode == 0 || mode == 2) {
+            fprintf(stdout,"INFO:                         \"Start-time\"   \"End-time\"   \"Number-of-Repeats\"   \"Delay-time\"\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                         \"Start-time\" and \"End-time\" are the start and end of the segment to be repeated.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                         \"Delay-time\", for any repeating segment,\n");
+            fprintf(stdout,"INFO:                         is the time between the START of one repeated element and the START of the next.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                         Delay zero will produce a delay equal to the segment length.\n");
+            fprintf(stdout,"INFO:                         Otherwise, delays less than 0.05 seconds may produce output like an oscillator.\n");
+        } else {
+            fprintf(stdout,"INFO:                         \"Start-time\"   \"End-time\"   \"Number-of-Repeats\"   \"Offset-time\"\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO:                         \"Offset-time\", for any repeating segment,\n");
+            fprintf(stdout,"INFO:                         is the time between the END of one repeated element and the START of the next.\n");
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:                         Selected segments  must be at least 0.01 seconds in duration\n");
+        fprintf(stdout,"INFO:                         and can overlap one-another, or backtrack in the source sound.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANGE OF ANY RANDOM EXPANSION OF DELAY TIMES ......... For any segment, the delay times may each be randomly stretched.\n");
+        fprintf(stdout,"INFO:                            This parameter specifies the upper limit of such streching, and this limit may vary through time.\n");
+        fprintf(stdout,"INFO:                            An expansion of \"1.0\" results in no stretching.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANGE OF ANY RANDOM PITCH VARIATION(SEMITONES) ..... For any segment, the pitch of each repeat may randomly vary.\n");
+        fprintf(stdout,"INFO:                            This parameter specifies the upper limit of such pitch-variation, in semitones.\n");
+        fprintf(stdout,"INFO:                            An expansion limit of e.g. \"1.5\" results in random pitch shifts in the range 1.5 semitones down to 1.5 semitones up.\n");
+        fprintf(stdout,"INFO:                            A value of zero results in no transposition.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RANDOM SEED .............................................................. An integer. Repeated process-runs with same source and same seed value gives identical output.\n");
+        if(mode == 2) {
+            fprintf(stdout,"INFO: ACCELERATION OF REPEATS ...................................... e.g. \"3\" means Gradually shorten delays until they reach 1/3 duration .\n");
+            fprintf(stdout,"INFO: WARP OF ACCELERATION ................................................ Warp value >1 shortens by less initially and by more later. Warp 1 has no effect.\n");
+            fprintf(stdout,"INFO: FADE CONTOUR .............................................................. 1  Gives linear fade:   >1  Faster followed by slower decay:   <1  Slower followed by faster.\n");
+            fprintf(stdout,"INFO: \n");
+        }
+        break;
+    case(VERGES):
+        fprintf(stdout,"INFO: PLAY SOURCE, WITH SPECIFIED BRIEF MOMENTS GLISSING UP OR DOWN ABRUPTLY, AND POSSIBLY ACCENTED.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Best applied to attack points in the source.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: VERGE TIMES ............................................... Textifle, being a list of times at which to create the verges.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: VERGE TRANSPOSITION(SEMITONES) ......... Initial semitone transposition at the verge-time.\n");
+        fprintf(stdout,"INFO:                            This parameter specifies the upper limit of such streching, and this limit may vary through time.\n");
+        fprintf(stdout,"INFO:                            An expansion of \"1.0\" results in no stretching.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: VERGE SLOPE ............................................... Slope of glissando. Default 1 (linear). Other values are steeper.\n");
+        fprintf(stdout,"INFO: VERGE DURATION ........................................ Duration of the verges.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \"TRANSPOSITION\", \"SLOPE\" and \"DURATION\" can vary through time.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DON'T SEARCH FOR LOCAL PEAKS ....... Use the exact verge-times supplied. Do not search for local peaks.\n");
+        fprintf(stdout,"INFO: BOOST VERGE LEVEL ..................................... Boost the level of the verges.\n");
+        fprintf(stdout,"INFO: SUPPRESS NON-VERGES .............................. Suppress any input signal which is not a verge.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \"BOOST\" and \"SUPPRESS\" Cannot be used together.\n");
+        break;
+    case(MOTOR):
+        fprintf(stdout,"INFO: CREATING A FAST STREAM OF PULSES, ENVELOPED BY A SLOWER-PULSING STREAM.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Create fast (inner) pulse-stream, within slower (outer) pulsing-enveloping.\n");
+        fprintf(stdout,"INFO: Under every outer envelope-pulse, the inner events are cut, successively, from the input source(s).\n");
+        fprintf(stdout,"INFO: Each outer-pulse (possibly shortened by randomisation) must hold at least 2 inner-pulses (possibly lengthened by randomisation).\n");
+        fprintf(stdout,"INFO: Shortish sources with a changing spectrum (or shortish segments cut from a larger source) are recommended.\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: MODE: Uses a single source. Reads src-segment, then advances during pulse crescendo, regressing during decrescendo.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: MODE: Uses several elements cut from a single source, with cuts specified in \"SLICE TIMES\".\n");
+            fprintf(stdout,"INFO:             Reads a segment from an element then advances during pulse crescendo, regressing during decrescendo.\n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: MODE: Uses several srcs. Reads element from a src then advances during pulse crescendo, regressing during decrescendo.\n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: MODE: Uses a single source. Reads src-segment then advances.\n");
+            break;
+        case(4):
+            fprintf(stdout,"INFO: MODE: Uses several elements cut from a single source, with cuts specified in \"SLICE TIMES\".\n");
+            fprintf(stdout,"INFO:             Reads an element-segment then advances.\n");
+            break;
+        case(5):
+            fprintf(stdout,"INFO: MODE: Uses several srcs. Reads a src-segment then advances.\n");
+            break;
+        case(6):
+            fprintf(stdout,"INFO: MODE: Uses a single source. Reads src-segment, advancing for rest of read, or regressing for rest of read. Decision to advance or regress is random.\n");
+            break;
+        case(7):
+            fprintf(stdout,"INFO: MODE: Uses several elements cut from a single source, with cuts specified in \"SLICE TIMES\".\n");
+            fprintf(stdout,"INFO:             Reads element-segment advancing for rest of read, or regressing for of the read. Decision to advance or regress is random.\n");
+            break;
+        case(8):
+            fprintf(stdout,"INFO: MODE: Uses several srcs. Reads src-segment advancing for rest of read, or regressing for rest the read. Decision to advance or regress is random.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        switch(mode) {
+        case(1):
+        case(4):
+        case(7):
+            fprintf(stdout,"INFO: SLICE TIMES (Mode 2 only) ........................... Slice times to cut source input sound into several source segments.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: TOTAL OUTPUT DURATION ........................... Duration of output sound to produce.\n");
+        fprintf(stdout,"INFO: INNER PULSE FRQ(Hz) ................................. Frq rate of inner (faster) pulses.\n");
+        fprintf(stdout,"INFO: OUTER PULSE RATE(Hz) ............................... Frq rate of outer (enveloping) pulses.\n");
+        fprintf(stdout,"INFO: INNER PULSES PROPORTION ON-TO-OFF TIME ... Proportion of the inner pulse which sounds (the rest is silence, or a low-level tail: see below).\n");
+        fprintf(stdout,"INFO: OUTER PULSES PROPORTION ON-TO-OFF TIME .. Proportion of the outer pulse which sounds (the rest is silence).\n");
+        fprintf(stdout,"INFO: SYMMETRY OF OUTER PULSES ....................... Position of peak within envelope: 0 is start, 1 is end: 1/2 is halfway through envelope.\n");
+        fprintf(stdout,"INFO: INNER PULSE FRQ RANDOMISATION ................ Range of randomisation of the inner-pulse frequency (0 to 1) (max range (val 1) from dur/3 to 3*dur/2).\n");
+        fprintf(stdout,"INFO: OUTER PULSE FRQ RANDOMISATION ............... Range of randomisation of the outer-envelope frequency. (similarly)\n");
+        fprintf(stdout,"INFO: PITCH RANDOMISATION RANGE(SEMITONES) ..... Range of pitch variation of inner pulse, moving from one envelope to next. (0-3 semitones)\n");
+        fprintf(stdout,"INFO: ATTENUATION RANDOMISATION RANGE ........... Range of any random attenuation of inner-pulses (0: no attenuation :: 1: rand attenuation  from  none to zero level output).\n");
+        fprintf(stdout,"INFO: SYMMETRY RANDOMISATION ......................... Range of randomisation of envelope symmetry (0 to 1).\n");
+        fprintf(stdout,"INFO: INNER PULSES DECAY TAIL ........................... Length of decay tails on inner-pulses, a multiple of their duration.\n");
+        fprintf(stdout,"INFO: OUTER PULSE SHARPNESS ............................ Slope of outer-envelope. 1 = linear: >1 slow-to-fast rise:  <1 fast_to_slow rise.\n");
+        fprintf(stdout,"INFO: READ ADVANCE RANDOMISATION ................... Randomisation of the step advance in reading the input. (Range 0 to 1).\n");
+        fprintf(stdout,"INFO: RANDOM SEED .............................................. Same seed value, with same values for randomising params, produces identical output.\n");
+        fprintf(stdout,"INFO: ADVANCE BY FIXED STEP IN SRC READS ........... Default is to step regularly through src so we reach its end, whatever the length of the pulse.\n");
+        switch(mode) {
+        case(1):
+        case(4):
+        case(7):
+            fprintf(stdout,"INFO: USE SEGMENTS CYCLICALLY .......................... Default is to randomly permute the order of the segments.\n");
+            break;
+        case(2):
+        case(5):
+        case(8):
+            fprintf(stdout,"INFO: USE SRCS CYCLICALLY ............................... Default is to randomly permute the order of the srcs.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: All parameters EXCEPT \"SEED\" and \"DURATION\" can vary through time.\n");
+        break;
+    case(STUTTER):
+        fprintf(stdout,"INFO: SLICE SOURCE INTO ELEMENTS, AND RANDOMLY PLAY SEGMENTS SLICED FROM START OF SEGMENTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Best applied to attack points in the source (e.g. start of word or syllable of text).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: SLICE TIMES  ...................................................... Slice times to cut source input sound into several elements.\n");
+        fprintf(stdout,"INFO: OUTPUT DURATION ...............................................Duration of output sound to produce.\n");
+        fprintf(stdout,"INFO: MAX SEGMENT JOINS ............................................ Segments can be used independently, or joined together consecutively.\n");
+        fprintf(stdout,"INFO:                                                                                                This parameter determines the maximum number of segments to be joined.\n");
+        fprintf(stdout,"INFO: PROPORTION OF SILENCE ...................................... Cut elements can be separated by silence\n");
+        fprintf(stdout,"INFO:                                                                                                This parameter determines the proportion of segments that are followed by silence.\n");
+        fprintf(stdout,"INFO: MIN SILENCE DURATION ........................................ Minimum duration of any intervening silences.\n");
+        fprintf(stdout,"INFO: MAX SILENCE DURATION ........................................ Maximum duration of any intervening silences.\n");
+        fprintf(stdout,"INFO: RANDOM SEED .................................................... Same seed value, with same values for randomising params, produces identical output.\n");
+        fprintf(stdout,"INFO: MAX RANGE OF RANDOM TRANSPOSITION(SEMITONES) .. Maximum range over which cut segments can be randomly transposed.\n");
+        fprintf(stdout,"INFO: MAX RANGE_OF RANDOM ATTENUATION .................... Maximum range over which cut segments can be attenuated.\n");
+        fprintf(stdout,"INFO: SEGMENT LENGTH BIAS .......................................... Bias < 0 favours shorter cuts from segments. Bias > 0, longer cuts.\n");
+        fprintf(stdout,"INFO: MIN SEGMENT DURATION(mS) .................................. Minimum duration of any cut segment.\n");
+        fprintf(stdout,"INFO: PERMUTE SEGMENT ORDER ..................................... Play a cut from each elements in random order, than permute order and repeat.\n");
+        fprintf(stdout,"INFO:                                                                                                (Default: elements selected entirely at random.)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \"TRANSPOSITION\", \"ATTENUATION\" and \"BIAS\" can vary through time.\n");
+        break;
+    case(SCRUNCH):
+        switch(mode) {
+        case(0):    fprintf(stdout,"INFO: CUT SOURCE INTO WAVESET(GROUP)S AND PERMUTE THEIR ORDER TO FORM OUTPUT STREAM.\n");                   break;
+        case(1):    fprintf(stdout,"INFO: CUT SOURCE INTO WAVESET(GROUP)S, THE SELECT AT RANDOM INTO OUTPUT STREAM.\n");                        break;
+        case(2):    fprintf(stdout,"INFO: CUT SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF INCREASING LENGTH (PITCH FALLING).\n");  break;
+        case(3):    fprintf(stdout,"INFO: CUT SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF DECREASING LENGTH (PITCH RISING).\n");   break;
+        case(4):    fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF INCREASING LENGTH (PITCH FALLING).\n");  break;
+        case(5):    fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF DECREASING LENGTH (PITCH RISING).\n");   break;
+        case(6):    fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE ALTERNATELY IN ORDER OF INCREASING THEN DECREASING LENGTH (PITCH FALL-RISE).\n"); break;
+        case(7):    fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE ALTERNATELY IN ORDER OF DECREASING THEN INCREASING LENGTH (PITCH RISE-FALL).\n"); break;
+        case(8):    fprintf(stdout,"INFO: CUT SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF INCREASING LOUDNESS.\n");    break;
+        case(9):    fprintf(stdout,"INFO: CUT SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF DECREASING LOUDNESS.\n");    break;
+        case(10):   fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF INCREASING LOUDNESS.\n");    break;
+        case(11):   fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE THEM IN ORDER OF DECREASING LOUDNESS.\n");    break;
+        case(12):   fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE ALTERNATELY IN ORDER OF INCREASING THEN DECREASING LOUDNESS.\n"); break;
+        case(13):   fprintf(stdout,"INFO: CUT SEGMENTS OF SOURCE INTO WAVESET(GROUP)S AND ARRANGE ALTERNATELY IN ORDER OF DECREASING THEN INCREASING LOUDNESS.\n"); break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        if(mode <= 1)
+            fprintf(stdout,"INFO: OUTPUT DURATION ...............................................Duration of output sound to produce.\n");
+        else if((mode > 3 && mode < 8) || mode > 9)
+            fprintf(stdout,"INFO: SLICE TIMES ...................................................... Textfile of (increasing) times at which to divide src into segments for processing.\n");
+        fprintf(stdout,"INFO: RANDOM SEED .................................................... Same seed value, with same values for randomising params, produces identical output.\n");
+        fprintf(stdout,"INFO: COUNT_OF_WAVESETS_IN_A_GROUP ....................... Count (and then cut) wavesets in groups of this size.\n");
+        fprintf(stdout,"INFO: MAX RANGE OF RANDOM TRANSPOSITION(SEMITONES) .. Maximum range over which cut segments can be randomly transposed.\n");
+        fprintf(stdout,"INFO: MAX RANGE_OF RANDOM ATTENUATION .................... Maximum range over which cut segments can be attenuated.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \"TRANSPOSITION\", and \"ATTENUATION\" can vary through time.\n");
+        break;
+    case(IMPULSE):
+        fprintf(stdout,"INFO: GENERATE IMPULSES OR IMPULSE STREAMS, PITCHED OR CHIRPING.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT DURATION .............................. Duration of output sound to produce.\n");
+        fprintf(stdout,"INFO: PITCH OF IMPULSE STREAM(MIDI) ............ Not the pitch of the impulses, but the rate at which they occur.\n");
+        fprintf(stdout,"INFO: GLISSING OF IMPULSE .......................... Zero value gives a fixed-pitch impulse, >zero, impulses gliss (up then down). CARE: high valus may clip.\n");
+        fprintf(stdout,"INFO: SLOPE OF IMPULSE .............................. Value 1, impulses rise and fall in level linearly. Higher values give steeper slopes.\n");
+        fprintf(stdout,"INFO: NUMBER OF PEAKS PER IMPULSE .............. Dividing this number by the frq of the stream (derived from pitch) gives the (Start) pitch of the impulses themselves.\n");
+        fprintf(stdout,"INFO: IMPULSE LEVEL ................................... Loudness of the impulses.\n");
+        fprintf(stdout,"INFO: PROPORTIONAL GAP BETWEEN IMPULSES .. Zero gives no gap. +ve vals leave silent space between impulses e.g. 0.5 gives a gap of 1/2 the duration of the impulse.\n");
+        fprintf(stdout,"INFO:                                                                                                          -ve values cause the impulses to overlap. With -0.5 they overlap by 1/2 their length.\n");
+        fprintf(stdout,"INFO: SAMPLE RATE .................................... Sample rate of the output sound.\n");
+        fprintf(stdout,"INFO: OUTPUT CHANNEL CNT ......................... Number of channels in the output sound.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \"PITCH\", \"GLISSING\", \"SLOPE\", \"NUMBER OF PEAKS\", \"LEVEL\" and \"GAP\" can vary through time.\n");
+        break;
+    case(TWEET):
+        switch(mode) {
+        case(0):
+        case(1):
+            fprintf(stdout,"INFO: SUBSITUTE CHIRPS FOR VOCAL FORMANTS.\n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: SUBSITUTE NOISE FOR VOCAL FORMANTS.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIMEBLOKS IN SRC NOT TO SEARCH FOR FOFS ... Textfile of pairs of times in src where there are no FOFs expected,\n");
+        fprintf(stdout,"INFO: FREQUENCY OF SRC(HZ) .............................. A textfile of time : frequency pairs, being the extracted pitch contour of the input sound\n");
+        fprintf(stdout,"INFO: LOWEST LEVEL AT WHICH FOFS DETECTED(dB) ... If any FOF is more than this number of dBs below the level of the loudest FOF detected, it is ignored.\n");
+        fprintf(stdout,"INFO:                                                                                    (A ZERO value will search for FOFs at any level).\n");
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: NUMBER OF PEAKS IN CHIRP ... ...................... Number of peaks in the chirp which replaces the FOF. (Frq will vary depending on size of FOF)\n");
+            fprintf(stdout,"INFO: GLISSING OF CHIRP ..................................... Amount of glissing of the chirps.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: \"NUMBER OF PEAKS\", and \"GLISSING\" can vary through time.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: FREQUENCY OF CHIRP ................................. (Fixed) Frequency of the chirps.\n");
+            fprintf(stdout,"INFO: GLISSING OF CHIRP ..................................... Amount of glissing of the chirps.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: \"FREQUENCY\" and \"GLISSING\" can vary through time.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: COSIN SMOOTH FOFS .................................. Cosinusoidal onset and decay applied to FOFs, before replacement sound inserted.\n");
+        break;
+    case(RRRR_EXTEND): // verasion 8+ 
+        switch(mode) {
+            case(0):
+            case(1):
+                fprintf(stdout,"INFO: TIME-EXTEND NATURAL ITERATIVE EVENTS IN A SRC (LIKE ROLLED 'rrr' IN SPEECH) IN A PLAUSIBLE WAY\n");
+                break;
+            case(2):
+                fprintf(stdout,"INFO: FIND AND CUT OUT EACH GRAIN OF AN ITERATIVE EVENT IN A SRC SOUND (LIKE ROLLED 'rrr' IN SPEECH)\n");
+                fprintf(stdout,"INFO: AND SAVE EACH GRAIN (AND THE PRE-ITERATE AND POST-ITERATE CHUNKS OF THE SRC) TO ITS OWN SOUNDFILE BY FIRST\n");
+                break;
+        }
+        switch(mode) {
+            case(0):
+            case(2):
+            fprintf(stdout,"INFO: SPECIFYING WHERE THE ITERATIVE EVENT IS IN THE SOURCE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: START OF SECTION TO BE EXTENDED ......................... Time of start of the iterated material in the source.\n");
+            fprintf(stdout,"INFO: END OF SECTION TO BE EXTENDED ............................ Time of end of the iterated material in the source.\n");
+            fprintf(stdout,"INFO: ANTICIPATED NO OF SEGMENTS TO FIND IN SRC............ Estimate how many iterations you hear in marked area.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: LETTING THE PROCESS SEARCH FOR THE (FIRST) ITERATIVE EVENT IN THE SOURCE.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PARAMETERS ----------------------------------------------------\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINUMUM NO OF SEGMENTS TO FIND IN SRC ................ Estimate how many iterations you hear in marked area.\n");
+            fprintf(stdout,"INFO: APPROX SIZE OF GRANULE (MS) ................................ Anticipated size of grain (try 15mS).\n");
+            fprintf(stdout,"INFO: GATE LEVEL BELOW WHICH SIGNAL ENVELOPE IGNORED .. Don't search for grains where signal drops below gate-level.\n");
+            fprintf(stdout,"INFO: NUMBER OF GRAINS AT ITERATIVE START TO OMIT ........ Allows you to play through first N grains you find\n");
+            fprintf(stdout,"INFO:                                                                  before using the ensuing grains for the time-extension process.\n");
+            break;
+        }
+        fprintf(stdout,"INFO: APPROX RANGE OF ITERATIVE SOUND (OCTAVES) ......... The acceptable variation in grainsize of grains to find (Try 1).\n");
+        fprintf(stdout,"INFO:                                                                  This is the 'pitch'-range of the (low_frq) iteration, and NOT the resonant frequency.\n");
+        fprintf(stdout,"INFO:                                                                  e.g. for a rolled 'rrr' it is the frq of the 'rrr' itself (even if unvoiced)\n");
+        fprintf(stdout,"INFO:                                                                  and not the pitch of any sung note (if the 'rrr' is voiced).\n");
+        switch(mode) {
+            case(0):
+            case(1):
+            fprintf(stdout,"INFO: TIME EXTENSION OF THE MATERIAL ITSELF (TEM).......... How much to time-extend the marked material (by randomised repetition).\n");
+            fprintf(stdout,"INFO: MAX ADJACENT OCCURENCES OF ANY SEG IN OUTPUT ... Iterated material extended by reusing the individual grains in a randomised pattern.\n");
+            fprintf(stdout,"INFO:                                                              In this pattern, grain-A may occur next to an identical copy of grain-A, or not.\n");
+            fprintf(stdout,"INFO:                                                              This parameter specifies how many adjacent copies of any segment you are prepared to allow.\n");
+            fprintf(stdout,"INFO: AMPLITUDE SCATTER .............................................. The iterated segments may vary in amplitude.\n");
+            fprintf(stdout,"INFO:                                                            0 retains original amplitude: N produces random amplitudes between orig and (1-N) * orig.\n");
+            fprintf(stdout,"INFO: PITCH SCATTER ................................................... The iterated segments may vary in pitch.\n");;
+            fprintf(stdout,"INFO:                      0 retains original pitch: N produces random pitchshift between N and -N semitones.\n");
+            fprintf(stdout,"INFO: GRAIN SEPARATION TIMESTRETCH (GST) .................... Material can also be time-stretched by inserting silence between the grains.\n");
+            fprintf(stdout,"INFO:                                                              This parameter, varying upwards from 1 (= no timestretch), is independent of the TEM parameter\n");;
+            fprintf(stdout,"INFO:                                                              and will overiride it if GST makes the output longer, or shorter than the length implied by TEM.\n");
+            fprintf(stdout,"INFO:                                                              In any breakpoint file for this parameter, times are measured FROM THE START OF THE ITERATED SEGMENT\n");
+            fprintf(stdout,"INFO:                                                              (rather than the start of the source file) and the final value of \"1.0\" in the brkfile defines the time-end of the GST.\n");
+            fprintf(stdout,"INFO:                                                              Note that if your brkpoint values don't begin and end at \"1.0\" there will be a discontinuity\n");
+            fprintf(stdout,"INFO:                                                              if you attach the sound before (or after) the iterated segment to the iterated segment itself.\n");
+            fprintf(stdout,"INFO: GRAIN SEPARATION REGULARISTION ........................... When set to 1, attempts to make grains appear at a fixed regular rate\n");
+            fprintf(stdout,"INFO:                                                              independent of the invidual grain durations.\n");;
+            fprintf(stdout,"INFO:                                                              It will only kick in once the grains have been stretched by GST (and total regularity is not possible\n");
+            fprintf(stdout,"INFO:                                                               until the average step from one grain start to the next is greater than size of largest grain).\n");
+            fprintf(stdout,"INFO:                                                              In any breakpoint file for this parameter, times are measured FROM THE START OF THE ITERATED SEGMENT\n");
+            fprintf(stdout,"INFO:                                                              (rather than the start of the source file).\n");
+            fprintf(stdout,"INFO: DON'T KEEP SOUND BEFORE ITERATE ..................... If flag is set, start of sound (before iterated material) is discarded.\n");
+            fprintf(stdout,"INFO: DON'T KEEP SOUND AFTER ITERATE ....................... If flag is set, end of sound (after iterated material) is discarded.\n");
+        }
+        break;
+    case(SORTER):
+        fprintf(stdout,"INFO: CHOPS MONO SOURCE INTO ELEMENTS, THEN REORGANISES BY LOUDNESS, OR DURATION.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Mode 1: Sort to Crescendo.\n");
+        fprintf(stdout,"INFO: Mode 2: Sort to Decrescendo.\n");
+        fprintf(stdout,"INFO: Mode 3: Sort to Accelerando. (With very small elements, may rise in pitch).\n");
+        fprintf(stdout,"INFO: Mode 4: Sort to Ritardando.  (With very small elements, may fall in pitch).\n");
+        fprintf(stdout,"INFO: Mode 5: Order at Random.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ELEMENT SIZE ... Approximate size of elements to sort, in seconds.\n");
+        fprintf(stdout,"INFO:                                   If set to zero, individual wavesets are chosen as elements.\n");
+        fprintf(stdout,"INFO: SMOOTHING .........  Fade in (and out) each segment, with a \"SMOOTH\" mS splice.\n");
+        fprintf(stdout,"INFO:                                   If elementsize is zero, this is ignored.\n");
+        fprintf(stdout,"INFO: SEED ................... Mode 5 (\"Order at Random\"): a rerun with same non-zero seed value\n");
+        fprintf(stdout,"INFO:                                   outputs the SAME random ordering of elements.\n");
+        fprintf(stdout,"INFO:                                   (Zero seed-value gives different random ordering on each run).\n");
+        fprintf(stdout,"INFO: OUTPITCH ........... Output elements time-spacing equivalent to the MIDI pitch,\"OPCH\".\n");
+        fprintf(stdout,"INFO:                                   If \"AS FREQUENCY\" flag is used, value can be set to 128 to specify\n");
+        fprintf(stdout,"INFO:                                   the median pitch of the source.\n");
+        fprintf(stdout,"INFO:                                   If value is set to zero, parameter is ignored.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AS FRQEQUENCY .. Element size is read as a frq value (= 1.0/duration)\n");
+        fprintf(stdout,"INFO:                                   and could be e.g. a frequency-trace of the pitch of the source.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The following parameters can only be used if \"AS FRQEQUENCY\" flag is set.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ELEMENT PITCH .. Transpose input elements to the MIDI pitch specified.\n");
+        fprintf(stdout,"INFO:                                   If value set to 128, the median pitch of the source is used.\n");
+        fprintf(stdout,"INFO:                                   If value is set to zero, parameter is ignored.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The following parameter is only useful if \"ELEMENT PITCH\" is set.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: META GROUPING ... Size of meta-grouping, in seconds.\n");
+        fprintf(stdout,"INFO:                                   Allows larger units to be (approximately) pitch-correlated.\n");
+        fprintf(stdout,"INFO:                                   Source is first cut to pitch-wavelen-scale elements & transpositions calculated.\n");
+        fprintf(stdout,"INFO:                                   These elements are then further grouped to (approx) \"META GROUPING\" size.\n");
+        fprintf(stdout,"INFO:                                   This must be larger than the largest element (1/frq) from frq trace.\n");
+        fprintf(stdout,"INFO:                                   If \"META GROUPING\" is set to zero, it is ignored.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: If \"ELEMENT PITCH\" is NOT set, larger groupings are obtained by using larger value of \"ELEMENT SIZE\".\n");
+        break;
+    case(SPECFNU):
+        switch(mode) {
+        case(0):
+            fprintf(stdout,"INFO: NARROW FORMANTS: Steepens skirts of formant peaks by power factor.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: NARROWING ........................................ Narrowing of individual formant peaks. Range 1 to 1000. Timevariable.\n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: SUPPRESS SET ...................................... Suppress the listed formants. \"OFF\" can be any combination of\n");
+            fprintf(stdout,"INFO:                                                                                \"1\",\"2\",\"3\" & \"4\" but not all of them, and with no repetitions.\n");
+            fprintf(stdout,"INFO: ZERO TOP OF SPECTRUM .......................... Zero top of spectrum (above fourth formant).\n");
+            fprintf(stdout,"INFO: FORCE FUNDAMENTAL ............................. Force lowest formant to use fundamental frq as peak.\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: EXCLUDE HARMONIC PARTIALS .................. Exclude harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED... Re.place unpitched (or extremely quiet) windows by silence.\n");
+            break;
+        case(1):
+            fprintf(stdout,"INFO: SQUEEZE SPECTRUM AROUND FORMANT: Squeeze around specified formant.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SQUEEZE ............................................ Squeeze factor. Range 1 to 10. Timevariable.\n");
+            fprintf(stdout,"INFO: CENTRE FORMANT ................................. Formant peak at centre of squeeze. (range 1 to 4)\n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: SQUEEZE AROUND TROUGH ABOVE ............. Squeeze around trough above specified peak.\n");
+            fprintf(stdout,"INFO: FORCE FUNDAMENTAL ............................. Force lowest formant to use fundamental frq as peak.\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ............ Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: EXCLUDE HARMONIC PARTIALS .................. Exclude harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            break;
+        case(2):
+            fprintf(stdout,"INFO: INVERT FORMANTS: Formant peaks become troughs, and troughs peaks.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: VIBRATE RATE ........................................ If not zero, cycle between original & inversion at this frq. Timevariable.\n");
+            fprintf(stdout,"INFO: GAIN .................................................... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ................................ Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS .............. Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: EXCLUDE HARMONIC PARTIALS .................... Exclude harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .... Replace unpitched (or extremely quiet) windows by silence.\n");
+            break;
+        case(3):
+            fprintf(stdout,"INFO: ROTATE FORMANTS: Formant peaks & frqs move up (or down) spectrum.\n");
+            fprintf(stdout,"INFO:         reappearing at foot (top) of formant-area, when they reach its edge.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ROTATION SPEED ................................... Spectrum rotation speed, e.g. 2 = twice every second.\n");
+            fprintf(stdout,"INFO:                                                                                 Range -300 to 300 rotations per second. Timevariable.\n");
+            fprintf(stdout,"INFO: GAIN ................................................... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ............................... Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ............ Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: EXCLUDE HARMONIC PARTIALS ................... Exclude harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED ... Replace unpitched (or extremely quiet) windows by silence.\n");
+            break;
+        case(4):
+            fprintf(stdout,"INFO: SPECTRAL NEGATIVE: Spectral values inverted for each channel.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GAIN ...... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: FLAT ...... Do not re-envelope the output spectrum.\n");
+            break;
+        case(5):
+            fprintf(stdout,"INFO: SUPPRESS FORMANTS: Suppresses the selected formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: SUPPRESS SET ............................... which of (4) formants to suppress. e.g. \"1\" means suppress 1st,\n");
+            fprintf(stdout,"INFO:                                                                    while \"134\" means suppress 1st, 3rd and 4th.\n");
+            fprintf(stdout,"INFO: GAIN ........................................... Output gain or attenuation. (Range 0.1 to 10).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ...................... Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS .... Exclude non-harmonic partials.\n");
+            break;
+        case(6):
+            fprintf(stdout,"INFO: GENERATE FILTER(S) FROM FORMANT(S): Outputs varibank filter data textfile.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: DATAFILE .......................... Textfile containing.\n");
+            fprintf(stdout,"INFO:     (1)  LIST OF TIMES at which src to be divided into blocks for analysis.\n");
+            fprintf(stdout,"INFO:                      Resulting filter step-changes between vals created from each block.\n");
+            fprintf(stdout,"INFO:                      Value ZERO means use the entire source to make 1 fixed filter.\n");
+            fprintf(stdout,"INFO:     (2)  PITCH GRID on which pitches you are searching for must lie.\n");
+            fprintf(stdout,"INFO:                      There must first be a marker indicating the grid type. These are..\n");
+            fprintf(stdout,"INFO:                              #HS:    Followed by listed MIDI pitches to search for.\n");
+            fprintf(stdout,"INFO:                              #HF:    Followed by listed MIDI pitches to search for IN ALL OCTAVES.\n");
+            fprintf(stdout,"INFO:                              #SCALE: Followed by just TWO values.\n");
+            fprintf(stdout,"INFO:                                    (a) the number of equal pitch divisions in an octave.\n");
+            fprintf(stdout,"INFO:                                    (b) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO:                              #ELACS: Followed by just THREE values.\n");
+            fprintf(stdout,"INFO:                                    (a) Size of \"octave\" in (possibly fractional) semitones.\n");
+            fprintf(stdout,"INFO:                                    (b) the number of equal pitch divisions in \"octave\".\n");
+            fprintf(stdout,"INFO:                                    (c) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO: PEAKS PER FORMANT ........ (Max) number of peaks from each formant to use. (Default value 1). \n");
+            fprintf(stdout,"INFO: FORCE A PITCH BELOW ..... Try to ensure there is 1 (or more) pitch(es) below this MIDI value.\n");
+            fprintf(stdout,"INFO: KEEP PEAK LOUDNESS ....... Keep relative (summed) loudnesses of peaks as part of filter design.\n");
+            fprintf(stdout,"INFO: INVERT PEAK LOUDNESS .... Keep inverse of loudnesses as part of filter design.\n");
+            fprintf(stdout,"INFO:                                                   Default. All filter amplitudes set to 1.0\n");
+            fprintf(stdout,"INFO: FORCE FUNDAMENTAL ...... Force lowest formant to use fundamental frq as peak.\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ........ Use short-window for extracting spectral envelope.\n");
+            break;
+        case(7):
+            fprintf(stdout,"INFO: MOVE FORMANTS BY: Displace individual formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MOVE1 .................................................. Frq displacement, up or down, of formant 1. Timevariable.\n");
+            fprintf(stdout,"INFO: MOVE2,MOVE3,MOVE4 ............................... Similarly for other formants.\n");
+            fprintf(stdout,"INFO:                                          (Formants moving below zero or above nyquist/2 will disappear).\n");
+            fprintf(stdout,"INFO: GAIN .................................................... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ZERO TOP OF SPECTRUM ............................ Zero top of spectrum (above fourth formant).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ................................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS .............. Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: EXCLUDE HARMONIC PARTIALS .................... Exclude harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .... Replace unpitched (or extremely quiet) windows by silence.\n");
+            break;
+        case(8):
+            fprintf(stdout,"INFO: MOVE FORMANTS TO: Displace individual formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FRQ1 ................................................... New frq of formant 1. Timevariable.\n");
+            fprintf(stdout,"INFO: FRQ2,FRQ3,FRQ4 ................................... Similarly for other formants.\n");
+            fprintf(stdout,"INFO: GAIN ................................................... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ZERO TOP OF SPECTRUM ........................... Zero top of spectrum (above fourth formant).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ............................... Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: NARROW FORMANT BANDS ........................ Use narrow formant bands.\n");
+            fprintf(stdout,"INFO:                                                                    Using narrow bands can give counterintuitive results.\n");
+            fprintf(stdout,"INFO:                                                                    Doesn't capture so many harmonic peaks, so sounds duller.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ............. Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: EXCLUDE HARMONIC PARTIALS ................... Exclude harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED ... Replace unpitched (or extremely quiet) windows by silence.\n");
+            break;
+        case(9):
+            fprintf(stdout,"INFO: ARPEGGIATE SPECTRUM: Arpeggiate spectrum of source, under formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE ..................... Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: GAIN ......................................... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ..................... Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS .. Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ............................. Arpeggiate downwards (default upwards).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ............................ Arpeggiate up and down.\n");
+            break;
+        case(10):
+            fprintf(stdout,"INFO: OCTAVE-SHIFT UNDER FORMANTS: Octave-shift src spectrum, under formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: OCTAVE SHIFT ...................................... Octave shift (Range -4 to + 4). (Timevariable).\n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE .............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................ Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ............................................ Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ....................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: FILL TOP OF SPECTRUM ........................... If transposing downwards, fill spectrum top with extra harmonics.\n");
+            break;
+        case(11):
+            fprintf(stdout,"INFO: TRANSPOSE UNDER FORMANTS: tranpose spectrum of src, under formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: TRANSPOSITION (SEMITONES).................... Semitone transposition (Range -48 to + 48). (Timevariable).\n");
+            fprintf(stdout,"INFO: GAIN ................................................... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE ............................... Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................. Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ............................................. Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ............ Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ....................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: FILL TOP OF SPECTRUM ........................... If transposing downwards, fill spectrum top with extra harmonics.\n");
+            break;
+        case(12):
+            fprintf(stdout,"INFO: FRQSHIFT UNDER FORMANTS: Frqshift src spectrum of under formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FREQUENCY SHIFT ................................. Frequency shift(Hz) (Range -1000 to +1000). (Timevariable).\n");
+            fprintf(stdout,"INFO: GAIN ........................................ ......... Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE .............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................ Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ............................................ Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ............ Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ....................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: FILL TOP OF SPECTRUM ........................... If transposing downwards, fill spectrum top with extra harmonics.\n");
+            break;
+        case(13):
+            fprintf(stdout,"INFO: RESPACE PARTIALS UNDER FORMANTS: Respace partials in src spectrum,retaining formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: FREQUENCY SPACING ............................ New frq spacing of partials (Hz) (Range 1 to 1000).(Timevariable).\n");
+            fprintf(stdout,"INFO: GAIN ................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE ............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................ Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ........................................... Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ....................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: FILL TOP OF SPECTRUM ........................... If transposing downwards, fill spectrum top with extra harmonics.\n");
+            break;
+        case(14):
+            fprintf(stdout,"INFO: PITCH-INVERT UNDER FORMANTS: Invert pitch of src, under formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: INTERVAL MAP ................................... Set map to ZERO if no mapping is required..OTHERWISE\n");
+            fprintf(stdout,"INFO:                                                                                         map is a textfile of paired values showing how intervals\n");
+            fprintf(stdout,"INFO:                                                                                         (in, possibly fractional, SEMITONES)\n");
+            fprintf(stdout,"INFO:                                                                                         are to be mapped onto their inversions.\n");
+            fprintf(stdout,"INFO:                                                                                         Range +-%0lf semitones (+- %.0lf octaves).\n",MAXINTRANGE,MAXINTRANGE/SEMITONES_PER_OCTAVE);
+            fprintf(stdout,"INFO: PIVOT PITCH ....................................... Pitch about which to invert pitch of src (Range %d to %d).\n",SPEC_MIDIMIN,MIDIMAX);
+            fprintf(stdout,"INFO:                                                                                         Pitch as MIDI, with possibly fractional val.  (Timevariable).\n");
+            fprintf(stdout,"INFO:                                                                                         If value zero entered, uses the mean pitch of the input.\n");
+            fprintf(stdout,"INFO: GAIN ................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE ............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................ Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ........................................... Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: LOW PITCH LIMIT .................................. Minimum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: HIGH PITCH LIMIT ................................. Maximum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ...................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ..................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            break;
+        case(15):
+            fprintf(stdout,"INFO: PITCH-EXAGGERATE/SMOOTH UNDER FORMANTS: Exaggerate/Smooth pitch-line, retaining the formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PIVOT PITCH ....................................... Pitch about which to exaggerate/smooth the pitchline of src (Range %d to %d).\n",SPEC_MIDIMIN,MIDIMAX);
+            fprintf(stdout,"INFO:                                                                                Pitch as MIDI, with possibly fractional val.  (Timevariable).\n");
+            fprintf(stdout,"INFO:                                                                                If value zero entered, uses the MEAN pitch of the input.\n");
+            fprintf(stdout,"INFO: RANGE MULTIPLIER ................................  Expand or Contract Range of pitchline. (Range 0 - 1).\n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE .............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................ Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ........................................... Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: LOW PITCH LIMIT ................................... Minimum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: HIGH PITCH LIMIT .................................. Maximum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ...................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ..................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: TIE TO TOP ......................................... Tie to TOP of pitch range.\n");
+            fprintf(stdout,"INFO: TIE TO FOOT ....................................... Tie to FOOT of pitch range.\n");
+            fprintf(stdout,"INFO: TIE TO MIDDLE ..................................... Also Tie to range middle (only with other \"TIE\" flags) .\n");
+            fprintf(stdout,"INFO: ABOVE MEAN ONLY ................................ Do range change ABOVE mean only.\n");
+            fprintf(stdout,"INFO: BELOW MEAN ONLY ................................ Do range change BELOW mean only.\n");
+            break;
+        case(16):
+            fprintf(stdout,"INFO: QUANTISE PITCH: Force source onto a specified pitch field.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH GRID .......................................... Textfile defining PITCH GRID on which quantised pitches must lie.\n");
+            fprintf(stdout,"INFO:                  There must first be a marker indicating the grid type. These are..\n");
+            fprintf(stdout,"INFO:                  #HS:    Followed by listed MIDI pitches to search for.\n");
+            fprintf(stdout,"INFO:                  #HF:    Followed by listed MIDI pitches to search for IN ALL OCTAVES.\n");
+            fprintf(stdout,"INFO:                  #THF:   Followed by lines each with time + list of MIDI pitches.\n");
+            fprintf(stdout,"INFO:                                    1st time must be zero & times must increase.\n");
+            fprintf(stdout,"INFO:                                    Each MIDI list must be the same length.\n");
+            fprintf(stdout,"INFO:                                    To change number of pitches from line to line, duplicate values.\n");
+            fprintf(stdout,"INFO:                  #SCALE: Followed by just TWO values.\n");
+            fprintf(stdout,"INFO:                                    (a) the number of equal pitch divisions in an octave.\n");
+            fprintf(stdout,"INFO:                                    (b) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO:                  #ELACS: Followed by just THREE values.\n");
+            fprintf(stdout,"INFO:                                    (a) Size of \"octave\" in (possibly fractional) semitones.\n");
+            fprintf(stdout,"INFO:                                    (b) the number of equal pitch divisions in \"octave\".\n");
+            fprintf(stdout,"INFO:                                    (c) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE .............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................. Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ............................................ Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: LOW PITCH LIMIT ................................... Minimum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: HIGH PITCH LIMIT .................................. Maximum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ....................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: ALLOW ORNAMENTS ............................... Allow ORNAMENTS in the quantised pitch-line.\n");
+            fprintf(stdout,"INFO: NO SMOOTHING .................................... No smoothing of transitions between pitches.\n");
+            break;
+        case(17):
+            fprintf(stdout,"INFO: PITCH RANDOMISE: Randomise pitch of src.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH GRID (OR ZERO) .......................... Zero OR a textfile defining PITCH GRID on which pitches are pre-quantised.\n");
+            fprintf(stdout,"INFO:                  IF SET TO ZERO, no pre-quantisation of pitch takes place \n");
+            fprintf(stdout,"INFO:                  If a textfile, in that file there must first be a marker indicating the grid type. These are..\n");
+            fprintf(stdout,"INFO:                  #HS:    Followed by listed MIDI pitches to search for.\n");
+            fprintf(stdout,"INFO:                  #HF:    Followed by listed MIDI pitches to search for IN ALL OCTAVES.\n");
+            fprintf(stdout,"INFO:                  #THF: Followed by lines each with time + list of MIDI pitches.\n");
+            fprintf(stdout,"INFO:                                    1st time must be zero & times must increase.\n");
+            fprintf(stdout,"INFO:                                    Each MIDI list must be the same length.\n");
+            fprintf(stdout,"INFO:                                    To change number of pitches from line to line, duplicate values.\n");
+            fprintf(stdout,"INFO:                  #SCALE: Followed by just TWO values.\n");
+            fprintf(stdout,"INFO:                                    (a) the number of equal pitch divisions in an octave.\n");
+            fprintf(stdout,"INFO:                                    (b) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO:                  #ELACS: Followed by just THREE values.\n");
+            fprintf(stdout,"INFO:                                    (a) Size of \"octave\" in (possibly fractional) semitones.\n");
+            fprintf(stdout,"INFO:                                    (b) the number of equal pitch divisions in \"octave\".\n");
+            fprintf(stdout,"INFO:                                    (c) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO: RANDOMISATION RANGE ........................ Semitone range within which random offsets generated. (Range 0 to %d)\n",RANDPITCHMAX);
+            fprintf(stdout,"INFO: RANDOMISATION SLEW .......................... Relationship between (possible) upward & downward random variation.\n");
+            fprintf(stdout,"INFO:                           e.g. 2: uprange = 2 * downrange     0.5: uprange = 0.5 * downrange.\n");
+            fprintf(stdout,"INFO:                           Ranges 0.1 to 10. (Value 1 has no effect).\n");
+            fprintf(stdout,"INFO: GAIN ................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE ............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................ Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ........................................... Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: LOW PITCH LIMIT ..................................  Minimum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: HIGH PITCH LIMIT .................................. Maximum acceptable pitch (MIDI, possibly fractional).\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ...................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            fprintf(stdout,"INFO: FAST PITCH-CHANGE .............................. Allow fast pitch-motion in the quantised pitch-line.\n");
+            fprintf(stdout,"INFO: NO SMOOTHING .................................... No smoothing of transitions between pitches.\n");
+            fprintf(stdout,"INFO: NO FORMANT RESHAPING ........................ Do not reshape formants after pitch randomisation.\n");
+            break;
+        case(18):
+            fprintf(stdout,"INFO: RANDOMISE SPECTRUM UNDER FORMANTS: Randomise spectrum, under formants.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: RANDOMISATION .................................. Randomisation of partial frequencies (Range 0 to 1).(Timevariable).\n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: ARPEGGIATION RATE .............................. Rate of arpeggiation of spectrum (Range -50 to +50 Hz).\n");
+            fprintf(stdout,"INFO: LOW CUT ............................................. Cut off frequencies below this. (range 20 to 10000)\n");
+            fprintf(stdout,"INFO: HIGH CUT ............................................ Cut off frequencies above this. (range 50 to 10000)\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW .............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: EXCLUDE NON-HARMONIC PARTIALS ........... Exclude non-harmonic partials.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: DOWNWARDS ....................................... Arpeggiate downwards (default upwards) (Only when ARPEGGIATION RATE > 0).\n");
+            fprintf(stdout,"INFO: UP AND DOWN ...................................... Arpeggiate up and down. (Only when ARPEGGIATION RATE > 0)\n");
+            break;
+        case(19):
+            fprintf(stdout,"INFO: SEE SPECTRAL ENVELOPES: \n");
+            fprintf(stdout,"INFO: Outputs viewable (not playable) sndfile showing spectral envelope at each window as a block of +ve samples.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ... Use short-window for extracting spectral envelope.\n");
+            break;
+        case(20):
+            fprintf(stdout,"INFO: SEE SPECTRAL PEAKS & TROUGHS: Frequencies of troughs/peaks in each window printed to textfile.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Format of the printout is:\n");
+            fprintf(stdout,"INFO:    \"Trough  PEAK-1  Trough  PEAK-2  Trough  PEAK-3  Trough  PEAK-4  Trough\"\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ... Use short-window for extracting spectral envelope.\n");
+            break;
+        case(21):
+            fprintf(stdout,"INFO: LIST TIMES OF TROUGHS BETWEEN SYLLABLES: Times printed to textfile.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: Will usually need post-correction \"by hand\".\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: MINIMUM SYLLABE DURATION .... Minimum acceptable duration for a syllable (default %.04lf)\n",MIN_SYLLAB_DUR);
+            fprintf(stdout,"INFO: MINIMUM PEAK HEIGTH ............ Minimum height of peak above bracketing trofs (default %.04lf).\n",MIN_PEAKTROF_GAP);
+            fprintf(stdout,"INFO:                                                                    (Maximum possible height is 1.0).\n");
+            fprintf(stdout,"INFO: GET PEAKS ........................... Get syllable amplitude-peaks, rather than interening troughs.\n");
+            fprintf(stdout,"INFO: GET TROUGHS AND PEAKS ........ Get both troughs and peaks,\n");
+            break;
+        case(22):
+            fprintf(stdout,"INFO: SINE SPEECH: Convert formant frequencies to sinus tones.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: PITCH GRID (OR ZERO) ........................ ZERO or a textfile.\n");
+            fprintf(stdout,"INFO:                                If this is set to ZERO, no pitch quantisation takes place.\n");
+            fprintf(stdout,"INFO:                                Otherwise, this is textfile of data about pitches to quantise to.\n");
+            fprintf(stdout,"INFO:                                There must first be a marker indicating the grid type. These are..\n");
+            fprintf(stdout,"INFO:                                #HS:    Followed by listed MIDI pitches to quantise to.\n");
+            fprintf(stdout,"INFO:                                #HF:    Followed by listed MIDI pitches to quantise to IN ALL OCTAVES.\n");
+            fprintf(stdout,"INFO:                                #THF:   Followed by lines each with time + list of MIDI pitches.\n");
+            fprintf(stdout,"INFO:                                        1st time must be zero & times must increase.\n");
+            fprintf(stdout,"INFO:                                        Each MIDI list must be the same length.\n");
+            fprintf(stdout,"INFO:                                        To change no of pitches from line to line, duplicate values.\n");
+            fprintf(stdout,"INFO:                                #SCALE: Followed by just TWO values.\n");
+            fprintf(stdout,"INFO:                                      (a) the number of equal pitch divisions in an octave.\n");
+            fprintf(stdout,"INFO:                                      (b) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO:                                #ELACS: Followed by just THREE values.\n");
+            fprintf(stdout,"INFO:                                      (a) Size of \"pseudo-octave\" in (possibly fractional) semitones.\n");
+            fprintf(stdout,"INFO:                                      (b) the number of equal pitch divisions in peudo-octave.\n");
+            fprintf(stdout,"INFO:                                      (c) MIDI pitch of any pitch to tune the scales to.\n");
+            fprintf(stdout,"INFO: \n");
+            fprintf(stdout,"INFO: GAIN .................................................. Output gain or attenuation. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: DEPTH ................................................ Degree of sinusoidisation. Range 0 to 1.\n");
+            fprintf(stdout,"INFO: LEVEL1 ............................................... Relative gain or attenuation of formant1. (Range 0.01 to 10)\n");
+            fprintf(stdout,"INFO: LEVEL2,LEVEL3,LEVEL4 ............................ similar for the other formants.\n");
+            fprintf(stdout,"INFO: HFIELD DEPTH1 .................................... If Harmonic Field applied, how strongly to force formant1 pitches to Field (Range 0-1).\n");
+            fprintf(stdout,"INFO: HFIELD DEPTH2, DEPTH3, DEPTH4 .............. Similarly for other formant bands.\n");
+            fprintf(stdout,"INFO: USE SHORT WINDOW ............................. Use short-window for extracting spectral envelope.\n");
+            fprintf(stdout,"INFO: FORCE FUNDAMENTAL ............................ Force lowest formant to use fundamental frq as peak.\n");
+            fprintf(stdout,"INFO: NONPITCH_&_LOLEVEL_WINDOWS_ZEROED .. Replace unpitched (or extremely quiet) windows by silence.\n");
+            fprintf(stdout,"INFO: SMOOTHING ........................................ Smoothing between pitches in formant traces.\n");
+            break;
+        }
+        break;
+    case(FLATTEN):
+        fprintf(stdout,"INFO: EQUALISE LEVELS OF SEGMENTS (e.g. SYLLABLES) WITHIN A SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ELEMENTSIZE ...... Approx size of elements (e.g. syllables) in the source sound.\n");
+        fprintf(stdout,"INFO: SHOULDER ......... Risetime to attain new (segment) level, in mS. (Range 20 to ELEMENTSIZE/2).\n"
+        "                                                                           Will never be longer than the time from segment edge to segment peak.\n");
+        fprintf(stdout,"INFO: TAIL ................. Portion of end of sound to be treated as a whole segment. (Range 0 to < duration (secs)).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIP :   Use the \"TAIL\" parameter to handle any anomalies (sudden loudness) at file end.\n");
+        break;
+    case(BOUNCE):
+        fprintf(stdout,"INFO: REPEAT SOURCE, \"BOUNCING\" (ACCELERATING REPETITION WITH FADING LEVEL).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1:  Waveset-interpolate between markers.\n");
+        fprintf(stdout,"INFO: MODE 2:  Waveset-interpolate within alternate marked blocks.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF BOUNCES ............................ Number of bouncing repeats (after initial sound) (Range 1 to 100).\n");
+        fprintf(stdout,"INFO: FIRST BOUNCE EXTENT ........................ Timestep to first bounce entry (Range 0.04 to 10).\n");
+        fprintf(stdout,"INFO: BOUNCE ACCEL ...................................... Step to next bounce is \"Bounce-accel\" times step to previous bounce (Range 0.1 to 1).\n");
+        fprintf(stdout,"INFO: FINAL LEVEL ........................................ Level of final bounce, relative to source level (Range 0 to 1).\n");
+        fprintf(stdout,"INFO: LEVEL DECAY SLOPE ............................ Slope of level reduction: > 1 Greater reduction at start : < 1 Greater reduction at end (Range .1 to 10).\n");
+        fprintf(stdout,"INFO: SHRINK GRADUALLY(MIN_DURATION) ..  Successive events are shrunk (by cutting them short) in same proportion as change in bounce-steps.\n");
+        fprintf(stdout,"INFO:                                                                           Zero value indicates NO CUTTING. Minimum non-zero value = 0.02.\n");
+        fprintf(stdout,"INFO: TRIM TO SIZE ...................................... If bounced elements overlap in time, cut them short to avoid this overlap.\n");
+        fprintf(stdout,"INFO: CUTS FROM START ................................ (Automatic in Mode 2) If elements are cut short, trim from the start, retaining the end of the source.\n");
+        fprintf(stdout,"INFO:                                                                           (Default, trim from the end, retaining the start of the source).\n");
+        break;
+    case(DISTMARK):
+        fprintf(stdout,"INFO: INTERPOLATE BETWEEN WAVESETS AT MARKED TIMES IN (MONO) SOURCE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIME MARKS IN SOURCE ..................... Times in source at which wavesets are to be selected.\n");
+        fprintf(stdout,"INFO: WAVESETGROUP LENGTH(mS) ............... Approximate length, in mS, of waveset group to find (time-variable).\n");
+        fprintf(stdout,"INFO: TIMESTRETCH ....................................... Timestretch (in output file) of steps between marks in source (time-variable).\n");
+        fprintf(stdout,"INFO: GROUPLENGTH RANDOMISATION ........... Randomisation of lengths of interpolated wavesets (time-variable).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: RETROGRADE AND PHASE INVERT ALTERNATE WAVESETS (Tends to lower the pitch).\n");
+        fprintf(stdout,"INFO: RETAIN ORIGINAL TAIL ..................... Once the final marker is reached, the remainder of the source is copied to the output.\n");
+        fprintf(stdout,"INFO: ATTENUATION OF DISTORTED REGIONS ... reduction of level of the distorted segments relative to the undistorted.\n");
+        fprintf(stdout,"INFO: RETAIN ORIGINAL TAIL ..................... Once the final marker is reached, the remainder of the source is copied to the output.\n");
+        fprintf(stdout,"INFO:                                                                                 (Any source-sound before the first marker is also copied into the output).\n");
+        fprintf(stdout,"INFO: SWITCH RETAINED AND DISTORTED ELEMENTS ...Switch which set of elements is distorted, and which is undistorted.\n");
+        break;
+    case(DISTREP):
+        fprintf(stdout,"INFO: REPEAT (GROUPS OF) WAVESETS, USING SPLICES TO SMOOTH TRANSITIONS..\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Each (group of) waveset(s), in turn, is repeated.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (2)  After the first repetition-set, the process jumps to a time in the input corresponding to the time at end of current output\n");
+        fprintf(stdout,"INFO:            and selects its next waveset from there, so the output is not time-dilated relative to the input.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: REPETITION COUNT ................................ Number of times to repeat each waveset(group). Can vary over time.\n");
+        fprintf(stdout,"INFO: COUNT OF WAVESETS IN GROUP TO REPEAT .. How many wavesets, as a group, to repeat. Can vary over time.\n");
+        fprintf(stdout,"INFO: WAVESETS TO SKIP AT START .................... Number of wavesets to ignore at file start.\n");
+        fprintf(stdout,"INFO: SPLICELENGTH (mS) ................................. Length of splices, in milliseconds (0 to 50, default 15).\n");
+        break;
+    case(TOSTEREO):
+        fprintf(stdout,"INFO: MOVE STEREO SOURCE FROM A MONO-MERGE TO TRUE STEREO, OR VICE VERSA, AND POSSIBLY INTO A MULTICHANNEL SPACE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: There are 4 possible processes.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  The stereo signal starts out merged into mono, the same signal being presented on BOTH channels of the original stereo image,\n");
+        fprintf(stdout,"INFO:          and the true stereo image gradually emerges on the same 2 channels.\n");
+        fprintf(stdout,"INFO: (2)  The stereo signal starts out as true stereo on a pair of channels and is gradually merged into mono,\n");
+        fprintf(stdout,"INFO:          the same merged signal being presented on both of these channels.\n");
+        fprintf(stdout,"INFO: (3)  The stereo signal starts out merged into mono, the merged signal being presented on a SINGLE mono channel,\n");
+        fprintf(stdout,"INFO:          and the true stereo image gradually emerges onto the TWO ADJACENT CHANNELS (only) : the signal \"FORKS\".\n");
+        fprintf(stdout,"INFO: (4)  The stereo signal starts out as true stereo on 2 channels SEPARATED BY an empty INTERVENING CHANNEL,\n");
+        fprintf(stdout,"INFO:          and is gradually merged into a mono signal, presenting only on the intermediate channel.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Options (3) and (4) are only available if the count of \"OUTPUT CHANNELS\" is set greater than 2.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: DIVERGE START TIME .......................... Time of start of divergence from mono-merged signal (moving towards true stereo).\n");
+        fprintf(stdout,"INFO: DIVERGE END TIME .............................  Time of complete emergence of true stereo.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: If the \"DIVERGE\" times are IN REVERSED ORDER, the signal will gradually MERGE FROM stereo INTO mono.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OUTPUT CHANNELS ............................. Number of channels of output file.\n");
+        fprintf(stdout,"INFO: LEFT CHANNEL TO : or FORK FROM .......... Channel to which original Left stereo channel is routed in output stereo image\n");
+        fprintf(stdout,"INFO:                                                                          OR Channel from which signal Forks.\n");
+        fprintf(stdout,"INFO: RIGHT CHANNEL TO ............................. Channel to which original Right stereo channel is routed in output stereo image.\n");
+        fprintf(stdout,"INFO:                                                                          If set to ZERO and \"OUTPUT CHANNELS\" is greater than Stereo,\n");
+        fprintf(stdout,"INFO:                                                                          output will FORK from \"FORK FROM\" channel to channels on either side.\n");
+        fprintf(stdout,"INFO: CHANNEL LEVELS IN MIX TO MONO ........... Level of each of the separated channel signals when mix-merged to mono.\n"); 
+        fprintf(stdout,"INFO:                                                                          A ZERO value sets a DEFAULT LEVEL. Otherwise, levels below 0.5 are invalid.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SUPPRESS):
+        fprintf(stdout,"INFO: SUPPRESS THE MOST PROMINENT PARTIALS IN THE FRQ BAND, AND AT THE TIMES, INDICATED\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TIMESLOTS .......................... Textfile of time-pairs indicating start & end of timeslots where action is to be taken.\n");
+        fprintf(stdout,"INFO: BAND LOW FREQUENCY ....... Frequency of BOTTOM of band in which partials are to be suppressed.\n");
+        fprintf(stdout,"INFO: BAND HIGH FREQUENCY ..... Frequency of TOP of band in which partials are to be suppressed.\n");
+        fprintf(stdout,"INFO: PARTIALS TO SUPPRESS ... The number of partials to suppress.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CALTRAIN):
+        fprintf(stdout,"INFO: BLUR THE HIGH FREQUNCY COMPONENTS OF THE SPECTRUM.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: AVERAGE OVER TIME (SECS) .. Time in seconds over which upper frequncy data is averaged.\n");
+        fprintf(stdout,"INFO: BLUR ABOVE FRQ (HZ) ............ Frequency (Hz) above which spectrum is blurred.\n");
+        fprintf(stdout,"INFO: CUT BASS BELOW FRQ (HZ) .... Frequencies below this in the spectrum are suppressed.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECENV):
+        fprintf(stdout,"INFO: APPLY SPECTRAL ENVELOPE OF FILE2 TO FILE1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: WINDOWSIZE (ANALCHANCNT OR OCTAVES) ...... frequency-width of the windows used to extract the spectral envelope.\n");
+        fprintf(stdout,"INFO:                                                                                     Either the number of analysis channels per window, or the window-width in octaves.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: BALANCE WITH SOURCES .............................. Ammount of original sources to mix into the transformed output.\n");
+        fprintf(stdout,"INFO:                                                                                     Values > 0 are the ratio of sourcefile 1 in the final mix.\n");
+        fprintf(stdout,"INFO:                                                                                     Values < 0 are converted to positive values and are then the ratio of sourcefile 2 in the mix.\n");
+        fprintf(stdout,"INFO:                                                                                     Default value is zero (none of either source is mixed into the output).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: READ WINDOWSIZE AS OCTAVES .................... Default: windowsize is the number of analysis channels per window.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: IMPOSE SPECTRAL ENVELOPE ......................... Impose spectral envelope of file 2 OVER that of file 1. Default is to REPLACE that of file 1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: LOUDNESS CONTOUR FOLLOWS FILE 2 .............. Default is to follow the loudness contour of File 1.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: If the window-amplitude of file 2 (but not file 1) falls below a (near-to-zero) threshold, the file 1 window is passed through with no processing.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(CLIP):
+        fprintf(stdout,"INFO: CLIP PEAKS OF SOUND (DISTORTION).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  Clip at given signal level.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (2)  Clip every waveset at given fraction of its maximum height.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS-----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CLIP LEVEL (Mode 1)....... Signal level at which input sound is clipped.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: CLIP LEVEL (Mode 2) .......Fraction of maximum height of each waveset at which (all) wavesets are clipped.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECEX):
+        fprintf(stdout,"INFO: TIMESTRETCH SEGMENT OF ANALYSIS FILE WITH RANDOMISATION OF WINDOWS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: STARTTIME OF REGION TO STRETCH ...................... Time in source where region to be stretched begins.\n");
+        fprintf(stdout,"INFO: DURATION OF REGION TO STRETCH ......................... Duration of region to be stretched.\n");
+        fprintf(stdout,"INFO: TIME STRETCHING RATIO ......................................... Time stretch to apply (at least 2).\n");
+        fprintf(stdout,"INFO: NO OF WINDOWS IN GROUPS-FOR-PERMUTATION ... Time-stretching repeats selected region, but with windows randomly permuted.\n");
+        fprintf(stdout,"INFO:                                                                                      Windows can be collected into groups, and these groups permuted.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: INCLUDE SOUND BEFORE STRETCHED PORTION ........... Sound before stretched portion is retained.\n");
+        fprintf(stdout,"INFO: INCLUDE SOUND AFTER STRETCHED PORTION ............. Sound after stretched portion is retained.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(MATRIX):
+        fprintf(stdout,"INFO: SPECTRALLY WARP SOUNDFILE, USING UNITARY MATRIX, OR OTHERWISE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  GENERATE (SAVE TO FILE) AND USE A RANDOM UNITARY MATRIX.\n");
+        fprintf(stdout,"INFO: (2)  USE AN EXISTING UNITARY MATRIX FILE.\n");
+        fprintf(stdout,"INFO: (3)  SWAP AMPLITUDE AND PHASE VALUES OF FFT.\n");
+        fprintf(stdout,"INFO: (4)  INVERT (x MINUS 1) PHASE VALUES IN FFT .\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS IF NOT IN MODE 2----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ANALYSIS POINTS..(2-32768 (power of 2)): default 1024\n");
+        fprintf(stdout,"INFO: .................More points give better freq resolution\n");
+        fprintf(stdout,"INFO: .................but worse time-resolution (e.g. rapidly changing spectrum).\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: OVERLAP..........Filter overlap factor (1-4): default 3\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(TRANSPART):
+        fprintf(stdout,"INFO: TRANSPOSE OR SHIFT ONLY PART OF SPECTRUM, ABOVE OR BELOW A GIVEN FREQUNCY.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES---------------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  TRANSPOSE ABOVE FRQ, RETAINING ORIGINAL FORMANTS.\n");
+        fprintf(stdout,"INFO: (2)  TRANSPOSE BELOW FRQ, RETAINING ORIGINAL FORMANTS.\n");
+        fprintf(stdout,"INFO: (3)  TRANSPOSE ABOVE FRQ, ALSO MOVING FORMANTS.\n");
+        fprintf(stdout,"INFO: (4)  TRANSPOSE BELOW FRQ, ALSO MOVING FORMANTS.\n");
+        fprintf(stdout,"INFO: (5)  FREQUENCY SHIFT ABOVE FRQ, RETAINING ORIGINAL FORMANTS.\n");
+        fprintf(stdout,"INFO: (6)  FREQUENCY SHIFT BELOW FRQ, RETAINING ORIGINAL FORMANTS.\n");
+        fprintf(stdout,"INFO: (7)  FREQUENCY SHIFT ABOVE FRQ, ALSO MOVING FORMANTS.\n");
+        fprintf(stdout,"INFO: (8)  FREQUENCY SHIFT BELOW FRQ, ALSO MOVING FORMANTS.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FOR TRANSPOSITION\n");
+        fprintf(stdout,"INFO: TRANSPOSITION IN SEMITONES ............ Semitone transposition. Range : 4 octaves, up or down.\n");
+        fprintf(stdout,"INFO: FOR FREQUENCY SHIFTING\n");
+        fprintf(stdout,"INFO: FREQUNCY SHIFT IN HZ ..................... Frequency shift in Hz. Range : (nyquist/4) up or down.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ABOVE/BELOW THIS FREQUENCY ONLY .. Frq above/below which spectrum shifted (Range: 5 to nyquist/2)\n");
+        fprintf(stdout,"INFO: OVERALL GAIN ............................... Range : 0.1 to 1.0\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECINVNU):
+        fprintf(stdout,"INFO: INVERT THE SPECTRAL AMPLITUDES OVER A SPECIFIED RANGE OF THE SPECTRUM\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: The spectral inversion is over a range of frequencies (a \"region\") which you specify (params 1 & 2).\n");
+        fprintf(stdout,"INFO: You must also search for the spectral peak lying between 0Hz and a cutoff frequency (param 3)\n");
+        fprintf(stdout,"INFO: This peak is used to create a spectral-amplitude-envelope, used to rebalance the inverted spectrum.\n");
+        fprintf(stdout,"INFO: Parameter (3) must lie between the Start Frq of the region (param 1)\n");
+        fprintf(stdout,"INFO: and the halfway-point frequency of that region.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  START FRQ OF REGION TO INVERT ................. Range : 0 to nyquist/2\n");
+        fprintf(stdout,"INFO: (2)  END FRQ OF REGION TO INVERT .................... Range : 100 to nyquist.\n");
+        fprintf(stdout,"INFO: (3)  TOP FRQ TO END SEARCH FOR SPECTRAL PEAK .. Range : 0 to nyquist\n");
+        fprintf(stdout,"INFO: (4)  GAIN ...................................................... Range : 0.1 to 1.0\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECCONV):
+        fprintf(stdout,"INFO: EXPERIMENTAL CONVOLUTION PROCESS (NOT RECOMMENDED)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1 : CONVOLVE SOUND WITH ITSELF\n");
+        fprintf(stdout,"INFO: MODE 2 : CONVOLVE SOUND WITH ANOTHER, EQUAL LENGTH OR SHORTER, SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  OVERALL GAIN ........................... Range : 0.1 to 10.0\n");
+        fprintf(stdout,"INFO: (2)  APPLY PROCESS THIS MANY TIMES .. Range : (Mode 1) 1 to 10  (Mode 2) 1 to 2.\n");
+        fprintf(stdout,"INFO: (3)  DON'T TIME-STRETCH FILE 2 ......... (Mode 2 ONLY)\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECSND):
+        fprintf(stdout,"INFO: TREAT SPECTRUM AS IF IT WERE A SOUND\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Spectral envelope is treated as a waveform.\n");
+        fprintf(stdout,"INFO: Ouput pitch derives from maximum amplitude in the spectrum.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: (1)  MINIMUM UPWARD TRANSPOSITION IN OCTAVES .... Range : 0 to 8\n");
+        fprintf(stdout,"INFO: (2)  MAXIMUM UPWARD TRANSPOSITION IN OCTAVES .... Range : 1 to 8.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(SPECFRAC):
+        fprintf(stdout,"INFO: CREATE FRACTAL VERSION OF SPECTRUM.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NB Ouput sounds depend on number of analysis channels used in source.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1 : Abutt 2 copies, then shrink to orig size by time-contraction.\n");
+        fprintf(stdout,"INFO: MODE 2 : Abutt copy with reverse-copy, then shrink by time-contraction.\n");
+        fprintf(stdout,"INFO: MODE 3 : As mode 2, but cut into segments and process each segment in turn.\n");
+        fprintf(stdout,"INFO: MODE 4 : As mode 3, but shrink by averaging.\n");
+        fprintf(stdout,"INFO: MODE 5 : Swap two halves of segments.\n");
+        fprintf(stdout,"INFO: MODE 6 : Reverse 2nd half of segments.\n");
+        fprintf(stdout,"INFO: MODE 7 : Interleave two halves of segments.\n");
+        fprintf(stdout,"INFO: MODE 8 : Reverse 2nd half of segments, then interleave.\n");
+        fprintf(stdout,"INFO: MODE 9 : Interleave, retaining original speed.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: NUMBER OF FRACTAL LAYERS .................. Number of times fractalisation process applied.\n");
+        fprintf(stdout,"INFO: OUTPUT ALL INTERMEDIATE FRACTALS .. Outputs sound made at each intermediate stage of fractalisation.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ENVSPEAK):
+        fprintf(stdout,"INFO: PROCESS SPEECH \"SYLLABLE\"-WISE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES 1-12  Extract the \"syllables\" by an automatic envelope-tracking process.\n");
+        fprintf(stdout,"INFO: MODES 13-24 Expects a File specifying the necessary cut-times to separate the sound into syllables.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: 1 & 13 : Repeat each syllable, N times.\n");
+        fprintf(stdout,"INFO: 2 & 14 : Reverse-repeat each syllable.\n");
+        fprintf(stdout,"INFO: 3 & 15 : Attenuate N in N+1 syllables.\n");
+        fprintf(stdout,"INFO: 4 & 16 : Attenuate all except N in N+1 syllables.\n");
+        fprintf(stdout,"INFO: 5 & 17 : Repeat each syllable N times, shrinking from its end, on each repeat, by 1/Nth.\n");
+        fprintf(stdout,"INFO: 6 & 18 : Repeat each syllable N times, shrinking from its start, on each repeat, by 1/N.\n");
+        fprintf(stdout,"INFO: 7 & 19 : Divide each syllable into N parts, and repeat just one of those parts, N times.\n");
+        fprintf(stdout,"INFO: 8 & 20 : For each syllable, repeat it, shrinking from its end by a specified Ratio.\n");
+        fprintf(stdout,"INFO: 9 & 21 : For each syllable, repeat it, shrinking from its start by a specified Ratio.\n");
+        fprintf(stdout,"INFO: 10 & 22 : Extract all the syllables.\n");
+        fprintf(stdout,"INFO: 11 & 23 : Randomly reorder the syllables.\n");
+        fprintf(stdout,"INFO: 12 & 24 : Reverse order of first N syllable , then order of 2nd N syllable,  etc.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (mS) (Modes 1-12 ONLY) ........... Size of envelope-search window in mS (default 50).\n");
+        fprintf(stdout,"INFO: SYLLABLE CUT TIMES (secs) (Modes 13-24 ONLY).............. Position of cuts (except at zero and end of file) to separate the syllables.\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH (mS) ............................................... Splice length in mS (default 15) \n");
+        fprintf(stdout,"INFO: INITIAL SYLLABLES TO SKIP ....................................... Number of syllables at sound start to send to output UNCHANGED.\n");
+        fprintf(stdout,"INFO: NUMBER OF REPETITIONS ........................................ Number of repetitions of each syllable (Range 2 upwards).\n");
+        fprintf(stdout,"INFO: N (ATTEN N in every N+1 SYLLABLES) ........................... Size of Each Group of syllables to attenuate : N = 3 means attenuate 3 in every 4.\n");
+        fprintf(stdout,"INFO: N (DON'T ATTEN N in every N+1 SYLLABS) .....................  Size of Each Group of syllables NOT to attenuate : N = 3 means DON'T attenuate 3 in every 4.\n");
+        fprintf(stdout,"INFO: GAIN ON ATTENUATED SYLLABLES ............................... Reduce the level of Attenuated syllables by this number of dBs: (Range -96 to < 0)\n");
+        fprintf(stdout,"INFO: NO OF PARTS TO DIVIDE SYLLABLES INTO .....................  For each syllable, Keep 1/Nth part, and repeat that part N times.\n");
+        fprintf(stdout,"INFO: WHICH DIVIDED ELEMENT TO USE ............................... Which division of the divided-sylllable to repeat (Range 1 to N)\n");
+        fprintf(stdout,"INFO: CONTRACTION RATIO ............................................. Reduce length of repeated elements by this Ratio : Range (> 0.0 to 1)\n");
+        fprintf(stdout,"INFO: DEGREE OF RANDOMISATION, LENGTHS OF REPET UNITS .. Degree of Randomisation of the lengths of repeated units.\n");
+        fprintf(stdout,"INFO: REVERSE ORDER IN GROUPS OF ................................. Reverse the order order of the first N syllables, then the order of the 2nd N, and so on ....\n");
+        fprintf(stdout,"INFO: SEED FOR RANDOM PERMUTATION ............................. (Modes 11 only) Initialises the random number generator for Random reorderings of the syllables.\n");
+        fprintf(stdout,"INFO:                                                                                                   If the Seed is NOT 0, using the same seed again on a future pass gives IDENTICAL random output.\n");
+        fprintf(stdout,"INFO: REPEATED ELEMENTS DO NOT GROW IN SIZE ................. (Mode 7 only) with many divisions, may give a mechanical or buzzing quality to the ouptut.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(EXTSPEAK):
+        fprintf(stdout,"INFO: OVERWRITE OR REPLACE SPEECH SYLLABLES WITH ALTERNATIVE \"SYLLABLES\"\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------------------------------------MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: FINDING THE ORIGINAL SYLLABLES IN INPUT FILE 1.\n");
+        fprintf(stdout,"INFO:            In Modes 1-6 the \"syllables\" in file-1 are extracted by an automatic process using the ENVELOPE WINDOW SIZE parameter.\n");
+        fprintf(stdout,"INFO:                                  Results may be good enough for some applications, but not as good as ...\n");
+        fprintf(stdout,"INFO:            In Modes 7-18 the syllable-boundaries in file-1 are marked \"by hand\" on a graphic of the original soundfile.\n");
+        fprintf(stdout,"INFO:                                  Markers at time zero, and at the end of the sound are not required.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: USE OF THE NEW SYLLABLES, FROM INPUT FILES 2,3 ....\n");
+        fprintf(stdout,"INFO:            In Modes 1-3,7-9     new syllables REPLACE, or are INJECTED BETWEEN, the original syllables.\n");
+        fprintf(stdout,"INFO:            In Modes 4-6,10-12 new syllables MIX INTO the original syllables.\n");
+        fprintf(stdout,"INFO:            In Modes 13-15        new syllables REPLACE the SPECIFIED original syllables.\n");
+        fprintf(stdout,"INFO:            In Modes 16-18        new syllables MIX INTO the SPECIFIED original syllables.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ORDER OF THE NEW SYLLABLES.\n");
+        fprintf(stdout,"INFO:            Modes 1,4,7,10,13,16:  Insert syllables in the Order of the input files. Or (\"SELECT INSERTS AT RANDOM\") Entirely at Random.\n");
+        fprintf(stdout,"INFO:            Modes 2,5,8,11,14,17:  Insert ALL syllables in the input files in some random order, then permute that order before adding more syllables, and so on.\n");
+        fprintf(stdout,"INFO:            Modes 3,6,9,12,15,18:  Insert syllables in a specific pattern, specified in the Pattern File.\n");
+        fprintf(stdout,"INFO:                                                   For example : Pattern \"1 5 2\" means insert syllables 1,5 and 2 from the input list, in that order, then repeat (so 1 5 2 1 5 2 1 ....etc.)\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------------------------------------INPUT DATA (Scroll down for MORE)---------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Many of the modes require you to enter data in a TEXT FILE.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:            SYLLABLE BOUNDARY TIMES   Modes 7-18             This LIST OF TIMES indicate where file1 is to be divided, to produce separate syllables.\n");
+        fprintf(stdout,"INFO:                                                                                             You do not need to indicate a cut at zero time or at the file end (if you do, these are ignored).\n");
+        fprintf(stdout,"INFO:                                                                                             there is one cut for the END of each syllable, and the area after the last cut is a final syllable.\n");
+        fprintf(stdout,"INFO:                                                                                             So with C cuts, there will be C+1 syllables.\n");
+        fprintf(stdout,"INFO:                                                                                             IN OTHER MODES \"syllables\" are cut automatically,\n");
+        fprintf(stdout,"INFO:                                                                                             using the ENVELOPE WINDOW SIZE parameter to scan the loudness envelope of the input file.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:            PATTERN OF INSERTS        Modes 3,6,8,12,15      This LIST OF NUMBERS indicates the order of the syllables to be added.\n");
+        fprintf(stdout,"INFO:                                                                                             The pattern \"2  5  1\" means add syllable 2, then syllable 5, then syllable 1: And then repeat this pattern as long as necessary.\n");
+        fprintf(stdout,"INFO:                            OTHERWISE:     Modes 1,4,7,10,13,16  Uses the new syllables in the order you enter them on the \"Chosen Files\" listing EXCEPT \n");
+        fprintf(stdout,"INFO:                                                                                             with the \"SELECT INSERTS AT RANDOM\" flag, which causes new syllables to be selected entirely randomly.\n");
+        fprintf(stdout,"INFO:                                                      Modes 2,5,8,11,14,17   Uses ALL new syllables in some random order, before creating a different random order and using ALL the files again, and so on ...\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:            SYLLABLES TO TARGET     Modes 12 - 18                This LIST OF NUMBERS indicates which of the syllables in the first infile are to reaplaced, or mixed-over by the syllables in the other files.\n");
+        fprintf(stdout,"INFO:                            OTHERWISE:                                           This is determined by the parameter \"N\" and the Flag \"N = RETAIN ...\".\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO:            Note that, in some modes 2 or 3 of these data sets are required, in the SAME textfile. In this case THE DATA SETS ARE SEPARATED BY A LINE WITH A SINGLE \"#\" CHARACTER.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------------------------------------PARAMETERS (Scroll down for MORE)---------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (mS) ...................................... Size of envelope-search window in mS (default 50).\n");
+        fprintf(stdout,"INFO: SPLICE LENGTH (mS) .................................................. Splice length for cutting and joining syllables, in mS (default 15) \n");
+        fprintf(stdout,"INFO: INITIAL SYLLABLES TO SKIP .......................................... Number of syllables at sound start to send to the output UNCHANGED.\n");
+        fprintf(stdout,"INFO: N = RETAIN 1 ORIG SYLLAB FOR EVERY N OVERWRITTEN ...... Size of Group replaced/overwritten/inserted : N = 3 means r-o-i 3 in every 4  (BUT see \"-k\" Flag)\n");
+        fprintf(stdout,"INFO: OVERALL ATTENUATION OF INSERTED SYLLABLES ............... Reduce the level of the new syllables by this number of dBs: (Range -96 to < 0)\n");
+        fprintf(stdout,"INFO: (NOT Modes 3,6,9,12,15,18) SEED FOR RANDOM GENERATOR Initialises the random number generator for Random reorderings of the syllables.\n");
+        fprintf(stdout,"INFO:                                                                                                        If the Seed is NOT 0, using the same seed again on a future pass gives IDENTICAL random output.\n");
+        fprintf(stdout,"INFO: N = RETAIN N ORIG SYLLABS FOR EVERY 1 OVERWRITTEN .... Changes the meaning of the Parameter N.\n");
+        fprintf(stdout,"INFO:                                                                                                       (see the examples below).\n");
+        fprintf(stdout,"INFO: TRANSPOSE (RATHER THAN CUT TO SIZE) INSERTS ............. Default option cuts (or pads with zeros) the resized syllables.\n");
+        fprintf(stdout,"INFO: FOLLOW ENVELOPE OF OVERWRITTEN SYLLABLES ............... Inserted syllables follow level-contour of original syllables.\n");
+        fprintf(stdout,"INFO: INSERT BETWEEN (RATHER THAN OVERWRITE) .................. Don't overwrite/mix-into the original syllables. INSERT the new syllables After the existing syllables.\n");
+        fprintf(stdout,"INFO:                                                                                                       (see the examples below).\n");
+        fprintf(stdout,"INFO: RETAIN ORIGINAL DURATION OF INSERTS ........................ This option (typically) changes the duration and rhythm of the output relative to that of the (1st) input file.\n");
+        fprintf(stdout,"INFO:                                                                                                        Default option RESIZES the inserted syllables to match the durations of the replaced syllables.\n");
+        fprintf(stdout,"INFO: (Modes 1,4,7,10,13,16) SELECT INSERTS AT RANDOM .......... Select next syllable to insert, from the input syllable-files, ENTIRELY at random.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ----------------------------------------------------------HOW THE N-patterning WORKS---------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: STARTING WITH A SET OF 9 SYLLABLES USING A VALUE N=2: ..... S S S S S S S S S\n");
+        fprintf(stdout,"INFO:                                         NO FLAGS gives .............................. S x x S x x S x x\n");
+        fprintf(stdout,"INFO:                                         \"N = RETAIN ...\" FLAG gives ............... S S x S S x S S x\n");
+        fprintf(stdout,"INFO:                                         \"INSERT ...\" FLAG gives ....................  S x x S x x S x x S x x S x x S x x S x x S x x S x x\n");
+        fprintf(stdout,"INFO:                                         Using BOTH OF THESE FLAGS gives ....... S S x S S x S S x S S x S\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(ENVSCULPT):
+        fprintf(stdout,"INFO: SCULPT SHARP ATTACK FROM SYLLABLE\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODES----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MODE 1 : SCULPT AN EVENT\n");
+        fprintf(stdout,"INFO: MODE 2 : SCULPT A USER-SPECIFIED DOUBLE-EVENT (e.g. Consonant-Vowel) .\n");
+        fprintf(stdout,"INFO: MODE 3 : SCULPT A DOUBLE-EVENT AUTOMATICALLY.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (mS) ................. Window Size for extracting envelope (1-64 dflt 20)\n");
+        fprintf(stdout,"INFO: RISE TIME (mS) ................................... (Max) Duration of attack onset (mS).\n");
+        fprintf(stdout,"INFO: DECAY DURATION ................................ Maximum time to reach zero after the attack peak.\n");
+        fprintf(stdout,"INFO: STEEPNESS  ........................................ Steepness of decay : 1 = linear, > 1 steeper.\n");
+        fprintf(stdout,"INFO: CONSONANT DECAY START ..................... Time at which sound after 1st attack can start to fall to zero.\n");
+        fprintf(stdout,"INFO: CONSONANT DECAY END ........................ End time of decay-to-zero after 1st attack.\n");
+        fprintf(stdout,"INFO: LOUDNESS RATIO OF 1st TO 2nd ATTACKS .. Ratio of loudness of First attack to loudness of Second (Dflt 1).\n");
+        fprintf(stdout,"INFO: ATTACK 2nd PEAK ONLY (Mode 3) ............. Peak One is isolated, but with no Attack.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(TREMENV):
+        fprintf(stdout,"INFO: TREMOLO A SOUND AFTER ITS PEAK, WITH TREMOLO-WIDTH NARROWING.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: TREMOLO FREQUENCY ....................... is frequency of the tremolo vibration itself.\n");
+        fprintf(stdout,"INFO: TREMOLO DEPTH ............................... amplitude depth of tremolo.\n");
+        fprintf(stdout,"INFO: ENVELOPE WINDOW SIZE (mS) ....... Window Size for extracting envelope (1-64 dflt 20)\n");
+        fprintf(stdout,"INFO: PEAK NARROWING .................. Tremolo peaks can be made narrower.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    case(DCFIX):
+        fprintf(stdout,"INFO: REMOVE DC SIGNAL FROM A DISTORTED SOUND.\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: Use with \"Distort Multiply\".\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: PARAMETERS----------------------------------------------------------\n");
+        fprintf(stdout,"INFO: \n");
+        fprintf(stdout,"INFO: MINIMUM DURATION OF DC (mS) ...... Minimu duration of any block of DC signal to be removed.\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    default:
+        fprintf(stdout,"ERROR: Unknown PROCESS\n");
+        fprintf(stdout,"INFO: \n");
+        break;
+    }
+    return 0;
+}
+
+void RoomReverbFormat(void)
+{
+    fprintf(stdout,"INFO: DELAY TIMES AMPS (& POSITIONS). A Text Datafile.\n");
+    fprintf(stdout,"INFO:       Each line has either 2 vals (TIME , AMP of one of delays) or 3 (3rd is spatial POSITION in stereo space).\n");
+    fprintf(stdout,"INFO:       TIMES (seconds) must be increasing. Duplicate times are ignored.\n");
+    fprintf(stdout,"INFO:       A zero time (no delay) overrides the mix parameter, and determines the level and pan of the (effectively mono) input.\n");
+    fprintf(stdout,"INFO:       AMP values must be in the range 0.0 to 1.0\n");
+    fprintf(stdout,"INFO:       Empty lines and lines starting with a semi-colon (e.g. comments) are permitted.\n");
+    fprintf(stdout,"INFO:       If a Position value is used in any line, outfile will be stereo.\n");
+    fprintf(stdout,"INFO:       POSITION values are nominally in the range -1 to +1:     0 = centre.  If all position values are 0, the output will be mono.\n");
+    fprintf(stdout,"INFO:       Values beyond these limits result in attenuation according to the inverse-square law, to suggest distance beyond the speakers.\n");
+}

dev/misc/vuform.c

@@ -0,0 +1,142 @@
+/*
+ * 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 <math.h>
+#include <sfsys.h>
+#include <string.h>
+
+/* RWD March 2012 changed sndsize to sndsizeEx */
+#define	FAILED		(-1)
+#define SUCCEEDED	(0)
+
+static int readfhead(int ifd);
+const char* cdp_version = "7.1.0";
+
+int main(int argc, char *argv[])
+{
+	int ifd;
+	FILE *fp;
+	int specenvcnt, k, len;
+	char *filename, out[64], *p, *q;
+	float *buf;
+	if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
+		fprintf(stdout,"%s\n",cdp_version);
+		fflush(stdout);
+		return 0;
+	}
+	if(argc!=2) {
+		fprintf(stdout,"ERROR: Insufficient params:: vuform formantfile.\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	if((ifd = sndopenEx(argv[1],0,CDP_OPEN_RDONLY)) < 0) {
+		fprintf(stdout,"ERROR: Failure to open file %s for input.\n",argv[1]);
+		fflush(stdout);
+		return(FAILED);
+	}
+	len = strlen(argv[1]);
+	if((filename = (char *)malloc((len+1) * sizeof(char)))==NULL) {
+		fprintf(stdout,"ERROR: Failure to allocate memory 1.\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	strcpy(filename,argv[1]);
+	p = filename;
+	q = filename + len;
+	while(p < q) {
+		if(*p == '.')
+			break;
+		p++;
+	}
+	p--;
+	*p++ = '1';
+	*p++ = '.';
+	*p++ = 't';
+	*p++ = 'x';
+	*p++ = 't';
+	k = sndsizeEx(ifd);
+	if(k <= 0) {
+		fprintf(stdout,"ERROR: No data in file\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	if((specenvcnt = readfhead(ifd)) < 0)
+		return(FAILED);
+	specenvcnt *= 3;
+	if(k < specenvcnt) {
+		fprintf(stdout,"ERROR: Too little data in file\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	if((buf = (float *)malloc(specenvcnt * sizeof(float)))==NULL) {
+		fprintf(stdout,"ERROR: Failure to allocate memory 2.\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	if(fgetfbufEx(buf,specenvcnt,ifd,0) < 0) {
+		fprintf(stdout,"ERROR: Can't read samples from file.\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	sndcloseEx(ifd);
+	if((fp = fopen(filename,"w"))==NULL) {
+		fprintf(stdout,"ERROR: Can't open outputfile\n");
+		fflush(stdout);
+		return(FAILED);
+	}
+	specenvcnt /= 3;
+	sprintf(out,"%d\n",specenvcnt);
+	fputs(out,fp);
+	for(k = specenvcnt;k < specenvcnt * 3;k++) {
+		if(k % specenvcnt == 0)
+			fputs("\n",fp);
+		sprintf(out,"%.12lf\n",buf[k]);
+		fputs(out,fp);
+	}
+	fclose(fp);
+	return(SUCCEEDED);
+}
+
+
+int readfhead(int ifd)
+{
+	int isf;
+	SFPROPS props = {0};
+	if(!snd_headread(ifd,&props)) {
+		fprintf(stdout,"ERROR: Failure to read properties\n");
+		fflush(stdout);
+		return(-1);
+	}
+	if(sndgetprop(ifd,"is a formant file",(char *) &isf,sizeof(int)) < 0) {
+		fprintf(stdout,"ERROR: Not a formant file.\n");
+		fflush(stdout);
+		return(-1);
+	}
+	return props.specenvcnt;
+}
+