initial commit

dev/cdp2k/CMakeLists.txt

@@ -0,0 +1,13 @@
+if(APPLE)
+  set(CMAKE_C_FLAGS "-O -Wall -mmacosx-version-min=10.8 -Dunix")
+else()
+  if(MINGW)
+    set(CMAKE_C_FLAGS "-O2 -Wall -DWIN32 -D_WIN32")
+  else()
+    set(CMAKE_C_FLAGS "-O2 -Wall -DCDP97 -Dunix -Dlinux -D_X86_")
+  endif()
+endif()
+
+set(CDP2K_SRCS ../cdparse/cdparse.c dzsetup.c formantsg.c mainfuncs.c parstruct.c readdata.c readfiles.c special.c tkinput.c tklib1.c tklib3.c validate.c writedata.c)
+
+add_library(cdp2k ${CDP2K_SRCS})

dev/cdp2k/Makefiled.osx

@@ -0,0 +1,29 @@
+# OSX debug Makefile for CDP2K program support library � Richard Dobson, CDP Ltd 2014,2022
+# NB this library has no PVOCEX dependencies.
+OPT = -g
+OBJS=cdparse.o dzsetup.o formantsg.o mainfuncs.o parstruct.o readdata.o readfiles.o \
+special.o tkinput.o tklib1.o tklib3.o validate.o writedata.o
+CC=cc
+CFLAGS= $(OPT) -Wall -mmacosx-version-min=10.8  -Dunix -I ../include -I ../../include
+
+.c.o:
+	$(CC) $(CFLAGS) -c $<
+
+all:	cdp2k
+
+cdparse.o:	../cdparse/cdparse.c
+	$(CC) $(CFLAGS) -c ../cdparse/cdparse.c
+
+cdp2k:	$(OBJS)
+#	ar -rcs libcdp2kd.a $(OBJS) 
+	libtool -static -o libcdp2kd.a $(OBJS)
+#	ranlib libcdp2kd.a
+
+clean:
+	rm -f *.o
+
+veryclean:	clean
+	rm -f libcdp2kd.a
+
+install:	cdp2k
+	cp libcdp2kd.a ../../lib

dev/cdp2k/dzsetup.c

@@ -0,0 +1,393 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version */
+#include <stdio.h>
+#include <stdlib.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <globcon.h>
+#include <cdpmain.h>
+
+#include <formants.h>
+#include <speccon.h>
+#include <modicon.h>
+#include <txtucon.h>
+
+#include <memory.h>         /*RWD*/
+#include <string.h>
+#include <sfsys.h>
+
+static int  establish_infile_and_outfile_property_structs(dataptr dz);
+static void pointer_initialisation(dataptr dz);
+static void initialise_file_property_struct(fileptr fp);
+static void free_tex_structure(dataptr dz);
+static void delete_motifs_here_and_beyond(motifptr startmtf);
+static void free_application_structure_and_related_brktables(dataptr dz);
+static void nullify_duplicate_wordptrs(dataptr dz);
+
+
+
+
+
+/**************************** ESTABLISH_DATASTRUCTURE ************************/
+
+int establish_datastructure(dataptr *dz)
+{
+    int exit_status;
+    if((*dz = (dataptr)malloc(sizeof(struct datalist)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for main data structure\n");
+        return(MEMORY_ERROR);
+    }
+    pointer_initialisation(*dz);
+    if((exit_status = establish_infile_and_outfile_property_structs(*dz))<0)
+        return(exit_status);
+    return(FINISHED);
+}
+
+/******************** ESTABLISH_INFILE_AND_OUTFILE_PROPERTY_STRUCTS *************************/
+
+int establish_infile_and_outfile_property_structs(dataptr dz)
+{
+    if((dz->infile = (fileptr)malloc(sizeof(struct fileprops)))==NULL) {
+        sprintf(errstr,"INSUFICIENT MEMORY for infile_property_struct\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->otherfile = (fileptr)malloc(sizeof(struct fileprops)))==NULL) {
+        sprintf(errstr,"INSUFICIENT MEMORY for otherfile_property_struct\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->outfile = (fileptr)malloc(sizeof(struct fileprops)))==NULL) {
+        sprintf(errstr,"INSUFICIENT MEMORY for outfile_property_struct\n");
+        return(MEMORY_ERROR);
+    }
+    initialise_file_property_struct(dz->infile);
+    initialise_file_property_struct(dz->otherfile);
+    initialise_file_property_struct(dz->outfile);
+    /*RWD.7.98 */
+    if((dz->outfilename = (char *) malloc(_MAX_PATH)) ==NULL){
+        sprintf(errstr,"INSUFFICIENT MEMORY for outfile name\n");
+        return MEMORY_ERROR;
+    }
+    return(FINISHED);
+}
+
+/******************************** POINTER_INITIALISATION *******************************/
+
+void pointer_initialisation(dataptr dz)
+{
+    //RWD.10.98
+    char *clipstring = NULL;
+
+    memset((char *)dz,0,sizeof(struct datalist));   /* THIS INITIALISES EVERYTHING ELSE TO ZERO!!! */
+    dz->process             = -1;
+    dz->maxmode             = -1;
+    dz->mode                = -1;
+/* PROCESS TYPES */
+    dz->input_data_type     = -2;
+    dz->outfiletype         = -2;
+    dz->process_type        = -2;
+/* OTHER FILE PONTERS */
+    dz->ofd                 = -1;
+    dz->other_file          = -1;
+    dz->extra_word          = -1;
+    dz->extrabrkno          = -1;
+    dz->deal_with_chan_data = RECTIFY_CHANNEL_FRQ_ORDER;
+    dz->is_sharp            = EIGHTH_TONE;      /* default */
+    dz->is_flat             = 1.0/EIGHTH_TONE;  /* default */
+    /*RWD.7.98 */
+    dz->outfilename         = NULL;
+    //RWD.10.98
+    dz->floatsam_output     = 0;
+    dz->peak_fval           = 1.0;      //only report if overrange
+    dz->true_outfile_stype  = SAMP_SHORT;
+    dz->clip_floatsams      = 1;
+    clipstring = getenv("CDP_NOCLIP_FLOATS");
+    if(clipstring != NULL)
+        if((strcmp(clipstring,"") != 0) && (atoi(clipstring) != 0))
+            dz->clip_floatsams  = 0;
+    dz->outpeaks = dz->otherpeaks = NULL;
+    dz->outpeakpos = dz->otherpeakpos = NULL;
+    dz->outchans = dz->otheroutchans = 0;
+    dz->needpeaks = dz->needotherpeaks = 0;
+}
+
+/******************************** INITIALISE_FILE_PROPERTY_STRUCT *************************/
+
+void initialise_file_property_struct(fileptr fp)
+{
+    fp->filetype    = -1;
+    fp->srate       = 0;
+    fp->stype       = -1;
+    fp->origstype   = -1;
+    fp->origrate    = 0;
+    fp->channels    = 0;
+    fp->origchans   = 0;
+    fp->specenvcnt  = 0;
+    fp->Mlen        = 0;
+    fp->Dfac        = 0;
+    fp->arate       = 0.0f;
+    fp->window_size = 0.0f;
+}
+
+/******************************* SUPERFREE ******************************/
+
+int superfree(dataptr dz)
+{
+    int n;
+    if(dz!=NULL) {
+        if(dz->tex != NULL)
+            free_tex_structure(dz);
+
+        if(dz->infile!=NULL)        free(dz->infile);       if(dz->outfile!=NULL)       free(dz->outfile);  
+        if(dz->fp!=NULL)            fclose(dz->fp);
+        if(dz->is_int!=NULL)        free(dz->is_int);       if(dz->no_brk!=NULL)        free(dz->no_brk);  
+        if(dz->is_active!=NULL)     free(dz->is_active);    
+        if(dz->bigbuf!=NULL)        free(dz->bigbuf);       if(dz->bigfbuf!=NULL)       free(dz->bigfbuf);  
+        if(dz->amp!=NULL)           free(dz->amp);          if(dz->freq!=NULL)          free(dz->freq);
+        if(dz->sbufptr!=NULL)       free(dz->sbufptr);      if(dz->sampbuf!=NULL)       free(dz->sampbuf); 
+        if(dz->flbufptr!=NULL)      free(dz->flbufptr);     if(dz->windowbuf!=NULL)     free(dz->windowbuf);
+        if(dz->ifd!=NULL) {
+            free(dz->ifd);
+            dz->ifd = NULL;       /*RWD Nov 2011 jic */
+        }
+        if(dz->insams!=NULL)        free(dz->insams);
+
+        if(dz->application!=NULL)
+            free_application_structure_and_related_brktables(dz);
+
+        if((dz->extrabrkno >= 0) && (dz->brk !=NULL) && (dz->brk[dz->extrabrkno] !=NULL)) 
+            free(dz->brk[dz->extrabrkno]);
+
+        if(dz->brk!=NULL)           free(dz->brk);          if(dz->brkptr!=NULL)        free(dz->brkptr);  
+        if(dz->brksize!=NULL)       free(dz->brksize);  
+        if(dz->lastind!=NULL)       free(dz->lastind);      if(dz->lastval!=NULL)       free(dz->lastval); 
+        if(dz->brkinit!=NULL)       free(dz->brkinit);      if(dz->firstval!=NULL)      free(dz->firstval); 
+        if(dz->param!=NULL)         free(dz->param);        if(dz->iparam!=NULL)        free(dz->iparam);
+        if(dz->vflag!=NULL)         free(dz->vflag);
+
+        if((dz->array_cnt > 0) && (dz->parray!=NULL)) {
+            for(n = 0;n< dz->array_cnt; n++)  { 
+                if(dz->parray[n]!=NULL)  
+                    free(dz->parray[n]); 
+            }
+        }
+        if((dz->iarray_cnt > 0) && (dz->iparray!=NULL)) {
+            for(n = 0;n< dz->iarray_cnt; n++) { 
+                if(dz->iparray[n]!=NULL) 
+                    free(dz->iparray[n]);
+            }
+        }
+        if((dz->larray_cnt > 0) && (dz->lparray!=NULL)) {
+            for(n = 0;n< dz->larray_cnt; n++) { 
+                if(dz->lparray[n]!=NULL) 
+                    free(dz->lparray[n]);                           
+            }
+        }   
+        /* RWD 4:2002 lfarray shadows lparray for sumbix syncatt and distort*/
+        if((dz->larray_cnt > 0) && (dz->lfarray!=NULL)) {
+            for(n = 0;n< dz->larray_cnt; n++) { 
+                if(dz->lfarray[n]!=NULL) 
+                    free(dz->lfarray[n]);                               
+            }
+        }
+
+        if(dz->lfarray != NULL)
+            free(dz->lfarray);
+
+
+        if(dz->parray!=NULL)        free(dz->parray);       if(dz->iparray!=NULL) free(dz->iparray);
+        if(dz->lparray!=NULL)       free(dz->lparray);      if(dz->sndbuf!=NULL) free(dz->sndbuf);
+        if(dz->fptr!=NULL)          free(dz->fptr);         if(dz->ptr!=NULL)
+            free(dz->ptr);
+        if(dz->specenvfrq!=NULL)    free(dz->specenvfrq);   if(dz->specenvpch!=NULL) free(dz->specenvpch);
+        if(dz->specenvamp!=NULL)    free(dz->specenvamp);   if(dz->specenvtop!=NULL) free(dz->specenvtop);
+        if(dz->specenvamp2!=NULL)   free(dz->specenvamp2);  if(dz->pitches!=NULL) free(dz->pitches);
+        if(dz->transpos!=NULL)      free(dz->transpos);     if(dz->pitches2!=NULL) free(dz->pitches2);
+        if(dz->transpos2!=NULL)     free(dz->transpos2);    if(dz->frq_template!=NULL) free(dz->frq_template);
+        if(dz->fsampbuf!=NULL)      free(dz->fsampbuf);     if(dz->filtpeak!=NULL) free(dz->filtpeak);
+        if(dz->fbandtop!=NULL)      free(dz->fbandtop);     if(dz->fbandbot!=NULL) free(dz->fbandbot);
+        if(dz->peakno!=NULL)        free(dz->peakno);       if(dz->lastpeakno!=NULL) free(dz->lastpeakno);
+        if(dz->band!=NULL)          free(dz->band);         if(dz->temp!=NULL)
+            free(dz->temp);
+        if(dz->origenv!=NULL)       free(dz->origenv);      if(dz->env!=NULL)
+            free(dz->env);
+        if(dz->rampbrk!=NULL)       free(dz->rampbrk);
+
+        if(dz->valstor!=NULL) {
+            for(n=0;n<dz->linecnt;n++) {
+                if(dz->valstor[n]!=NULL)
+                    free(dz->valstor[n]);
+            }
+            free(dz->valstor);
+        }
+        if(dz->buflist!=NULL) {
+            for(n=0;n<dz->bufcnt;n++) {
+                if(dz->buflist[n]!=NULL)
+                    free(dz->buflist[n]);
+            }
+            free(dz->buflist);
+        }
+
+        if(dz->wordstor!=NULL)
+            free_wordstors(dz);
+
+        if(dz->wordcnt!=NULL)       free(dz->wordcnt);      if(dz->act!=NULL)
+            free(dz->act);
+        if(dz->activebuf!=NULL)     free(dz->activebuf);    if(dz->activebuf_ptr!=NULL) free(dz->activebuf_ptr);
+
+
+        if(dz->outpeaks)
+            free(dz->outpeaks);
+        if(dz->otherpeaks)
+            free(dz->otherpeaks);
+        if(dz->outpeakpos)
+            free(dz->outpeakpos);
+        if(dz->otherpeakpos)
+            free(dz->otherpeakpos);
+
+        free(dz);
+    }
+    return(FINISHED);
+}
+
+/**************************** FREE_TEX_STRUCTURE *******************************/
+
+void free_tex_structure(dataptr dz)
+{
+    int n;
+    if(dz->tex->motifhead !=NULL)
+        delete_motifs_here_and_beyond(dz->tex->motifhead);
+    if(dz->tex->insnd !=NULL) {
+        for(n=0;n<dz->infilecnt;n++) {
+            if(((dz->tex->insnd)[n])->buffer != NULL)
+                free(((dz->tex->insnd)[n])->buffer);
+            free((dz->tex->insnd)[n]);
+        }
+        free(dz->tex->insnd);
+    }
+    if(dz->tex->phrase !=NULL) 
+        free(dz->tex->phrase);
+    if(dz->tex->perm !=NULL) {
+        for(n=0;n<PERMCNT;n++) {
+            if(dz->tex->perm[n] != NULL)
+                free(dz->tex->perm[n]);
+        }
+        free(dz->tex->perm);
+    }
+    free(dz->tex);
+}
+
+/********************** DELETE_MOTIFS_HERE_AND_BEYOND *******************************/
+
+void delete_motifs_here_and_beyond(motifptr startmtf)
+{
+    motifptr thismotif = startmtf;
+    if(thismotif==NULL)
+        return;
+    while(thismotif->next!=NULL)
+        thismotif=thismotif->next;
+    while(thismotif!=startmtf) {       
+        delete_notes_here_and_beyond(thismotif->firstnote);
+        thismotif=thismotif->last;
+        free(thismotif->next);
+    }
+    if(startmtf->last!=NULL)
+        startmtf->last->next = NULL;
+    free(startmtf);
+}
+
+/********************** DELETE_NOTES_HERE_AND_BEYOND *******************************/
+
+void delete_notes_here_and_beyond(noteptr startnote)
+{
+    noteptr thisnote = startnote;
+    if(thisnote==NULL)
+        return;
+    while(thisnote->next!=NULL)
+        thisnote=thisnote->next;
+    while(thisnote!=startnote) {
+        thisnote=thisnote->last;
+        free(thisnote->next);
+    }
+    if(startnote->last!=NULL)
+        startnote->last->next = NULL;
+    free(startnote);
+}
+
+/********************** FREE_APPLICATION_STRUCTURE_AND_RELATED_BRKTABLES *******************************/
+
+void free_application_structure_and_related_brktables(dataptr dz)
+{
+    int n;
+    aplptr ap = dz->application;
+    if((ap->total_input_param_cnt > 0) && (dz->brk!=NULL)) {
+        for(n = 0;n< ap->total_input_param_cnt; n++) { 
+            if(dz->brk[n]!=NULL) 
+                free(dz->brk[n]); 
+        }
+    }
+    if(ap->param_list!=NULL)            free(ap->param_list);     
+    if(ap->option_list!=NULL)           free(ap->option_list);
+    if(ap->variant_list!=NULL)          free(ap->variant_list);   
+    if(ap->internal_param_list!=NULL)   free(ap->internal_param_list);
+    if(ap->option_flags!=NULL)          free(ap->option_flags);   
+    if(ap->variant_flags!=NULL)         free(ap->variant_flags);
+    if(ap->lo!=NULL)                    free(ap->lo);             
+    if(ap->hi!=NULL)                    free(ap->hi);
+    free(dz->application);
+}
+
+/********************** FREE_WORDSTORS *******************************/
+
+void free_wordstors(dataptr dz)
+{
+    int n;
+    nullify_duplicate_wordptrs(dz);
+    for(n=0;n<dz->all_words;n++) {
+        if(dz->wordstor[n]!=NULL)
+            free(dz->wordstor[n]);
+    }
+    free(dz->wordstor);
+}
+
+/***************************** NULLIFY_DUPLICATE_WORDPTRS **************************/
+
+void nullify_duplicate_wordptrs(dataptr dz)
+{
+    int n, m;
+    for(n=0;n<dz->all_words-1;n++) {
+        if(dz->wordstor[n]!= NULL) {
+            for(m=n+1;m<dz->all_words;m++) {
+                if(dz->wordstor[m]!=NULL) {
+                    if(dz->wordstor[m]==dz->wordstor[n])
+                        dz->wordstor[m] = NULL;
+                }
+            }
+        }
+    }
+}
+

dev/cdp2k/formantsg.c

@@ -0,0 +1,597 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version */
+
+/* Sept 05: TW fix for formants put */
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+#include <string.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <globcon.h>
+#include <filetype.h>
+#include <formants.h>
+#include <speccon.h>
+#include <sfsys.h>
+
+
+#define CHAN_SRCHRANGE_F    (4)
+
+static int  set_specenv_frqs(int arraycnt,dataptr dz);
+static int  setup_octaveband_steps(double **interval,dataptr dz);
+static int  setup_low_octave_bands(int arraycnt,dataptr);
+
+/************************** INITIALISE_SPECENV *********************
+ *
+ *  MAR 1998: not sure if the follwoing comment is relevant any more
+ *  but I wont risk changing it at this stage.
+ *
+ *  WANTED and CLENGTH are calculated from scratch here, as dz->wanted
+ *  gets set equal to dz->specenvcnt for calculations on formant data,
+ *  while dz->clength may not yet be set!!      
+ */
+
+int initialise_specenv(int *arraycnt,dataptr dz)
+{
+    int wanted,clength;
+    switch(dz->infile->filetype) {
+    case(ANALFILE): 
+        wanted  = dz->infile->channels; 
+        break;
+    case(FORMANTFILE):
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+        wanted  = dz->infile->origchans;
+        break;
+    default:
+        sprintf(errstr,"Unknown original filetype: initialise_specenv()\n");
+        return(PROGRAM_ERROR);
+    }
+    clength = wanted/2;
+    *arraycnt   = clength + 1;
+    if((dz->specenvfrq = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for formant frq array.\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->specenvpch = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for formant pitch array.\n");
+        return(MEMORY_ERROR);
+    }
+    /*RWD  zero the data */
+    memset(dz->specenvpch,0,*arraycnt * sizeof(float));
+
+    if((dz->specenvamp = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for formant aplitude array.\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->specenvtop = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for formant frq limit array.\n");
+        return(MEMORY_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************************** READ_FORMANTBAND_DATA_AND_SETUP_FORMANTS *********************/
+
+int read_formantband_data_and_setup_formants(char ***cmdline,int *cmdlinecnt,dataptr dz)
+{
+    int exit_status;
+    int max_fbands = 0, arraycnt;
+    aplptr ap = dz->application;
+    if((exit_status = establish_formant_band_ranges(dz->infile->channels,ap))<0)
+        return(exit_status);
+
+    if(!sloom) {
+        if(strlen((*cmdline)[0])<3) {
+            sprintf(errstr,"Formant parameter missing on cmdline.\n");
+            return(USAGE_ONLY);
+        }
+        if(!strncmp((*cmdline)[0],"-f",2))
+            dz->specenv_type = FREQWISE_FORMANTS;           
+        else if(!strncmp((*cmdline)[0],"-p",2))
+            dz->specenv_type = PICHWISE_FORMANTS;           
+        else {
+            sprintf(errstr,"Formant flag missing on cmdline.\n");
+            return(USAGE_ONLY);
+        }
+        if(dz->specenv_type==PICHWISE_FORMANTS && ap->no_pitchwise_formants) {
+            sprintf(errstr,"-p flag can't be used: Too few analysis data channels.\n");
+            return(DATA_ERROR);
+        }
+        (*cmdline)[0] += 2;
+        if(sscanf((*cmdline)[0],"%d",&(dz->formant_bands))!=1) {
+            sprintf(errstr,"Cannot read count of formant_bands.\n");
+            return(USAGE_ONLY);
+        }
+        (*cmdline)++;
+        (*cmdlinecnt)--;
+    } else {
+        if((*cmdline)[0][0]!=NUMERICVAL_MARKER) {   /* TK  convention, values are preceded by '@' */
+            sprintf(errstr,"Invalid value for Formant bands switch sent from TK\n");
+            return(DATA_ERROR);
+        }
+        ((*cmdline)[0])++;
+        switch((*cmdline)[0][0]) {
+        case('0'):  dz->specenv_type = PICHWISE_FORMANTS;   break;          
+        case('1'):  dz->specenv_type = FREQWISE_FORMANTS;   break;          
+        default:
+            sprintf(errstr,"Bad value (%c) for Formant Flag sent from TK\n",((*cmdline)[0][0]));
+            return(DATA_ERROR);
+        }
+        (*cmdline)++;
+        (*cmdlinecnt)--;
+
+        if((*cmdline)[0][0]!=NUMERICVAL_MARKER) {   /* TK  convention, values are preceded by '@' */
+            sprintf(errstr,"Invalid value for Formant bands sent from TK\n");
+            return(DATA_ERROR);
+        }
+        ((*cmdline)[0])++;
+        if(sscanf((*cmdline)[0],"%d",&(dz->formant_bands))!=1) {
+            sprintf(errstr,"No formant band count sent from TK.\n");
+            return(USAGE_ONLY);
+        }
+        (*cmdline)++;
+        (*cmdlinecnt)--;
+    }
+    switch(dz->specenv_type) {
+    case(PICHWISE_FORMANTS): max_fbands = ap->max_pichwise_fbands;  break;
+    case(FREQWISE_FORMANTS): max_fbands = ap->max_freqwise_fbands;  break;
+    }
+    if(dz->formant_bands < ap->min_fbands) {
+        sprintf(errstr,"Too few formant_bands requested: min for this file is %d\n",ap->min_fbands);
+        return(DATA_ERROR);
+    }
+    if(dz->formant_bands > max_fbands) {
+        sprintf(errstr,"Too many formant_bands requested: max for this file is %d\n",max_fbands);
+        return(DATA_ERROR);
+    }
+    if((exit_status = initialise_specenv(&arraycnt,dz))<0)
+        return(exit_status);
+    if((exit_status = set_specenv_frqs(arraycnt,dz))<0)
+        return(exit_status);
+    dz->descriptor_samps = dz->infile->specenvcnt * DESCRIPTOR_DATA_BLOKS ;
+    return(FINISHED);
+}
+
+/************************ SET_SPECENV_FRQS ************************
+ *
+ * FREQWISE BANDS = number of channels for each specenv point
+ * PICHWISE BANDS  = number of points per octave
+ */
+
+int set_specenv_frqs(int arraycnt,dataptr dz)
+{
+    int exit_status;
+    double frqstep, thisfrq, nextfrq, bandbot;
+    double *interval;
+    int m, n, k = 0, cc;
+    switch(dz->specenv_type) {
+    case(FREQWISE_FORMANTS):
+        dz->specenvamp[0] = (float)0.0;
+        dz->specenvfrq[0] = (float)1.0;
+        dz->specenvpch[0] = (float)log10(dz->specenvfrq[0]);
+        dz->specenvtop[0] = (float)dz->halfchwidth;
+        frqstep = dz->halfchwidth * (double)dz->formant_bands;
+        thisfrq = dz->specenvtop[0];
+        k = 1;
+        while((nextfrq = thisfrq + frqstep) < dz->nyquist) {
+            if(k >= arraycnt) {
+                sprintf(errstr,"Formant array too small: set_specenv_frqs()\n");
+                return(PROGRAM_ERROR);
+            }
+            dz->specenvfrq[k] = (float)nextfrq;
+            dz->specenvpch[k] = (float)log10(dz->specenvfrq[k]);
+            nextfrq          += frqstep;
+            dz->specenvtop[k] = (float)min(dz->nyquist,nextfrq);
+            thisfrq           = nextfrq;
+            k++;
+        }
+        break;
+    case(PICHWISE_FORMANTS):
+        if((exit_status = setup_octaveband_steps(&interval,dz))<0)
+            return(exit_status);
+        if((exit_status = setup_low_octave_bands(arraycnt,dz))<0)
+            return(exit_status);
+        k  = TOP_OF_LOW_OCTAVE_BANDS;
+        cc = CHAN_ABOVE_LOW_OCTAVES;
+        while(cc <= dz->clength) {
+            m = 0;
+            if((bandbot = dz->chwidth * (double)cc) >= dz->nyquist)
+                break;
+            for(n=0;n<dz->formant_bands;n++) {
+                if(k >= arraycnt) {
+                    sprintf(errstr,"Formant array too small: set_specenv_frqs()\n");
+                    return(PROGRAM_ERROR);
+                }
+                dz->specenvfrq[k]   = (float)(bandbot * interval[m++]);
+                dz->specenvpch[k]   = (float)log10(dz->specenvfrq[k]);
+                dz->specenvtop[k++] = (float)(bandbot * interval[m++]);
+            }   
+            cc *= 2;        /* 8-16: 16-32: 32-64 etc as 8vas, then split into bands */
+        }
+        break;
+    }
+    dz->specenvfrq[k] = (float)dz->nyquist;
+    dz->specenvpch[k] = (float)log10(dz->nyquist);
+    dz->specenvtop[k] = (float)dz->nyquist;
+    dz->specenvamp[k] = (float)0.0;
+    k++;
+    dz->infile->specenvcnt = k;
+    return(FINISHED);
+}
+
+/************************* SETUP_OCTAVEBAND_STEPS ************************/
+
+int setup_octaveband_steps(double **interval,dataptr dz)
+{
+    double octave_step;
+    int n = 1, m = 0, halfbands_per_octave = dz->formant_bands * 2;
+    if((*interval = (double *)malloc(halfbands_per_octave * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY establishing interval array for formants.\n");
+        return(MEMORY_ERROR);
+    }
+    while(n < halfbands_per_octave) {
+        octave_step   = (double)n++/(double)halfbands_per_octave;
+        (*interval)[m++] = pow(2.0,octave_step);
+    }
+    (*interval)[m] = 2.0;
+    return(FINISHED);
+}
+
+/************************ SETUP_LOW_OCTAVE_BANDS ***********************
+ *
+ * Lowest PVOC channels span larger freq steps and therefore we must
+ * group them in octave bands, rather than in anything smaller.
+ */
+
+int setup_low_octave_bands(int arraycnt,dataptr dz)
+{
+    int n;
+    if(arraycnt < LOW_OCTAVE_BANDS) {
+        sprintf(errstr,"Insufficient array space for low_octave_bands\n");
+        return(PROGRAM_ERROR);
+    }
+    for(n=0;n<LOW_OCTAVE_BANDS;n++) {
+        switch(n) {
+        case(0):
+            dz->specenvfrq[0] = (float)1.0;                 /* frq whose log is 0 */
+            dz->specenvpch[0] = (float)0.0;
+            dz->specenvtop[0] = (float)dz->chwidth;         /* 8VA wide bands */
+            break;
+        case(1):
+            dz->specenvfrq[1] = (float)(dz->chwidth * 1.5); /* Centre Chs 1-2 */    
+            dz->specenvpch[1] = (float)log10(dz->specenvfrq[1]);
+            dz->specenvtop[1] = (float)(dz->chwidth * 2.0);
+            break;
+        case(2):
+            dz->specenvfrq[2] = (float)(dz->chwidth * 3.0); /* Centre Chs 2-4 */
+            dz->specenvpch[2] = (float)log10(dz->specenvfrq[2]);
+            dz->specenvtop[2] = (float)(dz->chwidth * 4.0);
+            break;
+        case(3):
+            dz->specenvfrq[3] = (float)(dz->chwidth * 6.0); /* Centre Chs 4-8 */    
+            dz->specenvpch[3] = (float)log10(dz->specenvfrq[3]);
+            dz->specenvtop[3] = (float)(dz->chwidth * 8.0);
+            break;
+        default:
+            sprintf(errstr,"Insufficient low octave band setups in setup_low_octave_bands()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/**************************** GETSPECENVAMP *************************/
+
+int getspecenvamp(double *thisamp,double thisfrq,int storeno,dataptr dz)
+{
+    double pp, ratio, ampdiff;
+    float *ampstore;
+    int z = 1;
+    if(thisfrq<0.0) {   /* NOT SURE THIS IS CORRECT */
+        *thisamp = 0.0; /* SHOULD WE PHASE INVERT & RETURN A -ve AMP ?? */
+        return(FINISHED);   
+    }
+    if(thisfrq<=1.0)
+        pp = 0.0;
+    else
+        pp = log10(thisfrq); 
+    while( dz->specenvpch[z] < pp){
+        z++;
+        /*RWD may need to trap on size of array? */
+        if(z == dz->infile->specenvcnt -1)
+            break;
+    }
+    switch(storeno) {
+    case(0):    
+        ampstore = dz->specenvamp;  break;
+    case(1):    
+        ampstore = dz->specenvamp2; break;
+    default:
+        sprintf(errstr,"Unknown storenumber in getspecenvamp()\n");
+        return(PROGRAM_ERROR);
+    }
+    ratio    = (pp - dz->specenvpch[z-1])/(dz->specenvpch[z] - dz->specenvpch[z-1]);
+    ampdiff  = ampstore[z] - ampstore[z-1];
+    *thisamp = ampstore[z-1] + (ampdiff * ratio);
+    *thisamp = max(0.0,*thisamp);
+    return(FINISHED);
+}
+
+/********************** EXTRACT_SPECENV *******************/
+
+int extract_specenv(int bufptr_no,int storeno,dataptr dz)    /* bufptr_no = flbufptr number (usually 0) */
+{
+    int    n, cc, vc, specenvcnt_less_one;
+    int    botchan, topchan;
+    double botfreq, topfreq;
+    double bwidth_in_chans;
+    float *ampstore;
+    switch(storeno) {
+    case(0):    ampstore = dz->specenvamp;  break;
+    case(1):    ampstore = dz->specenvamp2; break;
+    default:
+        sprintf(errstr,"Unknown storenumber in extract_specenv()\n");
+        return(PROGRAM_ERROR);
+    }
+    specenvcnt_less_one = dz->infile->specenvcnt - 1;
+    vc = 0;
+    switch(dz->deal_with_chan_data) {
+    case(RECTIFY_CHANNEL_FRQ_ORDER):
+        for(n=0;n<dz->infile->specenvcnt;n++)
+            ampstore[n] = (float)0.0;
+        topfreq = 0.0f;
+        n = 0;
+        while(n < specenvcnt_less_one) {
+            botfreq  = topfreq;
+            botchan  = (int)((botfreq + dz->halfchwidth)/dz->chwidth); /* TRUNCATE */
+            botchan -= CHAN_SRCHRANGE_F;
+            botchan  =  max(botchan,0);
+            topfreq  = dz->specenvtop[n];
+            topchan  = (int)((topfreq + dz->halfchwidth)/dz->chwidth); /* TRUNCATE */
+            topchan += CHAN_SRCHRANGE_F;
+            topchan  =  min(topchan,dz->clength);
+            for(cc = botchan,vc = botchan * 2; cc < topchan; cc++,vc += 2) {
+                if(dz->flbufptr[bufptr_no][FREQ] >= botfreq && dz->flbufptr[bufptr_no][FREQ] < topfreq)
+                    ampstore[n] = (float)(ampstore[n] + dz->flbufptr[bufptr_no][AMPP]);
+            }
+            bwidth_in_chans   = (double)(topfreq - botfreq)/dz->chwidth;
+            ampstore[n] = (float)(ampstore[n]/bwidth_in_chans);
+            n++;
+        }
+        break;
+    case(IGNORE_ACTUAL_CHAN_FRQS):
+        for(n=1;n<specenvcnt_less_one;n++)
+            ampstore[n] = (float)0.0;
+        ampstore[0] = (float)(dz->flbufptr[bufptr_no][0]/2.0); /* dz->halfchwidth WIDE CHANNEL */
+        cc = 1;
+        vc = 2;
+        n  = 1;                  /* OMIT LOWEST CHANNEL */
+        topfreq = dz->halfchwidth;
+        while(cc < dz->clength  && n < specenvcnt_less_one) {
+            botfreq  = topfreq;
+            topfreq += dz->chwidth;
+            if(topfreq < dz->specenvtop[n]) {
+                if(botfreq >= dz->specenvtop[n-1])  /* WHOLLY IN SPECENVBAND  */
+                    ampstore[n]=(float)(ampstore[n] + dz->flbufptr[bufptr_no][AMPP]);
+                else                                /* PARTLY IN SPECENVBAND  */
+                    ampstore[n]=(float)(ampstore[n]+(dz->flbufptr[bufptr_no][AMPP]/2.0));
+                cc++;   
+                vc += 2;
+            } else if(botfreq < dz->specenvtop[n]) { /* PARTLY IN SPECENVBAND  */
+                ampstore[n]=(float)(ampstore[n] + (dz->flbufptr[bufptr_no][AMPP]/2.0));
+                cc++;   
+                vc += 2;
+            } else {                                /* NOT IN SPECENVBAND     */
+                bwidth_in_chans = (dz->specenvtop[n]-dz->specenvtop[n-1])/dz->chwidth;
+                ampstore[n]   = (float)(ampstore[n]/bwidth_in_chans);
+                n++;                                /* GO TO NEXT SPECENVBAND */
+            }
+        }
+        break;
+    case(NOT_SET):           //RWD: add default action too...
+        sprintf(errstr,"DEAL_WITH_CHAN_DATA flag not set in extract_specenv()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/********************* EXTRACT_SPECENV_OVER_PARTIALS ***********************/
+
+int extract_specenv_over_partials(int *specenvcnt,double thispitch,int bufptr_no,dataptr dz)
+{                                            /* bufptr_no = flbufptr number (usually 0) */
+    int exit_status;
+    int n = 0, k, cc, vc, lastk = 0;
+    for(n=0;n<=dz->clength;n++)
+        dz->specenvamp[n] = 0.0F;
+    n = 0;
+    dz->specenvfrq[n]   = 1.0F;
+    dz->specenvpch[n++] = 0.0F;
+    for( cc = 0 ,vc = 0; cc < dz->clength; cc++, vc += 2) {
+        if((exit_status = is_harmonic(&k,dz->flbufptr[bufptr_no][FREQ],thispitch))<0)
+            return(exit_status);
+        if(exit_status==FALSE)
+            continue;
+        if(k==lastk) {
+            if(dz->flbufptr[bufptr_no][AMPP] > dz->specenvamp[n]) {
+                dz->specenvamp[n] = dz->flbufptr[bufptr_no][AMPP];                  /* GET LOUDEST PARTIAL */
+                dz->specenvfrq[n] = (float)max(1.0f,dz->flbufptr[bufptr_no][FREQ]);  /*    NEAR HARMONIC    */
+                dz->specenvpch[n] = (float)log10(dz->specenvfrq[n]);
+            }
+        } else {
+            n++;
+            dz->specenvamp[n] = dz->flbufptr[bufptr_no][AMPP];  /* KEEP AMP & FRQ OF PARTIAL */
+            dz->specenvfrq[n] = (float)max(1.0f,dz->flbufptr[bufptr_no][FREQ]);
+            dz->specenvpch[n] = (float)log10(dz->specenvfrq[n]);
+            lastk = k;
+        }
+    }
+    n++;
+    dz->specenvamp[n]   = 0.0F;
+    dz->specenvfrq[n]   = (float)dz->nyquist;
+    dz->specenvpch[n] = (float)log10(dz->specenvfrq[n]);
+    n++;
+    *specenvcnt = n;
+    return(FINISHED);
+}   
+
+/**************************** IS_HARMONIC *************************
+ *
+ * WARNING: Checks if FIRST FREQ is harmonic of 2nd: NOT VICE VERSA!!
+ */
+
+int is_harmonic(int *iratio,double frq1, double frq2)
+{
+    double ratio, intvl;
+    if(frq2 < FLTERR) {
+        sprintf(errstr,"Zero frequency submitted as fundamental to is_harmonic()\n");
+        return(PROGRAM_ERROR);
+    }
+    ratio = frq1/frq2;
+    *iratio = round(ratio);
+    if(ratio > *iratio)
+        intvl = ratio/(double)(*iratio);
+    else
+        intvl = (double)(*iratio)/ratio;
+    if(intvl > SEMITONE_INTERVAL)
+        return(FALSE);
+    return(TRUE);
+}
+                                                    
+/************************** INITIALISE_SPECENV2 *********************/
+
+int initialise_specenv2(dataptr dz)
+{
+    int wanted,clength;
+    int n;
+    switch(dz->infile->filetype) {
+    case(ANALFILE): 
+        wanted  = dz->infile->channels; 
+        break;
+    case(FORMANTFILE):
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+        wanted  = dz->infile->origchans;
+        break;
+    default:
+        sprintf(errstr,"Unknown original filetype: initialise_specenv2()\n");
+        return(PROGRAM_ERROR);
+    }
+    clength = wanted/2;
+    if((dz->specenvamp2 = (float *)malloc((clength+1) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for second formant amplitude array.\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<dz->infile->specenvcnt;n++)
+        dz->specenvamp2[n]  = 0.0f;
+    return(FINISHED);
+}
+
+/******************** WRITE_FORMANT_DESCRIPTOR **********************/
+
+int write_formant_descriptor(float **fptr1,float *fptr2,dataptr dz)
+{
+    int fsamps_to_write = dz->descriptor_samps/DESCRIPTOR_DATA_BLOKS;
+    *fptr1 = fptr2;
+    memmove((char *)(*fptr1),(char *)dz->specenvpch,(size_t)(fsamps_to_write * sizeof(float)));
+    *fptr1 += dz->infile->specenvcnt;
+    memmove((char *)(*fptr1),(char *)dz->specenvtop,(size_t)(fsamps_to_write * sizeof(float)));
+    *fptr1 += dz->infile->specenvcnt;
+    return(FINISHED);
+}
+
+/******************** SETUP_FORMANT_PARAMS **********************/
+
+int setup_formant_params(int fd,dataptr dz)
+{
+    int samps_read;
+    /*RWD what the f**** are these? */
+    int fsamps_to_read = dz->descriptor_samps/DESCRIPTOR_DATA_BLOKS;
+    
+    /*RWD need dz->bigbuflen2 ? */
+    if(dz->buflen2 <= 0) {
+//      sprintf(errstr,"bigbufsize2 not established: setup_formant_params()\n");
+        sprintf(errstr,"buflen2 not established: setup_formant_params()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->buflen2 < dz->descriptor_samps) {
+//      sprintf(errstr,"bigbufsize2 smaller than descriptor_samps: setup_formant_params()\n");
+        sprintf(errstr,"buflen2 smaller than descriptor_samps: setup_formant_params()\n");
+        return(PROGRAM_ERROR);
+    }
+    if((samps_read = fgetfbufEx(dz->flbufptr[2], dz->buflen2,fd,0)) < dz->descriptor_samps) {
+        if(samps_read<0) {
+            sprintf(errstr,"Sound read error.\n");
+            return(SYSTEM_ERROR);
+        }
+        sprintf(errstr,"No data in formantfile.\n");
+        return(DATA_ERROR);
+    }
+    /*TW Sept 05*/
+    dz->ssampsread = samps_read;
+
+    dz->flbufptr[1] = dz->flbufptr[2];
+    memmove((char *)dz->specenvpch,(char *)dz->flbufptr[1],(size_t)(fsamps_to_read * sizeof(float)));
+    dz->flbufptr[1] += dz->infile->specenvcnt;
+    memmove((char *)dz->specenvtop,(char *)dz->flbufptr[1],(size_t)(fsamps_to_read * sizeof(float)));
+    dz->flbufptr[1] += dz->infile->specenvcnt;
+    return(FINISHED);
+}
+
+/****************************** EXTRACT_FORMANT_PEAKS2 ***************************/
+
+int extract_formant_peaks2(int sl1param,int *thispkcnt,double lofrq_limit,double hifrq_limit,dataptr dz)
+{
+    int n;
+    int  falling = 0, last_channel_was_in_range = 1;
+    int *fppk = dz->stable->fpk[dz->iparam[sl1param]];
+    *thispkcnt = 0;
+    n = 1;
+    while(n<dz->infile->specenvcnt) {
+        if(dz->specenvfrq[n] < lofrq_limit) {
+            last_channel_was_in_range = 0;
+            n++;
+            continue;
+        }
+        if(dz->specenvamp[n] > dz->specenvamp[n-1])
+            falling = 0;
+        else {
+            if(!falling) {
+                if(last_channel_was_in_range)
+                    fppk[(*thispkcnt)++] = n-1;
+                falling = 1;
+            }
+        }
+        last_channel_was_in_range = 1;
+        if(dz->specenvfrq[n] > hifrq_limit)
+            break;
+        n++;
+    }
+    return(FINISHED);
+}
+

dev/cdp2k/mainfuncs.c

@@ -0,0 +1,2097 @@
+/*
+ * 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 <stdlib.h>
+#include <stdio.h>
+#include <osbind.h>
+#include <structures.h>
+#include <cdpmain.h>
+#include <tkglobals.h>
+#include <sfsys.h>
+#include <cdparams.h>
+#include <globcon.h>
+#include <localcon.h>
+#include <processno.h>
+#include <modeno.h>
+#include <filetype.h>
+#include <formants.h>
+#include <pnames.h>
+#include <sndinfo.h>
+#include <headread.h>
+#include <house.h>
+#include <pvoc.h>
+#include <special.h>
+#include <ctype.h>
+#include <string.h>
+#include <logic.h>
+#include <math.h>
+#include <float.h>
+#include <standalone.h>
+
+#ifdef unix
+#define round(x) lround((x))
+#else
+#define round(x) cdp_round((x))
+#endif
+
+static int do_extra_files(dataptr dz);
+static void strip_ext(char *temp) ;
+static int assign_wavetype(dataptr dz);
+extern char *get_other_filename_x(char *filename,char c);
+
+void dz2props(dataptr dz, SFPROPS* props);
+
+/*RWD we only do this for SNDFILEs, not analfiles etc */
+void dz2props(dataptr dz, SFPROPS* props)
+{
+    if(dz->outfiletype == SNDFILE_OUT){
+        switch(dz->true_outfile_stype){
+        case SAMP_SHORT:
+            props->samptype = SHORT16;
+            break;
+        case SAMP_FLOAT:
+            props->samptype = FLOAT32;
+            break;
+        case SAMP_BYTE:
+            props->samptype = SHORT8;
+            break;
+        case SAMP_LONG:
+            props->samptype = INT_32;
+            break;
+        case SAMP_2424:
+            props->samptype = INT2424;
+            break;
+        case SAMP_2432:
+            props->samptype = INT2432;
+            break;
+        case SAMP_2024:
+            props->samptype = INT2024;
+            break;
+        default:
+            props->samptype = INT_MASKED;
+            break;
+        }
+        props->srate = dz->outfile->srate;
+        props->chans = dz->outchans; //or outfile->channels?
+        props->type = wt_wave;
+        props->format = WAVE_EX;
+        props->chformat = MC_STD;
+        
+    }
+}
+
+/************************ SETUP_PARAM_RANGES_AND_DEFAULTS *********************/
+
+int setup_param_ranges_and_defaults(dataptr dz)
+{                   
+    int exit_status;
+    aplptr ap = dz->application;
+    if(ap->total_input_param_cnt>0) {
+        if((exit_status = set_param_ranges(dz->process,dz->mode,dz->nyquist,dz->frametime,dz->infile->arate,
+        dz->infile->srate,dz->wlength,dz->insams[0],dz->infile->channels,dz->wanted,
+        dz->infile->filetype,dz->linecnt,dz->duration,ap))<0)
+            return(exit_status);
+        if((exit_status = INITIALISE_DEFAULT_VALUES(dz->process,dz->mode,dz->infile->channels,
+        dz->nyquist,dz->frametime,dz->insams[0],dz->infile->srate,dz->wanted,
+        dz->linecnt,dz->duration,ap->default_val,dz->infile->filetype,ap))<0)
+            return(exit_status);
+        if(!sloom)
+            put_default_vals_in_all_params(dz);
+        else if(dz->process == BRASSAGE || dz->process == SAUSAGE)
+            put_default_vals_in_all_params(dz);
+    }
+    return(FINISHED);
+}
+
+/************************ HANDLE_FORMANTS *********************/
+
+int handle_formants(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int exit_status;
+    aplptr ap = dz->application;
+    if(ap->formant_flag) {
+
+        if(!sloom) {
+            if(*cmdlinecnt <= 0) {
+                sprintf(errstr,"Insufficient parameters on command line\n");
+                return(USAGE_ONLY);
+            } 
+        }
+        if((exit_status = read_formantband_data_and_setup_formants(cmdline,cmdlinecnt,dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/************************ HANDLE_FORMANT_QUIKSEARCH *********************/
+
+int handle_formant_quiksearch(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int exit_status;
+    aplptr ap = dz->application;
+    if(ap->formant_qksrch) {
+        if((exit_status = read_formant_qksrch_flag(cmdline,cmdlinecnt,dz))<0)
+            return(exit_status);
+    }
+
+    return(FINISHED);
+}
+                        
+/************************ HANDLE_SPECIAL_DATA *********************/
+
+int handle_special_data(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int exit_status;
+    aplptr ap = dz->application;
+
+    if(ap->special_data) {
+        if(!sloom) {
+            if(*cmdlinecnt <= 0) {
+                sprintf(errstr,"Insufficient parameters on command line.\n");
+                return(USAGE_ONLY);
+            }
+        }
+        if((exit_status = setup_special_data_ranges
+        (dz->mode,dz->infile->srate,dz->duration,dz->nyquist,dz->wlength,dz->infile->channels,ap))<0)
+            return(exit_status);
+
+        if((exit_status = read_special_data((*cmdline)[0],dz))<0)
+            return(exit_status);
+        (*cmdline)++;       
+        (*cmdlinecnt)--;
+    }
+    return(FINISHED);
+}
+                              
+/************************ READ_FORMANT_QKSRCH_FLAG *********************/
+
+int read_formant_qksrch_flag(char ***cmdline,int *cmdlinecnt,dataptr dz)
+{
+
+    if(!sloom) {
+        if(*cmdlinecnt <= 0)
+            return(FINISHED);
+        if(!strcmp((*cmdline)[0],"-i")) {
+             dz->deal_with_chan_data = IGNORE_ACTUAL_CHAN_FRQS;
+            (*cmdline)++;
+            (*cmdlinecnt)--;
+        }
+    } else {
+        ((*cmdline)[0])++;      /* Skip numericval marker */
+        switch((*cmdline)[0][0]) {
+        case('0'):  break;  /* default value remains set */
+        case('1'):  dz->deal_with_chan_data = IGNORE_ACTUAL_CHAN_FRQS; break;
+        default:
+            sprintf(errstr,"Unknown data at formant_quicksearch position in data sent from TK\n");
+            return(DATA_ERROR);
+        }
+        (*cmdline)++;
+        (*cmdlinecnt)--;
+    }
+    return(FINISHED);
+}
+
+/************************ HOUSEKEEP_FILES *********************/
+
+int do_housekeep_files(char *filename,dataptr dz)
+{
+    int exit_status;
+
+    if(dz->process==HOUSE_BUNDLE) {
+        if(dz->wordstor!=NULL)
+            free_wordstors(dz);
+        dz->all_words = 0;
+        if((exit_status = store_filename(filename,dz))<0)
+            return(exit_status);
+    }
+    if(!sloom) {                /* cmdline uses infilename as default outname */
+        if((exit_status = setup_file_outname_where_ness(filename,dz))<0)
+            return(exit_status);
+    }
+    if(dz->process==HOUSE_COPY) {
+        if(dz->mode!=COPYSF) {
+            if(dz->infile->filetype!=SNDFILE) {
+                sprintf(errstr,"This process only works with soundfiles.\n");
+                return(DATA_ERROR);
+            }
+            return(FINISHED);
+        }
+        switch(dz->infile->filetype) {
+        case(WORDLIST):     dz->process_type = TO_TEXTFILE;     dz->outfiletype = TEXTFILE_OUT;                   break;
+        case(SNDFILE):      dz->process_type = EQUAL_SNDFILE;   dz->outfiletype = SNDFILE_OUT;                    break;
+        case(ANALFILE):     dz->process_type = EQUAL_ANALFILE;  dz->outfiletype = ANALFILE_OUT;                   break;
+        case(PITCHFILE):    dz->process_type = PITCH_TO_PITCH;  dz->outfiletype = PITCH_OUT;                      break;
+        case(TRANSPOSFILE): dz->process_type = PITCH_TO_PITCH;  dz->outfiletype=PITCH_OUT;  dz->is_transpos=TRUE; break;
+        case(FORMANTFILE):  dz->process_type = EQUAL_FORMANTS;  dz->outfiletype = FORMANTS_OUT;                   break;
+        case(ENVFILE):      dz->process_type = EQUAL_ENVFILE;   dz->outfiletype = ENVFILE_OUT;                    break;
+        default:
+            sprintf(errstr,"Impossible infile type: assign_copy_constants()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/************************* CHECK_REPITCH_TYPE **********************/
+
+int check_repitch_type(dataptr dz)
+{
+    if(dz->infile->filetype==PITCHFILE && dz->mode==TTT) {
+        sprintf(errstr,"Cannot do a tranpos/transpos operation on a pitchfile\n");
+        return(DATA_ERROR);
+    } else if(dz->infile->filetype==TRANSPOSFILE) {
+        if(dz->mode==PPT) {
+            sprintf(errstr,"Can't do a pitch/pitch operation on a transposition file.\n");
+            return(DATA_ERROR);
+        } else if(dz->mode==PTP) {
+            sprintf(errstr,"Can't do a pitch/transpos starting with a transposition file.\n");
+            return(DATA_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/****************************** EXCEPTIONAL_REPITCH_VALIDITY_CHECK *********************************/
+
+int exceptional_repitch_validity_check(int *is_valid,dataptr dz)
+{
+    switch(dz->mode) {
+    case(PPT):
+    case(PTP):
+        if(dz->could_be_pitch==FALSE)
+            *is_valid = FALSE;            /*RWD was == both times */
+        break;
+    case(TTT):
+        if(dz->could_be_transpos==FALSE)
+            *is_valid = FALSE;
+        break;
+    default:
+        sprintf(errstr,"Unknown case in exceptional_repitch_validity_check()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/****************************** SETUP_BRKTABLESIZES *********************************/
+
+int setup_brktablesizes(infileptr infile_info,dataptr dz)
+{
+
+    if(could_be_transpos_and_or_pitch_infiletype(dz->infile->filetype)) {
+
+        if(dz->input_data_type==BRKFILES_ONLY
+        || dz->input_data_type==ALL_FILES
+        || dz->input_data_type==DB_BRKFILES_ONLY
+        || dz->input_data_type==UNRANGED_BRKFILE_ONLY) {    /* is NOT pitch or transpos data */
+            if(dz->extrabrkno < 0 || dz->brk==NULL) {
+                sprintf(errstr,"Attempt to use brksize before allocated:1: setup_brktablesizes()\n");
+                return(PROGRAM_ERROR);
+            }
+            dz->brksize[dz->extrabrkno] = infile_info->brksize;
+
+        } else                                          /* must be a pitch or transpos process */
+            dz->tempsize = infile_info->brksize;            
+
+    } else if(is_brkfile_infiletype(dz->infile->filetype)) {
+        if(dz->extrabrkno < 0 || dz->brk==NULL) {
+            sprintf(errstr,"Attempt to use brksize before allocated:2: setup_brktablesizes()\n");
+            return(PROGRAM_ERROR);
+        }
+        dz->brksize[dz->extrabrkno] = infile_info->brksize;
+    }
+    return(FINISHED);
+}
+
+/****************************** STORE_FILENAME *********************************/
+
+int store_filename(char *filename,dataptr dz)
+{
+    if(dz->wordstor != NULL) {
+        sprintf(errstr,"Cannot store filename: wordstor already allocated.\n");
+        return(PROGRAM_ERROR);
+    }
+    if((dz->wordstor = (char **)malloc(sizeof(char *)))==NULL) {
+        sprintf(errstr,"Cannot store filename.\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->wordstor[0] = (char *)malloc((strlen(filename)+1) * sizeof(char)))==NULL) {
+        sprintf(errstr,"Cannot store filename.\n");
+        return(MEMORY_ERROR);
+    }
+    if(strcpy(dz->wordstor[0],filename)!= dz->wordstor[0]) { 
+        sprintf(errstr,"Failed to copy filename to store.\n");
+        return(PROGRAM_ERROR);
+    }
+    dz->all_words++;
+    return(FINISHED);
+}
+
+/****************************** STORE_FURTHER_FILENAME *********************************/
+
+int store_further_filename(int n,char *filename,dataptr dz)
+{
+    if(dz->wordstor == NULL) {
+        if((dz->wordstor = (char **)malloc((n+1) *sizeof(char *)))==NULL) {
+            sprintf(errstr,"Cannot store further filename.\n");
+            return(MEMORY_ERROR);
+        }
+    } else {
+        if((dz->wordstor = (char **)realloc((dz->wordstor),(n+1) *sizeof(char *)))==NULL) {
+            sprintf(errstr,"Cannot store further filename.\n");
+            return(MEMORY_ERROR);
+        }
+    }
+    if((dz->wordstor[n] = (char *)malloc((strlen(filename)+1) * sizeof(char)))==NULL) {
+        sprintf(errstr,"Cannot store further filename.\n");
+        return(MEMORY_ERROR);
+    }
+    if(strcpy(dz->wordstor[n],filename)!=dz->wordstor[n]) { 
+        sprintf(errstr,"Failed to copy filename to store.\n");
+        return(PROGRAM_ERROR);
+    }
+    dz->all_words++;
+    return(FINISHED);
+}
+
+/************************ COUNT_AND_ALLOCATE_FOR_INFILES *********************/
+
+int count_and_allocate_for_infiles(int argc,char *argv[],dataptr dz)
+{
+    int exit_status;    
+    switch(dz->input_data_type) {
+    case(NO_FILE_AT_ALL):   /* processes actually do NOT USE the input file */
+        dz->infilecnt = 0;  
+        break;
+    case(SNDFILES_ONLY):            case(ANALFILE_ONLY):
+    case(MIXFILES_ONLY):            case(SNDLIST_ONLY):             case(WORDLIST_ONLY):
+    case(ENVFILES_ONLY):            case(BRKFILES_ONLY):            case(DB_BRKFILES_ONLY):
+    case(FORMANTFILE_ONLY):         case(PITCHFILE_ONLY):           case(PITCH_OR_TRANSPOS):
+    case(SND_OR_MIXLIST_ONLY):      case(SND_SYNC_OR_MIXLIST_ONLY): case(UNRANGED_BRKFILE_ONLY):
+        dz->infilecnt = 1;  
+        break;
+    case(ALL_FILES):        /* i.e. processes accept and use any type of file */
+        switch(dz->process) {
+        case(HOUSE_BUNDLE):
+            if((exit_status = count_bundle_files(argc,argv,dz))<0)
+                return(exit_status);
+            break;
+        case(INFO_DIFF):  dz->infilecnt = 2;    break;
+        default:          dz->infilecnt = 1;    break;
+        }
+        break;
+    case(TWO_SNDFILES):             case(SNDFILE_AND_ENVFILE):      case(SNDFILE_AND_BRKFILE):      
+    case(SNDFILE_AND_DB_BRKFILE):   case(TWO_ANALFILES):            case(ANAL_AND_FORMANTS):
+    case(PITCH_AND_FORMANTS):       case(PITCH_AND_PITCH):          case(PITCH_AND_TRANSPOS):
+    case(TRANSPOS_AND_TRANSPOS):    case(ANAL_WITH_PITCHDATA):      case(ANAL_WITH_TRANSPOS):
+    case(SNDFILE_AND_UNRANGED_BRKFILE):
+        dz->infilecnt = 2;  
+        break;
+    case(THREE_ANALFILES):
+//TW NEW
+    case(PFE):
+        dz->infilecnt = 3;  
+        break;
+    case(ONE_OR_MANY_SNDFILES):
+//TW NEW
+    case(ONE_OR_MORE_SNDSYS):
+        if((exit_status = count_infiles(argc,argv,dz))<0)
+            return(exit_status);
+        break;
+    case(MANY_SNDFILES):            case(MANY_ANALFILES):   case(ANY_NUMBER_OF_ANY_FILES):
+        if((exit_status = count_infiles(argc,argv,dz))<0)
+            return(exit_status);
+        if(dz->infilecnt < 2) {
+            sprintf(errstr,"Insufficient input files for this process\n");
+            return(USAGE_ONLY);
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown input_data_type: count_and_allocate_for_infiles()\n");
+        return(PROGRAM_ERROR);
+    }
+    return allocate_filespace(dz);
+}
+
+/************************ COUNT_INFILES *********************/
+
+int count_infiles(int argc,char *argv[],dataptr dz)
+{
+    int files_to_skip = 1, diff;
+    int other_unflagged_items;
+//TW NEW CODE OK
+    if(dz->outfiletype != NO_OUTPUTFILE)
+        files_to_skip++;
+
+    argc -= files_to_skip;
+    argv += files_to_skip;
+    if(argc<0) {
+        sprintf(errstr,"Insufficient cmdline parameters.\n");
+        return(USAGE_ONLY);
+    }
+    other_unflagged_items = 0;
+    while(argc > 0) {         /* count all unflagged items after outfile */
+        if(*(argv[0])!='-' || !isalpha(argv[0][1]))
+            other_unflagged_items++;        /* options, variants, formants, and formant_qiksrch are flagged */
+        argc--;
+        argv++;
+    }
+    if(dz->application->special_data)   /* subtract any special data item : not flagged */  
+        other_unflagged_items--;
+    if((diff = other_unflagged_items - dz->application->param_cnt)<0) {
+        sprintf(errstr,"Insufficient cmdline parameters.\n");
+        return(USAGE_ONLY);
+    }
+    dz->infilecnt = diff + 1; /* i.e. plus first infile */
+    return(FINISHED);
+}
+
+/************************ COUNT_BUNDLE_FILES *********************/
+
+int count_bundle_files(int argc,char *argv[],dataptr dz)
+{
+    /*int files_to_skip = 1;*/
+    int orig_argc = argc;
+    if(argc<1) {
+        sprintf(errstr,"Insufficient cmdline parameters.\n");
+        return(USAGE_ONLY);
+    }
+    while(argc > 0) {
+        if(*(argv[0])=='-') {
+            sprintf(errstr,"Invalid flag or parameter on cmdline.\n");
+            return(DATA_ERROR);
+        }
+        argc--;
+        argv++;
+    }
+    dz->infilecnt = orig_argc - 1; /* i.e. minus outfile */
+    return(FINISHED);
+}
+
+/******************************* PUT_DEFAULT_VALS_IN_ALL_PARAMS **************************/
+
+void put_default_vals_in_all_params(dataptr dz)
+{
+    aplptr ap = dz->application;
+    int n;
+    for(n=0;n<ap->total_input_param_cnt;n++) {
+        dz->param[n]  = ap->default_val[n];
+        if(dz->is_int[n])
+            dz->iparam[n] = round(dz->param[n]);
+    }
+}
+
+/************************ MAKE_INITIAL_CMDLINE_CHECK *********************/
+
+int make_initial_cmdline_check(int *argc,char **argv[])
+{
+    int exit_status;
+    if(*argc<4) {       /* INITIAL CHECK OF CMDLINE OR PRE-CMDLINE DATA */
+        /*RWD May 2005*/
+        fprintf(stdout,"CDP Release 7.1 2016\n");
+        if((exit_status = usage(*argc,*argv))<0)
+            return(exit_status);
+    }
+    (*argv)++;
+    (*argc)--;
+    return(FINISHED);
+}
+
+/************************ TEST_APPLICATION_VALIDITY *********************/
+
+int test_application_validity(infileptr infile_info,int process,int *valid,dataptr dz)
+{
+    int exit_status;
+    int is_valid = valid_application(process,valid);
+
+    if((dz->process==REPITCH || process==REPITCHB) && is_a_text_input_filetype(infile_info->filetype) && is_valid) {
+        if((exit_status = exceptional_repitch_validity_check(&is_valid,dz))<0)
+            return(exit_status);
+    }
+    if(!is_valid) {                         /* GUI: invalid applics WON'T BE DISPLAYED on menus */
+        sprintf(errstr,"Application doesn't work with this type of infile.\n");
+        return(USAGE_ONLY);                 /* validity can be checked from dz->valid bitflags  */
+    }
+    return(FINISHED);
+}
+
+/************************ PARSE_INFILE_AND_HONE_TYPE *********************/
+
+int parse_infile_and_hone_type(char *filename,int *valid,dataptr dz)
+{
+    int exit_status;
+    infileptr infile_info;
+
+    if(!sloom) {
+        if((infile_info = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for infile structure to test TK data.");
+            return(MEMORY_ERROR);
+        }
+        if((exit_status = cdparse(filename,infile_info))<0)
+            return(exit_status);
+        if((exit_status = establish_application_validities(infile_info->filetype,infile_info->channels,valid))<0)
+            return(exit_status);
+        if((exit_status = test_application_validity(infile_info,dz->process,valid,dz))<0) 
+            return(exit_status);
+        if((exit_status = copy_parse_info_to_main_structure(infile_info,dz))<0)
+            return(exit_status);
+        free(infile_info);
+    }
+                    /* KNOWING POSSIBLE TYPE OF INFILE, AND TYPE NEEDED BY PROCESS, HONE TYPE */
+    if(is_a_text_input_filetype(dz->infile->filetype)) {
+        if((exit_status = redefine_textfile_types(dz))<0)
+            return(exit_status);
+    }
+    switch(dz->process) {
+    case(HOUSE_COPY):   case(HOUSE_CHANS):  case(HOUSE_EXTRACT):    case(HOUSE_SPEC):   case(HOUSE_BUNDLE):
+    case(HOUSE_SORT):   case(HOUSE_DISK):
+    case(HOUSE_GATE):
+        if((exit_status = do_housekeep_files(filename,dz))<0)
+            return(exit_status);
+        break;
+    case(INFO_TIMELIST):    case(MIXDUMMY):
+    case(INFO_LOUDLIST):
+    case(MIX_ON_GRID):
+    case(MIX_AT_STEP):  case(TOPNTAIL_CLICKS):
+    case(MAKE_VFILT):
+        dz->all_words = 0;
+        if((exit_status = store_filename(filename,dz))<0)
+            return(exit_status);
+        break;
+    case(MOD_LOUDNESS):
+        if(dz->mode==LOUDNESS_LOUDEST || dz->mode==LOUDNESS_EQUALISE) { 
+            dz->all_words = 0;
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(RANDCUTS): case(RANDCHUNKS):
+        if(!sloom) {
+            dz->all_words = 0;
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(REPITCH):  case(REPITCHB):
+        if(!is_a_text_input_filetype(dz->infile->filetype)) {
+            if((exit_status = check_repitch_type(dz))<0)
+                return(exit_status);
+        }
+        break;
+    }
+    if(anal_infiles) {
+        if((exit_status = set_chunklens_and_establish_windowbufs(dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/************************* SET_CHUNKLENS_AND_ESTABLISH_WINDOWBUFS **********************/
+
+int set_chunklens_and_establish_windowbufs(dataptr dz)
+{
+    int exit_status;
+    int n;
+    switch(dz->infile->filetype) {
+    case(ANALFILE):
+        dz->clength     = dz->wanted / 2;
+        dz->chwidth     = dz->nyquist/(double)(dz->clength-1);
+        dz->halfchwidth = dz->chwidth/2.0;
+
+        if((exit_status = float_array(&dz->amp,dz->clength))<0)       
+            return(exit_status);
+        if((exit_status = float_array(&dz->freq,dz->clength))<0)
+            return(exit_status);
+        break;
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+        dz->wanted      = dz->infile->origchans;
+        dz->clength     = dz->infile->origchans / 2;
+        dz->chwidth     = dz->nyquist/(double)(dz->clength-1);
+        dz->halfchwidth = dz->chwidth/2.0;
+
+        if((exit_status = float_array(&dz->amp,dz->clength))<0)       
+            return(exit_status);
+        if((exit_status = float_array(&dz->freq,dz->clength))<0)
+            return(exit_status);
+        break;
+    case(FORMANTFILE):
+        dz->wanted      = dz->infile->specenvcnt;
+        break;
+    }
+    for(n=0;n<dz->extra_bufcnt;n++) {
+        if((exit_status = float_array(&(dz->windowbuf[n]),dz->wanted))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/******************************** SETUP_FILE_OUTNAME_WHERE_NESS ************************
+*
+*   CMDLINE uses infilename as basis of outfilename(s)
+*   TK uses the default outfilename instead
+*/
+
+int setup_file_outname_where_ness(char *filename,dataptr dz)
+{
+    int exit_status;
+    switch(dz->process) {                   
+    case(RANDCUTS):                 
+    case(RANDCHUNKS):                   
+    case(HOUSE_CHANS):                  
+    case(EDIT_CUTMANY):
+    case(MANY_ZCUTS):
+    case(SYLLABS):
+    case(SHUDDER):
+    case(JOIN_SEQ):
+    case(JOIN_SEQDYN):
+    case(SYNTH_WAVE):   case(SYNTH_NOISE):  case(SYNTH_SIL):    case(CLICK):
+    case(ENV_CREATE):   case(ENV_EXTRACT):  case(MULTI_SYN):    
+    case(FORMANTS):     case(FMNTSEE):
+    case(P_SEE):        case(P_HEAR):
+    case(PVOC_ANAL):    case(PVOC_SYNTH):
+    case(P_SYNTH):      case(P_VOWELS):     case(ANALENV):
+    case(LEVEL):        case(ENVSYN):
+        dz->all_words = 0;                                  
+        if((exit_status = store_filename(filename,dz))<0)
+            return(exit_status);
+        break;
+    case(RRRR_EXTEND):
+        if(dz->mode == 2) {
+            dz->all_words = 0;                                  
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(HOUSE_COPY):
+        if(dz->mode == DUPL) {
+            dz->all_words = 0;                                  
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(HOUSE_EXTRACT):
+        if(dz->mode==HOUSE_CUTGATE) {
+            dz->all_words = 0;
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(HOUSE_SORT):
+        if((exit_status = store_further_filename(dz->all_words,filename,dz))<0)
+            return(exit_status);
+        break;
+    case(HF_PERM1):
+    case(HF_PERM2):
+        if(dz->mode == HFP_SNDSOUT) {
+            dz->all_words = 0;
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(SYNTH_SPEC):
+    case(TWIXT):
+    case(HOUSE_GATE):
+    case(TIME_GRID):
+    case(FORMSEE):
+    case(MAKE):
+        dz->all_words = 0;                                  
+        if((exit_status = store_filename(filename,dz))<0)
+            return(exit_status);
+        break;
+    case(MAKE_VFILT):                           
+        if((exit_status = store_further_filename(dz->all_words,filename,dz))<0)
+            return(exit_status);
+        break;
+    case(MOD_LOUDNESS):
+        if(dz->mode==LOUDNESS_LOUDEST || dz->mode==LOUDNESS_EQUALISE) { 
+            if((exit_status = store_further_filename(dz->all_words,filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(MOD_RADICAL):
+//TW Store outputfile name, for use with tempfile mechanism to avoic sndseek problems
+        if(dz->mode==MOD_LOBIT || dz->mode==MOD_LOBIT2) { 
+            dz->all_words = 0;
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+        }
+        break;
+    case(BRASSAGE): case(SAUSAGE):
+//TW Store outputfile name, for use with tempfile mechanism to avoic sndseek problems
+        dz->all_words = 0;
+        if((exit_status = store_filename(filename,dz))<0)
+            return(exit_status);
+        break;
+    }
+    return(FINISHED);
+}
+
+/****************************** SET_SPECIAL_PROCESS_SIZES *********************************/
+
+int set_special_process_sizes(dataptr dz)
+{
+    int maxsize, minsize;                                     
+    int n;
+    switch(dz->process) {
+    case(SUM):      /* progs where outsize is maximum of insizes */
+    case(MAX):
+        maxsize = dz->insams[0];
+        for(n=0;n<dz->infilecnt;n++)
+            maxsize = max(dz->insams[n],maxsize);
+        dz->wlength = maxsize/dz->wanted;        
+        break;
+    case(CROSS):    /* progs where outsize is minimum of insizes */
+    case(MEAN):     
+    case(VOCODE):   
+    case(LEAF):
+        minsize = dz->insams[0];
+        for(n=1;n<dz->infilecnt;n++)
+            minsize = min(dz->insams[n],minsize);
+        dz->wlength = minsize/dz->wanted;
+        break;
+    }
+    return(FINISHED);
+}
+
+/************************ COPY_PARSE_INFO_TO_MAIN_STRUCTURE *********************/
+
+int copy_parse_info_to_main_structure(infileptr infile_info,dataptr dz)
+{
+
+    if(dz->infilecnt < 1 ||  dz->insams==NULL) {
+        sprintf(errstr,"Attempt to use file arrays before allocated: copy_parse_info_to_main_structure()\n");
+        return(PROGRAM_ERROR);
+    }
+    dz->infile->filetype    = infile_info->filetype;
+    /*dz->infilesize[0]     = infile_info->infilesize;*/
+    dz->insams[0]           = infile_info->insams;
+    dz->infile->srate       = infile_info->srate;
+    dz->infile->channels    = infile_info->channels;
+    dz->infile->stype       = infile_info->stype;
+    dz->infile->origstype   = infile_info->origstype;
+    dz->infile->origrate    = infile_info->origrate;
+    dz->infile->Mlen        = infile_info->Mlen;
+    dz->infile->Dfac        = infile_info->Dfac;
+    dz->infile->origchans   = infile_info->origchans;       
+    dz->infile->specenvcnt  = infile_info->specenvcnt;
+    dz->specenvcnt          = infile_info->specenvcnt;
+    dz->wanted              = infile_info->wanted;
+    dz->wlength             = infile_info->wlength;
+    dz->out_chans           = infile_info->out_chans;
+    dz->descriptor_samps    = infile_info->descriptor_samps;   /*RWD ???? */
+    dz->is_transpos         = infile_info->is_transpos;
+    dz->could_be_transpos   = infile_info->could_be_transpos;
+    dz->could_be_pitch      = infile_info->could_be_pitch;
+    dz->different_srates    = infile_info->different_srates;
+    dz->duplicate_snds      = infile_info->duplicate_snds;
+    dz->numsize             = infile_info->numsize;
+    dz->linecnt             = infile_info->linecnt;
+    dz->all_words           = infile_info->all_words;
+    dz->infile->arate       = infile_info->arate;
+    dz->frametime           = infile_info->frametime;
+    dz->infile->window_size = infile_info->window_size;
+    dz->nyquist             = infile_info->nyquist;
+    dz->duration            = infile_info->duration;
+    dz->minbrk              = infile_info->minbrk;
+    dz->maxbrk              = infile_info->maxbrk;
+    dz->minnum              = infile_info->minnum;
+    dz->maxnum              = infile_info->maxnum;
+    if(dz->process==MIXDUMMY || dz->process==HOUSE_BUNDLE || dz->process==HOUSE_SORT 
+    || dz->process==MIX_ON_GRID  || dz->process==ADDTOMIX     || dz->process==MIX_AT_STEP 
+    || dz->process==BATCH_EXPAND || dz->process==MIX_MODEL)
+        return FINISHED;
+
+    return setup_brktablesizes(infile_info,dz);
+}
+
+/************************ ALLOCATE_FILESPACE *********************/
+
+int allocate_filespace(dataptr dz)
+{
+    int n;
+    int zerofiles = 0;          
+/* BELOW CHANGED FROM < 0: JAN 2000 */
+    if(dz->infilecnt <= 0) {
+        zerofiles = 1;
+        dz->infilecnt = 1;   /* always want to allocate pointers */
+    }
+    /*
+    if((dz->infilesize = (int *)malloc(dz->infilecnt * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for infilesize array.\n");
+        return(MEMORY_ERROR);
+    }
+    */
+    if((dz->insams = (int *)malloc(dz->infilecnt * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for infile-sampsize array.\n");
+        return(MEMORY_ERROR);
+    }                   
+    if((dz->ifd = (int *)malloc(dz->infilecnt * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for infile poniters array.\n");
+        return(MEMORY_ERROR);
+    }                   
+    for(n=0;n<dz->infilecnt;n++) {
+        dz->ifd[n]        = -1;
+        dz->insams[n]     = 0L;
+        /*dz->infilesize[n] = 0L;*/
+    }
+    if(zerofiles)
+        dz->infilecnt = 0;
+    return(FINISHED);
+}
+
+/************************ HANDLE_EXTRA_INFILES *********************/
+
+int handle_extra_infiles(char ***cmdline,int *cmdlinecnt,dataptr dz)
+{
+                    /* OPEN ANY FURTHER INFILES, CHECK COMPATIBILITY, STORE DATA AND INFO */
+    int  exit_status;
+    int  n, k = 0;
+    char *filename;
+
+    if(dz->process == ADDTOMIX || dz->process == BATCH_EXPAND || dz->process == MIX_MODEL)
+        k = dz->all_words - 1;
+
+    if(dz->infilecnt > 1) {
+        for(n=1;n<dz->infilecnt;n++) {
+            filename = (*cmdline)[0];
+            switch(dz->process) {
+            case(ADDTOMIX):
+            case(BATCH_EXPAND):
+            case(MIX_MODEL):
+                if((exit_status = store_further_filename(n+k,filename,dz))<0)
+                    return(exit_status);
+                if((exit_status = handle_other_infile(n,filename,dz))<0)
+                    return(exit_status);
+                break;
+            case(MIX_ON_GRID):
+            case(MIX_AT_STEP):
+                if((exit_status = store_further_filename(n,filename,dz))<0)
+                    return(exit_status);
+                break;
+
+            case(HOUSE_BUNDLE):
+            case(MIXDUMMY):
+                if((exit_status = store_further_filename(n,filename,dz))<0)
+                    return(exit_status);
+                break;
+            case(INFO_TIMELIST):
+            case(INFO_LOUDLIST):
+                if((exit_status = store_further_filename(n,filename,dz))<0)
+                    return(exit_status);
+                if((exit_status = handle_other_infile(n,filename,dz))<0)
+                    return(exit_status);
+                break;
+            case(MOD_LOUDNESS):
+                if(dz->mode==LOUDNESS_LOUDEST || dz->mode==LOUDNESS_EQUALISE) { 
+                    if((exit_status = store_further_filename(n,filename,dz))<0)
+                        return(exit_status);
+                }
+                if((exit_status = handle_other_infile(n,filename,dz))<0)
+                    return(exit_status);
+                break;
+            default:
+                if((exit_status = handle_other_infile(n,filename,dz))<0)
+                    return(exit_status);
+                break;
+            }
+            (*cmdline)++;
+            (*cmdlinecnt)--;
+        }
+        if((exit_status = set_special_process_sizes(dz))<0)
+            return(exit_status);
+    }
+    if(dz->process == BATCH_EXPAND || dz->process == MIX_MODEL)
+        dz->itemcnt = dz->infilecnt - 1;
+    return(FINISHED);
+}
+
+/************************ HANDLE_OUTFILE *********************/
+/* RWD I have a theory: this could be split into two functions where indicated:
+ *  handle_outfile_name()
+ * and handle_outfile()
+ * and then handle_outfile() can be relocated at the end of param_preprocess(), 
+ * wher it belongs; and all these tests can be eliminated!
+ */
+/************************ HANDLE_OUTFILE *********************/
+
+int handle_outfile(int *cmdlinecnt,char ***cmdline,int is_launched,dataptr dz)
+{
+    int exit_status;
+    char *filename = NULL;
+    char *filename2;
+    int n;
+
+    int look_for_float_flag = 0;
+    if(dz->outfiletype==NO_OUTPUTFILE) {
+
+        /* Look at all those "NO_OUTPUTFILE" processes which actually give a sound output (!!! it's a int story!) */
+        /* Some of these processes have NO output file name in the cmdline situation but DO have an outfilename in SLOOM */
+        /* as all SLOOM processes have an outfilename */
+
+        if(sloom) {
+            if (dz->process == RANDCUTS
+            ||  dz->process == RANDCHUNKS
+            ||  dz->process == HOUSE_CHANS
+            || (dz->process == HOUSE_EXTRACT && dz->mode == HOUSE_CUTGATE)) {
+                look_for_float_flag = 1;
+            }
+        }
+        /* Some of these processes DO have an output file name in the cmdline situation (and, as always, in SLOOM) */
+
+        if (dz->process == MIXINBETWEEN
+        ||  dz->process == CYCINBETWEEN
+        ||  dz->process == SYNTH_SPEC
+        ||  dz->process == HOUSE_GATE
+        || (dz->process == HF_PERM1 && dz->mode == HFP_SNDSOUT)
+        || (dz->process == HF_PERM2 && dz->mode == HFP_SNDSOUT)) {
+            look_for_float_flag = 1;
+        }
+    } else if(dz->outfiletype == SNDFILE_OUT) {
+
+        /* Look at all processes with a SOUNDFILE output: all such processes have an output file name in the cmdline */     
+        
+        look_for_float_flag = 1;
+    }
+    if(look_for_float_flag) {
+
+        /* For all these cases, check if the output file is flagged as float, and strip any flag */
+        
+        if(!sloom && (*cmdlinecnt<=0)) {
+            sprintf(errstr,"Insufficient cmdline parameters.\n");
+            return(USAGE_ONLY);
+        }
+        filename = (*cmdline)[0];
+        if(filename[0]=='-' && filename[1]=='f') {
+            dz->floatsam_output = 1;
+            dz->true_outfile_stype = SAMP_FLOAT;
+            filename+= 2;
+        }
+    }
+    if(dz->outfiletype==NO_OUTPUTFILE) {
+
+        /* These processes generate an output which is NOT a soundfile, and hence have an output file name on the cmd line */
+
+        if(dz->process == MAKE_VFILT
+        || (dz->process == MOD_PITCH && (dz->mode == MOD_TRANSPOS_INFO || dz->mode == MOD_TRANSPOS_SEMIT_INFO))) {
+            if(!sloom && (*cmdlinecnt<=0)) {
+                sprintf(errstr,"Insufficient cmdline parameters.\n");
+                return(USAGE_ONLY);
+            }
+            filename = (*cmdline)[0];
+            if(filename[0]=='-' && filename[1]=='f') {
+                sprintf(errstr,"-f flag used incorrectly on command line (output is not a sound file).\n");
+                return(USAGE_ONLY);
+            }
+        }
+    }
+    if (!sloom) {
+        if(dz->process == MAKE) {
+            if((filename = (*cmdline)[0]) == NULL) {
+                return(USAGE_ONLY);
+            }
+        }
+        if(dz->process == MAKE || dz->process == FORMSEE) {
+            if((exit_status = setup_file_outname_where_ness(filename,dz))<0) {    
+                print_messages_and_close_sndfiles(exit_status,is_launched,dz);  
+                return(exit_status);
+            }
+        }
+        if (dz->process == MAKE) {
+            if((filename = get_other_filename_x(filename,'1')) == NULL) {
+                sprintf(errstr,"Insufficient memory to store modified outfilename.\n");
+                return MEMORY_ERROR;
+            }
+        }
+    }
+    /* in all these cases we wish to remember the name of the output filename from the cmdline */
+
+    if(dz->process == ANALENV
+    || dz->process == BRASSAGE
+    || dz->process == CLICK
+    || dz->process == EDIT_CUTMANY 
+    || dz->process == MANY_ZCUTS 
+    || dz->process == ENV_CREATE 
+    || dz->process == ENV_EXTRACT
+    || dz->process == FMNTSEE      
+    || dz->process == FORMANTS   
+    || ((dz->process == FORMSEE) && sloom)
+    || dz->process == HF_PERM1
+    || dz->process == HF_PERM2
+    || dz->process == JOIN_SEQ 
+    || dz->process == JOIN_SEQDYN
+    || dz->process == LEVEL
+    || ((dz->process == MAKE) && sloom)
+    || dz->process == P_HEAR
+    || dz->process == P_SEE      
+    || dz->process == P_SYNTH    
+    || dz->process == P_VOWELS 
+    || dz->process == PVOC_ANAL  
+    || dz->process == PVOC_SYNTH
+    || dz->process == SAUSAGE 
+    || dz->process == SHUDDER 
+    || dz->process == SYLLABS
+    || dz->process == SYNTH_NOISE 
+    || dz->process == SYNTH_WAVE 
+    || dz->process == MULTI_SYN
+    || dz->process == SYNTH_SIL 
+    || dz->process == TIME_GRID 
+    || dz->process == TWIXT
+    || dz->process == ENVSYN
+    || (dz->process == RRRR_EXTEND && dz->mode == 2) 
+    || (dz->process == MOD_RADICAL && (dz->mode == MOD_LOBIT || dz->mode == MOD_LOBIT2))) {
+
+        /* all processes with a SOUNDFILE output have already been checked, so any outfiles found here must be NON soundfiles */
+        
+        if(filename == NULL) {
+            if(!sloom && (*cmdlinecnt<=0)) {
+                sprintf(errstr,"Insufficient cmdline parameters.\n");
+                return(USAGE_ONLY);
+            }
+            filename = (*cmdline)[0];
+
+            if(filename[0]=='-' && filename[1]=='f') {
+                sprintf(errstr,"-f flag used incorrectly on command line (output is not a sound file).\n");
+                return(USAGE_ONLY);
+            }
+        }       
+        if((exit_status = setup_file_outname_where_ness(filename,dz))<0) {    
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);  
+            return(exit_status);
+        }
+    }
+    if (!sloom) {
+        if (dz->process==SHUDDER || dz->process == BRASSAGE || dz->process == SAUSAGE || dz->process == FORMSEE) {
+            if((filename = get_other_filename_x(filename,'1')) == NULL) {
+                sprintf(errstr,"Insufficient memory to store modified outfilename.\n");
+                return MEMORY_ERROR;
+            }
+            if((n = sndopenEx(dz->wordstor[0],0,CDP_OPEN_RDONLY)) >= 0) {
+                sprintf(errstr,"Output file %s already exists",dz->wordstor[0]);
+                if(sndcloseEx(n) < 0)
+                    strcat(errstr,": Cannot close the file.");
+                strcat(errstr,"\n");
+                return(GOAL_FAILED);
+            }
+        }
+    }
+    if(sloom) {
+
+        /* ALL sound loom processes have an output filename: so get it, if not already found */
+
+        if(filename == NULL)
+            filename = (*cmdline)[0];
+
+        /* These cases, on the soundloom , have ANALFILE & PITCHFILE output, and need to save or use outfilename as basis for additional outfile names */
+
+        if(dz->process==PITCH || dz->process==TRACK) {
+            dz->all_words = 0;
+            if((exit_status = store_filename(filename,dz))<0)
+                return(exit_status);
+            if((exit_status = do_extra_files(dz)) != FINISHED)
+                return(exit_status); 
+        }
+        if(dz->process==HOUSE_COPY && dz->mode == DUPL) {
+            if((exit_status = setup_file_outname_where_ness(filename,dz))<0) {    
+                print_messages_and_close_sndfiles(exit_status,is_launched,dz);  
+                return(exit_status);
+            }
+        }
+    }
+
+    if(dz->outfiletype==NO_OUTPUTFILE) {
+
+        /* in these cases also, we wish to remember the name of the output file name on the cmdline. */
+        /* In non-soundloom case, some programs use the input filename to generate the outfilename,  */
+        /* whereas Sound Loom ALWAYS has an outfilename which can be used.                           */
+
+        if(sloom) {
+            if(dz->process == MIXINBETWEEN || dz->process == CYCINBETWEEN) {
+                if((exit_status = read_new_filename(filename,dz))<0)
+                    return(exit_status);            /* read outfile as if it were special data */
+            } else if(dz->process != HF_PERM1 && dz->process != HF_PERM2) {
+                if((exit_status = setup_file_outname_where_ness(filename,dz))<0)
+                    return(exit_status);
+            }
+        } else {
+            if(dz->process == MIXINBETWEEN || dz->process == CYCINBETWEEN) {
+                if(file_has_invalid_startchar(filename)) {
+                    sprintf(errstr,"Filename %s has invalid start character(s)\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((exit_status = read_new_filename(filename,dz))<0)
+                    return(exit_status);            /* read outfile as if it were special data */
+            }
+
+            if(dz->process == SYNTH_SPEC || dz->process == MAKE_VFILT) {
+                if(file_has_invalid_startchar(filename)) {
+                    sprintf(errstr,"Filename %s has invalid start character(s)\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((exit_status = setup_file_outname_where_ness(filename,dz))<0)
+                    return(exit_status);
+            }
+        }
+    } else {
+
+        /* all other processes have an outputfile but not a sound outputfile (these were checked previously) */
+        /* so, if a filename does not yet exist, get it from the cmdline */
+        /* (all sloom outfilenames have already been read) */
+            
+        if(filename == NULL) {
+            if(*cmdlinecnt<=0) {
+                sprintf(errstr,"Insufficient cmdline parameters.\n");
+                return(USAGE_ONLY);
+            }
+            filename = (*cmdline)[0];
+            if(filename[0]=='-' && filename[1]=='f') {
+                sprintf(errstr,"-f flag used incorrectly on command line (output is not a sound file).\n");
+                return(USAGE_ONLY);
+            }
+            if(file_has_invalid_startchar(filename) || value_is_numeric(filename)) {
+                sprintf(errstr,"Outfile name %s has invalid start character(s) or looks too much like a number.\n",filename);
+                return(DATA_ERROR);
+            }
+        }
+    }
+
+    //TW mechanics to setup sloom (and cmdline) compatible temp file: + normal usage SHUDDER
+
+    if(sloom) {
+        if (dz->process==SHUDDER || dz->process == BRASSAGE || dz->process == SAUSAGE || dz->process == FORMSEE
+        || dz->process == MAKE)
+            get_other_filename(filename,'1');
+    }
+
+// DEC 2009 FIX
+//  if(dz->process==HOUSE_BUNDLE || dz->process==INFO_DIFF /* || (sloom && dz->process==PITCH)  */
+    if(dz->process==HOUSE_BUNDLE 
+    || dz->process==HOUSE_DUMP
+    || (dz->process == MOD_LOUDNESS && dz->mode == LOUDNESS_EQUALISE)) {
+        if((exit_status = store_further_filename(dz->all_words,filename,dz))<0)
+            return(exit_status);
+    }
+
+    if(!sloom) {
+        if(dz->process == EDIT_CUTMANY || dz->process == SYLLABS || dz->process == MANY_ZCUTS) {
+            n = strlen(filename);
+            if ((filename2 = (char *)malloc(n+2))==NULL) {
+                sprintf(errstr,"Insufficient memory to store output filename.\n");
+                return(MEMORY_ERROR);
+            }
+            strcpy(filename2,filename);
+            insert_new_number_at_filename_end(filename2,1,0);
+            filename = filename2;
+        }
+    }
+
+    /* EXCEPT IN THOSE CASES WHERE outfile creation has to be delayed, create the outfile NOW */
+
+    if(!(
+       dz->process == SYNTH_WAVE 
+    || (!sloom && dz->process == HOUSE_COPY && dz->mode == DUPL)
+    || dz->process == MULTI_SYN
+    || dz->process == SYNTH_NOISE 
+    || dz->process == SYNTH_SPEC 
+    || dz->process == SYNTH_SIL
+    || dz->process == HOUSE_SPEC
+    || dz->process == HOUSE_CHANS
+    || dz->process == MIXINTERL
+    || (dz->process >= SIMPLE_TEX  && dz->process <= TMOTIFSIN)
+    || (dz->process == MOD_SPACE   && dz->mode == MOD_PAN)
+    || (dz->process == MOD_REVECHO && dz->mode == MOD_STADIUM)
+    || (dz->process == BRASSAGE    && dz->mode == GRS_REVERB)
+    || (dz->process == BRASSAGE    && dz->mode == GRS_BRASSAGE)
+    || (dz->process == BRASSAGE    && dz->mode == GRS_FULL_MONTY)
+    || dz->process == SAUSAGE
+    || (dz->process == MIXMAX      && dz->mode == MIX_LEVEL_ONLY)
+    || dz->process == AUTOMIX
+    || dz->process == MIX
+    || dz->process == MIXTWO
+    || dz->process == ENV_EXTRACT
+    || dz->process == ENV_CREATE    
+    || dz->process == ENV_BRKTOENV
+    || dz->process == ENV_DBBRKTOENV
+    || dz->process == FORMANTS
+    || dz->process == FMNTSEE
+    || dz->process == FORMSEE
+    || dz->process == P_SEE
+    || dz->process == P_HEAR
+    || dz->process == PVOC_ANAL
+    || dz->process == PVOC_SYNTH
+    || dz->process == P_SYNTH
+    || dz->process == P_VOWELS
+    || dz->process == ANALENV
+    || dz->process == LEVEL
+    || (dz->process == HF_PERM1 && (dz->mode == HFP_SNDOUT || dz->mode == HFP_SNDSOUT))
+    || (dz->process == HF_PERM2 && (dz->mode == HFP_SNDOUT || dz->mode == HFP_SNDSOUT))
+    || dz->process == DEL_PERM
+    || dz->process == P_GEN
+    || dz->process == CLICK
+    || dz->process == MIXINBETWEEN
+    || dz->process == CYCINBETWEEN
+    || dz->process == SCALED_PAN
+    || (dz->process == HOUSE_EXTRACT && dz->mode == HOUSE_CUTGATE)
+    || dz->process == HOUSE_GATE
+    || dz->process == HOUSE_SORT
+//NEW DEC 2010
+    || dz->process == TIME_GRID
+    /* and those cases where there really is no outfile */
+    ||  (( dz->process == ENV_WARPING 
+        || dz->process == ENV_REPLOTTING  
+        || dz->process == ENV_RESHAPING) && dz->mode == ENV_PEAKCNT)
+    || (dz->process == MOD_LOUDNESS && dz->mode == LOUDNESS_LOUDEST)
+    || (dz->process == MOD_PITCH && (dz->mode == MOD_TRANSPOS_SEMIT_INFO || dz->mode == MOD_TRANSPOS_INFO))
+    || (dz->process == TSTRETCH && dz->mode == TSTR_LENGTH)
+    || dz->process == GRAIN_ASSESS
+    || dz->process == GRAIN_COUNT
+    || dz->process == DISTORT_CYCLECNT
+    || dz->process == FIND_PANPOS
+    || dz->process == INFO_PROPS
+    || dz->process == INFO_SFLEN
+    || (dz->process == INFO_TIMELIST && !sloom)
+    || dz->process == INFO_TIMESUM
+    || dz->process == INFO_TIMEDIFF
+    || dz->process == INFO_SAMPTOTIME
+    || dz->process == INFO_TIMETOSAMP
+    || dz->process == INFO_MAXSAMP
+    || dz->process == INFO_MAXSAMP2
+    || dz->process == INFO_LOUDCHAN
+    || dz->process == INFO_FINDHOLE
+    || dz->process == INFO_DIFF
+    || dz->process == INFO_CDIFF
+    || dz->process == INFO_MUSUNITS
+    || dz->process == WINDOWCNT
+    || dz->process == CHANNEL
+    || dz->process == FREQUENCY
+    || dz->process == P_INFO
+    || dz->process == P_ZEROS
+    || dz->process == ZCROSS_RATIO
+    || dz->process == MAKE_VFILT
+    || dz->process == RANDCHUNKS
+    || dz->process == RANDCUTS
+    || dz->process == ENVSYN
+    )) {
+        if((exit_status = create_sized_outfile(filename,dz))<0)
+            return(exit_status);
+    } 
+    /* if an outfile name has been read, copy it to dz->outfilename and advance along the cmdline */
+
+    if(filename != NULL) {
+    /*RWD.7.98 - mainly for SYNTH */
+    //TW also for MIX programs ETC so may as well do it universally
+        strcpy(dz->outfilename,filename);      
+        (*cmdline)++;
+        (*cmdlinecnt)--;
+    }
+    return(FINISHED);
+}
+
+/****************************** PRINT_MESSAGES_AND_CLOSE_SNDFILES ******************************/
+
+int print_messages_and_close_sndfiles(int exit_status,int is_launched,dataptr dz)
+{
+    int n;                          /* OUTPUT ERROR MESSAGES */
+    switch(exit_status) {
+    case(FINISHED):     break;
+    case(PROGRAM_ERROR):    
+        fprintf(stdout,"ERROR: INTERNAL ERROR: (Bug?)\n");
+        splice_multiline_string(errstr,"ERROR:");
+        break;
+    case(SYSTEM_ERROR):     
+        fprintf(stdout,"ERROR: SYSTEM ERROR\n");
+        splice_multiline_string(errstr,"ERROR:");
+        break;
+    case(MEMORY_ERROR):     
+        fprintf(stdout,"ERROR: MEMORY ERROR\n");
+        splice_multiline_string(errstr,"ERROR:");
+        break;
+    case(USER_ERROR):       
+        if(sloom) {
+            fprintf(stdout,"ERROR: DATA OR RANGE ERROR\n");
+            splice_multiline_string(errstr,"ERROR:");
+        } else {
+            fprintf(stdout,"ERROR: INCORRECT USE\n");
+            splice_multiline_string(errstr,"ERROR:");
+        }
+        break;
+    case(DATA_ERROR):       
+        fprintf(stdout,"ERROR: INVALID DATA\n");
+        splice_multiline_string(errstr,"ERROR:");
+        break;
+    case(GOAL_FAILED):      
+        fprintf(stdout,"ERROR: CANNOT ACHIEVE TASK:\n");
+        splice_multiline_string(errstr,"ERROR:");
+        break;
+    case(USAGE_ONLY):
+        if(sloom) {
+            fprintf(stdout,"ERROR: PROGRAM ERROR: usage messages should not be called.\n");
+            fflush(stdout);
+        } else
+            fprintf(stdout,"%s",errstr);                                
+        break;
+    case(TK_USAGE):         
+        if(!sloom)
+            fprintf(stdout,"ERROR: PROGRAM ERROR: TK usage messages should not be called.\n");
+        else
+            exit_status = FINISHED;
+        break;
+    default:
+        fprintf(stdout,"ERROR: INTERNAL ERROR: (Bug?)\n");
+        fprintf(stdout,"ERROR: Unknown case in print_messages_and_close_sndfiles)\n");
+        exit_status = PROGRAM_ERROR;
+        break;
+    }
+    if(dz != NULL) {                /* CLOSE (& DELETE) SNDFILES */
+        if(dz->ofd >= 0 && (exit_status!=FINISHED || !is_launched) && sndunlink(dz->ofd) < 0)
+            fprintf(stdout, "ERROR: Can't set output soundfile for deletion.\n");
+        if((dz->ofd >= 0) && dz->needpeaks){
+            if(sndputpeaks(dz->ofd,dz->outchans,dz->outpeaks)) {
+                fprintf(stdout,"WARNING: failed to write PEAK data\n");
+                fflush(stdout);
+            }
+        }
+//      if(dz->ofd >= 0  && sndcloseEx(dz->ofd) < 0) {
+//          fprintf(stdout, "WARNING: Can't close output sf-soundfile : %s\n",sferrstr());
+//          fflush(stdout);
+//      }
+
+        if(dz->ofd >= 0) {
+            if(sndcloseEx(dz->ofd) < 0) {
+                fprintf(stdout, "WARNING: Can't close output sf-soundfile : %s\n",sferrstr());
+                fflush(stdout);
+            }
+        }
+        if(dz->other_file >= 0 && exit_status!=FINISHED && sndunlink(dz->other_file) < 0) {
+            fprintf(stdout, "ERROR: Can't set secondary soundfile for deletion.\n");
+            fflush(stdout);
+        }
+        if((dz->other_file >= 0) && dz->needotherpeaks){
+            if(sndputpeaks(dz->other_file,dz->otheroutchans,dz->otherpeaks)) {
+                fprintf(stdout,"WARNING: failed to write PEAK data\n");
+                fflush(stdout);
+            }
+        }
+        if(dz->other_file >= 0  && sndcloseEx(dz->other_file) < 0)
+            fprintf(stdout, "WARNING: Can't close secondary soundfile.\n");
+        if(dz->ifd != NULL && dz->infilecnt >= 0) {
+            for(n=0;n<dz->infilecnt;n++) {
+              /* ALL OTHER CASES */
+                if(dz->ifd[n] >= 0 && sndcloseEx(dz->ifd[n]) < 0)
+                    fprintf(stdout, "WARNING: Can't close input sf-soundfile %d.\n",n+1);
+            }
+        }
+    }
+//  sffinish();
+    if(sloom)
+        fprintf(stdout,"END:");
+    else
+#ifdef unix
+        fprintf(stdout,"\n\n");
+#else
+        fprintf(stdout,"\n");   
+#endif
+    fflush(stdout);
+    if(exit_status != FINISHED) {
+        return(FAILED);
+    }
+    return(SUCCEEDED);
+}
+
+/****************************** DO_EXTRA_FILES *********************************/
+
+int do_extra_files(dataptr dz)
+{
+    char temp[200];
+    int endword = dz->all_words - 1;
+    strcpy(temp,dz->wordstor[endword]);
+//TW REVISION Dec 2002
+//  p = temp + strlen(temp) - 1;
+//  sprintf(p,"1");
+    insert_new_number_at_filename_end(temp,1,1);
+    switch(dz->mode) {
+    case(PICH_TO_BIN):
+//TW CORRECTED Dec 2002
+        if((dz->other_file = sndcreat_formatted(temp,dz->insams[0]/dz->wanted,SAMP_FLOAT,
+        1,dz->infile->srate,CDP_CREATE_NORMAL)) < 0) {
+            sprintf(errstr,"Cannot open output pitch file %s\n",temp);
+            return(DATA_ERROR);
+        }
+        break;
+    case(PICH_TO_BRK):        
+        strip_ext(temp);
+        if((dz->fp = fopen(temp,"w"))==NULL) {
+            sprintf(errstr,"Cannot open file %s for output.\n",temp);
+            return(DATA_ERROR);
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown mode.\n");
+        return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/******************************* CREATE_SIZED_OUTFILE **************************/
+
+int create_sized_outfile(char *filename,dataptr dz)
+{
+    int maxsize, minsize;
+    int exit_status, n, orig_chans = 1;
+    int stype = SAMP_FLOAT;
+
+    switch(dz->process) {
+    case(PVOC_ANAL):
+        dz->true_outfile_stype = stype;
+        dz->outfilesize = -1;
+        break;
+    case(PVOC_SYNTH):   case(PVOC_EXTRACT):
+        if(dz->floatsam_output != 1)
+            stype = dz->outfile->stype;
+//NOV 2005: proposed RWD fix, changes above line to PVOC
+//          stype = dz->outfile->stype;
+        dz->true_outfile_stype = stype;
+        dz->outfilesize = -1;
+        break;
+    case(SYNTH_SPEC):   
+        dz->outfilesize = -1;
+        break;
+    default:
+        switch(dz->process_type) {
+        case(EQUAL_SNDFILE):
+            /*RWD May 2005 */
+#ifdef NOTDEF
+            if(dz->floatsam_output != 1)
+                stype = SAMP_SHORT;
+            else
+                stype = dz->infile->stype;
+            dz->true_outfile_stype = stype;     
+#else
+            if(dz->infile->stype < 0)       /* if no infile, default to shorts */
+                dz->infile->stype = SAMP_SHORT;
+            if(dz->floatsam_output != 1)
+                stype = dz->infile->stype;     /* keep infile stype for outfile */
+            else 
+               stype = SAMP_FLOAT;             /* or force floats */
+            dz->true_outfile_stype = stype;
+
+#endif
+            dz->outfilesize = dz->insams[0];           /* RWD watch this... */
+            break;
+        case(EQUAL_ENVFILE):
+        case(EQUAL_ANALFILE):   case(PITCH_TO_PITCH):
+            stype = dz->infile->stype;
+            dz->true_outfile_stype = stype;     
+            dz->outfilesize = dz->insams[0];           /* RWD watch this... */
+            break;
+        case(CREATE_ENVFILE):
+            dz->infile->channels = 1;
+            /* fallthro */
+        case(EXTRACT_ENVFILE):  case(UNEQUAL_ENVFILE):
+        case(BIG_ANALFILE):     case(PITCH_TO_BIGPITCH):
+            dz->true_outfile_stype = stype;
+            dz->outfilesize = -1;
+            break;
+        case(ANAL_TO_FORMANTS):
+        case(EQUAL_FORMANTS):
+            dz->true_outfile_stype = stype;
+/*
+DO FORMANT FILES HAVE TO HAVE ONE CHANNEL ????? YES
+*/
+            dz->outfilesize = -1;
+// COMMENT dz->infile->channels (MUST BE/IS) set to correct outval, then reset, external to this call
+            break;
+        case(PITCH_TO_ANAL):
+            dz->true_outfile_stype = stype;
+            dz->outfilesize = -1;
+// This reset of infile->channels is for the benefit of MAKE & MAKE2: reset is below
+            orig_chans = dz->infile->channels;
+            dz->infile->channels = dz->infile->origchans;
+            break;
+        case(UNEQUAL_SNDFILE):
+/*RWD May 2005 this code back to front! */
+#ifdef NOTDEF
+            if(dz->floatsam_output!=1)
+                stype = SAMP_SHORT;
+            else
+                stype = dz->infile->stype;
+            dz->true_outfile_stype = stype;
+            dz->outfilesize = -1;
+#else
+            if(dz->infile->stype < 0)       /* if no infile, default to shorts */
+                dz->infile->stype = SAMP_SHORT;
+            if(dz->floatsam_output!=1)
+                stype = dz->infile->stype;   /* outfile has infile sample type */
+            else
+                stype = SAMP_FLOAT;
+            dz->true_outfile_stype = stype;  /* or floats if asked for */
+            dz->outfilesize = -1;
+
+
+#endif
+            break;
+        case(PSEUDOSNDFILE):
+            dz->true_outfile_stype = SAMP_SHORT;
+            dz->outfilesize = -1;
+// COMMENT dz->infile->channels (MUST BE/IS) set to correct outval, then reset, external to this call
+            break;
+        case(MAX_ANALFILE):
+            maxsize = dz->insams[0];
+            for(n=1;n<dz->infilecnt;n++)
+                maxsize = max(maxsize,dz->insams[n]);
+            dz->outfilesize = maxsize;
+            break;
+        case(MIN_ANALFILE):
+            minsize = dz->insams[0];
+            for(n=1;n<dz->infilecnt;n++)
+                minsize = min(minsize,dz->insams[n]);
+            dz->outfilesize = minsize;
+            break;
+        case(PITCH_TO_PSEUDOSND):
+            dz->outfilesize = dz->wlength;         /* RWD watch this... */
+// COMMENT dz->infile->channels (MUST BE/IS) set to correct outval, then reset, external to this call
+            break;
+        case(TO_TEXTFILE):
+            if(file_has_reserved_extension(filename)) {
+                sprintf(errstr,"Cannot open a textfile (%s) with a reserved extension.\n",filename);
+                return(USER_ERROR);
+            }
+            if((dz->fp = fopen(filename,"w"))==NULL) {
+                sprintf(errstr,"Cannot open output file %s\n",filename);
+                return(USER_ERROR);
+            }
+            return FINISHED;
+        default:
+            sprintf(errstr,"Invalid process_type %d: create_sized_outfile()\n",dz->process_type);
+            return(PROGRAM_ERROR);
+        }       
+        break;
+    }
+
+    /* RWD April 2005 write WAVE_EX if possible! */
+    /*TODO: read channel format from input, somewhere into dz*/
+    if(dz->outfiletype== SNDFILE_OUT && (dz->infile->channels > 2 || stype > SAMP_FLOAT)){
+        SFPROPS props, inprops;
+        dz2props(dz,&props);
+        props.chans = dz->infile->channels;
+        props.srate = dz->infile->srate;
+        if(dz->ifd && dz->ifd[0] >=0) {
+            if(snd_headread(dz->ifd[0], &inprops))    /* snd_getchanformat not working ...*/
+                props.chformat = inprops.chformat;
+        }
+#ifdef _DEBUG
+        printf("DEBUG: writing WAVE_EX outfile\n");
+#endif
+
+        dz->ofd = sndcreat_ex(filename,dz->outfilesize,&props,SFILE_CDP,CDP_CREATE_NORMAL); 
+        if(dz->ofd < 0){
+            sprintf(errstr,"Cannot open output file %s\n", filename);
+            return(DATA_ERROR);
+        }
+    }
+    else{
+        if((dz->ofd = sndcreat_formatted(filename,dz->outfilesize,stype,
+                dz->infile->channels,dz->infile->srate,CDP_CREATE_NORMAL)) < 0) {
+            sprintf(errstr,"Cannot open output file %s\n", filename);
+            return(DATA_ERROR);
+        }
+    }
+    dz->outchans = dz->infile->channels;
+    if((exit_status = establish_peak_status(dz))<0)
+        return(exit_status);
+    switch(dz->process_type) {
+    case(PITCH_TO_ANAL):        /* RESET, See above */
+        dz->infile->channels = orig_chans;
+        break;
+    }
+    switch(dz->process) {
+    case(PVOC_ANAL): case(PVOC_SYNTH):  case(PVOC_EXTRACT):
+        dz->outfilesize = sndsizeEx(dz->ofd);
+        dz->total_samps_written = 0L;
+        break;
+    default:
+        switch(dz->process_type) {
+        case(UNEQUAL_SNDFILE):  case(UNEQUAL_ENVFILE):      case(CREATE_ENVFILE):
+        case(EXTRACT_ENVFILE):  case(BIG_ANALFILE):         case(ANAL_TO_FORMANTS):
+        case(PITCH_TO_ANAL):    case(PITCH_TO_BIGPITCH):    case(PSEUDOSNDFILE):
+        case(PITCH_TO_PSEUDOSND):
+// TW THIS doesn't achieve anythuing, I think.
+            dz->outfilesize = sndsizeEx(dz->ofd);
+            break;
+        }
+        break;
+    }
+    if(dz->process_type != TO_TEXTFILE) {
+        if((exit_status = assign_wavetype(dz)) < 0)
+            return exit_status;
+    }
+    return(FINISHED);
+}
+
+
+/* RWD.7.98 sfsys98 version, for SYNTH */
+
+//TW REDUNDANT ??
+//int create_sized_outfile_formatted(const char *filename,int srate,int channels, int stype,dataptr dz)
+//{
+//  if((dz->ofd = sndcreat_formatted(filename,-1,stype,
+//          channels,srate,CDP_CREATE_NORMAL)) < 0) {
+//      sprintf(errstr,"Cannot open output file %s: %s\n", filename,rsferrstr);
+//      return SYSTEM_ERROR;
+//  }
+//  //RWD.10.98
+//  dz->true_outfile_stype = stype; 
+//  dz->total_samps_written = 0L;
+//  return FINISHED;
+//}
+
+//TW CREATE TEMPFILE NAME (for bad sndseek cases: and other spcial cases)
+void get_other_filename(char *filename,char c)
+{
+    char *p, *end;
+    p = filename + strlen(filename);
+    end = p;
+    while(p > filename) {
+        p--;
+        if(*p == '.')
+            break;              /* return start of final name extension */
+        else if(*p == '/' || *p == '\\') {
+            p =  end;           /* directory path component found before finding filename extension */
+            break;              /* go to end of name */
+        }
+    }
+    if(p == filename)
+        p = end;                /* no finalname extension found, go to end of name */
+    p--;                        /* insert '1' at name end */
+    *p = c;
+    return;
+}
+
+void insert_new_number_at_filename_end(char *filename,int num,int overwrite_last_char)
+/* FUNCTIONS ASSUMES ENOUGH SPACE IS ALLOCATED !! */
+{
+    char *p;
+    char ext[64];
+    p = filename + strlen(filename) - 1;
+    while(p > filename) {
+        if(*p == '/' || *p == '\\' || *p == ':') {
+            p = filename;
+            break;
+        }
+        if(*p == '.') {
+            strcpy(ext,p);
+            if(overwrite_last_char)
+                p--;
+            sprintf(p,"%d",num);
+            strcat(filename,ext);
+            return;
+        }
+        p--;
+    }
+    if(p == filename) {
+        p += strlen(filename);
+        if(overwrite_last_char)
+            p--;
+        sprintf(p,"%d",num);
+    }
+}
+
+void insert_new_chars_at_filename_end(char *filename,char *str)
+/* FUNCTIONS ASSUMES ENOUGH SPACE IS ALLOCATED !! */
+{
+    char *p;
+    char ext[64];
+    p = filename + strlen(filename) - 1;
+    while(p > filename) {
+        if(*p == '/' || *p == '\\' || *p == ':') {
+            p = filename;
+            break;
+        }
+        if(*p == '.') {
+            strcpy(ext,p);
+            *p = ENDOFSTR;
+            strcat(filename,str);
+            strcat(filename,ext);
+            return;
+        }
+        p--;
+    }
+    if(p == filename)
+        strcat(filename,str);
+}
+
+void replace_filename_extension(char *filename,char *ext)
+/* FUNCTIONS ASSUMES ENOUGH SPACE IS ALLOCATED !! */
+{
+    char *p;
+    p = filename + strlen(filename) - 1;
+    while(p > filename) {
+        if(*p == '/' || *p == '\\' || *p == ':') {
+            p = filename;
+            break;
+        }
+        if(*p == '.') {
+            *p = ENDOFSTR;
+            strcat(filename,ext);
+            return;
+        }
+        p--;
+    }
+    if(p == filename)
+        strcat(filename,ext);
+}
+
+void delete_filename_lastchar(char *filename)
+{
+    char *p, *q = filename + strlen(filename);
+    p = q - 1;
+    while(p > filename) {
+        if(*p == '/' || *p == '\\' || *p == ':') {
+            p = filename;
+            break;
+        }
+        if(*p == '.') {
+            while(p <= q) {
+                *(p - 1) = *p;
+                p++;
+            }
+            return;
+        }
+        p--;
+    }
+    if(p == filename) {
+        p = q - 1;
+        *p = ENDOFSTR;
+    }
+}
+
+int reset_peak_finder(dataptr dz)
+{
+    int j;
+    
+    if(dz->needpeaks && (dz->ofd >= 0)){
+        if(sndputpeaks(dz->ofd,dz->outchans,dz->outpeaks)) {
+            fprintf(stdout,"WARNING: failed to write PEAK data\n");
+            fflush(stdout);
+        }
+    }
+    if(dz->outpeaks==NULL) {
+        dz->outpeaks = (CHPEAK *) malloc(sizeof(CHPEAK) * dz->outchans);
+        if(dz->outpeaks==NULL)
+            return MEMORY_ERROR;
+        dz->outpeakpos = (unsigned int *) malloc(sizeof(unsigned int) * dz->outchans);
+        if(dz->outpeakpos==NULL)
+            return MEMORY_ERROR;
+    }   
+//JAN 2007 moved
+    for(j = 0;j<dz->outchans;j++)
+        dz->outpeakpos[j] = 0;
+    for(j = 0;j<dz->outchans;j++) {
+        dz->outpeaks[j].value = 0.0;
+        dz->outpeaks[j].position = 0;
+    }
+    dz->needpeaks = 1;
+    return FINISHED;
+}
+
+int establish_peak_status(dataptr dz)
+{
+    int i;
+
+    if(dz->outpeaks!=NULL)
+        return FINISHED;
+
+    if(dz->process < FOOT_OF_GROUCHO_PROCESSES) {
+        switch(dz->process) {
+//sound or pseudosnd output
+        case(FMNTSEE):  case(FORMSEE):  case(PVOC_SYNTH):
+        case(LEVEL):    case(P_SEE):    
+// 2010
+        case(MTON):     case(FLUTTER):
+        case(SETHARES): case(MCHSHRED):
+        case(MCHZIG):   case(MCHSTEREO):
+            break;
+        default:
+//spectral output
+            dz->needpeaks = 0;
+            return FINISHED;
+        }
+    }
+//spectral output
+    switch(dz->process) {   
+    case(P_SYNTH):  case(P_INSERT): case(P_PTOSIL): case(P_NTOSIL): case(P_SINSERT):    
+    case(P_GEN):    case(P_INTERP): case(MAKE2):    case(ANALENV):  case(FREEZE2):
+    case(PVOC_ANAL):    case(MAKE): case(ENVSYN):
+// 2010
+    case(ANALJOIN):     case(ONEFORM_GET):  case(ONEFORM_PUT):  case(ONEFORM_COMBINE):
+    case(SPEC_REMOVE):  case(SPECROSS):     case(SPECLEAN):     case(SPECTRACT):
+    case(BRKTOPI):      case(SPECSLICE):
+    case(TUNEVARY):                 /* RWD Nov 21, may need to add other progs here... */
+        dz->needpeaks = 0;
+        return FINISHED;
+
+//processes which generate text data.
+// 2010
+    switch(dz->process) {
+    case(PTOBRK):
+    case(RMRESP):   
+    case(MULTIMIX): 
+        dz->needpeaks = 0;
+        return FINISHED;
+    }
+
+//processes which write to intermediate temporary files: needpeaks set to 1 later.
+    case(SYNTH_SPEC):   case(MIXTWO):   case(SHUDDER):      
+        dz->needpeaks = 0;
+        return FINISHED;
+//processes which are normalised via an intermediate temporary files: needpeaks set to 1 later.
+    case(MOD_RADICAL):
+        if(dz->mode == MOD_LOBIT || dz->mode == MOD_LOBIT2) {
+            dz->needpeaks = 0;
+            return FINISHED;
+        }
+        break;
+//processes with several outputs, where peak is reset to zero before each file is written-to
+    case(HOUSE_GATE):   
+    case(TIME_GRID):
+        dz->needpeaks = 0;
+        return FINISHED;
+    case(TWIXT):
+        if(dz->mode == TRUE_EDIT) {
+            dz->needpeaks = 0;
+            return FINISHED;
+        }
+        break;
+//processes needing no maxsamp data
+    case(HOUSE_DUMP):   
+        dz->needpeaks = 0;
+        return FINISHED;
+    }
+    dz->needpeaks = 1;
+    dz->outpeaks = (CHPEAK *) malloc(sizeof(CHPEAK) * dz->outchans);
+    if(dz->outpeaks==NULL)
+        return MEMORY_ERROR;
+    dz->outpeakpos = (unsigned int *) malloc(sizeof(unsigned int) * dz->outchans);
+    if(dz->outpeakpos==NULL)
+        return MEMORY_ERROR;
+    for(i=0;i < dz->outchans;i++){
+        dz->outpeaks[i].value = 0.0f;
+        dz->outpeaks[i].position = 0;
+        dz->outpeakpos[i] = 0;
+    }
+    return FINISHED;
+}
+
+void strip_ext(char *temp) 
+{
+    char *p = temp + strlen(temp) - 1;
+    while(p > temp) {
+        if(*p == '.') {
+            *p = ENDOFSTR;
+            return;
+        }
+        p--;
+    }
+}
+
+int assign_wavetype(dataptr dz)
+{
+    //wavetype wtype;
+    int isenv = 1;
+    int dummy = 1;
+    switch(dz->process) {
+        case(PVOC_ANAL):
+        //wtype = wt_analysis;
+        break;
+    case(PVOC_SYNTH):   case(PVOC_EXTRACT): case(SYNTH_SPEC):
+        //wtype = wt_wave;
+        break;
+    case(REPITCH):
+        //if(dz->mode == PTP)
+        //    wtype = wt_transposition;
+        //else
+        //    wtype = wt_pitch;
+        break;
+    default:
+        switch(dz->process_type) {
+        case(EQUAL_SNDFILE):    
+        case(UNEQUAL_SNDFILE):
+        case(PSEUDOSNDFILE):
+        case(PITCH_TO_PSEUDOSND):
+//          wtype = wt_wave;
+            break;
+        case(EQUAL_ENVFILE):
+        case(CREATE_ENVFILE):
+        case(EXTRACT_ENVFILE):
+        case(UNEQUAL_ENVFILE):
+            if(sndputprop(dz->ofd,"is an envelope",(char *) &isenv,sizeof(int)) < 0){
+                sprintf(errstr,"Failure to write envelope property. assign_wavetype()\n");
+                return(PROGRAM_ERROR);
+            }
+//          wtype = wt_binenv;
+            break;
+        case(EQUAL_ANALFILE):
+        case(BIG_ANALFILE):
+        case(MAX_ANALFILE):
+        case(MIN_ANALFILE):
+        case(PITCH_TO_ANAL):
+ //           wtype = wt_analysis;
+            break;
+        case(PITCH_TO_PITCH):
+        case(PITCH_TO_BIGPITCH):
+            if((dz->process == REPITCH && dz->mode != PTP) || dz->is_transpos) {
+                if(sndputprop(dz->ofd,"is a transpos file", (char *)&dummy, sizeof(int)) < 0) {
+                    sprintf(errstr,"Failure to write transposition property. assign_wavetype()\n");
+                    return(PROGRAM_ERROR);
+                }
+//              wtype = wt_transposition;
+            } else if((dz->process == P_APPROX || dz->process == P_INVERT || dz->process == P_QUANTISE || 
+            dz->process == P_RANDOMISE || dz->process == P_SMOOTH || dz->process == P_VIBRATO) 
+            && (dz->mode == 1)) {
+                if(sndputprop(dz->ofd,"is a transpos file", (char *)&dummy, sizeof(int)) < 0) {
+                    sprintf(errstr,"Failure to write transposition property. assign_wavetype()\n");
+                    return(PROGRAM_ERROR);
+                }
+            } else if((dz->process == P_EXAG) && (dz->mode == 1 || dz->mode == 3 || dz->mode == 5)) {
+                if(sndputprop(dz->ofd,"is a transpos file", (char *)&dummy, sizeof(int)) < 0) {
+                    sprintf(errstr,"Failure to write transposition property. assign_wavetype()\n");
+                    return(PROGRAM_ERROR);
+                }
+            } else {
+                if(sndputprop(dz->ofd,"is a pitch file", (char *)&dummy, sizeof(int)) < 0) {
+                    sprintf(errstr,"Failure to write pitch property. assign_wavetype()\n");
+                    return(PROGRAM_ERROR);
+                }
+//              wtype = wt_pitch;
+            }
+            break;
+        case(ANAL_TO_FORMANTS):
+        case(EQUAL_FORMANTS):
+            if(sndputprop(dz->ofd,"is a formant file", (char *)&dummy, sizeof(int)) < 0) {
+                sprintf(errstr,"Failure to write formant property. assign_wavetype(): %s\n",sferrstr());
+                return(PROGRAM_ERROR);
+            }
+//          wtype = wt_formant;
+            break;
+        default:
+            sprintf(errstr,"Unknown process_type while assigning output wavetype.\n");
+            return PROGRAM_ERROR;
+        }
+    }
+//  if(sndputprop(dz->ofd,"type",(char *)&wtype,sizeof(wavetype)) < 0){
+//      sprintf(errstr,"Failure to write wavetype factor. assign_wavetype()\n");
+//      return(PROGRAM_ERROR);
+//  }
+    return FINISHED;
+}
+
+//TW MODIFY INPUT OUTFILENAME, to deal with intermediate temp files, in comdline case.
+//char *get_other_filename_x(char *filename,char c)
+//{
+//  char *p, *nufilename;
+//  int len = strlen(filename);
+//  char temp[] = "_cdptemp";
+//  len += 9;
+//  if(((char *)nufilename = (char *)malloc(len)) == NULL)
+//      return NULL;
+//  strcpy(nufilename,filename);
+//  strcat(nufilename,temp);
+//  p = nufilename + len;
+//  *p = ENDOFSTR;
+//  p--;
+//  *p = c;
+//  return nufilename;
+//}
+
+char *get_other_filename_x(char *filename,char c)
+{
+    char *p, *nufilename, ext[24];
+    int len = strlen(filename);
+    char temp[] = "_cdptemp";
+    len += 12;
+    if((nufilename = (char *)malloc(len)) == NULL)
+        return NULL;
+    strcpy(nufilename,filename);
+    ext[0] = c;
+    ext[1] = ENDOFSTR;
+    p = nufilename;
+    while(*p != ENDOFSTR) {
+        if(*p == '.') {
+            strcat(ext,p);
+            *p = ENDOFSTR;
+            break;
+        }
+        p++;
+    }
+    strcat(nufilename,temp);
+    strcat(nufilename,ext);
+    return nufilename;
+}
+
+// FEB 2010 TW
+
+void insert_separator_on_sndfile_name(char *filename,int cnt)
+/* FUNCTIONS ASSUMES ENOUGH SPACE IS ALLOCATED !! */
+{
+    int n;
+    char ext[8];
+    char *p = filename, *z = filename;                  //  z will be place to insert separator
+    p += strlen(filename);
+    p -= 4;     //  p set to start of any 4char extension [p]..a1   OR a1[p].wav    OR a1.[p]aiff   OR [p]aaa1  OR aaa[p]aaa1   OR aaaaaa1[p].wav   OR aaaaaa1.[p]aiff
+                //  if p <= start of name ... 
+                //  insert separator at end               [p]..a1 --> a1_                                                   
+    if(p > filename) {                          
+                //  if p is at start of 4 letter extension ... 
+                //  insert separator at [p]             a1[p].wav --> a1_.wav   aaaaaa1[p].wav --> aaaaaa1_.wav 
+
+        if(!strcmp(p,".wav") || !strcmp(p,".aif")) {
+            strcpy(ext,p);
+            z = p;
+        } else {
+            p--;//  p set to start of any 5char extension aa[p]aaaa1  OR aaaaaa1[p].aiff
+                //  if p less than start of name ... 
+                //  insert separator at end             [p]..aaa1 --> aaa1_     
+            if(p > filename) {
+                //  if p is at start of 5 letter extension ... 
+                //  insert separator at [p]             a1[p].aiff --> a1_.aiff aaaaaa1[p].aiff --> aaaaaa1_.aiff
+
+                if(!strcmp(p,".aiff")) {
+                    strcpy(ext,p);
+                    z = p;
+                //  else, no extension match
+                //  insert separator at end of name     aa[p]aaaa1 --> aaaaaa1_
+                }
+            }
+        }
+    }
+    if(z == filename) {
+        for(n=0;n<cnt;n++)
+            strcat(filename,"_");
+    } else {
+        for(n=0;n<cnt;n++)
+            *z++ = '_';
+        *z = ENDOFSTR;
+    }
+}

dev/cdp2k/parstruct.c

@@ -0,0 +1,1819 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <processno.h>
+#include <logic.h>
+#include <modeno.h>
+#include <special.h>
+#include <cdparams.h>
+#include <globcon.h>
+
+static int  set_param_data(aplptr ap, int special_data,int maxparamcnt,int paramcnt,char *paramlist);
+static int  set_vflgs(aplptr ap,char *optflags,int optcnt,char *optlist,
+                      char *varflags,int vflagcnt, int vparamcnt,char *varlist);
+
+/****************************** SET_LEGAL_PARAM_STRUCTURE *********************************/
+
+int set_legal_param_structure(int process,int mode, aplptr ap)
+{
+    /*  |                             |m| |        | */
+    /*  |                             |a| |        | */
+    /*  |                             |x| |        | */
+    /*  |                             |p|p|        | */
+    /*  |                             |a|a|        | */
+    /*  |  special-data               |r|r| param  | */
+    /*  |                             |a|a|  list  | */
+    /*  |                             |m|m|        | */
+    /*  |                             |c|c|        | */
+    /*  |                             |n|n|        | */
+    /*  |                             |t|t|        | */
+    
+    switch(process) {
+        case(ACCU):     return set_param_data(ap,0                        ,0,0,""      );
+        case(ALT):      return set_param_data(ap,0                        ,0,0,""      );
+        case(ARPE):     return set_param_data(ap,0                        ,2,2,"iD"    );
+        case(AVRG):     return set_param_data(ap,0                        ,1,1,"I"     );
+        case(BARE):     return set_param_data(ap,0                        ,0,0,""      );
+        case(BLTR):     return set_param_data(ap,0                        ,2,2,"II"    );
+        case(BLUR):     return set_param_data(ap,0                        ,1,1,"I"     );
+        case(BRIDGE):   return set_param_data(ap,0                        ,0,0,""      );
+        case(CHANNEL):  return set_param_data(ap,0                        ,1,1,"d"     );
+        case(CHORD):    return set_param_data(ap,SEMIT_TRANSPOS_SET       ,0,0,""      );
+        case(CHORUS):
+            switch(mode) {
+                case(CH_AMP):
+                    return set_param_data(ap,0                        ,2,1,"D0"    );
+                case(CH_FRQ):
+                case(CH_FRQ_UP):
+                case(CH_FRQ_DN):
+                    return set_param_data(ap,0                        ,2,1,"0D"    );
+                case(CH_AMP_FRQ):
+                case(CH_AMP_FRQ_UP):
+                case(CH_AMP_FRQ_DN):
+                    return set_param_data(ap,0                        ,2,2,"DD"    );
+            }
+            break;
+        case(CLEAN):
+            switch(mode) {
+                case(FROMTIME):
+                case(ANYWHERE):
+                case(FILTERING):
+                    return set_param_data(ap,0                        ,1,1,"d"     );
+                case(COMPARING):
+                    return set_param_data(ap,0                        ,1,0,"0"     );
+            }
+            break;
+        case(CROSS):    return set_param_data(ap,0                        ,0,0,""      );
+        case(CUT):      return set_param_data(ap,0                        ,2,2,"dd"    );
+        case(DIFF):     return set_param_data(ap,0                        ,0,0,""      );
+        case(DRUNK):    return set_param_data(ap,0                        ,3,3,"idd"   );
+        case(EXAG):     return set_param_data(ap,0                        ,1,1,"D"     );
+        case(FILT):
+            switch(mode) {
+                case(F_HI):
+                case(F_HI_NORM):
+                case(F_LO):
+                case(F_LO_NORM):
+                    return set_param_data(ap,0                        ,4,2,"D0D0"  );
+                case(F_HI_GAIN):
+                case(F_LO_GAIN):
+                    return set_param_data(ap,0                        ,4,3,"D0Dd"  );
+                case(F_BND):
+                case(F_BND_NORM):
+                case(F_NOTCH):
+                case(F_NOTCH_NORM):
+                    return set_param_data(ap,0                        ,4,3,"DDD0"  );
+                case(F_BAND_GAIN):
+                case(F_NOTCH_GAIN):
+                    return set_param_data(ap,0                        ,4,4,"DDDd"  );
+            }
+            break;
+        case(FMNTSEE):  return set_param_data(ap,0                        ,0,0,""      );
+        case(FOCUS):    return set_param_data(ap,0                        ,2,2,"iD"    );
+        case(FOLD):     return set_param_data(ap,0                        ,2,2,"DD"    );
+        case(FORM):     return set_param_data(ap,0                        ,0,0,""      );
+        case(FORMANTS): return set_param_data(ap,0                        ,0,0,""      );
+        case(FORMSEE):  return set_param_data(ap,0                        ,0,0,""      );
+        case(FREEZE):   return set_param_data(ap,FREEZE_DATA              ,0,0,""      );
+        case(FREEZE2):  return set_param_data(ap,FREEZE2_DATA             ,0,0,""      );
+        case(FREQUENCY):return set_param_data(ap,0                        ,1,1,"i"     );
+        case(GAIN):     return set_param_data(ap,0                        ,1,1,"D"     );
+        case(GLIDE):    return set_param_data(ap,0                        ,1,1,"d"     );
+        case(GLIS):
+            switch(mode) {
+                case(SHEPARD):
+                case(SELFGLIS):
+                    return set_param_data(ap,0                        ,2,1,"D0"    );
+                case(INHARMONIC):
+                    return set_param_data(ap,0                        ,2,2,"Dd"    );
+            }
+            break;
+        case(GRAB):     return set_param_data(ap,0                        ,1,1,"d"     );
+        case(GREQ):
+            switch(mode) {
+                case(GR_ONEBAND):
+                    return set_param_data(ap,FILTER_FRQS              ,0,0,""      );
+                case(GR_MULTIBAND):
+                    return set_param_data(ap,FILTER_BWS_AND_FRQS      ,0,0,""      );
+            }
+            break;
+        case(INVERT):   return set_param_data(ap,0                        ,0,0,""      );
+        case(LEAF):     return set_param_data(ap,0                        ,1,1,"i"     );
+        case(LEVEL):    return set_param_data(ap,0                        ,0,0,""      );
+        case(MAGNIFY):  return set_param_data(ap,0                        ,2,2,"dd"    );
+        case(MAKE):     return set_param_data(ap,0                        ,0,0,""      );
+        case(MAX):      return set_param_data(ap,0                        ,0,0,""      );
+        case(MEAN):     return set_param_data(ap,0                        ,0,0,""      );
+        case(MORPH):    return set_param_data(ap,0                        ,6,6,"dddddd");
+        case(NOISE):    return set_param_data(ap,0                        ,1,1,"D"     );
+        case(OCT):
+            switch(mode) {
+                case(OCT_UP):
+                case(OCT_DN):
+                    return set_param_data(ap,0                        ,2,1,"i0"    );
+                case(OCT_DN_BASS):
+                    return set_param_data(ap,0                        ,2,2,"iD"    );
+            }
+            break;
+        case(OCTVU):    return set_param_data(ap,0                        ,1,1,"d"     );
+        case(P_APPROX): return set_param_data(ap,0                        ,0,0,""      );
+        case(P_CUT):
+            switch(mode) {
+                case(PCUT_START_ONLY):
+                    return set_param_data(ap,0                        ,2,1,"D0"    );
+                case(PCUT_END_ONLY):
+                    return set_param_data(ap,0                        ,2,1,"0D"    );
+                case(PCUT_BOTH):
+                    return set_param_data(ap,0                        ,2,2,"DD"    );
+            }
+            break;
+        case(P_EXAG):
+            switch(mode) {
+                case(RANGE_ONLY_TO_P):
+                case(RANGE_ONLY_TO_T):
+                    return set_param_data(ap,0                        ,3,2,"DD0"   );
+                case(CONTOUR_ONLY_TO_P):
+                case(CONTOUR_ONLY_TO_T):
+                    return set_param_data(ap,0                        ,3,2,"D0D"   );
+                case(R_AND_C_TO_P):
+                case(R_AND_C_TO_T):
+                    return set_param_data(ap,0                        ,3,3,"DDD"   );
+            }
+            break;
+        case(P_FIX):    return set_param_data(ap,0                        ,0,0,""      );
+        case(P_HEAR):   return set_param_data(ap,0                        ,0,0,""      );
+        case(P_INFO):   return set_param_data(ap,0                        ,0,0,""      );
+        case(P_INVERT): return set_param_data(ap,INTERVAL_MAPPING         ,0,0,""      );
+        case(P_QUANTISE):   return set_param_data(ap,PITCHQUANTISE_SET    ,0,0,""      );
+        case(P_RANDOMISE):  return set_param_data(ap,0                    ,2,2,"DD"    );
+        case(P_SEE):
+            switch(mode) {
+                case(SEE_PITCH):
+                    return set_param_data(ap,0                        ,1,1,"d"     );
+                case(SEE_TRANSPOS):
+                    return set_param_data(ap,0                        ,1,0,"0"     );
+            }
+            break;
+        case(P_SMOOTH):     return set_param_data(ap,0                    ,1,1,"D"     );
+            //TW NEW
+        case(P_SYNTH):      return set_param_data(ap,PITCH_SPECTRUM       ,0,0,""      );
+        case(P_VOWELS):     return set_param_data(ap,PITCH_VOWELS         ,5,5,"dddDD" );
+        case(VFILT):        return set_param_data(ap,PITCH_VOWELS         ,4,4,"dddd"  );
+        case(P_GEN):        return set_param_data(ap,PITCH_CREATE         ,1,1,"i"     );
+        case(P_INSERT):     return set_param_data(ap,ZERO_INSERTTIMES     ,0,0,""      );
+        case(P_SINSERT):    return set_param_data(ap,ZERO_INSERTTIMES     ,0,0,""      );
+        case(P_PTOSIL):     return set_param_data(ap,0                    ,0,0,""      );
+        case(P_NTOSIL):     return set_param_data(ap,0                    ,0,0,""      );
+        case(ANALENV):      return set_param_data(ap,0                    ,0,0,""      );
+        case(P_BINTOBRK):   return set_param_data(ap,0                    ,0,0,""      );
+        case(MAKE2):        return set_param_data(ap,0                    ,0,0,""      );
+        case(P_INTERP):     return set_param_data(ap,0                    ,0,0,""      );
+            
+        case(P_TRANSPOSE):  return set_param_data(ap,0                    ,1,1,"d"     );
+        case(P_VIBRATO):    return set_param_data(ap,0                    ,2,2,"DD"    );
+        case(P_WRITE):  return set_param_data(ap,0                        ,0,0,""      );
+        case(P_ZEROS):  return set_param_data(ap,0                        ,0,0,""      );
+        case(PEAK):     return set_param_data(ap,0                        ,0,0,""      );
+        case(PICK):
+            switch(mode) {
+                case(PIK_HARMS):
+                case(PIK_OCTS):
+                case(PIK_ODD_HARMS):
+                    return set_param_data(ap,0                        ,2,1,"d0"    );
+                case(PIK_LINEAR):
+                case(PIK_DISPLACED_HARMS):
+                    return set_param_data(ap,0                        ,2,2,"dd"    );
+            }
+            break;
+        case(PITCH):
+            if(!sloom) {
+                switch(mode) {
+                    case(PICH_TO_BIN):
+                        return set_param_data(ap,OUT_PFILE              ,0,0,""      );
+                    case(PICH_TO_BRK):
+                        return set_param_data(ap,OUT_PBRKFILE           ,0,0,""      );
+                }
+            } else {
+                return set_param_data(ap,0                                  ,0,0,""      );
+            }
+            break;
+        case(PLUCK):    return set_param_data(ap,0                        ,1,1,"D"     );
+        case(PRINT):    return set_param_data(ap,0                        ,1,1,"d"     );
+        case(REPITCH):  return set_param_data(ap,0                        ,0,0,""      );
+        case(REPITCHB): return set_param_data(ap,0                        ,0,0,""      );
+        case(REPORT):   return set_param_data(ap,0                        ,1,1,"i"     );
+        case(SCAT):     return set_param_data(ap,0                        ,1,1,"I"     );
+        case(SHIFT):
+            switch(mode) {
+                case(SHIFT_ALL):
+                    return set_param_data(ap,0                        ,3,1,"D00"   );
+                case(SHIFT_ABOVE):
+                case(SHIFT_BELOW):
+                    return set_param_data(ap,0                        ,3,2,"DD0"   );
+                case(SHIFT_BETWEEN):
+                case(SHIFT_OUTSIDE):
+                    return set_param_data(ap,0                        ,3,3,"DDD"   );
+            }
+            break;
+        case(SHIFTP):
+            switch(mode) {
+                case(P_OCT_UP):
+                case(P_OCT_DN):
+                case(P_OCT_UP_AND_DN):
+                    return set_param_data(ap,0                        ,3,1,"D00"   );
+                case(P_SHFT_UP):
+                case(P_SHFT_DN):
+                    return set_param_data(ap,0                        ,3,2,"DD0"   );
+                case(P_SHFT_UP_AND_DN):
+                    return set_param_data(ap,0                        ,3,3,"DDD"   );
+            }
+            break;
+        case(SHUFFLE):  return set_param_data(ap,SHUFFLE_DATA             ,1,1,"i"     );
+        case(SPLIT):    return set_param_data(ap,SPECSPLI_DATA            ,0,0,""      );
+        case(SPREAD):   return set_param_data(ap,0                        ,0,0,""      );
+        case(STEP):     return set_param_data(ap,0                        ,1,1,"d"     );
+        case(STRETCH):  return set_param_data(ap,0                        ,3,3,"ddd"   );
+        case(SUM):      return set_param_data(ap,0                        ,0,0,""      );
+        case(SUPR):     return set_param_data(ap,0                        ,1,1,"I"     );
+        case(S_TRACE):
+            switch(mode) {
+                case(TRC_ALL):
+                    return set_param_data(ap,0                        ,3,1,"I00"   );
+                case(TRC_ABOVE):
+                    return set_param_data(ap,0                        ,3,2,"ID0"   );
+                case(TRC_BELOW):
+                    return set_param_data(ap,0                        ,3,2,"I0D"   );
+                case(TRC_BETWEEN):
+                    return set_param_data(ap,0                        ,3,3,"IDD"   );
+            }
+            break;
+        case(TRACK):
+            switch(mode) {
+                case(TRK_TO_BIN):
+                    return set_param_data(ap,OUT_PFILE                ,1,1,"d"     );
+                case(TRK_TO_BRK):
+                    return set_param_data(ap,OUT_PBRKFILE             ,1,1,"d"     );
+            }
+            break;
+        case(TRNSF):
+            switch(mode) {
+                case(TRNS_RATIO):
+                    return set_param_data(ap,TRANSPOS_RATIO_OR_CONSTANT ,0,0,""      );
+                case(TRNS_OCT):
+                    return set_param_data(ap,TRANSPOS_OCTAVE_OR_CONSTANT,0,0,""      );
+                case(TRNS_SEMIT):
+                    return set_param_data(ap,TRANSPOS_SEMIT_OR_CONSTANT ,0,0,""      );
+                case(TRNS_BIN):
+                    return set_param_data(ap,0                          ,0,0,""      );
+            }
+            break;
+        case(TRNSP):
+            switch(mode) {
+                case(TRNS_RATIO):
+                    return set_param_data(ap,TRANSPOS_RATIO_OR_CONSTANT ,0,0,""      );
+                case(TRNS_OCT):
+                    return set_param_data(ap,TRANSPOS_OCTAVE_OR_CONSTANT,0,0,""      );
+                case(TRNS_SEMIT):
+                    return set_param_data(ap,TRANSPOS_SEMIT_OR_CONSTANT ,0,0,""      );
+                case(TRNS_BIN):
+                    return set_param_data(ap,0                          ,0,0,""      );
+            }
+            break;
+        case(TSTRETCH): return set_param_data(ap,0                        ,1,1,"D"     );
+        case(TUNE):
+            switch(mode) {
+                case(TUNE_FRQ):
+                    return set_param_data(ap,FRQ_OR_FRQSET            ,0,0,""      );
+                case(TUNE_MIDI):
+                    return set_param_data(ap,PITCH_OR_PITCHSET        ,0,0,""      );
+            }
+            break;
+        case(VOCODE):   return set_param_data(ap,0                        ,0,0,""      );
+        case(WARP):     return set_param_data(ap,0                        ,0,0,""      );
+        case(WAVER):
+            switch(mode) {
+                case(WAVER_STANDARD):
+                    return set_param_data(ap,0                        ,4,3,"DDd0"  );
+                case(WAVER_SPECIFIED):
+                    return set_param_data(ap,0                        ,4,4,"DDdd"  );
+            }
+            break;
+        case(WEAVE):    return set_param_data(ap,WEAVE_DATA               ,0,0,""      );
+        case(WINDOWCNT):return set_param_data(ap,0                        ,0,0,""      );
+        case(LIMIT):    return set_param_data(ap,0                        ,1,1,"D"     );
+        case(MULTRANS): return set_param_data(ap,SEMIT_TRANSPOS_SET       ,0,0,""      );
+            /*  |                             |m| |        | */
+            /*  |                             |a| |        | */
+            /*  |                             |x| |        | */
+            /*  |                             |p|p|        | */
+            /*  |                             |a|a|        | */
+            /******** GROUCHO ********/       /*  |  special-data             |r|r| param  | */
+            /*  |                         |a|a|  list  | */
+            /*  |                         |m|m|        | */
+            /*  |                         |c|c|        | */
+            /*  |                         |n|n|        | */
+            /*  |                         |t|t|        | */
+        case(DISTORT):
+            switch(mode) {
+                case(DISTORT_EXAGG):
+                    return set_param_data(ap,0                        ,1,1,"D"    );
+                default:      return set_param_data(ap,0                          ,1,0,"0"    );
+            }
+            break;
+        case(DISTORT_ENV):
+            switch(mode) {
+                case(DISTORTE_USERDEF):     /* 1 param + 0 variants: 2 INACTIVEs force internalparams to start at param[3] */
+                    return set_param_data(ap,DISTORT_ENVELOPE         ,3,1,"I00"  );
+                case(DISTORTE_TROFFED):     /* 2 params + 1 variant trof = param[1]: internals start at param[3] */
+                    return set_param_data(ap,0                        ,2,2,"ID"   );
+                    /* 1 param + 2 variants trof = param[1]: internals start at param[3] */
+                default:       return set_param_data(ap,0                         ,1,1,"I"    );
+            }
+            break;
+        case(DISTORT_AVG): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_OMT): return set_param_data(ap,0                         ,2,2,"Ii"   );
+            
+        case(DISTORT_MLT): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_DIV): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_HRM): return set_param_data(ap,HARMONIC_DISTORT          ,0,0,""     );
+        case(DISTORT_FRC): return set_param_data(ap,0                         ,2,2,"ID"   );
+        case(DISTORT_REV): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_SHUF):return set_param_data(ap,SHUFFLE_DATA              ,0,0,""     );
+        case(DISTORT_RPTFL):
+        case(DISTORT_RPT2):
+        case(DISTORT_RPT): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_INTP):return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_DEL): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_RPL): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_TEL): return set_param_data(ap,0                         ,1,1,"I"    );
+        case(DISTORT_FLT):
+            switch(mode) {
+                case(DISTFLT_HIPASS):
+                    return set_param_data(ap,0                        ,2,1,"D0"   );
+                case(DISTFLT_LOPASS):
+                    return set_param_data(ap,0                        ,2,1,"0D"   );
+                case(DISTFLT_BANDPASS):
+                    return set_param_data(ap,0                        ,2,2,"DD"   );
+            }
+            break;
+        case(DISTORT_INT): return set_param_data(ap,0                         ,0,0,""     );
+        case(DISTORT_CYCLECNT):
+            return set_param_data(ap,0                        ,0,0,""     );
+        case(DISTORT_PCH): return set_param_data(ap,0                         ,1,1,"D"    );
+        case(DISTORT_OVERLOAD):
+            switch(mode) {
+                case(OVER_NOISE):
+                    return set_param_data(ap,0                        ,3,2,"DD0"  );
+                case(OVER_SINE):
+                    return set_param_data(ap,0                        ,3,3,"DDD"  );
+            }
+            break;
+        case(DISTORT_PULSED):
+            switch(mode) {
+                case(PULSE_IMP):  return set_param_data(ap,PULSE_ENVELOPE        ,9,8,"ddDddd0Dd");
+                case(PULSE_SYN):  return set_param_data(ap,PULSE_ENVELOPE        ,9,9,"ddDddddDd");
+                case(PULSE_SYNI): return set_param_data(ap,PULSE_ENVELOPE        ,9,9,"idDdddiDd");
+            }
+            break;
+        case(ZIGZAG):
+            switch(mode) {
+                case(ZIGZAG_SELF):
+                    return set_param_data(ap,0                        ,4,4,"dddd" );
+                case(ZIGZAG_USER):
+                    return set_param_data(ap,ZIGDATA                      ,4,0,"0000" );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : ZIGZAG: set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(LOOP):
+            switch(mode) {
+                case(LOOP_ALL):
+                    return set_param_data(ap,0                        ,5,3,"00ddd");
+                case(LOOP_OUTLEN):
+                    return set_param_data(ap,0                        ,4,3,"d0dd" );
+                case(LOOP_RPTS):
+                    return set_param_data(ap,0                        ,4,3,"0idd" );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : LOOP: set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SCRAMBLE):    return set_param_data(ap,0                         ,3,3,"ddd"  );
+        case(ITERATE):
+            switch(mode) {
+                case(ITERATE_DUR):
+                    return set_param_data(ap,0                        ,1,1,"d"    );
+                case(ITERATE_REPEATS):
+                    return set_param_data(ap,0                        ,1,1,"i"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : ITERATE: set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(ITERATE_EXTEND):
+            switch(mode) {
+                case(ITERATE_DUR):
+                    return set_param_data(ap,0                        ,8,8,"dDDDDddd" );
+                case(ITERATE_REPEATS):
+                    return set_param_data(ap,0                        ,8,8,"iDDDDddd" );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : ITERATE_EXTEND: set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(DRUNKWALK):
+            switch(mode) {
+                case(TOTALLY_PISSED):
+                    return set_param_data(ap,0                        ,7,5,"dDDDD00");
+                case(HAS_SOBER_MOMENTS):
+                    return set_param_data(ap,0                         ,7,7,"dDDDDII");
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : DRUNKWALK: set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SIMPLE_TEX):  return set_param_data(ap,TEX_NOTEDATA              ,26,13,"dDDDIIDDDDDDI0000000000000");
+        case(GROUPS):      return set_param_data(ap,TEX_NOTEDATA              ,26,23,"dDDDIIDDDDDDDiDDiIIDDDD000");
+        case(ORNATE): case(PREORNATE):  case(POSTORNATE):
+            return set_param_data(ap,TEX_NOTEDATA             ,26,15,"dD00IIDDDD00DiDDi000000DD0");
+        case(MOTIFS): case(MOTIFSIN):
+            return set_param_data(ap,TEX_NOTEDATA             ,26,17,"dDDDIIDD00DDDiDDi000000DD0");
+        case(DECORATED): case(PREDECOR): case(POSTDECOR):
+            return set_param_data(ap,TEX_NOTEDATA             ,26,20,"dD00IIDDDD00DiDDiIIDDDD00i");
+        case(TIMED):       return set_param_data(ap,TEX_NOTEDATA              ,26,10,"dD00IIDDDDDD00000000000000");
+        case(TGROUPS):     return set_param_data(ap,TEX_NOTEDATA              ,26,21,"dD00IIDDDDDDDiDDiIIDDDD000");
+        case(TMOTIFS): case(TMOTIFSIN):
+            return set_param_data(ap,TEX_NOTEDATA             ,26,15,"dD00IIDD00DDDiDDi000000DD0");
+        case(GRAIN_COUNT):     return set_param_data(ap,0                     ,2,0,"00"       );
+        case(GRAIN_OMIT):      return set_param_data(ap,0                     ,2,2,"Ii"       );
+        case(GRAIN_DUPLICATE): return set_param_data(ap,0                     ,2,1,"I0"       );
+        case(GRAIN_REORDER):   return set_param_data(ap,GRAIN_REORDER_STRING  ,2,0,"00"       );
+        case(GRAIN_REPITCH):   return set_param_data(ap,GRAIN_PITCH_RATIOS    ,2,0,"00"       );
+        case(GRAIN_RERHYTHM):  return set_param_data(ap,GRAIN_TIME_RATIOS     ,2,0,"00"       );
+        case(GRAIN_REMOTIF):   return set_param_data(ap,GRAIN_TWO_RATIOS      ,2,0,"00"       );
+        case(GRAIN_TIMEWARP):  return set_param_data(ap,0                     ,2,1,"D0"       );
+        case(GRAIN_REVERSE):   return set_param_data(ap,0                     ,2,0,"00"       );
+        case(GRAIN_GET):       return set_param_data(ap,0                     ,2,0,"00"       );
+        case(GRAIN_POSITION):  return set_param_data(ap,GRAIN_TIMINGS         ,2,1,"d0"       );
+        case(GRAIN_ALIGN):     return set_param_data(ap,0                     ,2,2,"dD"       );
+        case(ENV_CREATE):
+            switch(mode) {
+                case(ENV_ENVFILE_OUT): return set_param_data(ap,ENV_CREATEFILE    ,4,1,"d000"    );
+                case(ENV_BRKFILE_OUT): return set_param_data(ap,ENV_CREATEFILE    ,4,0,"0000"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_CREATE in set_legal_param_structure()\n",mode);
+                    return (PROGRAM_ERROR);
+            }
+            break;
+        case(ENV_EXTRACT):     return set_param_data(ap,0                     ,4,1,"d000"     );
+            
+        case(ENV_WARPING):
+        case(ENV_REPLOTTING):
+            switch(mode) {
+                case(ENV_NORMALISE):
+                case(ENV_REVERSE):
+                case(ENV_CEILING):
+                    return set_param_data(ap,0                     ,4,1,"d000"     );
+                    
+                case(ENV_EXAGGERATING):
+                case(ENV_ATTENUATING):
+                case(ENV_LIFTING): return set_param_data(ap,0                     ,4,2,"dD00"     );
+                    
+                case(ENV_DUCKED):
+                case(ENV_INVERTING):
+                case(ENV_LIMITING):return set_param_data(ap,0                     ,4,3,"dDD0"     );
+                    
+                case(ENV_TSTRETCHING): return set_param_data(ap,0                 ,4,2,"dd00"     );
+                case(ENV_FLATTENING):  return set_param_data(ap,0                 ,4,2,"dI00"     );
+                case(ENV_GATING):      return set_param_data(ap,0                 ,4,3,"dD0i"     );
+                case(ENV_CORRUGATING): return set_param_data(ap,0                 ,4,3,"dII0"     );
+                case(ENV_EXPANDING):   return set_param_data(ap,0                 ,4,4,"dDDi"     );
+                case(ENV_TRIGGERING):  return set_param_data(ap,ENV_TRIGGER_RAMP  ,4,4,"dDdd"     );
+                case(ENV_PEAKCNT):     return set_param_data(ap,0                 ,4,2,"d0I0"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_WARPING or REPLOTTING in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(ENV_RESHAPING):
+            switch(mode) {
+                case(ENV_NORMALISE):
+                case(ENV_REVERSE):
+                case(ENV_CEILING):
+                    return set_param_data(ap,0                     ,4,0,"0000"     );
+                    
+                case(ENV_EXAGGERATING):
+                case(ENV_ATTENUATING):
+                case(ENV_LIFTING): return set_param_data(ap,0                     ,4,1,"0D00"     );
+                    
+                case(ENV_DUCKED):
+                case(ENV_INVERTING):
+                case(ENV_LIMITING):return set_param_data(ap,0                     ,4,2,"0DD0"     );
+                    
+                case(ENV_TSTRETCHING): return set_param_data(ap,0                 ,4,1,"0d00"     );
+                case(ENV_FLATTENING):  return set_param_data(ap,0                 ,4,1,"0I00"     );
+                case(ENV_GATING):      return set_param_data(ap,0                 ,4,2,"0D0i"     );
+                case(ENV_CORRUGATING): return set_param_data(ap,0                 ,4,2,"0II0"     );
+                case(ENV_EXPANDING):   return set_param_data(ap,0                 ,4,3,"0DDi"     );
+                case(ENV_TRIGGERING):  return set_param_data(ap,ENV_TRIGGER_RAMP  ,4,3,"0Ddd"     );
+                case(ENV_PEAKCNT):     return set_param_data(ap,0                 ,4,1,"00I0"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_RESHAPING in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(ENV_PROPOR):           return set_param_data(ap,0                ,4,0,"0000"     );    break;
+        case(ENV_IMPOSE):
+            switch(mode) {
+                case(ENV_ENVFILE_IN):
+                case(ENV_DB_BRKFILE_IN):
+                case(ENV_BRKFILE_IN): return set_param_data(ap,0                  ,4,0,"0000"     );
+                case(ENV_SNDFILE_IN): return set_param_data(ap,0                  ,4,1,"d000"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_IMPOSE in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(ENV_REPLACE):
+            switch(mode) {
+                case(ENV_ENVFILE_IN):     return set_param_data(ap,0                  ,4,0,"0000"     );
+                case(ENV_BRKFILE_IN):
+                case(ENV_DB_BRKFILE_IN):
+                case(ENV_SNDFILE_IN):     return set_param_data(ap,0                  ,4,1,"d000"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_REPLACE in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(ENV_DOVETAILING):
+            switch(mode) {
+                case(DOVE):        return set_param_data(ap,0                     ,4,4,"ddii"     );
+                case(DOVEDBL):     return set_param_data(ap,0                     ,4,2,"dd00"     );
+            }
+            break;
+        case(ENV_SWELL):       return set_param_data(ap,0                     ,4,2,"d0i0"     );
+        case(ENV_ATTACK):
+            switch(mode) {
+                case(ENV_ATK_GATED): return set_param_data(ap,0                   ,4,4,"dddd"     );
+                case(ENV_ATK_TIMED): return set_param_data(ap,0                   ,4,4,"dddd"     );
+                case(ENV_ATK_XTIME): return set_param_data(ap,0                   ,4,4,"dddd"     );
+                case(ENV_ATK_ATMAX): return set_param_data(ap,0                   ,4,3,"0ddd"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_ATTACK in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(ENV_CURTAILING):
+            switch(mode) {
+                case(ENV_START_AND_END):
+                case(ENV_START_AND_DUR):    return set_param_data(ap,0               ,4,3,"ddi0"     );
+                case(ENV_START_ONLY):       return set_param_data(ap,0               ,4,2,"d0i0"     );
+                case(ENV_START_AND_END_D):
+                case(ENV_START_AND_DUR_D):  return set_param_data(ap,0               ,4,2,"dd00"     );
+                case(ENV_START_ONLY_D):     return set_param_data(ap,0               ,4,1,"d000"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for ENV_CURTAILING in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            
+        case(ENV_ENVTOBRK):    return set_param_data(ap,0                     ,4,0,"0000"     );
+        case(ENV_ENVTODBBRK):  return set_param_data(ap,0                     ,4,0,"0000"     );
+        case(ENV_BRKTOENV):    return set_param_data(ap,0                     ,4,1,"d000"     );
+        case(ENV_DBBRKTOENV):  return set_param_data(ap,0                     ,4,1,"d000"     );
+        case(ENV_DBBRKTOBRK):  return set_param_data(ap,0                     ,4,0,"0000"     );
+        case(ENV_BRKTODBBRK):  return set_param_data(ap,0                     ,4,0,"0000"     );
+        case(ENV_PLUCK):       return set_param_data(ap,0                     ,4,2,"ii00"     );
+        case(ENV_TREMOL):      return set_param_data(ap,0                     ,4,3,"DDD0"     );
+            
+        case(MIX):             return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXTWO):          return set_param_data(ap,0                     ,0,0,""         );
+            //TW NEW
+        case(MIXMANY):         return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXBALANCE):      return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXCROSS):        return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXINTERL):       return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXINBETWEEN):
+            switch(mode) {
+                case(INBI_COUNT):  return set_param_data(ap,0                     ,1,1,"i"        );
+                case(INBI_RATIO):  return set_param_data(ap,INBTWN_RATIOS         ,1,0,"0"        );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for MIXINBETWEEN in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MIXTEST):         return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXMAX):          return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXFORMAT):       return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXDUMMY):        return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXSYNC):         return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXSYNCATT):      return set_param_data(ap,0                     ,0,0,""         );
+        case(MIXGAIN):         return set_param_data(ap,0                     ,2,1,"d0"       );
+        case(MIXTWARP):
+            switch(mode) {
+                case(MTW_REVERSE_T):    case(MTW_REVERSE_NT):
+                case(MTW_FREEZE_T):     case(MTW_FREEZE_NT):    case(MTW_TIMESORT):
+                    return set_param_data(ap,0                     ,2,0,"00"       );
+                case(MTW_DOMINO):       case(MTW_ADD_TO_TG):    case(MTW_SCATTER):
+                case(MTW_CREATE_TG_1):  case(MTW_CREATE_TG_2):  case(MTW_CREATE_TG_3):  case(MTW_CREATE_TG_4):
+                case(MTW_ENLARGE_TG_1): case(MTW_ENLARGE_TG_2): case(MTW_ENLARGE_TG_3): case(MTW_ENLARGE_TG_4):
+                    return set_param_data(ap,0                     ,2,1,"d0"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MIXTWARP in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MIXSWARP):
+            switch(mode) {
+                case(MSW_TWISTALL):return set_param_data(ap,0                     ,2,0,"00"       );
+                case(MSW_TWISTONE):return set_param_data(ap,0                     ,2,1,"i0"       );
+                    
+                case(MSW_FIXED):
+                case(MSW_NARROWED):return set_param_data(ap,0                     ,2,1,"d0"       );
+                    
+                case(MSW_LEFTWARDS):
+                case(MSW_RIGHTWARDS):
+                case(MSW_RANDOM):
+                case(MSW_RANDOM_ALT):
+                    return set_param_data(ap,0                     ,2,2,"dd"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MIXSWARP in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MIXSHUFL):
+            switch(mode) {
+                case(MSH_DUPLICATE):
+                case(MSH_REVERSE_N):
+                case(MSH_SCATTER):
+                case(MSH_FIXED_N):
+                case(MSH_OMIT):
+                case(MSH_OMIT_ALT):
+                    return set_param_data(ap,0                     ,2,0,"00"       );
+                case(MSH_DUPL_AND_RENAME):
+                    return set_param_data(ap,SNDFILENAME           ,2,0,"00"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MIXSHUFL in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            
+        case(EQ):
+            switch(mode) {
+                case(FLT_LOSHELF):
+                case(FLT_HISHELF): return set_param_data(ap,0                     ,5,2,"0dd00"    );
+                case(FLT_PEAKING): return set_param_data(ap,0                     ,5,3,"ddd00"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for EQ in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(LPHP):            return set_param_data(ap,0                     ,5,3,"0ddd0"    );
+        case(FSTATVAR):        return set_param_data(ap,0                     ,5,3,"DdD00"    );
+        case(FLTBANKN):
+            switch(mode) {
+                case(FLT_HARMONIC):
+                case(FLT_ALTERNATE):
+                case(FLT_SUBHARM): return set_param_data(ap,0                     ,5,4,"Dddd0"    );
+                case(FLT_EQUALSPAN):return set_param_data(ap,0                    ,5,5,"Ddddi"    );
+                case(FLT_LINOFFSET):return set_param_data(ap,0                    ,5,5,"Ddddd"    );
+                case(FLT_EQUALINT):return set_param_data(ap,0                     ,5,5,"Ddddd"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for FLTBANKN in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(FLTBANKC):
+            switch(mode) {
+                case(FLT_HARMONIC):
+                case(FLT_ALTERNATE):
+                case(FLT_SUBHARM): return set_param_data(ap,0                     ,6,2,"00dd00"    );
+                case(FLT_EQUALSPAN):return set_param_data(ap,0                    ,6,3,"00ddi0"    );
+                case(FLT_LINOFFSET):return set_param_data(ap,0                    ,6,3,"00ddd0"    );
+                case(FLT_EQUALINT):return set_param_data(ap,0                     ,6,3,"00ddd0"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for FLTBANKC in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(FLTBANKU):        return set_param_data(ap,FILTERBANK            ,5,2,"Dd000"    );
+        case(FLTBANKV):        return set_param_data(ap,TIMEVARYING_FILTERBANK,3,2,"Dd0"      );
+        case(FLTBANKV2):       return set_param_data(ap,TIMEVARY2_FILTERBANK  ,3,2,"Dd0"      );
+        case(FLTITER):         return set_param_data(ap,FILTERBANK            ,6,4,"dddd00"   );
+        case(FLTSWEEP):        return set_param_data(ap,0                     ,5,5,"DdDDD"    );
+        case(ALLPASS):         return set_param_data(ap,0                     ,5,2,"0dD00"    );
+            
+        case(MOD_LOUDNESS):
+            switch(mode) {
+                    //      case(LOUDNESS_GAIN):    return set_param_data(ap,0                ,2,1, "d0");
+                case(LOUDNESS_GAIN):    return set_param_data(ap,0                ,2,1, "D0");
+                    //      case(LOUDNESS_DBGAIN):  return set_param_data(ap,0                ,2,1, "d0");
+                case(LOUDNESS_DBGAIN):  return set_param_data(ap,0                ,2,1, "D0");
+                case(LOUDNESS_NORM):    return set_param_data(ap,0                ,1,0, "0");
+                case(LOUDNESS_SET):     return set_param_data(ap,0                ,1,0, "0");
+                case(LOUDNESS_BALANCE): return set_param_data(ap,0                ,2,0, "00");
+                case(LOUDNESS_PHASE):   return set_param_data(ap,0                ,0,0, "");
+                case(LOUDNESS_LOUDEST): return set_param_data(ap,0                ,2,0, "00");
+                case(LOUDNESS_EQUALISE): return set_param_data(ap,0               ,2,0, "00");
+                case(LOUD_PROPOR):      return set_param_data(ap,LOUDNESS         ,2,0, "00");
+                case(LOUD_DB_PROPOR):   return set_param_data(ap,LOUDNESS         ,2,0, "00");
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_LOUDNESS in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MOD_SPACE):
+            switch(mode) {
+                case(MOD_PAN):          return set_param_data(ap,0                ,1,1, "D");
+                case(MOD_MIRROR):       return set_param_data(ap,0                ,2,0, "00");
+                case(MOD_MIRRORPAN):    return set_param_data(ap,0                ,2,0, "00");
+                case(MOD_NARROW):       return set_param_data(ap,0                ,2,1, "d0");
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_SPACE in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(SCALED_PAN):           return set_param_data(ap,0                ,1,1, "D");
+        case(MOD_PITCH):
+            switch(mode) {
+                case(MOD_ACCEL):        return set_param_data(ap,0                ,2,2, "dd");
+                case(MOD_VIBRATO):      return set_param_data(ap,0                ,2,2, "DD");
+                default:                return set_param_data(ap,0                ,1,1, "D");
+            }
+            break;
+        case(MOD_REVECHO):
+            switch(mode) {
+                case(MOD_DELAY):        return set_param_data(ap,0                ,8,4,"dDD0000d");
+                case(MOD_VDELAY):       return set_param_data(ap,0                ,8,8,"dddddddd");
+                case(MOD_STADIUM):      return set_param_data(ap,0                ,0,0,"");
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_REVECHO in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MOD_RADICAL):
+            switch(mode) {
+                case(MOD_REVERSE):      return set_param_data(ap,0                ,0,0,"");
+                case(MOD_SHRED):        return set_param_data(ap,0                ,2,2,"id");
+                case(MOD_SCRUB):        return set_param_data(ap,0                ,1,1,"d");
+                case(MOD_LOBIT):        return set_param_data(ap,0                ,2,2,"ii");
+                case(MOD_LOBIT2):       return set_param_data(ap,0                ,2,1,"i0");
+                case(MOD_RINGMOD):      return set_param_data(ap,0                ,1,1,"D");
+                case(MOD_CROSSMOD):     return set_param_data(ap,0                ,0,0,"");
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_RADICAL in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(BRASSAGE):
+            switch(mode) {
+                case(GRS_PITCHSHIFT):   return set_param_data(ap,0                ,16,1, "00000D0000000000");
+                case(GRS_TIMESTRETCH):  return set_param_data(ap,0                ,16,1, "D000000000000000");
+                case(GRS_REVERB):       return set_param_data(ap,0                ,16,3, "0D000DD000000000");
+                case(GRS_SCRAMBLE):     return set_param_data(ap,0                ,16,1, "0000D00000000000");
+                case(GRS_GRANULATE):    return set_param_data(ap,0                ,16,1, "0D00000000000000");
+                case(GRS_BRASSAGE):     return set_param_data(ap,0                ,16,8, "DD00DDDDDD000000");
+                case(GRS_FULL_MONTY):   return set_param_data(ap,0                ,16,16,"DDDDDDDDDDDDDDDD");
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for BRASSAGE in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SAUSAGE):         return set_param_data(ap,0                      ,16,16,"DDDDDDDDDDDDDDDD");
+            
+        case(PVOC_ANAL):       return set_param_data(ap,0                     ,0,0,""         );
+        case(PVOC_SYNTH):      return set_param_data(ap,0                     ,2,0,"00"       );
+        case(PVOC_EXTRACT):    return set_param_data(ap,0                     ,0,0,""         );
+            
+            /* TEMPORARY TEST ROUTINE */
+        case(WORDCNT):         return set_param_data(ap,0                     ,0,0,""         );
+            /* TEMPORARY TEST ROUTINE */
+            
+        case(EDIT_CUT):
+            switch(mode) {
+                case(EDIT_SECS):   return set_param_data(ap,0                     ,2,2,"dd"       );
+                case(EDIT_SAMPS):
+                case(EDIT_STSAMPS):return set_param_data(ap,0                     ,2,2,"ii"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for EDIT_CUT in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(EDIT_CUTMANY): return set_param_data(ap,MANYCUTS                 ,1,1,"d"       );
+        case(STACK):        return set_param_data(ap,STACKDATA                ,5,5,"idddd"   );
+            
+        case(EDIT_CUTEND):
+            switch(mode) {
+                case(EDIT_SECS):   return set_param_data(ap,0                     ,2,1,"d0"       );
+                case(EDIT_SAMPS):
+                case(EDIT_STSAMPS):return set_param_data(ap,0                     ,2,1,"i0"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for EDIT_CUTEND in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(EDIT_ZCUT):
+            switch(mode) {
+                case(EDIT_SECS):   return set_param_data(ap,0                     ,2,2,"dd"       );
+                case(EDIT_SAMPS):
+                case(EDIT_STSAMPS):return set_param_data(ap,0                     ,2,2,"ii"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for EDIT_ZCUT in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MANY_ZCUTS):      return set_param_data(ap,MANYCUTS              ,0,0,""         );
+        case(EDIT_EXCISE):
+            switch(mode) {
+                case(EDIT_SECS):   return set_param_data(ap,0                     ,2,2,"dd"       );
+                case(EDIT_SAMPS):
+                case(EDIT_STSAMPS):return set_param_data(ap,0                     ,2,2,"ii"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for EDIT_EXCISE in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            
+        case(EDIT_EXCISEMANY): return set_param_data(ap,EXCISE_TIMES          ,2,0,"00"       );
+        case(INSERTSIL_MANY):  return set_param_data(ap,EXCISE_TIMES          ,2,0,"00"       );
+            
+        case(EDIT_INSERT):
+            switch(mode) {
+                case(EDIT_SECS):   return set_param_data(ap,0                     ,2,1,"d0"       );
+                case(EDIT_SAMPS):
+                case(EDIT_STSAMPS):return set_param_data(ap,0                     ,2,1,"i0"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for EDIT_INSERT in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(EDIT_INSERT2):    return set_param_data(ap,0                     ,2,2,"dd"       );
+            
+        case(EDIT_INSERTSIL):
+            switch(mode) {
+                case(EDIT_SECS):   return set_param_data(ap,0                     ,2,2,"dd"       );
+                case(EDIT_SAMPS):
+                case(EDIT_STSAMPS):return set_param_data(ap,0                     ,2,2,"ii"       );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for EDIT_INSERTSIL in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(EDIT_JOIN):       return set_param_data(ap,0                     ,2,0,"00"       );
+            
+        case(HOUSE_COPY):
+            switch(mode) {
+                case(COPYSF):      return set_param_data(ap,0                     ,1,0,"0"        );
+                case(DUPL):        return set_param_data(ap,0                     ,1,1,"i"        );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_COPY in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_DEL):       return set_param_data(ap,SNDFILENAME           ,0,0,""         );
+        case(HOUSE_CHANS):
+            switch(mode) {
+                case(HOUSE_CHANNEL):    return set_param_data(ap,0                ,1,1,"i"        );
+                case(HOUSE_CHANNELS):   return set_param_data(ap,0                ,0,0,""         );
+                case(HOUSE_ZCHANNEL):   return set_param_data(ap,0                ,1,1,"i"        );
+                case(STOM):             return set_param_data(ap,0                ,0,0,""         );
+                case(MTOS):             return set_param_data(ap,0                ,0,0,""         );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_CHANS in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_BUNDLE):    return set_param_data(ap,0                     ,0,0,""         );
+        case(HOUSE_SORT):
+            switch(mode) {
+                case(BY_FILETYPE):      return set_param_data(ap,0                ,3,0,"000"      );
+                case(BY_SRATE):         return set_param_data(ap,0                ,3,0,"000"      );
+                case(BY_DURATION):      return set_param_data(ap,0                ,3,3,"ddd"      );
+                case(BY_LOG_DUR):       return set_param_data(ap,0                ,3,3,"ddd"      );
+                case(IN_DUR_ORDER):     return set_param_data(ap,0                ,3,0,"000"      );
+                case(FIND_ROGUES):      return set_param_data(ap,0                ,3,0,"000"      );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_SORT in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_SPEC):
+            switch(mode) {
+                case(HOUSE_RESAMPLE): return set_param_data(ap,0                  ,1,1,"i"        );
+                default:              return set_param_data(ap,0                  ,0,0,""         );
+            }
+            break;
+        case(HOUSE_EXTRACT):
+            switch(mode) {
+                case(HOUSE_RECTIFY):  return set_param_data(ap,0                  ,1,1,"d"        );
+                case(HOUSE_CUTGATE):
+                case(HOUSE_CUTGATE_PREVIEW):
+                case(HOUSE_TOPNTAIL): return set_param_data(ap,0                  ,0,0,""         );
+                case(HOUSE_ONSETS):   return set_param_data(ap,0                  ,9,7,"d0dd0iddi");
+                case(HOUSE_BYHAND):   return set_param_data(ap,BY_HAND            ,0,0,""         );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_EXTRACT in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(TOPNTAIL_CLICKS):    return set_param_data(ap,0                  ,2,2,"dd"       );
+            //TW NEW: REPLACING BRACKETED OUT CODE (Dump & Recover abandoned)
+        case(HOUSE_BAKUP):        return set_param_data(ap,0                  ,0,0,""         );
+        case(HOUSE_GATE):         return set_param_data(ap,0                  ,0,0,""         );
+            
+        case(HOUSE_DISK):         return set_param_data(ap,0                  ,0,0,""         );
+            
+        case(INFO_PROPS):         return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_SFLEN):         return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_TIMELIST):      return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_LOUDLIST):      return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_TIMESUM):       return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_TIMEDIFF):      return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_SAMPTOTIME):    return set_param_data(ap,0                  ,1,1,"i"        );
+        case(INFO_TIMETOSAMP):    return set_param_data(ap,0                  ,1,1,"d"        );
+        case(INFO_MAXSAMP):       return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_MAXSAMP2):      return set_param_data(ap,0                  ,2,2,"dd"       );
+        case(INFO_LOUDCHAN):      return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_FINDHOLE):      return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_DIFF):          return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_CDIFF):         return set_param_data(ap,0                  ,0,0,""         );
+        case(INFO_PRNTSND):       return set_param_data(ap,0                  ,2,2,"dd"       );
+        case(INFO_MUSUNITS):
+            switch(mode) {
+                case(MU_MIDI_TO_FRQ):           case(MU_FRQ_TO_MIDI):       case(MU_FRQRATIO_TO_SEMIT):
+                case(MU_FRQRATIO_TO_INTVL):     case(MU_SEMIT_TO_FRQRATIO): case(MU_OCTS_TO_FRQRATIO):
+                case(MU_OCTS_TO_SEMIT):         case(MU_SEMIT_TO_OCTS):     case(MU_SEMIT_TO_INTVL):
+                case(MU_FRQRATIO_TO_TSTRETH):   case(MU_SEMIT_TO_TSTRETCH): case(MU_OCTS_TO_TSTRETCH):
+                case(MU_TSTRETCH_TO_FRQRATIO):  case(MU_TSTRETCH_TO_SEMIT): case(MU_TSTRETCH_TO_OCTS):
+                case(MU_TSTRETCH_TO_INTVL):     case(MU_GAIN_TO_DB):        case(MU_DB_TO_GAIN):
+                case(MU_FRQRATIO_TO_OCTS):      case(MU_MIDI_TO_NOTE):      case(MU_FRQ_TO_NOTE):
+                case(MU_FRQ_TO_DELAY):          case(MU_MIDI_TO_DELAY):     case(MU_TEMPO_TO_DELAY):
+                case(MU_DELAY_TO_FRQ):          case(MU_DELAY_TO_MIDI):     case(MU_DELAY_TO_TEMPO):
+                    return set_param_data(ap,0                  ,1,1,"d"        );
+                case(MU_NOTE_TO_FRQ):
+                case(MU_NOTE_TO_MIDI):
+                case(MU_NOTE_TO_DELAY):
+                    return set_param_data(ap,NOTE_REPRESENTATION      ,0,0,""         );
+                case(MU_INTVL_TO_FRQRATIO):
+                case(MU_INTVL_TO_TSTRETCH):
+                    return set_param_data(ap,INTERVAL_REPRESENTATION  ,0,0,""         );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for MUSUNITS in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SYNTH_WAVE):       return set_param_data(ap,0                    ,4,4,"iidD"     );
+        case(MULTI_SYN):        return set_param_data(ap,CHORD_SYN            ,4,3,"iid0"     );
+        case(SYNTH_NOISE):      return set_param_data(ap,0                    ,4,3,"iid0"     );
+        case(SYNTH_SIL):        return set_param_data(ap,0                    ,4,3,"iid0"     );
+        case(SYNTH_SPEC):       return set_param_data(ap,0                    ,7,7,"dDDDDDd"  );
+        case(RANDCUTS):         return set_param_data(ap,0                    ,2,2,"dd"       );
+        case(RANDCHUNKS):       return set_param_data(ap,0                    ,2,2,"id"       );
+        case(SIN_TAB):          return set_param_data(ap,0                    ,5,5,"DDddd"    );
+        case(ACC_STREAM):       return set_param_data(ap,ATTACK_STREAM        ,1,1,"D"        );
+        case(HF_PERM1):
+            switch(mode) {
+                case(HFP_SNDOUT):   return set_param_data(ap,0                    ,10,10,"idddiiiiii");
+                case(HFP_SNDSOUT):  return set_param_data(ap,0                    ,10,9, "idd0iiiiii");
+                case(HFP_TEXTOUT):  return set_param_data(ap,0                    ,10,6, "0000iiiiii");
+                case(HFP_MIDIOUT):  return set_param_data(ap,0                    ,10,6, "0000iiiiii");
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HF_PERM1 in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+        case(HF_PERM2):
+            switch(mode) {
+                case(HFP_SNDOUT):   return set_param_data(ap,0                    ,10,6,"idddi0000i");
+                case(HFP_SNDSOUT):  return set_param_data(ap,0                    ,10,5,"idd0i0000i");
+                case(HFP_TEXTOUT):  return set_param_data(ap,0                    ,10,2,"0000i0000i");
+                case(HFP_MIDIOUT):  return set_param_data(ap,0                    ,10,2,"0000i0000i");
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HF_PERM2 in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(DEL_PERM):         return set_param_data(ap,DELPERM              ,3,3,"idi");
+        case(DEL_PERM2):        return set_param_data(ap,DELPERM2             ,3,1,"00i");
+        case(TWIXT):
+            switch(mode) {
+                case(TRUE_EDIT):     return set_param_data(ap,SWITCH_TIMES        ,2,1,"d0");
+                case(IN_SEQUENCE):   return set_param_data(ap,SWITCH_TIMES        ,2,1,"d0");
+                case(RAND_REORDER):  return set_param_data(ap,SWITCH_TIMES        ,2,2,"di");
+                case(RAND_SEQUENCE): return set_param_data(ap,SWITCH_TIMES        ,2,2,"di");
+                default:
+                    //          sprintf(errstr,"Unknown mode (%d) for TWIXT in set_vflgs()\n",mode);
+                    sprintf(errstr,"Unknown mode (%d) for TWIXT in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SPHINX):
+            switch(mode) {
+                case(IN_SEQUENCE):   return set_param_data(ap,MANY_SWITCH_TIMES   ,2,1,"d0");
+                case(RAND_REORDER):  return set_param_data(ap,MANY_SWITCH_TIMES   ,2,2,"di");
+                case(RAND_SEQUENCE): return set_param_data(ap,MANY_SWITCH_TIMES   ,2,2,"di");
+                default:
+                    //          sprintf(errstr,"Unknown mode (%d) for SPHINX in set_vflgs()\n",mode);
+                    sprintf(errstr,"Unknown mode (%d) for SPHINX in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(MIX_ON_GRID):      return set_param_data(ap,GRIDDED_MIX          ,0,0,"");
+        case(AUTOMIX):          return set_param_data(ap,AUTO_MIX             ,1,1,"D");
+        case(NOISE_SUPRESS):    return set_param_data(ap,0                    ,4,4,"dddd");
+        case(TIME_GRID):        return set_param_data(ap,0                    ,3,3,"iDD");
+        case(SEQUENCER2):       return set_param_data(ap,SEQUENCER2_VALUES    ,1,1,"d");
+        case(SEQUENCER):        return set_param_data(ap,SEQUENCER_VALUES     ,1,1,"d");
+        case(CONVOLVE):
+            switch(mode) {
+                case(CONV_NORMAL):  return set_param_data(ap,0                    ,1,0,"0");
+                case(CONV_TVAR):    return set_param_data(ap,0                    ,1,1,"D");
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for CONVOLVE in set_legal_param_structure()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            
+        case(BAKTOBAK):         return set_param_data(ap,0                    ,2,2,"dd");
+        case(ADDTOMIX):         return set_param_data(ap,0                    ,0,0,"");
+        case(MIX_PAN):          return set_param_data(ap,0                    ,1,1,"D");
+        case(SHUDDER):          return set_param_data(ap,0                    ,8,8,"dDDDDDDD");
+        case(MIX_AT_STEP):      return set_param_data(ap,0                    ,1,1,"d");
+        case(FIND_PANPOS):      return set_param_data(ap,0                    ,1,1,"d");
+        case(CLICK):            return set_param_data(ap,CLICKTRACK           ,0,0,"");
+        case(DOUBLETS):         return set_param_data(ap,0                    ,2,2,"Di");
+        case(SYLLABS):          return set_param_data(ap,SYLLTIMES            ,2,2,"dd");
+        case(JOIN_SEQ):         return set_param_data(ap,JOINSEQ              ,2,0,"00");
+        case(JOIN_SEQDYN):      return set_param_data(ap,JOINSEQDYN           ,2,0,"00");
+        case(MAKE_VFILT):       return set_param_data(ap,0                    ,0,0,"");
+        case(BATCH_EXPAND):     return set_param_data(ap,BATCH                ,3,3,"iii");
+        case(MIX_MODEL):        return set_param_data(ap,0                    ,0,0,"");
+        case(CYCINBETWEEN):     return set_param_data(ap,0                    ,2,2,"id");
+        case(ENVSYN):
+            switch(mode) {
+                case(ENVSYN_USERDEF):
+                    return set_param_data(ap,ENVSYN_ENVELOPE          ,6,4,"ddDd00"  );
+                default:       return set_param_data(ap,0                         ,6,6,"ddDdDD"  );
+            }
+            break;
+        case(RRRR_EXTEND):
+            switch(mode) {
+                case(0):            return set_param_data(ap,0                    ,11,10,"dddidiDD0DD");
+                case(1):            return set_param_data(ap,0                    ,11,11,"dddidiDDiDD");
+                case(2):            return set_param_data(ap,0                    ,11,4, "dd0id000000");
+            }
+            break;
+        case(SSSS_EXTEND):      return set_param_data(ap,0                    ,4,4,"dddd");
+        case(HOUSE_GATE2):      return set_param_data(ap,0                    ,5,5,"ddddd");
+        case(GRAIN_ASSESS):     return set_param_data(ap,0                    ,2,0,"00"       );
+        case(ZCROSS_RATIO):     return set_param_data(ap,0                    ,0,0,"00"       );
+        case(GREV):
+            switch(mode) {
+                case(0):            return set_param_data(ap,0                    ,5,3,"ddI00");
+                case(1):            return set_param_data(ap,0                    ,5,4,"ddII0");
+                case(2):            return set_param_data(ap,0                    ,5,5,"ddIIi");
+                case(3):            return set_param_data(ap,0                    ,5,5,"ddIIi");
+                case(4):            return set_param_data(ap,0                    ,5,4,"ddID0");
+                case(5):            return set_param_data(ap,0                    ,5,3,"ddI00");
+                case(6):            return set_param_data(ap,GRAIN_TIMINGS        ,5,3,"ddI00");
+            }
+            break;
+            /*  |                         |m| |        | */
+            /*  |                         |a| |        | */
+            /*  |                         |x| |        | */
+            /*  |                         |p|p|        | */
+            /*  |                         |a|a|        | */
+            /*  |  special-data           |r|r| param  | */
+            /*  |                         |a|a|  list  | */
+            /*  |                         |m|m|        | */
+            /*  |                         |c|c|        | */
+            /*  |                         |n|n|        | */
+            /*  |                         |t|t|        | */
+        default:
+            sprintf(errstr,"Unknown process (%d) in set_legal_param_structure()\n",process);
+            return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}                                                           
+
+/************************** SET_LEGAL_OPTION_AND_VARIANT_STRUCTURE ***********/
+
+int set_legal_option_and_variant_structure(int process,int mode,aplptr ap)                                        
+{
+    /*|      | |        |        |v| |       */
+    /*|      |o|        |        |f|v|       */
+    /*|option|p| option |variant |l|p|variant*/
+    /*|flags |t|  list  | flags  |a|a|list   */
+    /*|      |c|        |        |g|r|       */
+    /*|      |n|        |        |c|a|     */
+    /*|      |t|        |        |n|m|     */
+    /*|      | |        |        |t|s|       */
+    switch(process) {
+        case(ACCU):        return set_vflgs(ap,""      ,0,""      ,"dg"    ,2,2,"DD"    );
+        case(ALT):         return set_vflgs(ap,""      ,0,""      ,"x"     ,1,0,"0"     );
+        case(ARPE):
+            switch(mode) {
+                case(ON): case(BOOST): case(ABOVE_BOOST): case(BELOW_BOOST):
+                    return set_vflgs(ap,"plhba", 5,"dDDDD" ,"NsTK"  ,4,2,"dI00"  );
+                    //TW JULY 2006
+                case(ABOVE): case(BELOW):
+                    return set_vflgs(ap,"plhba", 5,"dDD0D" ,""     ,0,0,""      );
+                default:       return set_vflgs(ap,"plhba", 5,"dDDDD" ,""      ,0,0,""      );
+            }
+            break;
+        case(AVRG):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(BARE):        return set_vflgs(ap,""      ,0,""      ,"x"     ,1,0,"0"     );
+        case(BLTR):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(BLUR):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(BRIDGE):      return set_vflgs(ap,"abcde" ,5,"ddddd" ,"fg"    ,2,2,"dd"    );
+        case(CHANNEL):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(CHORD):       return set_vflgs(ap,""      ,0,""      ,"btx"   ,3,2,"DD0"   );
+        case(CHORUS):      return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(CLEAN):       return set_vflgs(ap,"g"     ,1,"d"     ,""      ,0,0,""      );
+        case(CROSS):       return set_vflgs(ap,""      ,0,""      ,"i"     ,1,1,"D"     );
+        case(CUT):         return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(DIFF):        return set_vflgs(ap,""      ,0,""      ,"ca"    ,2,1,"D0"    );
+        case(DRUNK):       return set_vflgs(ap,""      ,0,""      ,"z"     ,1,0,"0"     );
+        case(EXAG):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(FILT):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(FMNTSEE):     return set_vflgs(ap,""      ,0,""      ,"v"     ,1,0,"0"     );
+        case(FOCUS):       return set_vflgs(ap,"bt"    ,2,"DD"    ,"s"     ,1,1,"i"     );
+        case(FOLD):        return set_vflgs(ap,""      ,0,""      ,"x"     ,1,0,"0"     );
+        case(FORM):        return set_vflgs(ap,"lhg"   ,3,"ddd"   ,""      ,0,0,""      );
+        case(FORMANTS):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(FORMSEE):     return set_vflgs(ap,""      ,0,""      ,"s"     ,1,0,"0"     );
+        case(FREEZE):      return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(FREEZE2):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(FREQUENCY):   return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(GAIN):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(GLIDE):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(GLIS):        return set_vflgs(ap,""      ,0,""      ,"t"     ,1,1,"d"     );
+        case(GRAB):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(GREQ):        return set_vflgs(ap,""      ,0,""      ,"r"     ,1,0,"0"     );
+        case(INVERT):      return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(LEAF):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(LEVEL):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(MAGNIFY):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(MAKE):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(MAX):         return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(MEAN):        return set_vflgs(ap,"lhc"   ,3,"ddi"   ,"z"     ,1,0,"0"     );
+        case(MORPH):       return set_vflgs(ap,"s"     ,1,"d"     ,""      ,0,0,""      );
+        case(NOISE):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(OCT):         return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(OCTVU):       return set_vflgs(ap,""      ,0,""      ,"f"     ,1,1,"d"     );
+        case(P_APPROX):    return set_vflgs(ap,"pts"   ,3,"DDD"   ,""      ,0,0,""      );
+        case(P_CUT):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_EXAG):      return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_FIX):       return set_vflgs(ap,""      ,0,""      ,"rxlhsbewi",9,7,"ddddidd00");
+        case(P_HEAR):      return set_vflgs(ap,"g"     ,1,"d"     ,""      ,0,0,""      );
+        case(P_INFO):      return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_INVERT):    return set_vflgs(ap,""      ,0,""      ,"mbt"   ,3,3,"Ddd"   );
+        case(P_QUANTISE):  return set_vflgs(ap,""      ,0,""      ,"o"     ,1,0,"0"     );
+        case(P_RANDOMISE): return set_vflgs(ap,""      ,0,""      ,"s"     ,1,1,"d"     );
+        case(P_SEE):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_SMOOTH):    return set_vflgs(ap,""      ,0,""      ,"ph"    ,2,1,"D0"    );
+            //TW NEW
+        case(P_SYNTH):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(VFILT):
+        case(P_VOWELS):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_GEN):       return set_vflgs(ap,"co"    ,2,"ii"    ,""      ,0,0,""      );
+        case(P_INSERT):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_SINSERT):   return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_PTOSIL):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_NTOSIL):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(ANALENV):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_BINTOBRK):  return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(MAKE2):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_INTERP):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+            
+        case(P_TRANSPOSE): return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_VIBRATO):   return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(P_WRITE):     return set_vflgs(ap,"d"     ,1,"d"     ,""      ,0,0,""      );
+        case(P_ZEROS):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(PEAK):        return set_vflgs(ap,"ctf"   ,3,"ddd"   ,"h"     ,1,0,"0"     );
+        case(PICK):        return set_vflgs(ap,"c"     ,1,"D"     ,""      ,0,0,""      );
+        case(PITCH):
+            switch(mode) {
+                case(PICH_TO_BIN):
+                    return set_vflgs(ap,"tgsnlh",6,"dididd"  ,"az"  ,2,0,"00"    );
+                case(PICH_TO_BRK):
+                    return set_vflgs(ap,"tgsnlhd",7,"dididdd","a"   ,1,0,"0"     );
+            }
+            break;
+        case(PLUCK):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(PRINT):       return set_vflgs(ap,"w"     ,1,"i",     ""      ,0,0,""      );
+        case(REPITCH):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(REPITCHB):    return set_vflgs(ap,"d"     ,1,"d"     ,""      ,0,0,""      );
+        case(REPORT):      return set_vflgs(ap,"bts"   ,3,"DDi"   ,""      ,0,0,""      );
+        case(SCAT):        return set_vflgs(ap,"b"     ,1,"D"     ,"rn"    ,2,0,"00"    );
+        case(SHIFT):       return set_vflgs(ap,""      ,0,""      ,"l"     ,1,0,"0"     );
+        case(SHIFTP):      return set_vflgs(ap,""      ,0,""      ,"d"     ,1,1,"D"     );
+        case(SHUFFLE):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(SPLIT):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(SPREAD):      return set_vflgs(ap,"s"     ,1,"D"     ,""      ,0,0,""      );
+        case(STEP):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(STRETCH):     return set_vflgs(ap,""      ,0,""      ,"d"     ,1,1,"D"     );
+        case(SUM):         return set_vflgs(ap,""      ,0,""      ,"c"     ,1,1,"D"     );
+        case(SUPR):        return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(S_TRACE):
+            switch(mode) {
+                case(TRC_ALL): return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+                default:       return set_vflgs(ap,""      ,0,""      ,"r"     ,1,0,"0"     );
+            }
+            break;
+        case(TRACK):
+            switch(mode) {
+                case(TRK_TO_BIN):
+                    return set_vflgs(ap,"tgsh"  ,4,"didd"  ,""      ,0,0,""      );
+                case(TRK_TO_BRK):
+                    return set_vflgs(ap,"tgshd" ,5,"diddd" ,""      ,0,0,""      );
+            }
+            break;
+        case(TRNSF):       return set_vflgs(ap,""      ,0,""      ,"lhx"   ,3,2,"DD0"   );
+        case(TRNSP):       return set_vflgs(ap,""      ,0,""      ,"lhx"   ,3,2,"DD0"   );
+        case(TSTRETCH):    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(TUNE):        return set_vflgs(ap,"fc"    ,2,"DD"    ,"tb"    ,2,2,"ID"    );
+        case(VOCODE):      return set_vflgs(ap,"lhg"   ,3,"ddd"   ,""      ,0,0,""      );
+        case(WARP):        return set_vflgs(ap,"pts"   ,3,"DDD"   ,""      ,0,0,""      );
+        case(WAVER):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(WEAVE):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(WINDOWCNT):   return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(LIMIT):       return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(MULTRANS):    return set_vflgs(ap,""      ,0,""      ,"btx"   ,3,2,"DD0"   );
+            
+            /************* GROUCHO **************/
+            /************* GROUCHO **************/
+            /************* GROUCHO **************/
+            
+        case(DISTORT):     return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(DISTORT_ENV):
+            switch(mode) {
+                case(DISTORTE_RISING):
+                case(DISTORTE_FALLING):     /* 1 param, 2 variants: param[1] = trof */
+                    return set_vflgs(ap,""      ,0,""      ,"te"    ,2,2,"DD"    );
+                case(DISTORTE_TROFFED):     /* 2 params, 1 variant: param[1] = trof */
+                    return set_vflgs(ap,""      ,0,""      ,"e"     ,1,1,"D"     );
+                case(DISTORTE_USERDEF):
+                    return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+            }
+            break;
+        case(DISTORT_AVG): return set_vflgs(ap,"m"     ,1,"d"     ,"s"     ,1,1,"i"     );
+        case(DISTORT_OMT): return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(DISTORT_MLT): return set_vflgs(ap,""      ,0,""      ,"s"     ,1,0,"0"     );
+        case(DISTORT_DIV): return set_vflgs(ap,""      ,0,""      ,"i"     ,1,0,"0"     );
+        case(DISTORT_HRM): return set_vflgs(ap,""      ,0,""      ,"p"     ,1,1,"d"     );
+        case(DISTORT_FRC): return set_vflgs(ap,""      ,0,""      ,"p"     ,1,1,"d"     );
+        case(DISTORT_REV): return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(DISTORT_SHUF):return set_vflgs(ap,"c"     ,1,"I"     ,"s"     ,1,1,"i"     );
+        case(DISTORT_RPT2):
+        case(DISTORT_RPT): return set_vflgs(ap,"c"     ,1,"I"     ,"s"     ,1,1,"i"     );
+        case(DISTORT_RPTFL): return set_vflgs(ap,"c"   ,1,"I"     ,"sf"    ,2,2,"id"    );
+        case(DISTORT_INTP):return set_vflgs(ap,""      ,0,""      ,"s"     ,1,1,"i"     );
+        case(DISTORT_DEL): return set_vflgs(ap,""      ,0,""      ,"s"     ,1,1,"i"     );
+        case(DISTORT_RPL): return set_vflgs(ap,""      ,0,""      ,"s"     ,1,1,"i"     );
+        case(DISTORT_TEL): return set_vflgs(ap,""      ,0,""      ,"sa"    ,2,1,"i0"    );
+        case(DISTORT_FLT): return set_vflgs(ap,""      ,0,""      ,"s"     ,1,1,"i"     );
+        case(DISTORT_INT): return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(DISTORT_CYCLECNT):
+            return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+        case(DISTORT_PCH): return set_vflgs(ap,"cs"    ,2,"Ii"    ,""      ,0,0,""      );
+        case(DISTORT_OVERLOAD):
+            return set_vflgs(ap,""      ,0,""      ,""      ,0,0,""      );
+            //TW NEW
+        case(DISTORT_PULSED):
+            return set_vflgs(ap,""      ,0,""      ,"se"    ,2,0,"00"    );
+            
+        case(ZIGZAG):
+            switch(mode) {
+                case(ZIGZAG_SELF):
+                    return set_vflgs(ap,"sm"    ,2,"dd"   ,"r"       ,1,1,"i"     );
+                case(ZIGZAG_USER):
+                    return set_vflgs(ap,"s"     ,1,"d"     ,""       ,0,0,""      );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : ZIGZAG: set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(LOOP):
+            switch(mode) {
+                case(LOOP_ALL):
+                    return set_vflgs(ap,"ws"    ,2,"dd"   ,"b"       ,1,0,"0"     );
+                case(LOOP_OUTLEN):
+                case(LOOP_RPTS):
+                    return set_vflgs(ap,"lws"   ,3,"ddd"  ,"b"       ,1,0,"0"     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : LOOP: set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SCRAMBLE):    return set_vflgs(ap,"w"     ,1,"d"    ,"sbe"     ,3,1,"i00"   );
+        case(ITERATE):     return set_vflgs(ap,""      ,0,""     ,"drpafgs" ,7,7,"DDDDDdi");
+        case(ITERATE_EXTEND): return set_vflgs(ap,""      ,0,""     ,"s" ,1,1,"i");
+        case(DRUNKWALK):
+            switch(mode) {
+                case(TOTALLY_PISSED):
+                    return set_vflgs(ap,"s"     ,1,"d"    ,"cor"     ,3,3,"DDi"   );
+                case(HAS_SOBER_MOMENTS):
+                    return set_vflgs(ap,"s"     ,1,"d"    ,"corlh"   ,5,5,"DDiDD" );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : DRUNKWALK: set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            
+        case(DECORATED): case(PREDECOR):  case(POSTDECOR):
+            return set_vflgs(ap,"aps"   ,3,"DDD"   ,"rwdihek",7,1,"i000000");
+        case(ORNATE):    case(PREORNATE): case(POSTORNATE):
+            return set_vflgs(ap,"aps"   ,3,"DDD"   ,"rwdihe" ,6,1,"i00000");
+        case(MOTIFS):    case(TMOTIFS):
+        case(MOTIFSIN):  case(TMOTIFSIN):
+            return set_vflgs(ap,"aps"   ,3,"DDD"   ,"rwdi"   ,4,1,"i000"  );
+        case(GROUPS):    case(TGROUPS):
+            return set_vflgs(ap,"aps"   ,3,"DDD"   ,"rwdi"   ,4,1,"i000"  );
+        case(SIMPLE_TEX):case(TIMED):
+            return set_vflgs(ap,"aps"   ,3,"DDD"   ,"rwcp"     ,4,1,"i000"    );
+            
+        case(GRAIN_COUNT):      case(GRAIN_OMIT):       case(GRAIN_REPITCH):    case(GRAIN_TIMEWARP):
+        case(GRAIN_GET):        case(GRAIN_DUPLICATE):  case(GRAIN_RERHYTHM):   case(GRAIN_ALIGN):
+        case(GRAIN_POSITION):   case(GRAIN_REORDER):    case(GRAIN_REMOTIF):    case(GRAIN_REVERSE):
+            return set_vflgs(ap,"blh"    ,3,"dDd"    ,"tx"     ,2,1,"d0"    );
+            
+        case(ENV_EXTRACT):
+            switch(mode) {
+                case(ENV_ENVFILE_OUT):
+                    return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+                case(ENV_BRKFILE_OUT):
+                    return set_vflgs(ap,"d" ,1,"d"     ,""       ,0,0,""      );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for ENV_EXTRACT: set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(ENV_CREATE):      return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_WARPING):     return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_RESHAPING):   return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_REPLOTTING):  return set_vflgs(ap,"d" ,1,"d"     ,""       ,0,0,""      );
+        case(ENV_IMPOSE):      return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+            //TW NEW
+        case(ENV_PROPOR):      return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_REPLACE):     return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_DOVETAILING): return set_vflgs(ap,"t" ,1,"i"     ,""       ,0,0,""      );
+        case(ENV_CURTAILING):  return set_vflgs(ap,"t" ,1,"i"     ,""       ,0,0,""      );
+        case(ENV_ENVTOBRK):    return set_vflgs(ap,"d" ,1,"d"     ,""       ,0,0,""      );
+        case(ENV_ENVTODBBRK):  return set_vflgs(ap,"d" ,1,"d"     ,""       ,0,0,""      );
+        case(ENV_BRKTOENV):    return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_DBBRKTOENV):  return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_DBBRKTOBRK):  return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_BRKTODBBRK):  return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_SWELL):       return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(ENV_ATTACK):      return set_vflgs(ap,"t" ,1,"i"     ,""       ,0,0,""      );
+        case(ENV_PLUCK):       return set_vflgs(ap,"ad",2,"id"    ,""       ,0,0,""      );
+        case(ENV_TREMOL):      return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+            
+        case(MIX):             return set_vflgs(ap,"seg",3,"ddd"  ,"a"      ,1,0,"0"     );
+        case(MIXTWO):          return set_vflgs(ap,"sjkbe",5,"ddddd",""     ,0,0,""      );
+            //TW NEW
+        case(MIXMANY):         return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXBALANCE):      return set_vflgs(ap,"kbe",3,"Ddd"  ,""       ,0,0,""      );
+        case(MIXINTERL):       return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXINBETWEEN):    return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXCROSS):
+            switch(mode) {
+                case(MCLIN):       return set_vflgs(ap,"sbe" ,3,"ddd" ,""       ,0,0,""      );
+                case(MCCOS):       return set_vflgs(ap,"sbep",4,"dddd",""       ,0,0,""      );
+            }
+            break;
+        case(MIXTEST):         return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXMAX):          return set_vflgs(ap,"se",2,"dd"    ,""       ,0,0,""      );
+        case(MIXFORMAT):       return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXDUMMY):        return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXSYNC):         return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+        case(MIXSYNCATT):      return set_vflgs(ap,"w" ,1,"i"     ,"p"      ,1,0,"0"     );
+        case(MIXTWARP):
+            switch(mode) {
+                case(MTW_TIMESORT):return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+                default:           return set_vflgs(ap,"se",2,"ii"    ,""       ,0,0,""      );
+            }
+        case(MIXSWARP):
+            switch(mode) {
+                case(MSW_TWISTALL):
+                case(MSW_TWISTONE):return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""      );
+                default:           return set_vflgs(ap,"se",2,"ii"    ,""       ,0,0,""      );
+            }
+            break;
+        case(MIXGAIN):         return set_vflgs(ap,"se",2,"ii"    ,""       ,0,0,""      );
+        case(MIXSHUFL):
+            switch(mode) {
+                case(MSH_DUPL_AND_RENAME):
+                    return set_vflgs(ap,"se",2,"ii"    ,"x"      ,1,0,"0"     );
+                default:
+                    return set_vflgs(ap,"se",2,"ii"    ,""       ,0,0,""      );
+            }
+            break;
+            
+            /*RWD May 2004 added t and a "d" to all filters ... correct? */
+        case(EQ):              return set_vflgs(ap,"ts"  ,2,"dd"    ,""       ,0,0,""    );
+        case(LPHP):            return set_vflgs(ap,"ts"  ,2,"dd"    ,""       ,0,0,""    );
+        case(FSTATVAR):        return set_vflgs(ap,"t"   ,1,"d"     ,""       ,0,0,""    );
+        case(FLTBANKN):        return set_vflgs(ap,"ts"  ,2,"dd"    ,"d"      ,1,0,"0"   );
+        case(FLTBANKC):        return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(FLTBANKU):        return set_vflgs(ap,"t"   ,1,"d"     ,"d"      ,1,0,"0"   );
+        case(FLTBANKV):        return set_vflgs(ap,"thr" ,3,"did"   ,"don"    ,3,0,"000" );
+        case(FLTBANKV2):       return set_vflgs(ap,"t"   ,1,"d"     ,"dn"     ,2,0,"00"  );
+        case(FLTITER):         return set_vflgs(ap,"srpa",4,"ddDD"  ,"dien"   ,4,0,"0000");
+        case(FLTSWEEP):        return set_vflgs(ap,"tp"  ,2,"dd"    ,""       ,0,0,""    );
+        case(ALLPASS):         return set_vflgs(ap,"ts"  ,2,"dd"    ,"l"      ,1,0,"0"   );
+            
+        case(MOD_LOUDNESS):
+            switch(mode) {
+                case(LOUDNESS_GAIN):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUDNESS_DBGAIN):  return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUDNESS_NORM):    return set_vflgs(ap,"l"   ,1,"d"     ,""       ,0,0,""    );
+                case(LOUDNESS_SET):     return set_vflgs(ap,"l"   ,1,"d"     ,""       ,0,0,""    );
+                case(LOUDNESS_BALANCE): return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUDNESS_PHASE):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUDNESS_LOUDEST): return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUDNESS_EQUALISE): return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUD_PROPOR):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(LOUD_DB_PROPOR):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_LOUDNESS in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MOD_SPACE):
+            switch(mode) {
+                case(MOD_PAN):          return set_vflgs(ap,"p"   ,1,"d"     ,""       ,0,0,""    );
+                case(MOD_MIRROR):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(MOD_MIRRORPAN):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(MOD_NARROW):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_SPACE in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(SCALED_PAN):           return set_vflgs(ap,"p"   ,1,"d"     ,""       ,0,0,""    );
+        case(MOD_PITCH):
+            switch(mode) {
+                case(MOD_ACCEL):      return set_vflgs(ap,"s"   ,1,"d"     ,""       ,0,0,""    );
+                case(MOD_VIBRATO):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                default:              return set_vflgs(ap,""    ,0,""      ,"o"      ,1,0,"0"   );
+            }
+            break;
+        case(MOD_REVECHO):
+            switch(mode) {
+                case(MOD_DELAY):      return set_vflgs(ap,"p"   ,1,"d"     ,"i"      ,1,0,"0"   );
+                case(MOD_VDELAY):     return set_vflgs(ap,"p"   ,1,"d"     ,"s"      ,1,1,"i"   );
+                case(MOD_STADIUM):    return set_vflgs(ap,"grse",4,"dddi"  ,"n"      ,1,0,"0"   );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_REVECHO in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(MOD_RADICAL):
+            switch(mode) {
+                case(MOD_REVERSE):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(MOD_SHRED):      return set_vflgs(ap,"s"   ,1,"d"     ,"n"      ,1,0,"0"   );
+                case(MOD_SCRUB):      return set_vflgs(ap,"hlse",4,"dddd"  ,"f"      ,1,0,"0"   );
+                case(MOD_LOBIT):
+                case(MOD_LOBIT2):     return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(MOD_RINGMOD):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(MOD_CROSSMOD):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for MOD_RADICAL in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(BRASSAGE):
+            switch(mode) {
+                case(GRS_PITCHSHIFT): return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(GRS_TIMESTRETCH):return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+                case(GRS_REVERB):     return set_vflgs(ap,"r"   ,1,"D"     ,""       ,0,0,""    );
+                case(GRS_SCRAMBLE):   return set_vflgs(ap,"r"   ,1,"D"     ,""       ,0,0,""    );
+                case(GRS_GRANULATE):  return set_vflgs(ap,""    ,0,""      ,"d"      ,1,0,"0"   );
+                case(GRS_BRASSAGE):   return set_vflgs(ap,"rjlc",4,"DDdi"  ,"dxn"    ,3,0,"000" );
+                case(GRS_FULL_MONTY): return set_vflgs(ap,"rjlc",4,"DDdi"  ,"dxn"    ,3,0,"000" );
+                default:
+                    sprintf(errstr,"Unknown mode (%d)  for BRASSAGE in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SAUSAGE):         return set_vflgs(ap,"rjlc",4,"DDdi"  ,"dxn"    ,3,0,"000"  );
+            
+        case(PVOC_ANAL):       return set_vflgs(ap,"co"  ,2,"ii"    ,""       ,0,0,""     );
+        case(PVOC_SYNTH):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(PVOC_EXTRACT):    return set_vflgs(ap,"co"  ,2,"ii"    ,"dlh"    ,3,3,"iii"  );
+            
+            /* TEMPORARY TEST ROUTINE */
+        case(WORDCNT):         return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+            /* TEMPORARY TEST ROUTINE */
+            
+            
+        case(EDIT_CUT):        return set_vflgs(ap,"w"   ,1,"d"     ,""       ,0,0,""     );
+            //TW NEW
+        case(EDIT_CUTMANY):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(STACK):           return set_vflgs(ap,""    ,0,""      ,"sn"     ,2,0,"00"   );
+            
+        case(EDIT_CUTEND):     return set_vflgs(ap,"w"   ,1,"d"     ,""       ,0,0,""     );
+        case(MANY_ZCUTS):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(EDIT_ZCUT):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(EDIT_EXCISE):     return set_vflgs(ap,"w"   ,1,"d"     ,""       ,0,0,""     );
+        case(EDIT_EXCISEMANY): return set_vflgs(ap,"w"   ,1,"d"     ,""       ,0,0,""     );
+        case(INSERTSIL_MANY):  return set_vflgs(ap,"w"   ,1,"d"     ,""       ,0,0,""     );
+        case(EDIT_INSERT):     return set_vflgs(ap,"wl"  ,2,"dd"    ,"o"      ,1,0,"0"    );
+            //TW NEW
+        case(EDIT_INSERT2):    return set_vflgs(ap,"wl"  ,2,"dd"    ,""       ,0,0,""     );
+        case(EDIT_INSERTSIL):  return set_vflgs(ap,"w"   ,1,"d"     ,"os"     ,2,0,"00"    );
+        case(EDIT_JOIN):       return set_vflgs(ap,"w"   ,1,"d"     ,"be"     ,2,0,"00"   );
+        case(HOUSE_COPY):
+            switch(mode) {
+                case(COPYSF):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                case(DUPL):
+                    if(!sloom)
+                        return set_vflgs(ap,""    ,0,""      ,"i"      ,1,0,"0"    );
+                    else
+                        return set_vflgs(ap,""    ,0,""      ,""       ,0,0,"0"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) : for HOUSE_COPY in set_vflgs()\n", mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_DEL):       return set_vflgs(ap,""    ,0,""      ,"a"      ,1,0,"0"     );
+        case(HOUSE_CHANS):
+            switch(mode) {
+                case(HOUSE_CHANNEL):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                case(HOUSE_CHANNELS):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                case(HOUSE_ZCHANNEL):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                case(STOM):             return set_vflgs(ap,""    ,0,""      ,"p"      ,1,0,"0"    );
+                case(MTOS):             return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_CHANS in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_BUNDLE):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(HOUSE_SORT):
+            switch(mode) {
+                case(BY_FILETYPE):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                case(BY_SRATE):         return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                case(BY_DURATION):      return set_vflgs(ap,""    ,0,""      ,"l"      ,1,0,"0"    );
+                case(BY_LOG_DUR):       return set_vflgs(ap,""    ,0,""      ,"l"      ,1,0,"0"    );
+                case(IN_DUR_ORDER):     return set_vflgs(ap,""    ,0,""      ,"l"      ,1,0,"0"    );
+                case(FIND_ROGUES):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_SORT in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_SPEC):
+            switch(mode) {
+                case(HOUSE_RESAMPLE): return set_vflgs(ap,""   ,0,""    ,""       ,0,0,""     );
+                case(HOUSE_CONVERT):  return set_vflgs(ap,""   ,0,""    ,""       ,0,0,""     );
+#ifdef NOTDEF
+                case(HOUSE_REPROP):   return set_vflgs(ap,"sct",3,"iii" ,""       ,0,0,""     );
+#else
+                    /*RWD May 2005 removed -t option */
+                case(HOUSE_REPROP):   return set_vflgs(ap,"sc",2,"ii" ,""       ,0,0,""     );
+#endif
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_SPEC in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(HOUSE_EXTRACT):
+            switch(mode) {
+                case(HOUSE_CUTGATE):
+                    if(sloom)
+                        return set_vflgs(ap,"gsethbilw",9,"diddiiddi","",0,0,"0");
+                    else
+                        return set_vflgs(ap,"gsethbilw",9,"diddiiddi","n",1,0,"0");
+                case(HOUSE_CUTGATE_PREVIEW):
+                    return set_vflgs(ap,""   ,0,""    ,""       ,0,0,""     );
+                case(HOUSE_ONSETS):   return set_vflgs(ap,""   ,0,""    ,""       ,0,0,""     );
+                case(HOUSE_TOPNTAIL): return set_vflgs(ap,"gs" ,2,"dd" ,"be"      ,2,0,"00"   );
+                case(HOUSE_RECTIFY):  return set_vflgs(ap,""   ,0,""    ,""       ,0,0,""     );
+                case(HOUSE_BYHAND):   return set_vflgs(ap,""   ,0,""    ,""       ,0,0,""     );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for HOUSE_SPEC in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(TOPNTAIL_CLICKS):  return set_vflgs(ap,""   ,0,""      ,"be"     ,2,0,"00"   );
+        case(HOUSE_BAKUP):      return set_vflgs(ap,""   ,0,""      ,""       ,0,0,""     );
+        case(HOUSE_GATE):       return set_vflgs(ap,"z"  ,1,"i"     ,""       ,0,0,""     );
+            
+        case(HOUSE_DISK):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+            
+        case(INFO_PROPS):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_SFLEN):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_TIMELIST):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_LOUDLIST):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_TIMESUM):    return set_vflgs(ap,"s"   ,1,"d"     ,""       ,0,0,""     );
+        case(INFO_TIMEDIFF):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_SAMPTOTIME): return set_vflgs(ap,""    ,0,""      ,"g"      ,1,0,"0"    );
+        case(INFO_TIMETOSAMP): return set_vflgs(ap,""    ,0,""      ,"g"      ,1,0,"0"    );
+        case(INFO_MAXSAMP):    return set_vflgs(ap,""    ,0,""      ,"f"      ,1,0,"0"    );
+        case(INFO_MAXSAMP2):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_LOUDCHAN):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_FINDHOLE):   return set_vflgs(ap,"t"   ,1,"d"     ,""       ,0,0,""     );
+        case(INFO_DIFF):       return set_vflgs(ap,"tn"  ,2,"di"    ,"lc"     ,2,0,"00"   );
+        case(INFO_CDIFF):      return set_vflgs(ap,"tn"  ,2,"di"    ,""       ,0,0,""     );
+        case(INFO_PRNTSND):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(INFO_MUSUNITS):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+            
+        case(MULTI_SYN):       return set_vflgs(ap,"at"  ,2,"di"    ,""       ,0,0,""     );
+        case(SYNTH_WAVE):      return set_vflgs(ap,"at"  ,2,"Di"    ,"f"      ,1,0,"0"    );
+        case(SYNTH_NOISE):     return set_vflgs(ap,"a"   ,1,"D"     ,"f"      ,1,0,"0"    );
+        case(SYNTH_SIL):       return set_vflgs(ap,""    ,0,""      ,"f"      ,1,0,"0"    );
+        case(SYNTH_SPEC):      return set_vflgs(ap,""    ,0,""      ,"p"      ,1,0,"0"    );
+        case(RANDCUTS):        return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(RANDCHUNKS):      return set_vflgs(ap,"m"   ,1,"d"     ,"ls"     ,2,0,"00"   );
+        case(SIN_TAB):         return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(ACC_STREAM):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""     );
+        case(HF_PERM1):        return set_vflgs(ap,""    ,0,""      ,"msao"   ,4,0,"0000" );
+        case(HF_PERM2):        return set_vflgs(ap,""    ,0,""      ,"msao"   ,4,0,"0000" );
+        case(DEL_PERM):        return set_vflgs(ap,""    ,0,""      ,""       ,0,0,"0000" );
+        case(DEL_PERM2):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,"0000" );
+        case(TWIXT):
+            switch(mode) {
+                case(TRUE_EDIT):     return set_vflgs(ap,""  ,0,""      ,""       ,0,0,""     );
+                case(IN_SEQUENCE):   return set_vflgs(ap,"w" ,1,"i"     ,"r"      ,1,0,"0"    );
+                case(RAND_REORDER):  return set_vflgs(ap,"w" ,1,"i"     ,"r"      ,1,0,"0"    );
+                case(RAND_SEQUENCE): return set_vflgs(ap,"w" ,1,"i"     ,"r"      ,1,0,"0"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for TWIXT in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        case(SPHINX):
+            switch(mode) {
+                case(IN_SEQUENCE):   return set_vflgs(ap,"w" ,1,"i"     ,"r"      ,1,0,"0"    );
+                case(RAND_REORDER):  return set_vflgs(ap,"w" ,1,"i"     ,"r"      ,1,0,"0"    );
+                case(RAND_SEQUENCE): return set_vflgs(ap,"w" ,1,"i"     ,"r"      ,1,0,"0"    );
+                default:
+                    sprintf(errstr,"Unknown mode (%d) for SPHINX in set_vflgs()\n",mode);
+                    return(PROGRAM_ERROR);
+            }
+            break;
+            //TW NEW
+        case(MIX_ON_GRID):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(AUTOMIX):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(NOISE_SUPRESS): return set_vflgs(ap,""    ,0,""      ,"n"      ,1,0,"0"   );
+        case(TIME_GRID):     return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(SEQUENCER2):    return set_vflgs(ap,""    ,0,""      ,"s"      ,1,1,"d"   );
+        case(SEQUENCER):     return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(CONVOLVE):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(BAKTOBAK):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(ADDTOMIX):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(MIX_PAN):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(SHUDDER):       return set_vflgs(ap,""    ,0,""      ,"b"      ,1,0,"0"   );
+        case(MIX_AT_STEP):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(FIND_PANPOS):   return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""    );
+        case(CLICK):
+            switch(mode) {
+                case(CLICK_BY_TIME): return set_vflgs(ap,"sez" ,3,"ddi"   ,"t"      ,1,0,"0"   );
+                case(CLICK_BY_LINE): return set_vflgs(ap,"sez" ,3,"iii"   ,"t"      ,1,0,"0"   );
+            }
+            break;
+        case(DOUBLETS):        return set_vflgs(ap,""    ,0,""      ,"s"      ,1,0,"0"     );
+        case(SYLLABS):         return set_vflgs(ap,""    ,0,""      ,"p"      ,1,0,"0"     );
+        case(JOIN_SEQDYN):     return set_vflgs(ap,"w"   ,1,"i"     ,"be"     ,2,0,"00"    );
+        case(JOIN_SEQ):        return set_vflgs(ap,"wm"  ,2,"di"    ,"be"     ,2,0,"00"    );
+        case(MAKE_VFILT):      return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+        case(BATCH_EXPAND):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+        case(MIX_MODEL):       return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+        case(CYCINBETWEEN):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+        case(ENVSYN):          return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+        case(RRRR_EXTEND):
+            switch(mode) {
+                case(0):           return set_vflgs(ap,""    ,0,""      ,"se"     ,2,0,"00"    );
+                case(1):           return set_vflgs(ap,""    ,0,""      ,"se"     ,2,0,"00"    );
+                case(2):           return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+            }
+            break;
+        case(SSSS_EXTEND):     return set_vflgs(ap,"g"   ,1,"d"     ,"x"      ,1,0,"0"     );
+        case(HOUSE_GATE2):     return set_vflgs(ap,""    ,0,""      ,"s"      ,1,0,"0"     );
+        case(GRAIN_ASSESS):    return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+        case(ZCROSS_RATIO):    return set_vflgs(ap,"se"  ,2,"dd"    ,""       ,0,0,""      );
+        case(GREV):            return set_vflgs(ap,""    ,0,""      ,""       ,0,0,""      );
+            
+            /*|      | |        |         |v| |       */
+            /*|      |o|        |         |f|v|       */
+            /*|option|p| option |variant  |l|p|variant*/
+            /*|flags |t|  list  | flags   |a|a|list   */
+            /*|      |c|        |         |g|r|       */
+            /*|      |n|        |         |c|a|       */
+            /*|      |t|        |         |n|m|       */
+            /*|      | |        |         |t|s|       */
+    }
+    sprintf(errstr,"Unknown process %d: set_vflgs()\n",process);
+    return(PROGRAM_ERROR);
+}
+
+/****************************** SET_VFLGS *********************************/
+
+int set_vflgs
+(aplptr ap,char *optflags,int optcnt,char *optlist,char *varflags,int vflagcnt, int vparamcnt,char *varlist)
+{
+    ap->option_cnt   = (char) optcnt;           /*RWD added cast */
+    if(optcnt) {
+        if((ap->option_list = (char *)malloc((size_t)(optcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY: for option_list\n");
+            return(MEMORY_ERROR);
+        }
+        strcpy(ap->option_list,optlist);
+        if((ap->option_flags = (char *)malloc((size_t)(optcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY: for option_flags\n");
+            return(MEMORY_ERROR);
+        }
+        strcpy(ap->option_flags,optflags);
+    }
+    ap->vflag_cnt = (char) vflagcnt;
+    ap->variant_param_cnt = (char) vparamcnt;
+    if(vflagcnt) {
+        if((ap->variant_list  = (char *)malloc((size_t)(vflagcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY: for variant_list\n");
+            return(MEMORY_ERROR);
+        }
+        strcpy(ap->variant_list,varlist);
+        if((ap->variant_flags = (char *)malloc((size_t)(vflagcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY: for variant_flags\n");
+            return(MEMORY_ERROR);
+        }
+        strcpy(ap->variant_flags,varflags);
+    }
+    return(FINISHED);
+}
+
+/****************************** SET_PARAM_DATA *********************************/
+
+int set_param_data(aplptr ap, int special_data,int maxparamcnt,int paramcnt,char *paramlist)
+{
+    ap->special_data   = (char)special_data;
+    ap->param_cnt      = (char)paramcnt;
+    ap->max_param_cnt  = (char)maxparamcnt;
+    if(ap->max_param_cnt>0) {
+        if((ap->param_list = (char *)malloc((size_t)(ap->max_param_cnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY: for param_list\n");
+            return(MEMORY_ERROR);
+        }
+        strcpy(ap->param_list,paramlist);
+    }
+    return(FINISHED);
+}
+

dev/cdp2k/readdata.c

@@ -0,0 +1,763 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <float.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <globcon.h>
+#include <processno.h>
+#include <special.h>
+#include <cdpmain.h>
+
+#include <sfsys.h>
+#include <string.h>         /*RWD*/
+
+#if defined unix || defined _MSC_VER
+#define round(x) lround((x))
+#endif
+
+static int  get_params(int *cmdlinecnt,char ***cmdline,dataptr dz);
+static int  get_options(int *cmdlinecnt,char ***cmdline,dataptr dz);
+static int  get_variants_and_flags(int *cmdlinecnt,char ***cmdline,dataptr dz);
+static int  get_option_no(char *paramstr,int *option_no,aplptr ap);
+static int  get_variant_no(char *paramstr,int *variant_no,aplptr ap);
+static int  get_brkpnt_data_from_file_and_test_it(char *filename,int paramno,dataptr dz);
+static int  read_param_as_value_or_brkfile_and_check_range(char *str,int paramno,dataptr dz);
+static int  get_real_paramno(int paramno,dataptr dz);
+static void out_of_range(int paramno,double val,double loval,double hival);
+
+/************************ READ_PARAMETERS_AND_FLAGS **********************/
+
+int read_parameters_and_flags(char ***cmdline,int *cmdlinecnt,dataptr dz)
+{
+    int exit_status;
+    aplptr ap = dz->application;
+    if(ap->param_cnt) {
+        if(!sloom) {
+            if(*cmdlinecnt <= 0) {
+                sprintf(errstr,"Insufficient parameters on command line.\n");
+                return(USAGE_ONLY);
+            }
+        }
+        if((exit_status = get_params(cmdlinecnt,cmdline,dz))<0)
+            return(exit_status);
+    }
+    if(ap->option_cnt) {
+        if((exit_status = get_options(cmdlinecnt,cmdline,dz))<0)
+            return(exit_status);
+    }
+    if(ap->vflag_cnt) {
+        if((exit_status = get_variants_and_flags(cmdlinecnt,cmdline,dz))<0)
+            return(exit_status);
+    }
+    if(!sloom) {
+        if(*cmdlinecnt > 0) {
+            if((*cmdline)[0][0]=='-') {
+                if(strlen((*cmdline)[0])>1)
+                    sprintf(errstr,"Unknown flag -%c on command line.\n",(*cmdline)[0][1]);
+                else
+                    sprintf(errstr,"Hanging '-' on command line.\n");
+            } else
+                sprintf(errstr,"Too many parameters on command line.\n");
+            return(USAGE_ONLY);
+        }
+    }
+    return(FINISHED);
+}       
+    
+/************************ GET_PARAMS **********************/
+
+int get_params(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int exit_status;
+    int n;
+    char *paramval;
+    aplptr ap = dz->application;
+
+    for(n=0;n<ap->max_param_cnt;n++) {
+        if(dz->is_active[n]) {
+            if(!sloom) {
+
+                if(*cmdlinecnt<=0) {
+                    sprintf(errstr,"Insufficient parameters on cmdline.\n");
+                    return(USER_ERROR);
+                }
+            }
+            paramval = (*cmdline)[0];
+            if((exit_status = read_param_as_value_or_brkfile_and_check_range(paramval,n,dz)) < 0)
+                return(exit_status);
+            (*cmdline)++;
+            (*cmdlinecnt)--;
+        }
+    }
+    return(FINISHED);
+}
+
+/************************ GET_OPTIONS **********************/
+
+int get_options(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int  exit_status;
+    aplptr ap = dz->application;
+    int  n, basecnt = ap->max_param_cnt;
+    int m = 0;
+    char *paramstr;
+    int* options_got;
+    int  option_no = 0, k = 0;
+    int  options_remain = TRUE;
+
+    if(!sloom) {
+        if((options_got = (int *)malloc(ap->option_cnt * sizeof(int)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for option checking array\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<ap->option_cnt;n++)
+            options_got[n]=FALSE;
+        while(*cmdlinecnt > 0 && options_remain) {
+            paramstr = (*cmdline)[0];
+            exit_status = get_option_no(paramstr,&option_no,dz->application);
+            switch(exit_status) {
+            case(CONTINUE):
+                if(options_got[option_no]==TRUE) {
+                    sprintf(errstr,"Duplicate option %c used on command line\n",*(paramstr+1));
+                    return(USAGE_ONLY);
+                }
+                options_got[option_no] = TRUE;  
+                paramstr += 2;
+                k = basecnt + option_no;
+                if((exit_status = read_param_as_value_or_brkfile_and_check_range(paramstr,k,dz))<0)
+                    return(exit_status);
+                (*cmdline)++;
+                (*cmdlinecnt)--;
+                break;
+            case(FINISHED):
+                options_remain = FALSE;
+                break;
+            default:
+                return(exit_status);
+            }
+        }       
+        free(options_got);
+    } else {
+        for(n=0,m=basecnt;n<ap->option_cnt;n++,m++) {
+//TW JULY 2006
+            if(dz->is_active[m]) {
+                paramstr = (*cmdline)[0];
+                if((exit_status = read_param_as_value_or_brkfile_and_check_range(paramstr,m,dz))<0)
+                    return(exit_status);
+                (*cmdline)++;
+                (*cmdlinecnt)--;
+            }
+        }
+    }
+    return(FINISHED);
+}
+
+/************************ GET_VARIANTS_AND_FLAGS **********************/
+
+int get_variants_and_flags(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int exit_status;
+    aplptr ap = dz->application;
+    int basecnt = ap->max_param_cnt + ap->option_cnt;
+    char *paramstr;                   
+    int flagno, paramno;
+    int* flags_got;
+    int n = 0, rawflags = 0;
+    if(!sloom) {
+        if((flags_got = (int *)malloc(ap->vflag_cnt * sizeof(int)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for variant checking array\n");
+            return(MEMORY_ERROR);
+        }
+        for(flagno=0;flagno<ap->vflag_cnt;flagno++)
+            flags_got[flagno]=FALSE;
+        while(*cmdlinecnt > 0) {
+            paramstr = (*cmdline)[0];
+            if((exit_status = get_variant_no(paramstr,&flagno,ap))<0)
+                return(exit_status);
+            if(flags_got[flagno]==TRUE) {
+                sprintf(errstr,"Duplicate flag %c used on command line\n",*(paramstr+1));
+                return(USER_ERROR);
+            }
+            flags_got[flagno] = TRUE;
+            if(flagno < ap->variant_param_cnt) {    
+                paramstr += 2;
+                paramno = basecnt+flagno;   
+                if((exit_status = read_param_as_value_or_brkfile_and_check_range(paramstr,paramno,dz))<0)
+                    return(exit_status);
+                if(dz->brksize[paramno] || !flteq(dz->param[paramno],ap->default_val[paramno]))
+                    dz->vflag[flagno] = TRUE;
+            } else
+                dz->vflag[flagno] = TRUE;
+            (*cmdline)++;
+            (*cmdlinecnt)--;
+        }
+        free(flags_got);
+    } else {
+        rawflags = ap->vflag_cnt - ap->variant_param_cnt;
+
+        for(flagno=0,paramno=basecnt;flagno<ap->variant_param_cnt;flagno++,paramno++) {
+            paramstr = (*cmdline)[0];
+            if((exit_status = read_param_as_value_or_brkfile_and_check_range(paramstr,paramno,dz))<0)
+                return(exit_status);
+            if(dz->brksize[paramno] || !flteq(dz->param[paramno],ap->default_val[paramno]))
+                dz->vflag[flagno] = TRUE;
+            (*cmdline)++;
+            (*cmdlinecnt)--;
+        }
+        if(rawflags > 0) {
+            basecnt = ap->variant_param_cnt;
+            for(n=0,flagno = basecnt;n<rawflags;n++,flagno++) {
+                paramstr = (*cmdline)[0];
+    /* NEW JUNE 1999 ---> */
+                if (strlen(paramstr) < 2) {
+                    sprintf(errstr,"Unmarked numeric val for flag %s\n",paramstr);    /*RWD 4:12:2003 was $s */
+                    return(DATA_ERROR);
+                } 
+                paramstr++;
+    /* <--- NEW JUNE 1999 */
+                if(!strcmp(paramstr,"0"))
+                    ;   /* flag = FALSE, default */
+                else if(!strcmp(paramstr,"1"))
+                    dz->vflag[flagno] = TRUE;
+                else {
+                    sprintf(errstr,"Unknown flag value '%s' sent from TK\n",paramstr);
+                    return(DATA_ERROR);
+                }
+                (*cmdline)++;
+                (*cmdlinecnt)--;
+            }
+        } 
+    }
+
+    return(FINISHED);
+}
+
+/************************************* GET_OPTION_NO  ****************************************/
+
+int get_option_no(char *paramstr,int *option_no,aplptr ap)
+{
+    char cmdline_flag, *p;
+    if(*paramstr++!='-') {
+        sprintf(errstr,"Unknown parameter '%s'\n",--paramstr);
+        return(USAGE_ONLY);
+    }
+    cmdline_flag = *paramstr++;
+    p = ap->option_flags;
+    while(*p != ENDOFSTR) {
+        if(*p == cmdline_flag) {
+            *option_no = p - ap->option_flags;              
+//TW JULY 2006
+            if(ap->option_list[*option_no]=='0') {
+                fprintf(stdout,"-%c is not a valid flag\n",cmdline_flag);
+                fflush(stdout);
+                return(USAGE_ONLY);
+            }
+            p++;
+            if(strlen(paramstr) <=0) {
+                sprintf(errstr,"option parameter missing with flag -%c\n",cmdline_flag);
+                return(USAGE_ONLY);
+            }
+            return(CONTINUE);
+        }
+        p++;
+    }
+    return(FINISHED);
+}
+
+/************************************ GET_VARIANT_NO  ************************************/
+
+int get_variant_no(char *paramstr,int *variant_no,aplptr ap)
+{
+
+    char cmdline_flag, *p;
+    if(*paramstr++!='-') {
+        sprintf(errstr,"Unknown parameter '%s'",--paramstr);
+        return(USER_ERROR);
+    }
+    cmdline_flag = *paramstr++;
+    p = ap->variant_flags;
+    while(*p != ENDOFSTR) {
+        if(*p == cmdline_flag) {                
+            *variant_no = p - ap->variant_flags;
+            p++;
+            if(*variant_no < ap->variant_param_cnt && strlen(paramstr) <=0) {
+                sprintf(errstr,"variant parameter missing with flag -%c\n",cmdline_flag);
+                return(USER_ERROR);
+            }
+            return(CONTINUE);
+        }
+        p++;
+    }
+    if(ap->option_cnt) {
+        p = ap->option_flags;
+        while(*p != ENDOFSTR) {
+            if(*p == cmdline_flag) {
+                sprintf(errstr,"option flag -%c out of order on cmdline.\n",cmdline_flag);
+                return(USER_ERROR);
+            }
+            p++;
+        }
+        sprintf(errstr,"Unknown variant flag -%c\n",cmdline_flag);
+        return(USER_ERROR);
+    } else {
+        sprintf(errstr,"Unknown flag '-%c'\n",cmdline_flag);
+        return(USER_ERROR);
+    }
+    return(FINISHED);
+}
+
+/***************** READ_PARAM_AS_VALUE_OR_BRKFILE_AND_CHECK_RANGE ********************/
+
+int read_param_as_value_or_brkfile_and_check_range(char *str,int paramno,dataptr dz)
+{
+    aplptr ap = dz->application;
+    int real_paramno;
+
+    if(!sloom) {                /* CMDLINE convention: filenames can't begin with numbers : */
+//TW Soundloom accepts numeric names, and extensions
+//   'value_is_numeric' Commandline still looks for numeric value first, 
+//   and if it finds it, assumes it's a number (if user uses filename "123.456" that's the user's problem)
+//   New 'file_has_invalid_startchar' traps bad directory paths, but permits numeric names
+
+        if(!value_is_numeric(str) && file_has_invalid_startchar(str)) {
+            sprintf(errstr,"Cannot read parameter %d [%s]\n",paramno+1,str);
+            return(USER_ERROR);
+        }
+
+        if(value_is_numeric(str)) {
+            if(sscanf(str,"%lf",&(dz->param[paramno]))<1) {
+                sprintf(errstr,"Cannot read parameter %d [%s].\n",paramno+1,str);
+                return(USER_ERROR);
+            }   
+            if(dz->process != ENV_DOVETAILING && dz->process != ENV_CURTAILING) {
+                if(flteq(dz->param[paramno],ap->lo[paramno]))
+                    dz->param[paramno] = ap->lo[paramno];
+                if(flteq(dz->param[paramno],ap->hi[paramno]))
+                    dz->param[paramno] = ap->hi[paramno];
+                if(dz->param[paramno] > ap->hi[paramno] || dz->param[paramno] < ap->lo[paramno]) {
+                    real_paramno = get_real_paramno(paramno,dz);
+                    out_of_range(real_paramno,dz->param[paramno],ap->lo[paramno],ap->hi[paramno]);
+                    return(USER_ERROR);
+                }
+            }
+            if(dz->is_int[paramno])
+                dz->iparam[paramno] = round(dz->param[paramno]);
+        } else {
+            if(dz->no_brk[paramno]) {
+                sprintf(errstr,"Cannot read parameter %d [%s]: brkpnt_files not permitted.\n",paramno+1,str);
+                return(USER_ERROR);
+            } else 
+                return get_brkpnt_data_from_file_and_test_it(str,paramno,dz);
+        }
+    } else {                    /* TK convention, all numeric values are preceded by NUMERICVAL_MARKER */
+        if(str[0]==NUMERICVAL_MARKER) {      
+            str++;              
+            if(strlen(str)<=0 || sscanf(str,"%lf",&(dz->param[paramno]))!=1) {
+                sprintf(errstr,"Invalid parameter value encountered.\n");
+                return(DATA_ERROR);
+            }
+            if(dz->process != ENV_DOVETAILING && dz->process != ENV_CURTAILING) {
+                if(flteq(dz->param[paramno],ap->lo[paramno]))
+                    dz->param[paramno] = ap->lo[paramno];
+                if(flteq(dz->param[paramno],ap->hi[paramno]))
+                    dz->param[paramno] = ap->hi[paramno];
+                if(dz->param[paramno] > ap->hi[paramno] || dz->param[paramno] < ap->lo[paramno]) {
+                    real_paramno = get_real_paramno(paramno,dz);
+                    out_of_range(real_paramno,dz->param[paramno],ap->lo[paramno],ap->hi[paramno]);
+                    return(USER_ERROR);
+                }
+            }
+
+            if(dz->is_int[paramno])
+                dz->iparam[paramno] = round(dz->param[paramno]);
+        } else {
+            if(dz->no_brk[paramno]) {
+                sprintf(errstr,"Cannot read parameter %d [%s]: brkpnt_files not permitted.\n",paramno+1,str);
+                return(USER_ERROR);
+            }
+            else 
+                return get_brkpnt_data_from_file_and_test_it(str,paramno,dz);
+        }
+    }
+    return(FINISHED);
+}
+
+/************************************* GET_REAL_PARAMNO ****************************************/
+
+int get_real_paramno(int paramno,dataptr dz)
+{
+    int m = 0, n;
+    for(n=0;n <= paramno;n++) {
+        if(dz->is_active[n])
+            m++;
+    }
+    if(dz->application->special_data)
+        m++;
+    return(m);
+}
+
+/*************************** GET_BRKPNT_DATA_FROM_FILE_AND_TEST_IT ***********************/
+
+int get_brkpnt_data_from_file_and_test_it(char *filename,int paramno,dataptr dz)
+{
+    FILE *fp;
+    aplptr ap = dz->application;
+    double *p, lasttime = 0.0;
+    int istime = 1;
+    int arraysize = BIGARRAY;
+    char temp[200], *q;
+    int n = 0, dcount;
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr, "Can't open brkpntfile %s to read data.\n",filename);
+        return(DATA_ERROR);
+    }
+    if((dz->brk[paramno] = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for brkpnt data in file %s.\n",filename);
+        return(MEMORY_ERROR);
+    }
+    p = dz->brk[paramno];
+    while(fgets(temp,200,fp)==temp) {
+        q = temp;
+        while(get_float_from_within_string(&q,p)) {
+            if(istime) {
+                if(p!= dz->brk[paramno] && *p <= lasttime) {
+                    sprintf(errstr,"Times (%lf & %lf) in brkpntfile %s are not in increasing order.\n",
+                    lasttime,*p,filename);
+                    return(DATA_ERROR);
+                }
+                lasttime = *p;
+            } else {
+                if(flteq(*p,ap->lo[paramno]))
+                    *p = ap->lo[paramno];
+                else if(flteq(*p,ap->hi[paramno]))
+                    *p = ap->hi[paramno];
+                if(*p < ap->lo[paramno] || *p > ap->hi[paramno]) {
+                    out_of_range_in_brkfile(filename,*p,ap->lo[paramno],ap->hi[paramno]); 
+                    return(DATA_ERROR);
+                }
+            }
+            istime = !istime;
+            p++;
+            if(++n >= arraysize) {
+                arraysize += BIGARRAY;
+                if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),arraysize * sizeof(double)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY to reallocate brkpnt data from file %s.\n",filename);
+                    return(MEMORY_ERROR);
+                }
+                p = dz->brk[paramno] + n;       
+            }
+        }
+    }       
+    if(n == 0) {
+        sprintf(errstr,"No data in brkpnt file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),n * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate brkpnt data from file %s.\n",filename);
+        return(MEMORY_ERROR);
+    }
+    if(((dcount = n/2) * 2) != n) {
+        sprintf(errstr,"Data not paired correctly in file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if(fclose(fp)<0) {
+        fprintf(stdout,"WARNING: Failed to close file %s.\n",filename);
+        fflush(stdout);
+    }
+    dz->brksize[paramno] = dcount;
+    dz->brkptr[paramno]  = dz->brk[paramno];    /* initialise brkptr */
+    return(FINISHED);
+}
+
+/**************************** OUT_OF_RANGE_IN_BRKFILE *************************/
+
+void out_of_range_in_brkfile(char *filename,double val,double loval,double hival) 
+{
+    sprintf(errstr,"Value (%lf) out of range (%lf to %lf) in brkpntfile %s.\n",val,loval,hival,filename);
+}
+
+/**************************** OUT_OF_RANGE *************************/
+
+void out_of_range(int paramno,double val,double loval,double hival) 
+{
+    sprintf(errstr,"Parameter[%d] Value (%lf) out of range (%lf to %lf)\n",paramno,val,loval,hival);
+}
+
+/************************* READ_AND_TEST_PITCH_OR_TRANSPOSITION_BRKVALS *****************************/
+
+int read_and_test_pitch_or_transposition_brkvals
+(FILE *fp,char *filename,double **brktable,int *brksize,int which_type,double minval,double maxval)
+{
+    int arraysize = BIGARRAY;
+    double *p, lasttime = 0.0;
+    int  istime = TRUE;
+    int n = 0,m, final_size;
+    char temp[200], *q;
+    if((*brktable = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for pitch-or-transposition brktable.\n");
+        return(MEMORY_ERROR);
+    }
+    p = *brktable;
+    while(fgets(temp,200,fp)==temp) {    /* READ AND TEST BRKPNT VALS */
+        q = temp;
+        while(get_float_from_within_string(&q,p)) {
+            if(istime) {
+                if(p==*brktable) {
+                    if(*p < 0.0) {
+                        sprintf(errstr,"First timeval(%lf) in brkpntfile %s is less than zero.\n",*p,filename);
+                        return(DATA_ERROR);
+                    }
+                } else {
+                    if(*p <= lasttime) {
+                        sprintf(errstr,"Times (%lf & %lf) in brkpntfile %s are not in increasing order.\n",
+                        lasttime,*p,filename);
+                        return(DATA_ERROR);
+                    }
+                }
+                lasttime = *p;
+            } else {
+                switch(which_type) {
+                case(TRANSPOS_SEMIT_OR_CONSTANT):
+                    *p = *p/12.0;       /* semitone to octave */
+                    /* fall thro */
+                case(TRANSPOS_OCTAVE_OR_CONSTANT):
+                    *p = pow(2.0,*p);   /* octave to frqratio */
+                    break;
+                case(NO_SPECIAL_TYPE):
+                    break;
+                }
+                if(flteq(*p,minval))
+                    *p = minval;
+                else if(flteq(*p,maxval))
+                    *p = maxval;
+                if(*p < minval || *p > maxval) {
+                    out_of_range_in_brkfile(filename,*p,minval,maxval); 
+                    return(DATA_ERROR);
+                }
+            }
+            istime = !istime;
+            p++;
+            if(++n >= arraysize) {
+                arraysize += BIGARRAY;
+                if((*brktable = (double *)realloc((char *)(*brktable),arraysize * sizeof(double)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY to reallocate pitch-or-transposition brktable.\n");
+                    return(MEMORY_ERROR);
+                }
+                p = *brktable + n;      
+            }
+        }
+    }       
+    if(n < 2) {
+        sprintf(errstr,"No data in brkpnt file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if(ODD(n)) {
+        sprintf(errstr,"Data not paired correctly in brkpntfile %s\n",filename);
+        return(DATA_ERROR);
+    }
+    final_size = n;
+    if((*brktable)[0] != 0.0)   /* Allow space for a value at time zero, if there isn't one */
+        final_size = n + 2;
+    if((*brktable = (double *)realloc((char *)(*brktable),final_size * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate pitch-or-transposition brktable.\n");
+        return(MEMORY_ERROR);
+    }
+    if(final_size != n) {       /* Force a value at time zero, if there isn't one */
+        for(m=n-1;m>=0;m--)
+            (*brktable)[m+2] = (*brktable)[m];
+        (*brktable)[0] = 0.0;   
+        (*brktable)[1] = (*brktable)[3];
+    }
+    *brksize = final_size/2;
+    return(FINISHED);
+}
+
+/************************* CONVERT_TO_WINDOW_BY_WINDOW_ARRAY *****************************/
+
+int convert_brkpntdata_to_window_by_window_array(double *brktable,int brksize,float **thisarray,int wlen,float timestep)
+{
+    int exit_status;
+    double *p, val;
+    int arraysize = BIGARRAY, n = 0;
+    double ttime = 0.0;
+    double firstval, lasttime, lastval;
+    double *endpair, *endoftab;
+    if((*thisarray = (float *)malloc(arraysize * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to create window array.\n");
+        return(MEMORY_ERROR);
+    }
+    p = brktable;
+    firstval = *(p+1);
+    endoftab = brktable + (brksize*2);
+    endpair  = endoftab - 2;
+    lasttime = *endpair;
+    lastval  = *(endpair+1);
+    while(n < wlen) {
+        if(ttime <= 0.0)            (*thisarray)[n] = (float)firstval;
+        else if(ttime >= lasttime)  (*thisarray)[n] = (float)lastval;
+        else {
+            if((exit_status = interp_val(&val,ttime,brktable,endoftab,&p))<0)
+                return(exit_status);
+            (*thisarray)[n] = (float)val;
+        }
+        if(++n >= arraysize) {
+            arraysize += BIGARRAY;
+            if((*thisarray = (float *)realloc((char *)(*thisarray),arraysize*sizeof(float)))==NULL) {
+                sprintf(errstr,"INSUFFICIENT MEMORY to reallocate window array.\n");
+                return(MEMORY_ERROR);
+            }
+        }
+        ttime += timestep;
+    }
+    if((*thisarray = (float *)realloc((char *)(*thisarray),(wlen+1) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate window array.\n");
+        return(MEMORY_ERROR);
+    }
+    (*thisarray)[wlen] = 0.0f;  /* SAFETY VALUE */
+    return(FINISHED);
+}
+
+/********************** INTERP_VAL *******************/
+
+int interp_val(double *val,double ttime,double *startoftab,double *endoftab,double **p)
+{
+    double hival, hiind, loval, loind, dval;
+    if(ttime > **p) {
+        while(**p<ttime) {
+            if((*p += 2) >= endoftab) {
+                sprintf(errstr,"Time off end of table :interp_val()\n");
+                return(PROGRAM_ERROR);
+            }
+        }
+    }
+    if(*p < startoftab+2) {
+        sprintf(errstr,"Pointer off start of table: Error in interp_val()\n");
+        return(PROGRAM_ERROR);
+    }
+    hival  = *(*p+1);
+    hiind  = **p;
+    loval  = *(*p-1);
+    loind  = *(*p-2);
+    dval    = (ttime - loind)/(hiind - loind);
+    dval   *= (hival - loval);
+    dval   += loval;
+    *val    = dval;
+    return(FINISHED);
+}
+
+/**************************** CONVERT_DB_AT_OR_BELOW_ZERO_TO_GAIN ********************************/
+
+int convert_dB_at_or_below_zero_to_gain(double *val)
+{
+    if (*val>0.0)  {
+        sprintf(errstr,"dB value out of range (> 0dB)\n");
+        return(DATA_ERROR);
+    } else if(*val<=MIN_DB_ON_16_BIT)
+        *val = 0.0;
+    else if(flteq(*val,0.0))
+        *val = 1.0;
+    else /* *val<0.0 */ {
+        *val  = -(*val);
+        *val /= 20.0;
+        *val  = pow(10.0,*val);
+        *val  = 1.0/(*val);
+    }
+    return(FINISHED);
+}
+
+/*************************** GET_MAXVALUE_IN_BRKTABLE ************************/
+
+int get_maxvalue_in_brktable(double *brkmax,int paramno,dataptr dz)
+{
+    double *p = dz->brk[paramno];
+    int n;
+    *brkmax = -DBL_MAX;
+    if(dz->brksize[paramno] <= 0) {
+        sprintf(errstr,"Brktable is empty.\n");
+        return(DATA_ERROR);
+    }
+    p++;
+    for(n=0;n<dz->brksize[paramno];n++) {
+        if(*p > *brkmax)
+            *brkmax = *p;
+        p+=2;
+    }
+    if(*brkmax <= -DBL_MAX) {
+        sprintf(errstr,"Invalid values in brktable.\n");
+        return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/*************************** GET_MINVALUE_IN_BRKTABLE ************************/
+
+int get_minvalue_in_brktable(double *brkmin,int paramno,dataptr dz)
+{
+    double *p = dz->brk[paramno];
+    int n;
+    *brkmin = DBL_MAX;
+    if(dz->brksize[paramno] <= 0) {
+        sprintf(errstr,"Brktable is empty.\n");
+        return(DATA_ERROR);
+    }
+    p++;
+    for(n=0;n<dz->brksize[paramno];n++) {
+        if(*p < *brkmin)
+            *brkmin = *p;
+        p+=2;
+    }
+    if(*brkmin >= DBL_MAX) {
+        sprintf(errstr,"Invalid values in brktable.\n");
+        return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/********************* GET_MAXVALUE *********************/
+
+int get_maxvalue(int paramno,double *maxval,dataptr dz)
+{
+    int exit_status;
+    if(dz->brksize==NULL) {
+        sprintf(errstr,"brksize array not initialised: get_maxvalue()\n");
+        return(PROGRAM_ERROR);
+    } 
+    if(dz->brksize[paramno]) {
+        if((exit_status = get_maxvalue_in_brktable(maxval,paramno,dz))<0)
+            return(exit_status);
+    } else {
+        if(dz->is_int[paramno])
+            *maxval = (double)dz->iparam[paramno];
+        else
+            *maxval = dz->param[paramno];
+    }
+    return(FINISHED);
+}
+

dev/cdp2k/readfiles.c

@@ -0,0 +1,1673 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <cdpmain.h>
+#include <filetype.h>
+#include <globcon.h>
+#include <formants.h>
+#include <processno.h>
+#include <modeno.h>
+#include <logic.h>
+#include <special.h>
+#include <speccon.h>
+
+#include <sfsys.h>
+#ifdef _DEBUG
+#include <assert.h>
+#endif
+
+#include <string.h>             /*RWD */
+
+#if defined unix || defined _MSC_VER
+#define round(x) lround((x))
+#endif
+
+static int  get_pitch_or_transpos_binarydata_from_first_file(float **thisdata,dataptr dz);
+static int  read_pitch_or_transposition_brkvals(char *filename,double **brktable,int *brksize);
+static int  store_numbers(char *filename,dataptr dz);
+static int  store_wordlist(char *filename,dataptr dz);
+static int  store_brktable(char *filename,dataptr dz);
+static int  open_checktype_getsize_and_compareheader(char *filename,int fileno,fileptr *fp2,dataptr dz);
+//TW NEW
+//static int  headcompare_and_update(int fd,char *filename,int *this_filetype,fileptr *fp2,dataptr dz);
+static int  headcompare_and_update(int fd,char *filename,int *this_filetype,fileptr *fp2,int fileno,dataptr dz);
+
+static int  set_otherfile_header(int fd,char *filename,dataptr dz);
+//TW NEW
+//static int  check_later_filetype_valid_for_process(char *filename,int file_type,dataptr dz);
+static int  check_later_filetype_valid_for_process(char *filename,int file_type,int fileno,dataptr dz);
+
+static int  check_for_data_in_later_file(char *filename,int filetype,int fileno,dataptr dz);
+static int  read_brkvals_from_other_file(FILE *fp,char *filename,dataptr dz);
+static int  read_dB_brkvals_from_other_file(FILE *fp,char *filename,dataptr dz);
+static int  setup_valid_wlength(dataptr dz);
+static int  get_pitch_or_transpos_binarydata_from_other_file(int max_arraysize,int fileno,
+                                                             float **thisdata,fileptr fp2,dataptr dz);
+static int  getsize_and_get_brkpntdata_from_other_pitch_or_transpos_file
+(char *filename,double minval, double maxval,int which_type, dataptr dz);
+static int  establish_minwindowlength_or_minduration_in_secs(double *brktable,int brksize,char *filename,dataptr dz);
+static int  establish_duration_in_secs(double *duration,double *brktable,int brksize,char *filename);
+#ifdef NOTDEF
+static int  check_for_pitch_zeros(char *filename,float *pitcharray,int wlen);
+#endif
+static int  test_brkvals(double minval,double maxval,float *floatarray,int arraysize);
+static int  inform_infile_structure(fileptr fp1,fileptr fp2,dataptr dz);
+
+/************************************************************************************/
+/************************************************************************************/
+/*        READING THE FIRST FILE : WHERE DATA IS KNOWN FROM PARSING PROCESS         */
+/************************************************************************************/
+/************************************************************************************/
+
+/************************** OPEN_FIRST_INFILE *****************************/
+
+int open_first_infile(char *filename,dataptr dz)
+{
+    int exit_status;
+    int arraycnt;
+    switch(dz->infile->filetype) {
+        case(ANYFILE):
+            break;
+        case(SNDFILE):      case(ANALFILE):     case(PITCHFILE):
+        case(TRANSPOSFILE): case(FORMANTFILE):  case(ENVFILE):
+            if((dz->ifd[0] = sndopenEx(filename,0,CDP_OPEN_RDONLY)) < 0) {
+                sprintf(errstr,"Failure to open file %s for input.\n",filename);
+                return(SYSTEM_ERROR);
+            }
+            
+#ifdef _DEBUG
+            assert(dz->insams[0] >0);
+            
+#endif
+            /* RWD Feb 2007 workaround for close/reopen problem */
+#ifdef _WIN32
+            sndseekEx(dz->ifd[0],0,0);
+#endif
+            switch(dz->infile->filetype) {
+                case(PITCHFILE):
+                    if((dz->pitches = (float *)malloc((size_t) (dz->insams[0] * sizeof(float))))==NULL) {
+                        sprintf(errstr,"INSUFFICIENT MEMORY to store binary pitch data.\n");
+                        return(MEMORY_ERROR);
+                    }
+                    if((exit_status = get_pitch_or_transpos_binarydata_from_first_file(&(dz->pitches),dz))<0)
+                        return(exit_status);
+                    break;
+                case(TRANSPOSFILE):
+                    if((dz->transpos = (float *)malloc((size_t)(dz->insams[0] * sizeof(float))))==NULL) {
+                        sprintf(errstr,"INSUFFICIENT MEMORY to store binary transposition data.\n");
+                        return(MEMORY_ERROR);
+                    }
+                    if((exit_status = get_pitch_or_transpos_binarydata_from_first_file(&(dz->transpos),dz))<0)
+                        return(exit_status);
+                    break;
+                case(FORMANTFILE):
+                    if((exit_status = initialise_specenv(&arraycnt,dz))<0)
+                        return(exit_status);
+                    break;
+            }
+            
+            break;
+        case(TEXTFILE):
+            if((exit_status = read_pitch_or_transposition_brkvals(filename,&(dz->temp),&(dz->tempsize)))<0)
+                return(exit_status);
+            break;
+        case(BRKFILE):
+        case(DB_BRKFILE):
+        case(UNRANGED_BRKFILE):
+            if((exit_status = store_brktable(filename,dz))<0)
+                return(exit_status);
+            if(dz->input_data_type!=ALL_FILES && dz->input_data_type!=ANY_NUMBER_OF_ANY_FILES)
+                dz->infilecnt = 0;
+            break;
+        case(NUMLIST):
+            if((exit_status = store_numbers(filename,dz))<0)
+                return(exit_status);
+            dz->infilecnt = 0;
+            break;
+        case(SNDLIST):
+        case(SYNCLIST):
+        case(MIXFILE):
+        case(LINELIST):
+        case(WORDLIST):
+            if((exit_status = store_wordlist(filename,dz))<0)
+                return(exit_status);
+            if(dz->input_data_type!=ALL_FILES && dz->input_data_type!=ANY_NUMBER_OF_ANY_FILES)
+                dz->infilecnt = 0;
+            break;
+        default:
+            sprintf(errstr,"Unknown filetype: open_first_infile()\n");
+            return(PROGRAM_ERROR);
+    }
+    if(dz->infilecnt>0 && dz->infile->filetype!=TEXTFILE)
+        dz->samps_left = dz->insams[0];
+    return(FINISHED);
+}
+
+/********************* GET_PITCH_OR_TRANSPOS_BINARYDATA_FROM_FIRST_FILE *************************/
+
+int get_pitch_or_transpos_binarydata_from_first_file(float **thisdata,dataptr dz)
+{
+    int /*seccnt,*/ samps_read;
+    int samps_to_read = dz->insams[0];
+    unsigned int arraysize;
+    
+    if((*thisdata = (float *)malloc((size_t)(samps_to_read * sizeof(float))))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to store binary pitch or transposition data.\n");
+        return(MEMORY_ERROR);
+    }
+    if((samps_read  = fgetfbufEx((*thisdata), samps_to_read,dz->ifd[0],0))<0) {
+        sprintf(errstr,"Sound read error.\n");
+        return(SYSTEM_ERROR);
+    }
+    if(samps_read!= dz->insams[0]) {
+        sprintf(errstr,"Problem reading data: get_pitch_or_transpos_binarydata_from_first_file()\n");
+        return(PROGRAM_ERROR);
+    }
+    arraysize = samps_read;
+    if((*thisdata = (float *)realloc((char *)(*thisdata),(arraysize + 1) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate binary pitch or transposition data.\n");   /* 1 float for safety */
+        return(MEMORY_ERROR);
+    }
+    (*thisdata)[arraysize] = 0.0f;  /* SAFETY POSITION */
+    return(FINISHED);
+}
+
+/************************* READ_PITCH_OR_TRANSPOSITION_BRKVALS *****************************/
+
+int read_pitch_or_transposition_brkvals(char *filename,double **brktable,int *brksize)
+{
+    int arraysize = (*brksize) * 2;
+    double *p, d;
+    int n = 0,m, final_size;
+    char temp[200], *q;
+    FILE *fp;
+    
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr, "Can't open file %s to read data.\n",filename);
+        return(DATA_ERROR);
+    }
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(*brksize <= 0) {
+        sprintf(errstr,"Array size not set: read_pitch_or_transposition_brkvals()\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    if((*brktable = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to store pitch or transposition brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    p = *brktable;
+    while(fgets(temp,200,fp)==temp) {    /* READ AND TEST BRKPNT VALS */
+        q = temp;
+        while(get_float_from_within_string(&q,&d)) {
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(n >= arraysize) {
+                sprintf(errstr,"More values found than indicated by parse.\n");
+                return(PROGRAM_ERROR);
+            }
+#endif
+            
+            *p = d;
+            p++;
+            n++;
+        }
+    }
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(n!=arraysize) {
+        sprintf(errstr,"Count of pitch or transposition values does not tally with parse.\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    final_size = n;
+    if((*brktable)[0] != 0.0)   /* Allow space for a value at time zero, if there isn't one */
+        final_size = n + 2;
+    if((*brktable = (double *)realloc((char *)(*brktable),final_size * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate pitch or transposition brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    if(final_size != n) {       /* Force a value at time zero, if there isn't one */
+        for(m=n-1;m>=0;m--)
+            (*brktable)[m+2] = (*brktable)[m];
+        (*brktable)[0] = 0.0;
+        (*brktable)[1] = (*brktable)[3];
+    }
+    *brksize = final_size/2;
+    return(FINISHED);
+}
+
+/*************************** STORE_NUMBERS ***********************/
+
+int store_numbers(char *filename,dataptr dz)
+{
+    double *p, d;
+    char   temp[200], *q;
+    int   n = 0;
+    FILE   *fp;
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr,"Failed to open file %s for input.\n",filename);
+        return(DATA_ERROR);
+    }
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(dz->numsize<=0) {
+        sprintf(errstr,"Accounting problem in numfile transfer: store_numbers()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->array_cnt < 1) {
+        sprintf(errstr,"No double array available for number list: get_numtable_from_framework()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->parray[0] != NULL) {
+        sprintf(errstr,"Double array for number list already allocated: get_numtable_from_framework()\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    if((dz->parray[0] = (double *) malloc(dz->numsize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to allocate numbers array.\n");
+        return(MEMORY_ERROR);
+    }
+    p = dz->parray[0];
+    while(fgets(temp,200,fp)!=NULL) {
+        q = temp;
+        while(get_float_from_within_string(&q,&d)) {
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(n >= dz->numsize) {
+                sprintf(errstr,"Number of input numbers exceeds parsed size: file %s\n",filename);
+                return(PROGRAM_ERROR);
+            }
+#endif
+            
+            *p = d;
+            p++;
+            n++;
+        }
+    }
+    if(n != dz->numsize) {
+        sprintf(errstr,"Number of input numbers != parsed size: file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************************* STORE_WORDLIST *****************************/
+
+int store_wordlist(char *filename,dataptr dz)
+{
+    char temp[200],*p,*q;
+    int n;
+    int total_wordcnt = 0;
+    int wordcnt_in_line;
+    int line_cnt = 0;
+    FILE *fp;
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(dz->linecnt <= 0) {
+        sprintf(errstr,"Accounting problem: get_wordlist()\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    if((dz->wordstor = (char **)malloc(dz->all_words * sizeof(char *)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for wordstores.\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<dz->all_words;n++)        /* initialise, for testing and safe freeing */
+        dz->wordstor[n] = NULL;
+    
+    if((dz->wordcnt  = (int *)malloc(dz->linecnt * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for line wordcounts.\n");
+        return(MEMORY_ERROR);
+    }
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr,"Failed to open file %s for input.\n",filename);
+        return(DATA_ERROR);
+    }
+    while(fgets(temp,200,fp)!=NULL) {
+        p = temp;
+        if(is_an_empty_line_or_a_comment(p))
+            continue;
+        
+#ifdef IS_CDPMAIN_TESTING
+        if(line_cnt >= dz->linecnt) {
+            sprintf(errstr,"Too many lines found: does not tally with parsing data.\n");
+            return(PROGRAM_ERROR);
+        }
+#endif
+        
+        wordcnt_in_line = 0;
+        while(get_word_from_string(&p,&q)) {
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(total_wordcnt >= dz->all_words) {
+                sprintf(errstr,"Error in word accounting: store_wordlist_without_comments()\n");
+                return(PROGRAM_ERROR);
+            }
+#endif
+            
+            if((dz->wordstor[total_wordcnt] = (char *)malloc((strlen(q) + 1) * sizeof(char)))==NULL) {
+                sprintf(errstr,"INSUFFICIENT MEMORY for wordstor %d\n",total_wordcnt+1);
+                return(MEMORY_ERROR);
+            }
+            strcpy(dz->wordstor[total_wordcnt],q);
+            total_wordcnt++;
+            wordcnt_in_line++;
+        }
+        dz->wordcnt[line_cnt] = wordcnt_in_line;
+        line_cnt++;
+    }
+    /* NEW : APRIL 2009 !! */
+    dz->linecnt = line_cnt;
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(dz->linecnt != line_cnt) {
+        sprintf(errstr,"Count of lines does not tally with parsing data.\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->all_words != total_wordcnt) {
+        sprintf(errstr,"Count of words does not tally with parsing data.\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    if(dz->infile->filetype==SNDLIST) {     /* reorganise snds in sndlist onto separate lines */
+        if(dz->linecnt != dz->all_words) {
+            if((dz->wordcnt  = (int *)realloc(dz->wordcnt,dz->all_words * sizeof(int)))==NULL) {
+                sprintf(errstr,"INSUFFICIENT MEMORY to reallocate word counts.\n");
+                return(MEMORY_ERROR);
+            }
+            dz->linecnt = dz->all_words;
+            for(n=0;n<dz->linecnt;n++)
+                dz->wordcnt[n] = 1;
+        }
+    }
+    //TW NOT SURE WHETHER YOU REMOVED fclose(fp) FOR A PURPOSE from the code set you have
+    //OR I ADDED IT TO THE CODESET MORE RECENTLY, due to its omission throwing up a problem ???
+    fclose(fp);
+    return(FINISHED);
+}
+
+/*************************** STORE_BRKTABLE ***********************/
+
+int store_brktable(char *filename,dataptr dz)
+{
+    double *p, d, *brktable;
+    int arraysize;
+    char temp[200], *q;
+    int n = 0,m, final_size;
+    FILE *fp;
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr,"Failed to open file %s for input.\n",filename);
+        return(DATA_ERROR);
+    }
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(dz->extrabrkno < 0) {
+        sprintf(errstr,"invalid index for extrabrkno: get_brktable()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->brksize[dz->extrabrkno] <= 0) {
+        sprintf(errstr,"invalid size for brktable: get_brktable()\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    arraysize = dz->brksize[dz->extrabrkno] * 2;
+    if((dz->brk[dz->extrabrkno] = (double*) malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to store input brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    brktable  = dz->brk[dz->extrabrkno];
+    
+    p = brktable;
+    while(fgets(temp,200,fp)!=NULL) {
+        q = temp;
+        while(get_float_from_within_string(&q,&d)) {
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(n >= arraysize) {
+                sprintf(errstr,"Too much data to put in allocated array: Accounting error.\n");
+                return(PROGRAM_ERROR);
+            }
+#endif
+            
+            *p = d;
+            p++;
+            n++;
+        }
+    }
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(n != arraysize) {
+        sprintf(errstr,"Count of brkfile data does not tally with parse: file %s\n",filename);
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    if(brktable[0] != 0.0)  { /* Allow space for a value at time zero, if there isn't one */
+        final_size = n + 2;
+        if((dz->brk[dz->extrabrkno] = (double *)realloc
+            ((char *)dz->brk[dz->extrabrkno],final_size * sizeof(double)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY to reallocate input brktable data.\n");
+            return(MEMORY_ERROR);
+        }
+        brktable  = dz->brk[dz->extrabrkno];
+        for(m=n-1;m>=0;m--)
+            brktable[m+2] = brktable[m];
+        brktable[0] = 0.0;
+        brktable[1] = brktable[3];
+        dz->brksize[dz->extrabrkno]++;
+    }
+    return(FINISHED);
+}
+
+/************************************************************************************/
+/************************************************************************************/
+/*      READING SUBSEQUENT FILES : WHERE DATA NOT KNOWN FROM PARSING PROCESS        */
+/************************************************************************************/
+/************************************************************************************/
+
+
+/***************************** HANDLE_OTHER_INFILE **************************/
+
+int handle_other_infile(int fileno,char *filename,dataptr dz)   /* fileno = 1,2,3.*/
+{
+    int     exit_status, current_status;
+    int     wlengthf, arraysize;
+    double  maxval;
+    int     arraycnt;
+    fileptr fp2 = NULL;
+#ifdef IS_CDPMAIN_TESTING
+    if(fileno < 1 || fileno>dz->infilecnt) {
+        sprintf(errstr,"Attempted to open infile not accounted for: handle_other_infile()\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    if((exit_status = open_checktype_getsize_and_compareheader(filename,fileno,&fp2,dz))<0)
+        return(exit_status);
+    current_status = exit_status;
+    
+    switch(dz->input_data_type) {
+        case(TWO_SNDFILES):
+        case(MANY_SNDFILES):
+        case(ONE_OR_MANY_SNDFILES):
+            //TW NEW
+        case(ONE_OR_MORE_SNDSYS):
+            
+        case(SNDFILE_AND_BRKFILE):
+        case(SNDFILE_AND_UNRANGED_BRKFILE):
+        case(SNDFILE_AND_DB_BRKFILE):
+        case(SNDFILE_AND_ENVFILE):
+        case(TWO_ANALFILES):
+        case(THREE_ANALFILES):
+        case(MANY_ANALFILES):
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(current_status!=FINISHED) {
+                sprintf(errstr,"%s is not a valid data file for this application.\n",filename);
+                return(USER_ERROR);
+            }
+#endif
+            
+            break;
+            
+        case(ANAL_AND_FORMANTS):    /* formant data is read in param_preprocess, once buffers setup */
+        case(PITCH_AND_FORMANTS):   /* formant data is read in param_preprocess, once buffers setup */
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(current_status!=FINISHED) {
+                sprintf(errstr,"%s is not a valid data file for this application.\n",filename);
+                return(DATA_ERROR);
+            }
+#endif
+            /* set processing length to min of input files */
+            if((wlengthf = (dz->insams[fileno]/dz->infile->specenvcnt) - DESCRIPTOR_DATA_BLOKS)<=0) {
+                sprintf(errstr,"No data in formant file %s\n",filename);
+                return(DATA_ERROR);
+            }
+            dz->wlength = min(dz->wlength,wlengthf);
+            dz->descriptor_samps = dz->infile->specenvcnt * DESCRIPTOR_DATA_BLOKS ;
+            if((exit_status = initialise_specenv(&arraycnt,dz))<0)
+                return(exit_status);
+            break;
+            //TW NEW CASE
+        case(PFE):                  /* formant data is read in param_preprocess, once buffers setup */
+            if(fileno==1) {
+                /* set processing length to min of input files */
+                if((wlengthf = (dz->insams[fileno]/dz->infile->specenvcnt) - DESCRIPTOR_DATA_BLOKS)<=0) {
+                    sprintf(errstr,"No data in formant file %s\n",filename);
+                    return(DATA_ERROR);
+                }
+                dz->wlength = min(dz->wlength,wlengthf);
+                dz->descriptor_samps = dz->infile->specenvcnt * DESCRIPTOR_DATA_BLOKS;
+                if((exit_status = initialise_specenv(&arraycnt,dz))<0)
+                    return(exit_status);
+            }
+            break;
+            
+        case(ANAL_WITH_PITCHDATA):
+            switch(current_status) {
+                case(FINISHED):
+                    /* pitchdata derived from analdata: hence lengths must be equal */
+                    if((int)(dz->insams[fileno]) != dz->wlength) {
+                        sprintf(errstr,"Pitchfile (%d vals) and analysisfile (%d windows) are not same length\n",dz->insams[fileno],dz->wlength);
+                        return(DATA_ERROR);
+                    }
+                    arraysize = dz->wlength;
+                    if((exit_status = get_pitch_or_transpos_binarydata_from_other_file(arraysize,fileno,&(dz->pitches),fp2,dz))<0)
+                        return(exit_status);
+                    break;
+                case(CONTINUE):
+                    if((exit_status = getsize_and_get_brkpntdata_from_other_pitch_or_transpos_file
+                        (filename,-2.0,dz->nyquist+1.0,NO_SPECIAL_TYPE,dz))<0)
+                        return(exit_status);
+                    break;
+            }
+            break;
+            
+        case(ANAL_WITH_TRANSPOS):
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(current_status!=FINISHED) {
+                sprintf(errstr,"%s is not a valid data file for this application.\n",filename);
+                return(USER_ERROR);
+            }
+#endif
+            
+            arraysize = max(dz->wlength,dz->insams[1]);
+            /* transposdata will be adjusted to size of analdata */
+            if((exit_status = get_pitch_or_transpos_binarydata_from_other_file(arraysize,fileno,&(dz->transpos),fp2,dz))<0)
+                return(exit_status);
+            break;
+            
+        case(PITCH_AND_PITCH):
+            switch(current_status) {
+                case(FINISHED):             /* THIS file is a binary file, so binary data header available */
+                    if((exit_status = setup_valid_wlength(dz))<0)
+                        return(exit_status);
+                    arraysize  = max(dz->wlength,dz->insams[1]);
+                    if((exit_status = get_pitch_or_transpos_binarydata_from_other_file(arraysize,fileno,&(dz->pitches2),fp2,dz))<0)
+                        return(exit_status);
+                    break;
+                case(CONTINUE):                             /* Implies input file is NOT a binary file */
+                    if(dz->infile->filetype == TEXTFILE) {  /* Implies NEITHER file is a binary file */
+                        if(dz->outfiletype  == PITCH_OUT) {
+                            sprintf(errstr,"Can't generate binary output data from exclusively brkpntfile input.\n");
+                            return(DATA_ERROR);
+                        }
+                        maxval = DEFAULT_NYQUIST;   /* nyquist is NOT defined */
+                    } else
+                        maxval = dz->nyquist;   /* nyquist is defined by 1st input file */
+                    if((exit_status = getsize_and_get_brkpntdata_from_other_pitch_or_transpos_file
+                        (filename,-1.0,maxval,NO_SPECIAL_TYPE,dz))<0)
+                        return(exit_status);
+                    break;
+            }
+            /****
+             if((exit_status = check_for_pitch_zeros(filename,dz->pitches2,dz->wlength))<0)
+             return(exit_status);
+             ****/
+            break;
+            
+        case(PITCH_AND_TRANSPOS):
+        case(TRANSPOS_AND_TRANSPOS):
+            switch(current_status) {
+                case(FINISHED):             /* THIS file is a binary file, so binary data header available */
+                    if((exit_status = setup_valid_wlength(dz))<0)
+                        return(exit_status);
+                    arraysize  = max(dz->wlength,dz->insams[1]);
+                    switch(dz->input_data_type) {
+                        case(PITCH_AND_TRANSPOS):
+                            if((exit_status = get_pitch_or_transpos_binarydata_from_other_file
+                                (arraysize,fileno,&(dz->transpos),fp2,dz))<0)
+                                return(exit_status);
+                            break;
+                        case(TRANSPOS_AND_TRANSPOS):
+                            if((exit_status = get_pitch_or_transpos_binarydata_from_other_file
+                                (arraysize,fileno,&(dz->transpos2),fp2,dz))<0)
+                                return(exit_status);
+                            break;
+                    }
+                    break;
+                case(CONTINUE):                             /* Implies input file is NOT a binary file */
+                    if(dz->infile->filetype == TEXTFILE) {  /* Implies NEITHER file is a binary file */
+                        if(dz->outfiletype  == PITCH_OUT) {
+                            sprintf(errstr,"Can't generate binary output data from exclusively brkpntfile input.\n");
+                            return(DATA_ERROR);
+                        }
+                    }
+                    if((exit_status = getsize_and_get_brkpntdata_from_other_pitch_or_transpos_file
+                        (filename,MIN_TRANSPOS,MAX_TRANSPOS,NO_SPECIAL_TYPE,dz))<0)
+                        return(exit_status);
+                    break;
+            }
+            break;
+        case(ALL_FILES):
+            if(dz->process==INFO_DIFF)
+                break;
+        case(ANY_NUMBER_OF_ANY_FILES):
+            if(dz->process==HOUSE_BUNDLE || dz->process==ADDTOMIX || dz->process==BATCH_EXPAND || dz->process==MIX_MODEL)
+                break;
+        default:
+            sprintf(errstr,"File '%s' has invalid data-type for this application.\n",filename);
+            return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************************** OPEN_CHECKTYPE_GETSIZE_AND_COMPAREHEADER *****************************/
+
+int open_checktype_getsize_and_compareheader(char *filename,int fileno,fileptr *fp2,dataptr dz)
+{
+    int exit_status;
+    FILE *fp;
+    int filetype;
+    
+    if((dz->ifd[fileno] = sndopenEx(filename,0,CDP_OPEN_RDONLY)) < 0) {
+        switch(dz->input_data_type) {
+            case(ANAL_WITH_PITCHDATA):
+            case(PITCH_AND_PITCH):
+            case(PITCH_AND_TRANSPOS):
+            case(TRANSPOS_AND_TRANSPOS):
+                //TW NEW
+                return(CONTINUE);
+            case(ANY_NUMBER_OF_ANY_FILES):
+                if(dz->process == ADDTOMIX || dz->process == BATCH_EXPAND) {
+                    sprintf(errstr,"cannot open input file %s to read data.\n",filename);
+                    return(DATA_ERROR);
+                }
+                
+                return(CONTINUE);
+            case(SNDFILE_AND_BRKFILE):
+            case(SNDFILE_AND_UNRANGED_BRKFILE):
+                if((fp = fopen(filename,"r"))==NULL) {  /* test for a brkpnt file */
+                    sprintf(errstr, "Can't open file %s to read data.\n",filename);
+                    return(DATA_ERROR);
+                }
+                return read_brkvals_from_other_file(fp,filename,dz);
+            case(SNDFILE_AND_DB_BRKFILE):
+                if((fp = fopen(filename,"r"))==NULL) {  /* test for a brkpnt file */
+                    sprintf(errstr, "Can't open file %s to read data.\n",filename);
+                    return(DATA_ERROR);
+                }
+                return read_dB_brkvals_from_other_file(fp,filename,dz);
+            case(TWO_SNDFILES):
+            case(MANY_SNDFILES):
+            case(ONE_OR_MANY_SNDFILES):
+            case(SNDFILE_AND_ENVFILE):
+            case(TWO_ANALFILES):
+            case(THREE_ANALFILES):
+            case(MANY_ANALFILES):
+            case(ANAL_WITH_TRANSPOS):
+            case(ANAL_AND_FORMANTS):
+            case(PITCH_AND_FORMANTS):
+                //TW NEW CASES
+            case(ONE_OR_MORE_SNDSYS):
+            case(PFE):
+                sprintf(errstr,"cannot open input file %s to read data.\n",filename);
+                return(DATA_ERROR);
+                
+            case(ALL_FILES):
+                if(dz->process==INFO_DIFF) {
+                    if((fp = fopen(filename,"r"))==NULL)
+                        sprintf(errstr, "Can't open file %s to read data.\n",filename);
+                    else
+                        sprintf(errstr,"This process does not work with text files [%s].\n",filename);
+                    return(DATA_ERROR);
+                }
+                /* fall thro */
+            case(NO_FILE_AT_ALL):
+            case(SNDFILES_ONLY):
+            case(ANALFILE_ONLY):
+            case(ENVFILES_ONLY):
+            case(PITCHFILE_ONLY):
+            case(FORMANTFILE_ONLY):
+            case(BRKFILES_ONLY):
+            case(DB_BRKFILES_ONLY):
+            case(MIXFILES_ONLY):
+            case(SNDLIST_ONLY):
+            case(SND_OR_MIXLIST_ONLY):
+            case(SND_SYNC_OR_MIXLIST_ONLY):
+                sprintf(errstr,"Should be impossible to call func open_checktype_getsize_and_compareheader()\n");
+                return(PROGRAM_ERROR);
+            default:
+                sprintf(errstr,"open_checktype_getsize_and_compareheader() not defined for this filetype\n");
+                return(PROGRAM_ERROR);
+        }
+    }
+    if(dz->has_otherfile) {
+        if((exit_status = set_otherfile_header(dz->ifd[fileno],filename,dz))<0)
+            return(exit_status);
+        filetype = dz->otherfile->filetype;
+    } else {
+        //TW NEW
+        //      if((exit_status = headcompare_and_update(dz->ifd[fileno],filename,&filetype,fp2,dz))<0)
+        if((exit_status = headcompare_and_update(dz->ifd[fileno],filename,&filetype,fp2,fileno,dz))<0)
+            return(exit_status);
+    }
+    
+    if((dz->insams[fileno] = sndsizeEx(dz->ifd[fileno]))<0) {       /* FIND SIZE OF FILE */
+        sprintf(errstr, "Can't read size of input file %s.\n"
+                "open_checktype_getsize_and_compareheader()\n",filename);
+        return(PROGRAM_ERROR);
+    }
+    if((exit_status = check_for_data_in_later_file(filename,filetype,fileno,dz))<0)
+        return(exit_status);
+    
+    return(FINISHED);
+}
+
+/***************************** HEADCOMPARE_AND_UPDATE *******************************/
+
+//TW NEW
+//int headcompare_and_update(int fd,char *filename,int *this_filetype,fileptr *fp2,dataptr dz)
+int headcompare_and_update(int fd,char *filename,int *this_filetype,fileptr *fp2,int fileno,dataptr dz)
+{
+    int exit_status;
+    fileptr fp1 = dz->infile;
+    double maxamp, maxloc;
+    int maxrep;
+    int getmax = 0, getmaxinfo = 0;
+    infileptr ifp;
+    if((ifp = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to store data on later infile. (1)\n");
+        return(MEMORY_ERROR);
+    }
+    if((*fp2 = (fileptr)malloc(sizeof(struct fileprops)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to store data on later infile. (2)\n");
+        return(MEMORY_ERROR);
+    }
+    if((exit_status = readhead(ifp,fd,filename,&maxamp,&maxloc,&maxrep,getmax,getmaxinfo))<0)
+        return(exit_status);
+    copy_to_fileptr(ifp,*fp2);
+    if((exit_status = check_later_filetype_valid_for_process(filename,(*fp2)->filetype,fileno,dz))<0)
+        return(exit_status);
+    
+    if(fp1->filetype==TEXTFILE) {
+        *this_filetype = (*fp2)->filetype;
+        return(FINISHED);
+    }
+    switch(dz->input_data_type) {
+        case(TWO_SNDFILES):
+        case(MANY_SNDFILES):
+        case(ONE_OR_MANY_SNDFILES): /* compare properties common to all short and float files except envfiles */
+            if((*fp2)->filetype != fp1->filetype) {
+                sprintf(errstr,"Incompatible file type in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+    }
+    switch(dz->input_data_type) {
+            /***
+             compare specifically formant properties : possible future usage *
+             case(FORMANTS_AND_FORMANTS):
+             if((*fp2)->specenvcnt != fp1->specenvcnt) {
+             sprintf(errstr,"Incompatible specenvcnt in input file %s.\n",filename);
+             return(DATA_ERROR):
+             }
+             dz->specenvcnt = fp1->specenvcnt;
+             * fall thro *
+             ***/
+        case(PITCH_AND_FORMANTS):   /* compare properties not in analfiles */
+        case(PITCH_AND_PITCH):
+        case(PITCH_AND_TRANSPOS):
+        case(TRANSPOS_AND_TRANSPOS):
+        case(PITCH_OR_TRANSPOS):
+            if((*fp2)->origchans != fp1->origchans) {
+                sprintf(errstr,"Incompatible original-channel-count in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            /* fall thro */
+        case(ANAL_AND_FORMANTS):    /* compare properties common to all float files except envfiles */
+        case(ANAL_WITH_PITCHDATA):
+        case(ANAL_WITH_TRANSPOS):
+        case(TWO_ANALFILES):
+        case(THREE_ANALFILES):
+        case(MANY_ANALFILES):
+            if((*fp2)->origstype != fp1->origstype) {
+                sprintf(errstr,"Incompatible original-sample-type in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            if((*fp2)->origrate != fp1->origrate) {
+                sprintf(errstr,"Incompatible original-sample-rate in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            if((*fp2)->arate != fp1->arate) {
+                sprintf(errstr,"Incompatible analysis-sample-rate in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            if((*fp2)->Mlen != fp1->Mlen) {
+                sprintf(errstr,"Incompatible analysis-window-length in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            if((*fp2)->Dfac != fp1->Dfac) {
+                sprintf(errstr,"Incompatible decimation factor in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            /* fall thro */
+        case(TWO_SNDFILES):
+        case(MANY_SNDFILES):
+        case(ONE_OR_MANY_SNDFILES): /* compare properties common to all short and float files except envfiles */
+            if((*fp2)->srate != fp1->srate) {
+                sprintf(errstr,"Incompatible sample-rate in input file %s.\n",filename);
+                return(DATA_ERROR);
+            }
+            
+            switch(dz->input_data_type) {
+                case(TWO_ANALFILES):
+                case(THREE_ANALFILES):
+                case(MANY_ANALFILES):
+                case(TWO_SNDFILES):
+                case(MANY_SNDFILES):
+                case(ONE_OR_MANY_SNDFILES):
+                    if((*fp2)->channels != fp1->channels) {
+                        if(!(dz->process == MOD_LOUDNESS) && !(dz->mode == 6)) {
+                            sprintf(errstr,"Incompatible channel-count in input file %s.\n",filename);
+                            return(DATA_ERROR);
+                        }
+                    }
+                    break;
+                case(ANAL_AND_FORMANTS):    /* compare properties and derived properties */
+                case(ANAL_WITH_PITCHDATA):
+                case(ANAL_WITH_TRANSPOS):
+                    if((*fp2)->origchans != fp1->channels) {
+                        sprintf(errstr,"Incompatible (original) channel-count in input file %s.\n",filename);
+                        return(DATA_ERROR);
+                    }
+            }
+            break;
+        case(SNDFILE_AND_ENVFILE):
+            break;
+        case(ANY_NUMBER_OF_ANY_FILES):
+            //TW NEW CASE
+        case(ONE_OR_MORE_SNDSYS):
+            break;
+            //TW NEW CASE
+        case(PFE):
+            if(fileno==1) {
+                if((*fp2)->origchans != fp1->origchans) {
+                    sprintf(errstr,"Incompatible original-channel-count in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((*fp2)->origstype != fp1->origstype) {
+                    sprintf(errstr,"Incompatible original-sample-type in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((*fp2)->origrate != fp1->origrate) {
+                    sprintf(errstr,"Incompatible original-sample-rate in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((*fp2)->arate != fp1->arate) {
+                    sprintf(errstr,"Incompatible analysis-sample-rate in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((*fp2)->Mlen != fp1->Mlen) {
+                    sprintf(errstr,"Incompatible analysis-window-length in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((*fp2)->Dfac != fp1->Dfac) {
+                    sprintf(errstr,"Incompatible decimation factor in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                if((*fp2)->srate != fp1->srate) {
+                    sprintf(errstr,"Incompatible sample-rate in formant file %s.\n",filename);
+                    return(DATA_ERROR);
+                }
+                /* NO LONGER POSSIBLE WITH NEW SFSYS
+                 if((*fp2)->stype != fp1->stype) {
+                 sprintf(errstr,"Incompatible sample type in formant file %s.\n",filename);
+                 return(DATA_ERROR);
+                 }
+                 */
+                fp1->specenvcnt = (*fp2)->specenvcnt;
+                dz->specenvcnt  = fp1->specenvcnt;
+            } else {
+                //NEW
+                if((*fp2)->srate != fp1->srate) {
+                    sprintf(errstr,"Incompatible sample-rate (%d) in envelope file %s (must be %d).\n",
+                            (*fp2)->srate,filename,fp1->srate);
+                    return(DATA_ERROR);
+                }
+                //NEW TO HERE
+            }
+            *this_filetype = (*fp2)->filetype;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"Inaccessible case in  headcompare_and_update()\n");
+            return(PROGRAM_ERROR);
+    }
+    /* ADD ANY ADDITIONAL PROPERTIES TO INFILE PROP LIST */
+    switch(dz->input_data_type) {
+        case(PITCH_AND_FORMANTS):
+        case(ANAL_AND_FORMANTS):    /* NB: origchans, if needed, will be set at headwrite stage */
+            fp1->specenvcnt = (*fp2)->specenvcnt;
+            dz->specenvcnt  = fp1->specenvcnt;
+            break;
+    }
+    *this_filetype = (*fp2)->filetype;
+    return(FINISHED);
+}       
+
+/***************************** SET_OTHERFILE_HEADER *******************************
+ *
+ * Set up an independent header.
+ */
+
+int set_otherfile_header(int fd,char *filename,dataptr dz)
+{
+    int exit_status;
+    double maxamp, maxloc;
+    int maxrep;
+    int getmax = 0, getmaxinfo = 0;
+    infileptr ifp;
+    if((ifp = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to store data on other file.\n");
+        return(MEMORY_ERROR);
+    }
+    if((exit_status = readhead(ifp,fd,filename,&maxamp,&maxloc,&maxrep,getmax,getmaxinfo))<0)
+        return(exit_status);
+    copy_to_fileptr(ifp,dz->otherfile);
+    if((exit_status = check_later_filetype_valid_for_process(filename,dz->otherfile->filetype,0,dz))<0)
+        return(exit_status);
+    return(FINISHED);
+}       
+
+/***************************** CHECK_LATER_FILETYPE_VALID_FOR_PROCESS *******************************/
+
+//TW NEW
+//int check_later_filetype_valid_for_process(char *filename,int file_type,dataptr dz)
+int check_later_filetype_valid_for_process(char *filename,int file_type,int fileno,dataptr dz)
+{
+    switch(dz->input_data_type) {
+        case(NO_FILE_AT_ALL):
+        case(ALL_FILES):
+        case(ANY_NUMBER_OF_ANY_FILES):
+            break;
+        case(TWO_SNDFILES):
+        case(MANY_SNDFILES):
+        case(ONE_OR_MANY_SNDFILES):
+            if(file_type != SNDFILE) {
+                sprintf(errstr,"%s is not a sound file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+        case(SNDFILE_AND_ENVFILE):
+            if(file_type != ENVFILE) {
+                sprintf(errstr,"%s is not an envelope file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+        case(TWO_ANALFILES):
+        case(THREE_ANALFILES):
+        case(MANY_ANALFILES):
+            if(file_type != ANALFILE) {
+                sprintf(errstr,"%s is not an analysis file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+        case(PITCH_AND_PITCH):
+        case(ANAL_WITH_PITCHDATA):
+            if(file_type != PITCHFILE) {
+                sprintf(errstr,"%s is not a pitch file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+        case(PITCH_AND_TRANSPOS):
+        case(TRANSPOS_AND_TRANSPOS):
+        case(ANAL_WITH_TRANSPOS):
+            if(file_type != TRANSPOSFILE) {
+                sprintf(errstr,"%s is not a transposition file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+        case(ANAL_AND_FORMANTS):
+        case(PITCH_AND_FORMANTS):
+            /*  case(FORMANTS_AND_FORMANTS): */
+            if(file_type != FORMANTFILE) {
+                sprintf(errstr,"%s is not a formants file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+            //TW NEW CASE
+        case(ONE_OR_MORE_SNDSYS):
+            break;
+            //TW NEW CASE
+        case(PFE):
+            if(fileno==1) {
+                if(file_type != FORMANTFILE) {
+                    sprintf(errstr,"%s is not a formants file.\n",filename);
+                    return(DATA_ERROR);
+                }
+            } else if (file_type != ENVFILE) {
+                sprintf(errstr,"%s is not an envelope file.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+        default:
+            sprintf(errstr,"Impossible input_data_type: check_later_filetype_valid_for_process()\n");
+            return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************************************ CHECK_FOR_DATA_IN_LATER_FILE *****************************************/
+
+int check_for_data_in_later_file(char *filename,int filetype,int fileno,dataptr dz)
+{
+    int clength;
+    
+    //TW NEW
+    //  if(dz->input_data_type == ANY_NUMBER_OF_ANY_FILES) {
+    if(dz->input_data_type == ANY_NUMBER_OF_ANY_FILES || dz->input_data_type == ONE_OR_MORE_SNDSYS) {
+        if(dz->insams[fileno]==0) {
+            sprintf(errstr, "File %s contains no data.\n",filename);
+            return(DATA_ERROR);
+        }
+        return(FINISHED);
+    }
+    
+    switch(filetype) {
+        case(FORMANTFILE):
+            
+#ifdef IS_CDPMAIN_TESTING
+            
+            if(fileno >= 2) {
+                sprintf(errstr,"check_for_data_in_later_file()\n"
+                        "only works (so far) for ONE input formantfile accompanying 1st file.\n");
+                return(PROGRAM_ERROR);
+            }
+            if(dz->infile->filetype  == SNDFILE || dz->infile->filetype  == FORMANTFILE) {
+                sprintf(errstr,"check_for_data_in_later_file()\n"
+                        "Not yet able to deal with FORMANTFILE accompanying FORMANTFILE or SNDFILE.\n");
+                return(PROGRAM_ERROR);
+            }
+#endif
+            
+            if(dz->insams[fileno] <= (int)(DESCRIPTOR_DATA_BLOKS * dz->infile->specenvcnt)) {
+                sprintf(errstr, "File %s contains no formant data.\n",filename);
+                return(DATA_ERROR);
+            }
+            switch(dz->infile->filetype) {
+                case(FORMANTFILE):
+                case(SNDFILE):
+                case(ENVFILE):
+                    break;
+                case(ANALFILE):
+                    clength = (dz->infile->channels)/2;             /* channels per window */
+                    if(dz->infile->specenvcnt > clength+1) {
+                        sprintf(errstr,"Formant data incompatible with existing channel data.\n"
+                                "check_for_data_in_later_file()\n");
+                        return(PROGRAM_ERROR);
+                    }
+                    break;
+                case(PITCHFILE):
+                case(TRANSPOSFILE):
+                    clength = (dz->infile->origchans)/2;            /* channels per window */
+                    if(dz->infile->specenvcnt > clength+1) {
+                        sprintf(errstr,"Formant data incompatible with existing channel data.\n"
+                                "check_for_data_in_later_file()\n");
+                        return(PROGRAM_ERROR);
+                    }
+                    break;
+                default:
+                    sprintf(errstr,"Unknown case for original filetype combining with FORMATFILE\n");
+                    return(PROGRAM_ERROR);
+            }
+            break;
+        default:
+            if(dz->insams[fileno]==0) {
+                sprintf(errstr, "File %s contains no data.\n",filename);
+                return(DATA_ERROR);
+            }
+            break;
+    }
+    return(FINISHED);
+}
+
+/************************* READ_BRKVALS_FROM_OTHER_FILE *****************************
+ *
+ * This only reads 0-1 range brkdata from 2nd file of a pair,
+ * and only where extrabrkno has been established for this infile_type.
+ * i.e. SNDFILE_AND_BRKFILE at Jan 16: 1998.
+ */
+
+int read_brkvals_from_other_file(FILE *fp,char *filename,dataptr dz)
+{
+    double maxval = 0.0;
+    double minval = 0.0;
+    int arraysize = BIGARRAY;
+    double *p, lasttime = 0.0;
+    int  istime = TRUE;
+    int n = 0;
+    char temp[200], *q;
+    int paramno = dz->extrabrkno;
+    switch(dz->input_data_type) {
+        case(SNDFILE_AND_BRKFILE):
+            maxval = 1.0;
+            minval = 0.0;
+            break;
+        case(SNDFILE_AND_UNRANGED_BRKFILE):
+            maxval = (double)MAXSAMP;
+            minval = 0.0;
+            break;
+    }
+    if(paramno<0) {
+        sprintf(errstr,"extrabrk not allocated: read_brkvals_from_other_file()\n");
+        return(PROGRAM_ERROR);
+    }
+    if((dz->brk[paramno] = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for input brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    p = dz->brk[paramno];
+    while(fgets(temp,200,fp)==temp) {    /* READ AND TEST BRKPNT VALS */
+        q = temp;
+        while(get_float_from_within_string(&q,p)) {
+            if(istime) {
+                if(p==dz->brk[paramno]) {
+                    if(*p < 0.0) {
+                        sprintf(errstr,"First timeval(%lf) in brkpntfile %s is less than zero.\n",*p,filename);
+                        return(DATA_ERROR);
+                    }
+                } else {
+                    if(*p <= lasttime) {
+                        sprintf(errstr,"Times (%lf & %lf) in brkpntfile %s are not in increasing order.\n",
+                                lasttime,*p,filename);
+                        return(DATA_ERROR);
+                    }
+                }
+                lasttime = *p;
+            } else {
+                if(*p < minval || *p > maxval) {
+                    sprintf(errstr,"Brkpntfile value (%lf) out of range (%.0lf - %.0lf)\n",*p,minval,maxval);   /*RWD 4:12:2003 added *p arg */
+                    return(DATA_ERROR);
+                }
+            }
+            istime = !istime;
+            p++;
+            if(++n >= arraysize) {
+                arraysize += BIGARRAY;
+                if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),arraysize * sizeof(double)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY to reallocate input brktable data.\n");
+                    return(MEMORY_ERROR);
+                }
+                p = dz->brk[paramno] + n;
+            }
+        }
+    }
+    if(n < 4) {
+        sprintf(errstr,"Not enough data in brkpnt file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if(ODD(n)) {
+        sprintf(errstr,"Data not paired correctly in brkpntfile %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),n * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate input brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->brksize[paramno] = n/2;
+    dz->otherfile->filetype = BRKFILE;
+    return(FINISHED);
+}
+
+/************************* READ_DB_BRKVALS_FROM_OTHER_FILE *****************************
+ *
+ * This only reads dB range brkdata from 2nd file of a pair, converting vals to normalised range..
+ * and only where extrabrkno has been established for this infile_type.
+ * i.e. SNDFILE_AND_DB_BRKFILE at Jan 16: 1998.
+ */
+
+int read_dB_brkvals_from_other_file(FILE *fp,char *filename,dataptr dz)
+{
+    int exit_status;
+    double maxval = 0.0;
+    double minval = MIN_DB_ON_16_BIT;
+    int arraysize = BIGARRAY;
+    double *p, lasttime = 0.0;
+    int  istime = TRUE;
+    int n = 0;
+    char temp[200], *q;
+    int paramno = dz->extrabrkno;
+    if(paramno<0) {
+        sprintf(errstr,"extrabrk not allocated: read_dB_brkvals_from_other_file()\n");
+        return(PROGRAM_ERROR);
+    }
+    if((dz->brk[paramno] = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for input brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    p = dz->brk[paramno];
+    while(fgets(temp,200,fp)==temp) {    /* READ AND TEST BRKPNT VALS */
+        q = temp;
+        while(get_float_from_within_string(&q,p)) {
+            if(istime) {
+                if(p==dz->brk[paramno]) {
+                    if(*p < 0.0) {
+                        sprintf(errstr,"First timeval(%lf) in brkpntfile %s is less than zero.\n",*p,filename);
+                        return(DATA_ERROR);
+                    }
+                } else {
+                    if(*p <= lasttime) {
+                        sprintf(errstr,"Times (%lf & %lf) in brkpntfile %s are not in increasing order.\n",
+                                lasttime,*p,filename);
+                        return(DATA_ERROR);
+                    }
+                }
+                lasttime = *p;
+            } else {
+                if(*p < minval || *p > maxval) {
+                    sprintf(errstr,"dB brkpntfile value (%lf) out of range (%.0lf = %.0lf)\n",
+                            *p,minval,maxval);          /*RWD 4:12:2003 added args */
+                    return(DATA_ERROR);
+                }
+                if((exit_status = convert_dB_at_or_below_zero_to_gain(p))<0)
+                    return(exit_status);
+            }
+            istime = !istime;
+            p++;
+            if(++n >= arraysize) {
+                arraysize += BIGARRAY;
+                if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),arraysize * sizeof(double)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY to reallocate input brktable data.\n");
+                    return(MEMORY_ERROR);
+                }
+                p = dz->brk[paramno] + n;
+            }
+        }
+    }
+    if(n < 4) {
+        sprintf(errstr,"No data in brkpnt file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if(ODD(n)) {
+        sprintf(errstr,"Data not paired correctly in brkpntfile %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),n * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate input brktable data.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->brksize[paramno] = n/2;
+    dz->otherfile->filetype = DB_BRKFILE;
+    return(FINISHED);
+}
+
+/********************************** SETUP_VALID_WLENGTH ************************************/
+
+int setup_valid_wlength(dataptr dz)
+{
+    if(dz->infile->filetype == TEXTFILE) {
+        if(dz->duration <= 0.0) {
+            sprintf(errstr,"duration of first file not set: setup_valid_wlength()\n");
+            return(PROGRAM_ERROR);
+        }
+        dz->wlength = round(dz->duration/dz->frametime); /* wlength of file1 */
+    }
+    dz->wlength = min(dz->wlength,dz->insams[1]);
+    return(FINISHED);
+}
+
+/********************* GET_PITCH_OR_TRANSPOS_BINARYDATA_FROM_OTHER_FILE *************************/
+
+int get_pitch_or_transpos_binarydata_from_other_file(int max_arraysize,int fileno,float **thisdata,fileptr fp2,dataptr dz)
+{
+    int exit_status;
+    int  /*seccnt,*/ samps_to_read, samps_read, actual_arraysize;
+    float lastval;
+    fileptr fp1 = dz->infile;
+    
+#ifdef IS_CDPMAIN_TESTING
+    if(fileno >= 2) {
+        sprintf(errstr,"get_pitch_or_transpos_binarydata_from_other_file() does not work YET for > 2 infiles\n");
+        return(PROGRAM_ERROR);
+    }
+#endif
+    
+    samps_to_read = max_arraysize;
+    
+    max_arraysize = samps_to_read;
+    if((*thisdata = (float *)malloc((size_t)(samps_to_read * sizeof(float))))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for 2nd pitch or transposition array.\n");
+        return(MEMORY_ERROR);
+    }
+    if((samps_read  = fgetfbufEx((*thisdata), samps_to_read,dz->ifd[fileno],0))<0) {
+        sprintf(errstr,"Sound read error.\n");
+        return(SYSTEM_ERROR);
+    }
+    if(samps_read != dz->insams[fileno]) {
+        sprintf(errstr,"Problem reading data: get_pitch_or_transpos_binarydata_from_other_file()\n");
+        return(PROGRAM_ERROR);
+    }
+    actual_arraysize = dz->insams[fileno];
+    switch(dz->input_data_type) {
+        case(PITCH_AND_PITCH):
+            if(dz->infile->filetype!=TEXTFILE)     /* force data to be min length of two input files */
+                actual_arraysize = min(actual_arraysize,dz->wlength);
+            else {
+                dz->nyquist = (double)fp2->origrate/2.0;
+                dz->wlength = actual_arraysize;
+            }
+            //TW NEW
+            //      if((exit_status = test_brkvals(-1.0,dz->nyquist,*thisdata,actual_arraysize))<0)
+            if((exit_status = test_brkvals(NOT_SOUND,dz->nyquist,*thisdata,actual_arraysize))<0)
+                return(exit_status);
+            if(dz->infile->filetype==TEXTFILE) {   /* 1st input is brkpnt, 2nd is binary */
+                if((exit_status = inform_infile_structure(fp1,fp2,dz))<0)
+                    return(exit_status);
+                if((exit_status = convert_brkpntdata_to_window_by_window_array
+                    (dz->temp,dz->tempsize,&dz->pitches,dz->wlength,dz->frametime))<0)
+                    return(exit_status);
+            }
+            break;
+        case(PITCH_AND_TRANSPOS):
+            if(dz->infile->filetype!=TEXTFILE)     /* force data to be min length of two input files */
+                actual_arraysize = min(actual_arraysize,dz->wlength);
+            else
+                dz->wlength = actual_arraysize;
+            if((exit_status = test_brkvals(MIN_TRANSPOS,MAX_TRANSPOS,*thisdata,actual_arraysize))<0)
+                return(exit_status);
+            if(dz->infile->filetype==TEXTFILE) {   /* 1st input is brkpnt, 2nd is binary */
+                if((exit_status = inform_infile_structure(fp1,fp2,dz))<0)
+                    return(exit_status);
+                if((exit_status = convert_brkpntdata_to_window_by_window_array
+                    (dz->temp,dz->tempsize,&dz->pitches,dz->wlength,dz->frametime))<0)
+                    return(exit_status);
+            }
+            break;
+        case(TRANSPOS_AND_TRANSPOS):
+            if(dz->infile->filetype!=TEXTFILE)     /* force data to be min length of two input files */
+                actual_arraysize = min(actual_arraysize,dz->wlength);
+            else
+                dz->wlength = actual_arraysize;
+            if((exit_status = test_brkvals(MIN_TRANSPOS,MAX_TRANSPOS,*thisdata,actual_arraysize))<0)
+                return(exit_status);
+            if(dz->infile->filetype==TEXTFILE) {   /* 1st input is brkpnt, 2nd is binary */
+                if((exit_status = inform_infile_structure(fp1,fp2,dz))<0)
+                    return(exit_status);
+                if((exit_status = convert_brkpntdata_to_window_by_window_array
+                    (dz->temp,dz->tempsize,&dz->transpos,dz->wlength,dz->frametime))<0)
+                    return(exit_status);
+            }
+            break;
+        case(ANAL_WITH_TRANSPOS):
+            /* force data to be length of 1st input files */
+            lastval = (*thisdata)[actual_arraysize-1];
+            
+#ifdef IS_CDPMAIN_TESTING
+            if(max_arraysize < dz->wlength) {
+                sprintf(errstr,"Error in establishing arraysize: get_pitch_or_transpos_binarydata_from_other_file()\n");
+                return(PROGRAM_ERROR);
+            }
+#endif 
+            
+            while(actual_arraysize < dz->wlength) {
+                (*thisdata)[actual_arraysize] = lastval;
+                actual_arraysize++;
+            }
+            break;
+        case(ANAL_WITH_PITCHDATA):
+            /* data is length of 1st input files */
+            actual_arraysize = max_arraysize;
+            break;
+        default:
+            sprintf(errstr,"Invalid case in get_pitch_or_transpos_binarydata_from_other_file()\n");
+            return(PROGRAM_ERROR);
+    }
+    if((*thisdata = (float *)realloc((char *)(*thisdata),(actual_arraysize + 1) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate 2nd table of pitch or transposition data.\n");
+        return(MEMORY_ERROR);
+    }
+    (*thisdata)[actual_arraysize] = 0.0f;   /* SAFETY POSITION */
+    return(FINISHED);
+}
+
+/********************** GETSIZE_AND_GET_BRKPNTDATA_FROM_OTHER_PITCH_OR_TRANSPOS_FILE *******************/
+
+int getsize_and_get_brkpntdata_from_other_pitch_or_transpos_file
+(char *filename,double minval, double maxval,int which_type, dataptr dz)
+{
+    int exit_status;
+    FILE *fp;
+    double *brktable = NULL;
+    /*int  init = 1, istime = 1;*/
+    int /* n = 0,*/ brksize;
+    int wlen;
+    float timestep;
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr, "Can't open brkpntfile %s to read data.\n",filename);
+        return(DATA_ERROR);
+    }
+    if((exit_status=read_and_test_pitch_or_transposition_brkvals
+        (fp,filename,&brktable,&brksize,which_type,minval,maxval))<0) {
+        if(brktable != NULL)
+            free(brktable);
+        return(exit_status);
+    }
+    if(fclose(fp)<0) {
+        fprintf(stdout,"WARNING: Failed to close file %s.\n",filename);
+        fflush(stdout);
+    }
+    switch(dz->input_data_type) {
+            
+#ifdef IS_CDPMAIN_TESTING
+        case(ANAL_WITH_TRANSPOS):
+            sprintf(errstr,"Inaccesible case: getsize_and_get_brkpntdata_from_other_pitch_or_transpos_file()\n");
+            return(PROGRAM_ERROR);
+#endif
+            
+        case(ANAL_WITH_PITCHDATA):
+            break;  /* files are same length: so minwindowlength = wlength */
+        default:
+            if((exit_status = establish_minwindowlength_or_minduration_in_secs(brktable,brksize,filename,dz))<0) {
+                free(brktable);
+                return(exit_status);
+            }
+            break;
+    }
+    
+    if(dz->wlength==0) { /* Neither input binary: use default_frametime & convert both files to bin form */
+        wlen     = round(dz->duration/DEFAULT_FRAMETIME);
+        timestep = DEFAULT_FRAMETIME;
+    } else {
+        wlen     = dz->wlength;
+        timestep = dz->frametime;
+    }
+    
+    switch(dz->input_data_type) {
+        case(ANAL_WITH_PITCHDATA):  /* First file is binary: convert second */
+            if((exit_status = convert_brkpntdata_to_window_by_window_array(brktable,brksize,&dz->pitches,wlen,timestep))<0) {
+                free(brktable);
+                return(exit_status);
+            }
+            break;
+        case(PITCH_AND_PITCH):
+            if(dz->wlength==0) {    /* Neither input is binary: convert first file */
+                if((exit_status = convert_brkpntdata_to_window_by_window_array
+                    (dz->temp,dz->tempsize,&dz->pitches,wlen,timestep))<0)
+                    return(exit_status);
+            }                       /* Convert second file */
+            if((exit_status = convert_brkpntdata_to_window_by_window_array(brktable,brksize,&(dz->pitches2),wlen,timestep))<0) {
+                free(brktable);
+                return(exit_status);
+            }
+            break;
+        case(PITCH_AND_TRANSPOS):
+            if(dz->wlength==0) {    /* Neither input is binary: convert first file */
+                if((exit_status = convert_brkpntdata_to_window_by_window_array
+                    (dz->temp,dz->tempsize,&dz->pitches,wlen,timestep))<0)
+                    return(exit_status);
+            }                       /* Convert second file */
+            if((exit_status = convert_brkpntdata_to_window_by_window_array
+                (brktable,brksize,&dz->transpos,wlen,timestep))<0) {
+                free(brktable);
+                return(exit_status);
+            }
+            break;
+        case(TRANSPOS_AND_TRANSPOS):
+            if(dz->wlength==0) {    /* Neither input is binary: convert first file */
+                if((exit_status = convert_brkpntdata_to_window_by_window_array
+                    (dz->temp,dz->tempsize,&dz->transpos,wlen,timestep))<0)
+                    return(exit_status);
+            }                       /* Convert second file */
+            if((exit_status = convert_brkpntdata_to_window_by_window_array
+                (brktable,brksize,&dz->transpos2,wlen,timestep))<0) {
+                free(brktable);
+                return(exit_status);
+            }
+            break;
+    }
+    free(brktable);
+    return(FINISHED);
+}
+
+/************************* ESTABLISH_MINWINDOWLENGTH_OR_MINDURATION_IN_SECS *****************************/
+
+int establish_minwindowlength_or_minduration_in_secs(double *brktable,int brksize,char *filename,dataptr dz)
+{
+    int exit_status;
+    double thisduration;
+    int thislen;
+    if((exit_status = establish_duration_in_secs(&thisduration,brktable,brksize,filename))<0)
+        return(exit_status);
+    if(dz->infile->filetype == TEXTFILE) {                      /* 1st file was a brkpntfile */
+        
+#ifdef IS_CDPMAIN_TESTING
+        if(dz->duration <= 0.0) {
+            sprintf(errstr,"duration not set: establish_minwindowlength_or_minduration_in_secs()\n");
+            return(PROGRAM_ERROR);
+        }
+#endif
+        
+        dz->duration = min(thisduration,dz->duration);
+    }
+    /* both files are brkpnt: hence wlength remains zero */
+    else {        /* 1st file was a binary file: so frametime is established */
+        
+#ifdef IS_CDPMAIN_TESTING
+        if(dz->wlength <=0) {
+            sprintf(errstr,"wlength not set: establish_minwindowlength_or_minduration_in_secs()\n");
+            return(PROGRAM_ERROR);
+        }
+#endif
+        
+        thislen = round(thisduration/dz->frametime);
+        dz->wlength = min(dz->wlength,thislen);
+    }
+    return(FINISHED);
+}
+
+/************************* ESTABLISH_DURATION_IN_SECS *****************************/
+
+int establish_duration_in_secs(double *duration,double *brktable,int brksize,char *filename)
+{
+    if((*duration = *(brktable + (brksize * 2) - 2))<=0.0) {
+        sprintf(errstr,"No significant data in file %s\n",filename);
+        return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************************ CHECK_FOR_PITCH_ZEROS ***************************/
+#ifdef NOTDEF
+int check_for_pitch_zeros(char *filename,float *pitcharray,int wlen)
+{
+    int n;
+    for(n=0;n<wlen;n++) {
+        if(pitcharray[n] < FLTERR) {
+            sprintf(errstr,"File %s contains unpitched windows: cannot proceed.\n",filename);
+            return(DATA_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+#endif
+/******************************* TEST_BRKVALS ****************************/
+
+int test_brkvals(double minval,double maxval,float *floatarray,int arraysize)
+{
+    float *p = floatarray;
+    float *pend = floatarray + arraysize;
+    while(p < pend) {
+        if(*p < minval) {
+            sprintf(errstr,"Value (%lf) too small (minval = %lf) in further file.\n",*p,minval);
+            return(DATA_ERROR);
+        }
+        if(*p > maxval) {
+            sprintf(errstr,"Value (%lf) too large (maxval = %lf) in further file.\n",*p,maxval);
+            return(DATA_ERROR);
+        }
+        p++;
+    }
+    return(FINISHED);
+}
+
+/******************************* INFORM_INFILE_STRUCTURE ****************************/
+
+int inform_infile_structure(fileptr fp1,fileptr fp2,dataptr dz)
+{
+    if(dz->infilecnt > 2) {
+        sprintf(errstr,"Input processes for 1 textfile & >1 nontextfile are NOT DEFINED\n"
+                "Hence 2 later nontextfiles are not header_compared\n");
+        return(PROGRAM_ERROR);
+    }
+    switch(dz->input_data_type) {
+        case(PITCH_AND_PITCH):
+        case(PITCH_AND_TRANSPOS):
+        case(TRANSPOS_AND_TRANSPOS):
+            fp1->filetype  = fp2->filetype; /* Setup infile properties here */
+            fp1->origchans = fp2->origchans;
+            fp1->origstype = fp2->origstype;
+            fp1->origrate  = fp2->origrate;
+            fp1->arate     = fp2->arate;
+            fp1->Mlen      = fp2->Mlen;
+            fp1->Dfac      = fp2->Dfac;
+            fp1->srate     = fp2->srate;
+            fp1->channels  = fp2->channels;
+            fp1->stype     = fp2->stype;
+            /* Setup other header-based parameters here */
+            dz->nyquist    = fp1->origrate/2.0;
+            dz->frametime  = (float)(1.0/fp1->arate);
+            break;
+        default:
+            sprintf(errstr,"No process defined taking this textfiletype and this sndfiletype.\n");
+            return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}

dev/cdp2k/special.c

@@ -0,0 +1,709 @@
+/*
+ * 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 <structures.h>
+#include <tkglobals.h>
+#include <globcon.h>
+#include <localcon.h>
+#include <special.h>
+#include <processno.h>
+#include <modeno.h>
+#include <stdio.h>
+#include <sfsys.h>
+
+static int  establish_special_data_type(int process,int mode, aplptr ap);
+static int  setup_special_data(int process,int mode,int srate,double duration,double nyquist,int wlength,int channels,aplptr ap);
+static int  setup_special_data_names(int process,int mode,aplptr ap);
+
+/****************************** DEAL_WITH_SPECIAL_DATA *********************************/
+
+int deal_with_special_data(int process,int mode,int srate,double duration,double nyquist,int wlength,int channels,aplptr ap)
+{
+    int exit_status;
+    if((exit_status = establish_special_data_type(process,mode,ap))<0)
+        return(exit_status);
+    if(ap->special_data) {
+        if((exit_status = setup_special_data(process,mode,srate,duration,nyquist,wlength,channels,ap))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/****************************** ESTABLISH_SPECIAL_DATA_TYPE *********************************/
+
+int establish_special_data_type(int process,int mode,aplptr ap)
+{
+    ap->special_data = 0;
+    switch(process) {
+
+            /*************************** SPEC ****************************/
+            /*************************** SPEC ****************************/
+            /*************************** SPEC ****************************/
+
+    case(CHORD):                    ap->special_data = SEMIT_TRANSPOS_SET;              break;
+    case(FREEZE):                   ap->special_data = FREEZE_DATA;                     break;
+    case(FREEZE2):                  ap->special_data = FREEZE2_DATA;                    break;
+    case(GREQ):
+        switch(mode) {
+        case(GR_ONEBAND):   ap->special_data = FILTER_FRQS;         break;
+        case(GR_MULTIBAND): ap->special_data = FILTER_BWS_AND_FRQS; break;
+        default:
+            sprintf(errstr,"Unknown mode in establish_special_data_type()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;                                                                  
+    case(P_INVERT):                 ap->special_data = INTERVAL_MAPPING;                break;
+    case(P_QUANTISE):               ap->special_data = PITCHQUANTISE_SET;               break;
+//TW NEW CASES
+    case(P_SYNTH):                  ap->special_data = PITCH_SPECTRUM;                  break;
+    case(P_VOWELS):
+    case(VFILT):                    ap->special_data = PITCH_VOWELS;                    break;
+    case(P_GEN):                    ap->special_data = PITCH_CREATE;                    break;
+    case(P_INSERT):                 ap->special_data = ZERO_INSERTTIMES;                break;
+    case(P_SINSERT):                ap->special_data = ZERO_INSERTTIMES;                break;
+    case(MIX_ON_GRID):              ap->special_data = GRIDDED_MIX;                     break;
+    case(AUTOMIX):                  ap->special_data = AUTO_MIX;                        break;
+
+    case(PITCH):
+        if(!sloom) {
+            switch(mode) {
+            case(PICH_TO_BIN):  ap->special_data = OUT_PFILE;           break;
+            case(PICH_TO_BRK):  ap->special_data = OUT_PBRKFILE;        break;
+            default:
+                sprintf(errstr,"Unknown mode in establish_special_data_type()\n");
+                return(PROGRAM_ERROR);
+            }
+        }
+        break;                                                                  
+    case(SHUFFLE):                  ap->special_data = SHUFFLE_DATA;                    break;
+    case(SPLIT):                    ap->special_data = SPECSPLI_DATA;                   break;
+    case(TRACK):
+        if(!sloom) {
+            switch(mode) {
+            case(TRK_TO_BIN):   ap->special_data = OUT_PFILE;           break;
+            case(TRK_TO_BRK):   ap->special_data = OUT_PBRKFILE;        break;
+            default:
+                sprintf(errstr,"Unknown mode in establish_special_data_type()\n");
+                return(PROGRAM_ERROR);
+            }
+        }
+        break;
+    case(TRNSF):
+    case(TRNSP):
+        switch(mode) {
+        case(TRNS_RATIO):   ap->special_data = TRANSPOS_RATIO_OR_CONSTANT;      break;
+        case(TRNS_OCT):     ap->special_data = TRANSPOS_OCTAVE_OR_CONSTANT;     break;
+        case(TRNS_SEMIT):   ap->special_data = TRANSPOS_SEMIT_OR_CONSTANT;      break;
+        case(TRNS_BIN):     break;
+        default:
+            sprintf(errstr,"Unknown mode in establish_special_data_type()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(TUNE):
+        switch(mode) {
+        case(TUNE_FRQ):     ap->special_data = FRQ_OR_FRQSET;                   break;
+        case(TUNE_MIDI):    ap->special_data = PITCH_OR_PITCHSET;               break;
+        default:
+            sprintf(errstr,"Unknown mode in establish_special_data_type()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;  
+    case(WEAVE):                    ap->special_data = WEAVE_DATA;                      break;
+    case(MULTRANS):                 ap->special_data = SEMIT_TRANSPOS_SET;              break;
+
+
+            /*************************** GROUCHO ****************************/
+            /*************************** GROUCHO ****************************/
+            /*************************** GROUCHO ****************************/
+
+    case(DISTORT_ENV):  
+        if(mode==DISTORTE_USERDEF)  ap->special_data = DISTORT_ENVELOPE;                break;
+    case(ENVSYN):
+        if(mode==ENVSYN_USERDEF)    ap->special_data = ENVSYN_ENVELOPE;                 break;
+    case(DISTORT_HRM):              ap->special_data = HARMONIC_DISTORT;                break;
+    case(DISTORT_SHUF):             ap->special_data = SHUFFLE_DATA;                    break;
+//TW NEW CASE
+    case(DISTORT_PULSED):           ap->special_data = PULSE_ENVELOPE;                  break;
+    case(ZIGZAG):       
+        if(mode==ZIGZAG_USER)       ap->special_data = ZIGDATA;                         break;
+
+    case(SIMPLE_TEX):       
+    case(GROUPS):           
+    case(ORNATE): 
+    case(PREORNATE):    
+    case(POSTORNATE):       
+    case(MOTIFS): 
+    case(MOTIFSIN):         
+    case(DECORATED): 
+    case(PREDECOR): 
+    case(POSTDECOR):        
+    case(TIMED):            
+    case(TGROUPS):          
+    case(TMOTIFS): 
+    case(TMOTIFSIN):                ap->special_data = TEX_NOTEDATA;                    break;
+
+    case(GRAIN_REORDER):            ap->special_data = GRAIN_REORDER_STRING;            break;
+    case(GRAIN_REPITCH):            ap->special_data = GRAIN_PITCH_RATIOS;              break;
+    case(GRAIN_RERHYTHM):           ap->special_data = GRAIN_TIME_RATIOS;               break;
+    case(GRAIN_REMOTIF):            ap->special_data = GRAIN_TWO_RATIOS;                break;
+    case(GRAIN_POSITION):           ap->special_data = GRAIN_TIMINGS;                   break;
+    case(GREV):
+        if(mode==GREV_PUT)
+            ap->special_data = GRAIN_TIMINGS;                   
+        break;
+    case(ENV_CREATE):
+        if(mode==ENV_ENVFILE_OUT 
+        || mode==ENV_BRKFILE_OUT)   ap->special_data = ENV_CREATEFILE;                  break;
+    case(ENV_WARPING):
+    case(ENV_REPLOTTING):
+    case(ENV_RESHAPING): 
+        if(mode==ENV_TRIGGERING)    ap->special_data = ENV_TRIGGER_RAMP;                break;
+    case(MIXINBETWEEN):             
+        if(mode==INBI_RATIO)
+            ap->special_data = INBTWN_RATIOS;
+        break;
+    case(MIXSHUFL): 
+        if(mode==MSH_DUPL_AND_RENAME) ap->special_data=SNDFILENAME;                     break;
+
+    case(FLTBANKU):    
+    case(FLTITER):                  ap->special_data = FILTERBANK;                      break;
+
+    case(FLTBANKV):                 ap->special_data = TIMEVARYING_FILTERBANK;          break;
+    case(FLTBANKV2):                ap->special_data = TIMEVARY2_FILTERBANK;            break;
+    case(INSERTSIL_MANY):
+    case(EDIT_EXCISEMANY):          ap->special_data = EXCISE_TIMES;                    break;
+    case(INFO_MUSUNITS):
+        if(mode==MU_NOTE_TO_FRQ
+        || mode==MU_NOTE_TO_MIDI)   ap->special_data = NOTE_REPRESENTATION;
+        else if(mode==MU_INTVL_TO_TSTRETCH
+             || mode==MU_INTVL_TO_FRQRATIO) 
+                                    ap->special_data = INTERVAL_REPRESENTATION;         break;
+    case(HOUSE_DEL):                ap->special_data = SNDFILENAME;                     break;
+    case(HOUSE_EXTRACT):
+        if(mode==HOUSE_BYHAND)  
+                                    ap->special_data = BY_HAND;                         break;
+    case(ACC_STREAM):               ap->special_data = ATTACK_STREAM;                   break;
+    case(DEL_PERM):                 ap->special_data = DELPERM;                         break;
+    case(DEL_PERM2):                ap->special_data = DELPERM2;                        break;
+    case(TWIXT):                    ap->special_data = SWITCH_TIMES;                    break;
+    case(SPHINX):                   ap->special_data = MANY_SWITCH_TIMES;               break;
+//TW NEW CASES
+    case(MANY_ZCUTS):
+    case(EDIT_CUTMANY):             ap->special_data = MANYCUTS;                        break;
+    case(STACK):                    ap->special_data = STACKDATA;                       break;
+    case(SEQUENCER):                ap->special_data = SEQUENCER_VALUES;                break;
+    case(SEQUENCER2):               ap->special_data = SEQUENCER2_VALUES;               break;
+    case(CLICK):                    ap->special_data = CLICKTRACK;                      break;
+    case(SYLLABS):                  ap->special_data = SYLLTIMES;                       break;
+    case(JOIN_SEQ):                 ap->special_data = JOINSEQ;                         break;
+    case(JOIN_SEQDYN):              ap->special_data = JOINSEQDYN;                      break;
+    case(BATCH_EXPAND):             ap->special_data = BATCH;                           break;
+    case(MOD_LOUDNESS):
+        if(mode == LOUD_PROPOR || mode == LOUD_DB_PROPOR)
+                                    ap->special_data = LOUDNESS;                        break;
+    case(MULTI_SYN):                ap->special_data = CHORD_SYN;                       break;
+    }
+    return(FINISHED);
+}
+
+/************************ SETUP_SPECIAL_DATA *********************/
+
+int setup_special_data(int process,int mode,int srate,double duration,double nyquist,int wlength,int channels,aplptr ap)
+{
+    int exit_status;
+
+    if((exit_status = setup_special_data_ranges(mode,srate,duration,nyquist,wlength,channels,ap))<0)
+        return(exit_status);
+    if((exit_status = setup_special_data_names(process,mode,ap))<0)
+        return(exit_status);
+    return(FINISHED);
+}
+
+/************************ SETUP_SPECIAL_DATA_RANGES *********************/
+
+int setup_special_data_ranges(int mode,int srate,double duration,double nyquist,int wlength,int channels,aplptr ap)
+{
+    int exit_status;
+
+    switch(ap->special_data) {
+
+                /************************ SPEC *********************/
+                /************************ SPEC *********************/
+                /************************ SPEC *********************/
+
+    case(TRANSPOS_RATIO_OR_CONSTANT):
+        ap->special_range       = TRUE;
+        ap->min_special         = MIN_TRANSPOS;
+        ap->max_special         = MAX_TRANSPOS;
+        ap->default_special     = DEFAULT_TRANSPOS;
+        break;
+    case(TRANSPOS_OCTAVE_OR_CONSTANT):
+        ap->special_range       = TRUE;
+        ap->min_special         = LOG2(MIN_TRANSPOS);
+        ap->max_special         = LOG2(MAX_TRANSPOS);
+        ap->default_special     = LOG2(DEFAULT_TRANSPOS);
+        break;
+    case(TRANSPOS_SEMIT_OR_CONSTANT):
+        ap->special_range       = TRUE;
+        ap->min_special         = 12.0 * LOG2(MIN_TRANSPOS);
+        ap->max_special         = 12.0 * LOG2(MAX_TRANSPOS);
+        ap->default_special     = 12.0 * LOG2(DEFAULT_TRANSPOS);
+        break;
+    case(SEMIT_TRANSPOS_SET):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 12.0 * LOG2(MIN_TRANSPOS);
+        ap->max_special         = 12.0 * LOG2(MAX_TRANSPOS);
+        ap->default_special     = 12.0 * LOG2(DEFAULT_TRANSPOS);
+        break;
+    case(FRQ_OR_FRQSET):
+        ap->special_range       = TRUE;
+        ap->min_special         = MINPITCH;         /* NEW */
+        ap->max_special         = nyquist;
+        ap->default_special     = CONCERT_A;
+        break;
+    case(PITCH_OR_PITCHSET):    
+        ap->special_range       = TRUE;
+        ap->min_special         = MIDIBOT;
+        if((exit_status = hztomidi(&(ap->max_special),nyquist))<0)
+            return(exit_status);
+        ap->default_special     = CONCERT_A_MIDI;
+        break;
+    case(FILTER_FRQS):          /* actually 1 bwdth and many frqs */
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = OCTAVES_PER_SEMITONE;
+        ap->max_special         = LOG2(nyquist - SPEC_MINFRQ);
+        ap->other_special_range = TRUE;
+        ap->min_special2        = SPEC_MINFRQ;
+        ap->max_special2        = (nyquist * 2.0)/3.0;
+        break;
+    case(FILTER_BWS_AND_FRQS):  /* actually frq followed by bwd, in pairs */    
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = SPEC_MINFRQ;
+        ap->max_special         = (nyquist * 2.0)/3.0;
+        ap->other_special_range = TRUE;
+        ap->min_special2        = OCTAVES_PER_SEMITONE;
+        ap->max_special2        = LOG2(nyquist - SPEC_MINFRQ);
+        break;
+    case(PITCHQUANTISE_SET):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = MIDIMIN;
+        ap->max_special         = MIDIMAX;
+        break;
+    case(INTERVAL_MAPPING):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = -MAXINTRANGE;
+        ap->max_special         = MAXINTRANGE;
+        break;
+    case(SPECSPLI_DATA):
+        ap->data_in_file_only   = TRUE;
+        break;
+    case(FREEZE_DATA):
+    case(FREEZE2_DATA):
+        ap->data_in_file_only   = TRUE;
+        break;
+    case(WEAVE_DATA):
+        ap->data_in_file_only   = TRUE;
+        ap->min_special         = (double)(-(wlength-2));
+        ap->max_special         = (double)(wlength-1);
+        break;
+    case(OUT_PFILE):
+    case(OUT_PBRKFILE):
+        if(!sloom)
+            ap->data_in_file_only   = TRUE;
+        break;
+//TW NEW CASES
+    case(PITCH_SPECTRUM):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = 1.0;
+        break;
+    case(PITCH_VOWELS):
+        ap->data_in_file_only   = VOWEL_STRING;
+        break;
+    case(PITCH_CREATE):
+        ap->data_in_file_only   = TRUE;
+        break;
+    case(ZERO_INSERTTIMES):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = duration;
+        if(mode==1)
+            ap->max_special *= 48000.0;     /* Times maximum samplerate : kludgy */
+        break;
+
+                    /************************ SPEC & GROUCHO ***********************/
+
+    case(SHUFFLE_DATA):
+        ap->data_in_file_only   = SHUFFLE_STRING;
+        break;
+
+                    /************************ GROUCHO ***********************/
+                    /************************ GROUCHO ***********************/
+                    /************************ GROUCHO ***********************/
+
+    case(DISTORT_ENVELOPE):
+    case(ENVSYN_ENVELOPE):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = 1.0;
+        break;
+//TW NEW CASE
+    case(PULSE_ENVELOPE):
+        if(mode == 0) {
+            ap->data_in_file_only   = TRUE;
+            ap->special_range       = TRUE;
+            ap->min_special         = 0.0;
+            ap->max_special         = 1.0;
+        } else {
+            ap->data_in_file_only   = FALSE;
+            ap->special_range       = TRUE;
+            ap->min_special         = 0.0;
+            ap->max_special         = 1.0;
+            ap->default_special     = 0.0;
+        }
+        break;
+    case(HARMONIC_DISTORT):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = MIN_HARMONIC;
+        ap->max_special         = MAX_HARMONIC;
+        ap->other_special_range = TRUE;
+        ap->min_special2        = MIN_HARM_AMP;
+        ap->max_special2        = MAX_HARM_AMP;
+        break;
+    case(ZIGDATA):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = ZIG_SPLICELEN * MS_TO_SECS * 3;
+        ap->max_special         = duration;
+        break;
+    case(TEX_NOTEDATA):
+        ap->data_in_file_only   = TRUE;
+        break;
+    case(GRAIN_REORDER_STRING):
+        ap->data_in_file_only   = REORDER_STRING;
+        break;
+    case(GRAIN_PITCH_RATIOS):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->max_special         = GR_MAX_TRANSPOS * SEMITONES_PER_OCTAVE;
+        ap->min_special         = -ap->max_special;
+        break;
+    case(GRAIN_TIME_RATIOS):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = GR_MIN_TSTRETCH;
+        ap->max_special         = GR_MAX_TSTRETCH;
+        break;
+    case(GRAIN_TWO_RATIOS):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->max_special         = GR_MAX_TRANSPOS * SEMITONES_PER_OCTAVE;
+        ap->min_special         = -(ap->max_special);
+        ap->other_special_range = TRUE;
+        ap->min_special2        = GR_MIN_TSTRETCH;
+        ap->max_special2        = GR_MAX_TSTRETCH;
+        break;
+//TW NEW CASE
+    case(SEQUENCER_VALUES):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->max_special         = GR_MAX_TRANSPOS * SEMITONES_PER_OCTAVE;
+        ap->min_special         = -(ap->max_special);
+        ap->other_special_range = TRUE;
+        ap->min_special2        = 0.0;
+        ap->max_special2        = 7200.0;   /* arbitrary : 2 hours */
+        break;
+    case(SEQUENCER2_VALUES):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->max_special         = MIDIMAX;
+        ap->min_special         = MIDIMIN;
+        ap->other_special_range = TRUE;
+        ap->min_special2        = 0.0;
+        ap->max_special2        = 7200.0;   /* arbitrary : 2 hours */
+        break;
+    case(GRAIN_TIMINGS):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = GRAIN_SPLICELEN * MS_TO_SECS;
+        ap->max_special         = MAX_FIRSTGRAIN_TIME;
+        break;
+    case(ENV_CREATEFILE):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = BIG_TIME;
+        ap->other_special_range = TRUE;
+        ap->min_special2        = 0.0;
+        ap->max_special2        = 1.0;
+        break;
+    case(ENV_TRIGGER_RAMP):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = duration;
+        ap->other_special_range = TRUE;
+        ap->min_special2        = 0.0;
+        ap->max_special2        = 1.0;
+        break;
+    case(SNDFILENAME):
+        ap->data_in_file_only   = SNDFILENAME_STRING;
+        break;
+    case(FILTERBANK):
+    case(TIMEVARYING_FILTERBANK):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        switch(mode) {
+        case(FLT_HZ):
+            ap->min_special     = FLT_MINFRQ;
+            ap->max_special     = FLT_MAXFRQ;
+            break;
+        case(FLT_MIDI):
+            ap->min_special     = unchecked_hztomidi(FLT_MINFRQ);
+            ap->max_special     = MIDIMAX;
+            break;
+        }
+        ap->other_special_range = TRUE;
+        ap->min_special2        = FLT_MINGAIN;
+        ap->max_special2        = FLT_MAXGAIN;
+        break;
+    case(TIMEVARY2_FILTERBANK):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = FALSE;
+        break;
+    case(EXCISE_TIMES):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        switch(mode) {
+        case(EDIT_SAMPS):
+            ap->min_special     = 0.0;
+            ap->max_special     = (int)((duration * (double)srate) + 1.0) * MAX_SNDFILE_OUTCHANS;
+            break;                      /* ROUND UP, times OVERKILL as this func doesn't know chancnt!! */
+        case(EDIT_STSAMPS):
+            ap->min_special     = 0.0;
+            ap->max_special     = (int)((duration * (double)srate) + 1.0);  /* ROUND UP */
+            break;
+        case(EDIT_SECS):
+            ap->min_special     = 0.0;
+            ap->max_special     = duration;
+            break;
+        }
+        break;
+    case(NOTE_REPRESENTATION):
+        ap->data_in_file_only   = NOTE_STRING;
+        break;
+    case(INTERVAL_REPRESENTATION):
+        ap->data_in_file_only   = INTERVAL_STRING;
+        break;
+    case(ATTACK_STREAM):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = MAX_SYN_DUR;  /* 2 hours */
+        break;
+    case(BY_HAND):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = (int)round(duration * (double)(srate * channels));
+        ap->other_special_range = TRUE;
+        ap->min_special2        = MINSAMP;
+        ap->max_special2        = MAXSAMP;
+        break;
+    case(DELPERM):
+    case(DELPERM2):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = -MIDIMAX/2;
+        ap->max_special         = MIDIMAX/2;
+        ap->other_special_range = TRUE;
+        ap->min_special2        = 0.05;
+        ap->max_special2        = .95;
+        break;
+    case(SWITCH_TIMES):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        ap->min_special         = 0.0;
+        ap->max_special         = duration;
+        break;
+    case(MANY_SWITCH_TIMES):
+//TW NEW CASE
+    case(MANYCUTS):
+        ap->data_in_file_only   = TRUE;
+        break;
+//TW NEW CASES
+    case(GRIDDED_MIX):
+    case(AUTO_MIX):
+        ap->data_in_file_only   = TRUE;
+        break;
+    case(STACKDATA):
+        ap->special_range       = TRUE;
+        ap->min_special         = -60.0;
+        ap->max_special         = 60.0;
+        ap->default_special     = 12.0;
+        break;
+    case(CLICKTRACK):
+    case(SYLLTIMES):
+    case(JOINSEQ):
+    case(JOINSEQDYN):
+    case(BATCH):
+    case(INBTWN_RATIOS):
+    case(LOUDNESS):
+        ap->data_in_file_only   = TRUE;
+        break;
+    case(CHORD_SYN):
+        ap->data_in_file_only   = TRUE;
+        ap->special_range       = TRUE;
+        switch(mode) {
+        case(0):
+            hztomidi(&ap->min_special,1.0/MAX_SYN_DUR);
+            ap->max_special         = 127;
+            break;
+        case(1):
+            ap->min_special     = 1.0/MAX_SYN_DUR;
+            ap->max_special     = miditohz(127.0);
+            break;
+        break;
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown special_data type: setup_special_data_ranges()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************************ SETUP_SPECIAL_NAMES *********************/
+
+int setup_special_data_names(int process,int mode,aplptr ap)
+{
+    switch(ap->special_data) {
+
+                /************************ SPEC *********************/
+    case(TRANSPOS_RATIO_OR_CONSTANT):   ap->special_data_name   = "TRANSPOSITION_RATIO";            break;
+    case(TRANSPOS_OCTAVE_OR_CONSTANT):  ap->special_data_name   = "TRANSPOSITION_IN_OCTAVES";       break;
+    case(TRANSPOS_SEMIT_OR_CONSTANT):   ap->special_data_name   = "TRANSPOSITION_IN_SEMITONES";     break;
+    case(SEMIT_TRANSPOS_SET):           ap->special_data_name   = "TRANSPOSITION_IN_SEMITONES";     break;
+    case(FRQ_OR_FRQSET):                ap->special_data_name   = "FREQUENCY_SET";                  break;
+    case(PITCH_OR_PITCHSET):            ap->special_data_name   = "PITCH_SET";                      break;
+    case(FILTER_FRQS):                  ap->special_data_name   = "BANDWIDTH_&_FILTER_FRQS";        break;
+    case(FILTER_BWS_AND_FRQS):          ap->special_data_name   = "FILTER_FRQS_&_BANDWIDTHS";       break;
+    case(PITCHQUANTISE_SET):            ap->special_data_name   = "QUANTISING_PITCHES";             break;
+    case(INTERVAL_MAPPING):             ap->special_data_name   = "INTERVALS_FOR_MAPPING";          break;
+    case(SPECSPLI_DATA):                ap->special_data_name   = "SPLITTING_DATA";                 break;
+    case(FREEZE_DATA):                  ap->special_data_name   = "FREEZE_DATA";                    break;
+    case(FREEZE2_DATA):                 ap->special_data_name   = "HOLD_DATA";                      break;
+    case(WEAVE_DATA):                   ap->special_data_name   = "WEAVE_DATA";                     break;
+//TW NEW CASES
+    case(PITCH_SPECTRUM):               ap->special_data_name   = "PARTIAL_LEVELS";                 break;
+    case(PITCH_VOWELS):                 ap->special_data_name   = "VOWELS";                         break;
+    case(PITCH_CREATE):                 ap->special_data_name   = "PITCH_DATA";                     break;
+    case(ZERO_INSERTTIMES):             ap->special_data_name   = "INSERTION_TIMEPAIRS";            break;
+
+        /************************ SPEC & GROUCHO ***********************/
+    case(SHUFFLE_DATA):                 ap->special_data_name   = "SHUFFLE_DATA";                   break;
+                /************************ GROUCHO ***********************/
+    case(DISTORT_ENVELOPE):             ap->special_data_name   = "USER_DISTORT_ENVELOPE";          break;
+    case(ENVSYN_ENVELOPE):              ap->special_data_name   = "USER_ENVELOPE";                  break;
+//TW NEW CASE
+    case(PULSE_ENVELOPE):               ap->special_data_name   = "IMPULSE_ENVELOPE";               break;
+    case(HARMONIC_DISTORT):             ap->special_data_name   = "HARMONIC-NO:AMPLITUDE_PAIRS";    break;
+    case(ZIGDATA):                      ap->special_data_name   = "ZIGZAG_TIMES";                   break;
+    case(TEX_NOTEDATA):                 ap->special_data_name   = "NOTE_DATA";                      break;
+    case(GRAIN_REORDER_STRING):         ap->special_data_name   = "CODE_FOR_REORDERING";            break;
+    case(GRAIN_PITCH_RATIOS):           ap->special_data_name   = "SEMITONE_SHIFT_EACH_GRAIN";      break;
+    case(GRAIN_TIME_RATIOS):            ap->special_data_name   = "DURATION_MULTIPLIER_EACH_GRAIN"; break;
+    case(GRAIN_TWO_RATIOS):             ap->special_data_name   = "PSHIFT&DUR-MULTIPLY_EACH_GRAIN"; break;
+//TW NEW CASE
+    case(SEQUENCER_VALUES):             ap->special_data_name   = "TIME,_SEMITONE_SHIFT_&_LEVEL";   break;
+    case(SEQUENCER2_VALUES):            ap->special_data_name   = "SOUND-NO,_TIME,_MIDIPITCH,_LEVEL,_DUR";   break;
+    case(GRAIN_TIMINGS):                ap->special_data_name   = "GRAIN_TIMINGS";                  break;
+    case(ENV_CREATEFILE):               ap->special_data_name   = "TIMES_&_(e)LEVELS_FOR_ENVELOPE"; break;
+    case(ENV_TRIGGER_RAMP):             ap->special_data_name   = "TIMES_&_LEVELS_OF_RAMP";         break;
+    case(SNDFILENAME):
+        switch(process) {
+        case(MIXSHUFL):                 ap->special_data_name   = "NEW_FILENAME";                   break;
+        case(HOUSE_DEL):                ap->special_data_name   = "GENERIC_FILENAME";               break;
+        }
+        break;                  
+    case(FILTERBANK):
+        switch(mode) {
+        case(FLT_HZ):                   ap->special_data_name   = "FRQ_AND_AMP_OF_FILTERS";         break;
+        case(FLT_MIDI):                 ap->special_data_name   = "PITCH(MIDI)_&_AMP_OF_FILTERS";   break;
+        }
+        break;
+    case(TIMEVARYING_FILTERBANK):
+    case(TIMEVARY2_FILTERBANK):
+        switch(mode) {
+        case(FLT_HZ):                   ap->special_data_name   = "TIMELIST_OF_FRQS&AMPS_OF_FILTS"; break;
+        case(FLT_MIDI):                 ap->special_data_name   = "TIMELIST_OF_PICHS&AMPS_OF_FILTS";break;
+        }
+        break;
+    case(EXCISE_TIMES):                 ap->special_data_name   = "START_&_END_TIMES_FOR_EXCISIONS";break;
+    case(NOTE_REPRESENTATION):          ap->special_data_name   = "NOTE_NAME";                      break;
+    case(INTERVAL_REPRESENTATION):      ap->special_data_name   = "INTERVAL_NAME";                  break;
+    case(ATTACK_STREAM):                ap->special_data_name   = "TIMES_OF_EVENTS";                break;
+    case(BY_HAND):                      ap->special_data_name   = "SAMPLE_NO_AND_SAMPLE_VALUE";     break;
+    case(DELPERM):                      ap->special_data_name   = "DELAY_PERMUTATION";              break;
+    case(DELPERM2):                     ap->special_data_name   = "TRANSPOS_+_DELAY_PERMUTATION";   break;
+    case(SWITCH_TIMES):                 ap->special_data_name   = "SWITCHING_TIMES";                break;
+    case(MANY_SWITCH_TIMES):            ap->special_data_name   = "SWITCHING_TIMES";                break;
+// TW NEW CASES
+    case(MANYCUTS):                     ap->special_data_name   = "SEGMENT_START_AND_END_TIMES";    break;
+    case(GRIDDED_MIX):                  ap->special_data_name   = "MIX_GRID";                       break;
+    case(AUTO_MIX):                     ap->special_data_name   = "MIX_BALANCE_FUNCTION";           break;
+    case(STACKDATA):                    ap->special_data_name   = "TRANSPOSITION_DATA";             break;
+    case(CLICKTRACK):                   ap->special_data_name   = "CLICKTRACK_DATA";                break;
+    case(SYLLTIMES):                    ap->special_data_name   = "SYLLABLE_TIMES";                 break;
+    case(JOINSEQ):                      ap->special_data_name   = "FILE_SEQUENCE";                  break;
+    case(JOINSEQDYN):                   ap->special_data_name   = "FILE_SEQUENCE_WITH_LOUDNESSES";  break;
+    case(BATCH):                        ap->special_data_name   = "NEW_PARAMETER_VALUES";           break;
+    case(INBTWN_RATIOS):                ap->special_data_name   = "MIX_RATIOS";                     break;
+    case(LOUDNESS):                     ap->special_data_name   = "LOUDNESS_ENVELOPE";              break;
+    case(CHORD_SYN):
+        switch(mode) {
+        case(0):                        ap->special_data_name   = "MIDI_PITCHES_OF_CHORD_NOTES";    break;
+        case(1):                        ap->special_data_name   = "FRQUENCIES_OF_CHORD_NOTES";      break;
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown special_data type: setup_special_data_names()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+

dev/cdp2k/tkinput.c

@@ -0,0 +1,437 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version */
+
+/* PRE CMDLINE DATA SENT FROM TK *****
+process
+mode
+infilecnt
+
+filetype            [ 0 ]   
+infilesize          [ 1 ]   
+insams              [ 2 ]
+srate               [ 3 ]
+channels            [ 4 ]
+wanted              [ 5 ]
+wlength             [ 6 ]
+linecnt             [ 7 ]
+arate               [ 8 ]
+frametime           [ 9 ]
+nyquist             [ 10 ]
+duration            [ 11 ]
+--------------------------
+stype               [ 12 ]
+origstype           [ 13 ]
+origrate            [ 14 ]
+Mlen                [ 15 ]
+Dfac                [ 16 ]
+origchans           [ 17 ]
+specenvcnt          [ 18 ]
+out_chans           [ 19 ]
+descriptor_samps    [ 20 ]
+is_transpos         [ 21 ]
+could_be_transpos   [ 22 ]
+could_be_pitch      [ 23 ]
+different_srates    [ 24 ]
+duplicate_snds      [ 25 ]
+brksize             [ 26 ]
+numsize             [ 27 ]
+all_words           [ 28 ]
+window_size         [ 29 ]
+minbrk              [ 30 ]
+maxbrk              [ 31 ]
+minnum              [ 32 ]
+maxnum              [ 33 ]
+********* PRE CMDLINE DATA SENT FROM TK */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>             /*RWD */
+#include <structures.h>
+#include <tkglobals.h>
+#include <globcon.h>
+#include <cdpmain.h>
+#include <processno.h>
+#include <cdpmain.h>
+#include <sfsys.h>
+#include <srates.h>
+
+#include <logic.h>
+
+
+static int  get_tk_cmdline_word(int *cmdlinecnt,char ***cmdline,char *q);
+static int  assign_file_data_storage(int infilecnt,dataptr dz);
+
+/********************************* PARSE_TK_DATA *********************************/
+
+int parse_tk_data(int argc,char *argv[],char ***cmdline,int *cmdlinecnt,dataptr dz)
+{
+    int exit_status;
+    int cnt = 1, infilecnt;
+    int filesize, insams, inbrksize;
+    double dummy;
+    int true_cnt = 0;
+//    aplptr ap;
+
+    while(cnt<=PRE_CMDLINE_DATACNT) {
+        if(cnt > argc) {
+            sprintf(errstr,"Insufficient data sent from TK\n");
+            return(DATA_ERROR);
+        }
+        switch(cnt) {
+        case(1):    
+            if(sscanf(argv[cnt],"%d",&dz->process)!=1) {
+                sprintf(errstr,"Cannot read process no. sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+
+        case(2):    
+            if(sscanf(argv[cnt],"%d",&dz->mode)!=1) {
+                sprintf(errstr,"Cannot read mode no. sent from TK\n");
+                return(DATA_ERROR);
+            }
+            if(dz->mode > 0)
+                dz->mode--;
+            if((exit_status = setup_particular_application(dz))<0)
+                return(exit_status);
+//            ap = dz->application;
+            break;
+
+        case(3):    
+            if(sscanf(argv[cnt],"%d",&infilecnt)!=1) {
+                sprintf(errstr,"Cannot read infilecnt sent from TK\n");
+                return(DATA_ERROR);
+            }
+            if(infilecnt < 1) {
+                true_cnt = cnt + 1;
+                cnt = PRE_CMDLINE_DATACNT;  /* force exit from loop after assign_file_data_storage */
+            }
+            if((exit_status = assign_file_data_storage(infilecnt,dz))<0)
+                return(exit_status);
+            break;
+        case(INPUT_FILETYPE+4): 
+            if(sscanf(argv[cnt],"%d",&dz->infile->filetype)!=1) {
+                sprintf(errstr,"Cannot read filetype sent from TK (%s)\n",argv[cnt]);
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_FILESIZE+4): 
+            if(sscanf(argv[cnt],"%d",&filesize)!=1) {
+                sprintf(errstr,"Cannot read infilesize sent from TK\n");
+                return(DATA_ERROR);
+            }
+            dz->insams[0] = filesize;   
+            break;
+        case(INPUT_INSAMS+4):   
+            if(sscanf(argv[cnt],"%d",&insams)!=1) {
+                sprintf(errstr,"Cannot read insams sent from TK\n");
+                return(DATA_ERROR);
+            }
+            dz->insams[0] = insams; 
+            break;
+        case(INPUT_SRATE+4):    
+            if(sscanf(argv[cnt],"%d",&dz->infile->srate)!=1) {
+                sprintf(errstr,"Cannot read srate sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_CHANNELS+4): 
+            if(sscanf(argv[cnt],"%d",&dz->infile->channels)!=1) {
+                sprintf(errstr,"Cannot read channels sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_STYPE+4):    
+            if(sscanf(argv[cnt],"%d",&dz->infile->stype)!=1) {
+                sprintf(errstr,"Cannot read stype sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_ORIGSTYPE+4):    
+            if(sscanf(argv[cnt],"%d",&dz->infile->origstype)!=1) {
+                sprintf(errstr,"Cannot read origstype sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_ORIGRATE+4): 
+            if(sscanf(argv[cnt],"%d",&dz->infile->origrate)!=1) {
+                sprintf(errstr,"Cannot read origrate sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_MLEN+4): 
+            if(sscanf(argv[cnt],"%d",&dz->infile->Mlen)!=1) {
+                sprintf(errstr,"Cannot read Mlen sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_DFAC+4): 
+            if(sscanf(argv[cnt],"%d",&dz->infile->Dfac)!=1) {
+                sprintf(errstr,"Cannot read Dfac sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_ORIGCHANS+4):    
+            if(sscanf(argv[cnt],"%d",&dz->infile->origchans)!=1) {
+                sprintf(errstr,"Cannot read origchans sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_SPECENVCNT+4):   
+            if(sscanf(argv[cnt],"%d",&dz->infile->specenvcnt)!=1) {
+                sprintf(errstr,"Cannot read specenvcnt sent from TK\n");
+                return(DATA_ERROR);
+            }
+            dz->specenvcnt = dz->infile->specenvcnt;
+            break;
+        case(INPUT_WANTED+4):   
+            if(sscanf(argv[cnt],"%d",&dz->wanted)!=1) {
+                sprintf(errstr,"Cannot read wanted sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_WLENGTH+4):  
+            if(sscanf(argv[cnt],"%d",&dz->wlength)!=1) {
+                sprintf(errstr,"Cannot read wlength sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_OUT_CHANS+4):    
+            if(sscanf(argv[cnt],"%d",&dz->out_chans)!=1) {
+                sprintf(errstr,"Cannot read out_chans sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+            /* RWD these chanegs to samps - tk will have to deal with that! */
+        case(INPUT_DESCRIPTOR_BYTES+4): 
+            if(sscanf(argv[cnt],"%d",&dz->descriptor_samps)!=1) {
+                sprintf(errstr,"Cannot read descriptor_samps sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_IS_TRANSPOS+4):  
+            if(sscanf(argv[cnt],"%d",&dz->is_transpos)!=1) {
+                sprintf(errstr,"Cannot read is_transpos sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_COULD_BE_TRANSPOS+4):    
+            if(sscanf(argv[cnt],"%d",&dz->could_be_transpos)!=1) {
+                sprintf(errstr,"Cannot read could_be_transpos sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_COULD_BE_PITCH+4):   
+            if(sscanf(argv[cnt],"%d",&dz->could_be_pitch)!=1) {
+                sprintf(errstr,"Cannot read could_be_pitch sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_DIFFERENT_SRATES+4): 
+            if(sscanf(argv[cnt],"%d",&dz->different_srates)!=1) {
+                sprintf(errstr,"Cannot read different_srates sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_DUPLICATE_SNDS+4):   
+            if(sscanf(argv[cnt],"%d",&dz->duplicate_snds)!=1) {
+                sprintf(errstr,"Cannot read duplicate_snds sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_BRKSIZE+4):  
+            if(sscanf(argv[cnt],"%d",&inbrksize)!=1) {
+                sprintf(errstr,"Cannot read brksize sent from TK\n");
+                return(DATA_ERROR);
+            }
+            if(inbrksize > 0) {
+                switch(dz->input_data_type) {
+                case(WORDLIST_ONLY):
+                    break;
+                case(PITCH_AND_PITCH):
+                case(PITCH_AND_TRANSPOS):
+                case(TRANSPOS_AND_TRANSPOS):
+                    dz->tempsize = inbrksize;
+                    break;
+                case(BRKFILES_ONLY):
+                case(UNRANGED_BRKFILE_ONLY):
+                case(DB_BRKFILES_ONLY):
+                case(ALL_FILES):
+                case(ANY_NUMBER_OF_ANY_FILES):
+                    if(dz->extrabrkno < 0) {
+                        sprintf(errstr,"Storage location number for brktable not established by CDP.\n");
+                        return(DATA_ERROR);
+                    }
+                    if(dz->brksize == NULL) {
+                        sprintf(errstr,"CDP has not established storage space for input brktable.\n");
+                        return(PROGRAM_ERROR);
+                    }
+                    dz->brksize[dz->extrabrkno] = inbrksize;
+                    break;
+                default:
+                    sprintf(errstr,"TK sent brktablesize > 0 for input_data_type [%d] not using brktables.\n",
+                    dz->input_data_type);
+                    return(PROGRAM_ERROR);
+                }
+                break;
+            }
+            break;
+        case(INPUT_NUMSIZE+4):  
+            if(sscanf(argv[cnt],"%d",&dz->numsize)!=1) {
+                sprintf(errstr,"Cannot read numsize sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_LINECNT+4):  
+            if(sscanf(argv[cnt],"%d",&dz->linecnt)!=1) {
+                sprintf(errstr,"Cannot read linecnt sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_ALL_WORDS+4):    
+            if(sscanf(argv[cnt],"%d",&dz->all_words)!=1) {
+                sprintf(errstr,"Cannot read all_words sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_ARATE+4):    
+            if(sscanf(argv[cnt],"%f",&dz->infile->arate)!=1) {
+                sprintf(errstr,"Cannot read arate sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_FRAMETIME+4):    
+            if(sscanf(argv[cnt],"%lf",&dummy)!=1) {
+                sprintf(errstr,"Cannot read frametime sent from TK\n");
+                return(DATA_ERROR);
+            }
+            dz->frametime = (float)dummy;
+            break;
+        case(INPUT_WINDOW_SIZE+4):  
+            if(sscanf(argv[cnt],"%f",&dz->infile->window_size)!=1) {
+                sprintf(errstr,"Cannot read window_size sent from TK\n");
+                    return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_NYQUIST+4):  
+            if(sscanf(argv[cnt],"%lf",&dz->nyquist)!=1) {
+                sprintf(errstr,"Cannot read nyquist sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_DURATION+4): 
+            if(sscanf(argv[cnt],"%lf",&dz->duration)!=1) {
+                sprintf(errstr,"Cannot read duration sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_MINBRK+4):   
+            if(sscanf(argv[cnt],"%lf",&dz->minbrk)!=1) {
+                sprintf(errstr,"Cannot read minbrk sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_MAXBRK+4):   
+            if(sscanf(argv[cnt],"%lf",&dz->maxbrk)!=1) {
+                sprintf(errstr,"Cannot read maxbrk sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_MINNUM+4):   
+            if(sscanf(argv[cnt],"%lf",&dz->minnum)!=1) {
+                sprintf(errstr,"Cannot read minnum sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        case(INPUT_MAXNUM+4):   
+            if(sscanf(argv[cnt],"%lf",&dz->maxnum)!=1) {
+                sprintf(errstr,"Cannot read maxnum sent from TK\n");
+                return(DATA_ERROR);
+            }
+            break;
+        default:
+            sprintf(errstr,"case switch item missing: parse_tk_data()\n");
+            return(PROGRAM_ERROR);
+        }
+        cnt++;
+    }
+    if(cnt!=PRE_CMDLINE_DATACNT+1) {
+        sprintf(errstr,"Insufficient pre-cmdline params sent from TK\n");
+        return(DATA_ERROR);
+    }
+
+    if(true_cnt)
+        cnt = true_cnt;
+    *cmdlinecnt = 0;        
+
+    while(cnt < argc) {
+        if((exit_status = get_tk_cmdline_word(cmdlinecnt,cmdline,argv[cnt]))<0)
+            return(exit_status);
+        cnt++;
+    }
+    return(FINISHED);
+}
+
+/********************************* GET_TK_CMDLINE_WORD *********************************/
+
+int get_tk_cmdline_word(int *cmdlinecnt,char ***cmdline,char *q)
+{
+    if(*cmdlinecnt==0) {
+        if((*cmdline = (char **)malloc(sizeof(char *)))==NULL)  {
+            sprintf(errstr,"INSUFFICIENT MEMORY for TK cmdline array.\n");
+            return(MEMORY_ERROR);
+        }
+    } else {
+        if((*cmdline = (char **)realloc(*cmdline,((*cmdlinecnt)+1) * sizeof(char *)))==NULL)    {
+            sprintf(errstr,"INSUFFICIENT MEMORY for TK cmdline array.\n");
+            return(MEMORY_ERROR);
+        }
+    }
+    if(((*cmdline)[*cmdlinecnt] = (char *)malloc((strlen(q) + 1) * sizeof(char)))==NULL)    {
+        sprintf(errstr,"INSUFFICIENT MEMORY for TK cmdline item %d.\n",(*cmdlinecnt)+1);
+        return(MEMORY_ERROR);
+    }
+    strcpy((*cmdline)[*cmdlinecnt],q);
+    (*cmdlinecnt)++;
+    return(FINISHED);
+}
+
+
+/****************************** ASSIGN_FILE_DATA_STORAGE *********************************/
+
+int assign_file_data_storage(int infilecnt,dataptr dz)
+{
+    int exit_status;
+    int no_sndfile_system_files = FALSE;
+    dz->infilecnt = infilecnt;
+    if((exit_status = allocate_filespace(dz))<0)
+        return(exit_status);
+    if(no_sndfile_system_files)
+        dz->infilecnt = 0;
+    return(FINISHED);
+}

dev/cdp2k/tklib1.c

@@ -0,0 +1,7488 @@
+/* Release 8 */
+/*
+ * 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
+ *
+ */
+// AUGUST 21: 2005
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <osbind.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <sfsys.h>
+#include <cdparams.h>
+#include <globcon.h>
+#include <localcon.h>
+#include <processno.h>
+#include <modeno.h>
+#include <filetype.h>
+#include <formants.h>
+#include <pnames.h>
+#include <sndinfo.h>
+#include <headread.h>
+#include <house.h>
+#include <pvoc.h>
+#include <distort1.h>
+#include <ctype.h>
+#include <string.h>
+#include <logic.h>
+#include <math.h>
+#include <float.h>
+//TW NEW
+#include <vowels2.h>
+
+/* WARNING: These function assumes brktables are INTERPOLATED LINEARLY */
+/* If not, function needs to take SRATE as a parameter, and compare sample-by-sample */
+
+#ifdef unix
+#define round(x) lround((x))
+#endif
+
+#define EQUIVALENT      (0)     /* brktables are identical */
+#define FIRST_LESS      (1)
+#define FIRST_GREATER   (2)
+#define CROSSED         (-1)    /* brktable vals cross */
+#define INVALID         (-1)    /* at least 1 of brktables has only 1 val or doesn't exist */
+
+static int      value_greater_than_brkvals(double val,double *brk,int brksize,int repel);
+static int      value_less_than_brkvals(double val,double *brk,int brksize,int repel);
+static int      brk_compare(double *brk1,int brksize1,double *brk2,int brksize2,int repel);
+static int      establish_orientation(double val1, double val2,int repel);
+static double   establish_current_time(double t1,double t2);
+static double   establish_value_at_current_time(double thistime,double *t,double *brk,double *v);
+static double   interpval(double thistime,double lastval, double nextval, double lasttime, double nexttime);
+int getpeakdata(int ifd, float *peakval,int *peakpos,SFPROPS props);
+
+/*
+#define TEST_HEADREAD 1
+*/
+#ifdef TEST_HEADREAD
+static int headread_check(SFPROPS props,char *filename,int ifd);
+#endif
+
+#define AN_HOUR     (3600.0)
+#define A_MINUTE    (60.0)
+
+/**************************** ITEMS FORMERLY IN FILETYPE **************************/
+
+char *get_last_slash(char *filename,int filenamelen);
+
+/**************************** ITEMS FORMERLY IN VALIDATE **************************/
+
+void validate(int applicno,int *valid);
+
+/***************************** GET_WORD_FROM_STRING ****************************
+ *
+ * Read a word in a larger string.
+ *
+ * p returns address reached after word read.
+ * q returns address of word.
+ *
+ */
+
+int get_word_from_string(char **p,char **q)
+{
+    while(isspace(**p))     /* SKIP LEADING SPACE */
+        (*p)++;
+    *q = *p;                /* SET IN_STRING POINTER */
+    if(**p==ENDOFSTR)
+        return(0);          /* END OF BIG_STRING: NO WORD THIS TIME */
+    while(!isspace(**p)) {
+        if(**p==ENDOFSTR)
+            return(1);      /* WORD FOUND: END OF BIG_STRING */
+        (*p)++;
+    }
+    **p = ENDOFSTR;         /* WORD FOUND,BUT NOT END OF BIG_STRING, SO ENDMARKED:  */
+    (*p)++;                 /* GO TO NEXT CHARACTER */
+    return(1);
+}
+
+/************************** GET_FLOAT_FROM_WITHIN_STRING **************************
+ * takes a pointer TO A POINTER to a string. If it succeeds in finding 
+ * a float it returns the float value (*val), and it's new position in the
+ * string (*str).
+ */
+
+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(FALSE);
+        has_digits = TRUE;
+        break;
+    }
+    p++;        
+    while(!isspace(*p) && *p!=NEWLINE && *p!=ENDOFSTR) {
+        if(isdigit(*p))
+            has_digits = TRUE;
+        else if(*p == '.') {
+            if(++decimal_point_cnt>1)
+                return(FALSE);
+        } else
+            return(FALSE);
+        p++;
+    }
+    if(!has_digits || sscanf(valstart,"%lf",val)!=1)
+        return(FALSE);
+    *str = p;
+    return(TRUE);
+}
+
+/**************************** FLTEQ *******************************/
+
+int flteq(double f1,double f2)
+{
+    double upperbnd, lowerbnd;
+    upperbnd = f2 + FLTERR;     
+    lowerbnd = f2 - FLTERR;     
+    if((f1>upperbnd) || (f1<lowerbnd))
+        return(FALSE);
+    return(TRUE);
+}
+
+//TW NEW, FOR FLOATPOINT DATA
+/**************************** FLTEQ *******************************/
+
+int smpflteq(double f1,double f2)
+{
+    double upperbnd, lowerbnd;
+    upperbnd = f2 + SMP_FLTERR;     
+    lowerbnd = f2 - SMP_FLTERR;     
+    if((f1>upperbnd) || (f1<lowerbnd))
+        return(FALSE);
+    return(TRUE);
+}
+
+/*********************************** SWAP *************************/
+
+void swap(double *d1, double *d2)
+{
+    double dd;
+    dd  = *d1;
+    *d1 = *d2;
+    *d2 = dd;
+}
+
+/*********************************** IISWAP *************************/
+
+void iiswap(int *d1, int *d2)
+{
+    int dd;
+    dd  = *d1;
+    *d1 = *d2;
+    *d2 = dd;
+}
+
+/************************** MIDITOHZ ************************/
+
+double miditohz(double val)
+{
+    val += 3.0;
+    val /= 12.0;
+    val  = pow((double)2.0,val);
+    val *= LOW_A;
+    return(val);
+}    
+
+/************************** HZTOMIDI *****************************/
+
+int hztomidi(double *midi,double hz)
+{   
+    double val;
+    if(hz< FLTERR) {
+        sprintf(errstr,"Sent a 0 Hz value to hztomidi()\n");
+        return(PROGRAM_ERROR);
+    }
+    val  = hz;
+    val /= LOW_A;
+    val  = LOG2(val);
+    val *= 12.0;
+    val -= 3.0;
+    *midi = val;
+    return(FINISHED);
+}
+
+/************************** UNCHECKED_HZTOMIDI *****************************/
+
+double unchecked_hztomidi(double hz)
+{
+    double val;
+    val  = hz;
+    val /= LOW_A;
+    val  = LOG2(val);
+    val *= 12.0;
+    val -= 3.0;
+    return(val);
+}
+
+/********************** GET_LEVEL ****************************/
+ 
+int get_level(char *thisword,double *level)
+{
+    if(is_dB(thisword)) {
+        if(!get_leveldb(thisword,level)) {
+            sprintf(errstr,"Failed to get dB level: get_level()\n");
+            return(PROGRAM_ERROR);
+        }       
+    } else {
+        if(sscanf(thisword,"%lf",level)!=1) {
+            sprintf(errstr,"Failed to get level: get_level()\n");
+            return(PROGRAM_ERROR);
+        }       
+    }
+    return(FINISHED);
+}
+
+/************************************* IS_DB ******************************/
+
+int is_dB(char *str)
+{
+    char *p = str + strlen(str);
+        p -= 2;
+    if(strcmp(p,"dB") && strcmp(p,"DB") && strcmp(p,"db"))
+        return(FALSE);
+    return(TRUE);
+}
+
+/**************************** GET_LEVELDB ********************************/
+
+int get_leveldb(char *str,double *val)
+{
+    int is_neg = 0;
+    if(sscanf(str,"%lf",val)!=1)
+        return(FALSE);  
+    *val = max(*val,MIN_DB_ON_16_BIT);
+//TW NEW
+    *val = min(*val,MAX_DB_ON_16_BIT);
+    if(flteq(*val,0.0)) {
+        *val = 1.0;
+        return(TRUE);
+    }
+    if(*val<0.0) {
+        *val = -(*val);
+        is_neg = 1;
+    }
+    *val /= 20.0;
+    *val = pow(10.0,*val);
+    if(is_neg)
+        *val = 1.0/(*val);
+    return(TRUE);
+}
+
+/**************************** DBTOGAIN ********************************/
+
+double dbtogain(double val)
+{
+    int is_neg = FALSE;
+    if(val <= MIN_DB_ON_16_BIT)
+        return(0.0);
+    if(flteq(val,0.0))
+        return(1.0);
+    if(val<0.0) {
+        val = -val;
+        is_neg = TRUE;
+    }
+    val /= 20.0;
+    val = pow(10.0,val);
+    if(is_neg)
+        val = 1.0/val;
+    return(val);
+}
+
+/***************************** IS_AN_EMPTY_LINE_OR_A_COMMENT **************************/
+
+int is_an_empty_line_or_a_comment(char *p)
+{
+    while(isspace(*p))
+        p++;
+    if(*p==';' || *p=='\n' || *p==ENDOFSTR)
+        return(1);
+    return(0);
+}
+
+
+/***************************** IS_A_COMMENT **************************/
+
+int is_a_comment(char *p)
+{
+    while(isspace(*p))
+        p++;
+    if(*p==';')
+        return(1);
+    return(0);
+}
+
+/***************************** IS_AN_EMPTY_LINE **************************/
+
+int is_an_empty_line(char *p)
+{
+    while(isspace(*p))
+        p++;
+    if(*p=='\n' || *p==ENDOFSTR)
+        return(1);
+    return(0);
+}
+
+/******************************* FLOAT_ARRAY ******************************
+ *
+ * Generate float array of required size.
+ */
+
+int float_array(float **q,int size)
+{
+    if((*q = (float *)malloc(size * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to create array of floats.\n");
+        return(MEMORY_ERROR);
+    }
+    return(FINISHED);
+}
+
+/******************************* CONVERT_TIME_AND_VALS_TO_SAMPLECNTS *******************************/
+
+int convert_time_and_vals_to_samplecnts(int paramno,dataptr dz)
+{
+    double *p, *pend;
+    if(dz->brksize==NULL) {
+        sprintf(errstr,"brksize array not initialised:convert_time_and_vals_to_samplecnts()\n");
+        return(PROGRAM_ERROR);
+    } 
+    if(dz->brksize[paramno]) {
+        if(dz->brk==NULL) {
+            sprintf(errstr,"brk not initialised:convert_time_and_vals_to_samplecnts()\n");
+            return(PROGRAM_ERROR);
+        } 
+        p    = dz->brk[paramno];
+        pend = dz->brk[paramno] + (dz->brksize[paramno] * 2);
+        while(p < pend) {
+            *p = (double)round(*p * (double)dz->infile->srate);
+            p++;
+        }
+        dz->iparam[paramno] = round(*(dz->brk[paramno] + 1));   /* initialise */
+    } else
+        dz->iparam[paramno] = round(dz->param[paramno] * (double)dz->infile->srate);
+    dz->is_int[paramno] = TRUE;
+    return FINISHED;
+}
+
+/************************** CONVERT_TIME_TO_SAMPLECNTS *******************************
+ *
+ * Converts time(s) to (stereo-pairs) sample-cnt.
+ */
+
+int convert_time_to_samplecnts(int paramno,dataptr dz)
+{
+    double *p, *pend;
+    if(dz->brksize==NULL) {
+        sprintf(errstr,"brksize not initialised:convert_time_to_samplecnts()\n");
+        return(PROGRAM_ERROR);
+    } 
+    if(dz->brksize[paramno]) {
+        if(dz->brk==NULL) {
+            sprintf(errstr,"brk not initialised:convert_time_to_samplecnts()\n");
+            return(PROGRAM_ERROR);
+        } 
+        p    = dz->brk[paramno];
+        pend = dz->brk[paramno] + (dz->brksize[paramno] * 2);
+        while(p < pend) {
+            *p = (double)round(*p * (double)dz->infile->srate);
+            p += 2;
+        }
+    }
+    return(FINISHED);
+}
+
+/*************************************** BRK_COMPARE *****************************************/
+
+int brk_compare(double *brk1,int brksize1,double *brk2,int brksize2,int repel)
+{
+    int cnt1 = 0, cnt2 = 0;
+    double *t1 = brk1, *t2 = brk2;
+    double *v1 = brk1 + 1,  *v2 = brk2 + 1;
+    double val1, val2, thistime;
+    int orientation = EQUIVALENT;
+
+    if(brksize1<2 || brksize2<2)
+        return(INVALID);
+
+    while((cnt1 < brksize1) && (cnt2 < brksize2)) {
+        thistime = establish_current_time(*t1,*t2);
+        if(*t1 > thistime) {
+            val1 = establish_value_at_current_time(thistime,t1,brk1,v1);
+            val2 = *v2;
+            if((orientation = establish_orientation(val1,val2,repel))!=EQUIVALENT)
+                break;
+            else if(repel)
+                return(CROSSED);
+            if(++cnt2 < brksize2) {
+                v2 += 2;
+                t2 += 2;
+            }
+        } else if (*t2 > thistime) {
+            val2 = establish_value_at_current_time(thistime,t2,brk2,v2);
+            val1 = *v1;
+            if((orientation = establish_orientation(val1,val2,repel))!=EQUIVALENT)
+                break;
+            else if(repel)
+                return(CROSSED);
+            if(++cnt1 < brksize1) {
+                v1 += 2;
+                t1 += 2;
+            }
+        } else {
+            val1 = *v1;
+            val2 = *v1;
+            if((orientation = establish_orientation(val1,val2,repel))!=EQUIVALENT)
+                break;
+            else if(repel)
+                return(CROSSED);
+            if(++cnt1 < brksize1) {
+                v1 += 2;
+                t1 += 2;
+            }
+            if(++cnt2 < brksize2) {
+                v2 += 2;
+                t2 += 2;
+            }
+        }
+    }
+    while((cnt1 < brksize1) && (cnt2 < brksize2)) {
+        thistime = establish_current_time(*t1,*t2);
+        if(*t1 > thistime) {
+            val1 = establish_value_at_current_time(thistime,t1,brk1,v1);
+            val2 = *v2;
+            switch(repel) {
+            case(TRUE):
+                switch(orientation) {
+                case(FIRST_GREATER):  if(val2 >= val1-FLTERR)   return(CROSSED);    break;
+                case(FIRST_LESS):     if(val1 >= val2-FLTERR)   return(CROSSED);    break;
+                }
+                break;
+            case(FALSE):
+                switch(orientation) {
+                case(FIRST_GREATER):  if(val2 > val1)   return(CROSSED);    break;
+                case(FIRST_LESS):     if(val1 > val2)   return(CROSSED);    break;
+                }
+                break;
+            }
+            cnt2++;
+            v2 += 2;
+            t2 += 2;
+        } else if (*t2 > thistime) {
+            val2 = establish_value_at_current_time(thistime,t2,brk2,v2);
+            val1 = *v1;
+            switch(repel) {
+            case(TRUE):
+                switch(orientation) {
+                case(FIRST_GREATER):  if(val2 >= val1-FLTERR)   return(CROSSED);    break;
+                case(FIRST_LESS):     if(val1 >= val2-FLTERR)   return(CROSSED);    break;
+                }
+                break;
+            case(FALSE):
+                switch(orientation) {
+                case(FIRST_GREATER):  if(val2 > val1)   return(CROSSED);    break;
+                case(FIRST_LESS):     if(val1 > val2)   return(CROSSED);    break;
+                }
+                break;
+            }
+            cnt1++;
+            v1 += 2;
+            t1 += 2;
+        } else {
+            val1 = *v1;
+            val2 = *v1;
+            switch(repel) {
+            case(TRUE):
+                switch(orientation) {
+                case(FIRST_GREATER):  if(val2 >= val1-FLTERR)   return(CROSSED);    break;
+                case(FIRST_LESS):     if(val1 >= val2-FLTERR)   return(CROSSED);    break;
+                }
+                break;
+            case(FALSE):
+                switch(orientation) {
+                case(FIRST_GREATER):  if(val2 > val1)   return(CROSSED);    break;
+                case(FIRST_LESS):     if(val1 > val2)   return(CROSSED);    break;
+                }
+                break;
+            }
+            cnt1++;
+            cnt2++;
+            v1 += 2;
+            t1 += 2;
+            v2 += 2;
+            t2 += 2;
+        }
+    }
+    return(orientation);    
+}
+
+/*************************** ESTABLISH_ORIENTATION **************************/
+
+int establish_orientation(double val1, double val2,int repel)
+{
+    if(repel) {
+        if(val1 < val2-FLTERR)
+            return(FIRST_LESS);
+        else if (val2 < val1-FLTERR)
+            return(FIRST_GREATER);
+    } else {
+        if(val1 < val2)
+            return(FIRST_LESS);
+        else if (val2 < val1)
+            return(FIRST_GREATER);
+    }
+    return(EQUIVALENT);         
+}
+
+/************************** ESTABLISH_CURRENT_TIME **************************/
+
+double establish_current_time(double t1,double t2)
+{
+    if(t1 <= t2)
+        return(t1);
+    else
+        return(t2);
+}
+
+/******************** ESTABLISH_VALUE_AT_CURRENT_TIME ***********************/
+
+double establish_value_at_current_time(double thistime,double *t,double *brk,double *v)
+{
+    double *lastt, val, lastval, lasttime;
+    if((lastt = t - 2) < brk)
+        val = *v;
+    else {
+        lastval  = *(v - 2);
+        lasttime = *(lastt);
+        val = interpval(thistime,lastval,*v,lasttime,*t);
+    }
+    return(val);
+}
+
+/***************************** INTERPVAL *****************************/
+
+double interpval(double thistime,double lastval, double nextval, double lasttime, double nexttime)
+{
+    double timestep = nexttime - lasttime;
+    double valstep  = nextval - lastval;
+    double thisstep = thistime - lasttime;
+    double timeratio = thisstep/timestep;
+    valstep *= timeratio;
+    return(lastval + valstep);
+}
+
+/***************************** VALUE_GREATER_THAN_BRKVALS *****************************/
+
+int value_greater_than_brkvals(double val,double *brk,int brksize,int repel)
+{
+    double *p = brk;
+    double *pend = p + (brksize*2);
+    p++;
+    if(repel) {
+        while(p < pend) {
+            if(*p > val-FLTERR)
+                return(FALSE);
+            p += 2;
+        }
+    } else {
+        while(p < pend) {
+            if(*p > val)
+                return(FALSE);
+            p += 2;
+        }
+    }
+    return(TRUE);
+}
+
+/***************************** VALUE_LESS_THAN_BRKVALS *****************************/
+
+int value_less_than_brkvals(double val,double *brk,int brksize,int repel)
+{
+    double *p = brk;
+    double *pend = p + (brksize*2);
+    p++;
+    if(repel) {
+        while(p < pend) {
+            if(*p < val+FLTERR)
+                return(FALSE);
+            p += 2;
+        }
+    } else {
+        while(p < pend) {
+            if(*p < val)
+                return(FALSE);
+            p += 2;
+        }
+    }
+    return(TRUE);
+}
+
+/***************************** FIRST_PARAM_NOT_LESS_THAN_SECOND *****************************/
+
+int first_param_not_less_than_second(int paramno1,int paramno2,dataptr dz)
+{
+    int exit_status;
+    int repel = FALSE;
+    if(dz->brksize[paramno1]) {
+        if(dz->brksize[paramno2]) {
+            if((exit_status = brk_compare
+            (dz->brk[paramno1],dz->brksize[paramno1],dz->brk[paramno2],dz->brksize[paramno2],repel))<0) {
+                sprintf(errstr,"Incompatible parameter values in brktables.\n");
+                return(FALSE);
+            }
+            if(exit_status == FIRST_LESS) {
+                sprintf(errstr,"Incompatible parameter values in brktables.\n");
+                return(FALSE);
+            }
+        } else {
+            if(value_greater_than_brkvals(dz->param[paramno2],dz->brk[paramno1],dz->brksize[paramno1],repel)) {
+                sprintf(errstr,"Incompatible parameter values somewhere in brktable.\n");
+                return(FALSE);
+            }
+        }
+    } else if(dz->brksize[paramno2]) {
+        if(value_less_than_brkvals(dz->param[paramno1],dz->brk[paramno2],dz->brksize[paramno2],repel)) {
+            sprintf(errstr,"Incompatible parameter values somewhere in brktable.\n");
+            return(FALSE);
+        }
+    } else {
+        if(dz->param[paramno2] > dz->param[paramno1]) {
+            sprintf(errstr,"Incompatible parameter values.\n");
+            return(FALSE);
+        }
+    }
+    return(TRUE);
+}
+
+/**************************** FIRST_PARAM_GREATER_THAN_SECOND *****************************/
+
+int first_param_greater_than_second(int paramno1,int paramno2,dataptr dz)
+{
+    int exit_status;
+    int repel = TRUE;
+    if(dz->brksize[paramno1]) {
+        if(dz->brksize[paramno2]) {
+            if((exit_status = brk_compare
+            (dz->brk[paramno1],dz->brksize[paramno1],dz->brk[paramno2],dz->brksize[paramno2],repel))<0) {
+                sprintf(errstr,"Incompatible parameter values in brktables.\n");
+                return(FALSE);
+            }
+            if(exit_status == FIRST_LESS) {
+                sprintf(errstr,"Incompatible parameter values in brktables.\n");
+                return(FALSE);
+            }
+        } else {
+            if(!value_less_than_brkvals(dz->param[paramno2],dz->brk[paramno1],dz->brksize[paramno1],repel)) {
+                sprintf(errstr,"Incompatible parameter values somewhere in brktable.\n");
+                return(FALSE);
+            }
+        }
+    } else if(dz->brksize[paramno2]) {
+        if(!value_greater_than_brkvals(dz->param[paramno1],dz->brk[paramno2],dz->brksize[paramno2],repel)) {
+            sprintf(errstr,"Incompatible parameter values somewhere in brktable.\n");
+            return(FALSE);
+        }
+    } else {
+        if(dz->param[paramno2] > dz->param[paramno1]-FLTERR) {
+            sprintf(errstr,"Incompatible parameter values.\n");
+            return(FALSE);
+        }
+    }
+    return(TRUE);
+}
+
+/***************************** ESTABLISH_ADDITIONAL_BRKTABLE **************************/
+
+int establish_additional_brktable(dataptr dz)
+{
+    int brkcnt = dz->application->total_input_param_cnt;
+    if(dz->extrabrkno >= 0) {
+        sprintf(errstr,"extra brktable already exists: establish_additional_brktable()\n");
+        return(PROGRAM_ERROR);
+    }
+    dz->extrabrkno = brkcnt;              
+    brkcnt++;           /* extra brktable for internal brkpntfile data */
+    if(dz->extrabrkno > 0) {
+        if((dz->brk      = (double **)realloc(dz->brk      ,brkcnt * sizeof(double *)))==NULL
+        || (dz->brkptr   = (double **)realloc(dz->brkptr   ,brkcnt * sizeof(double)  ))==NULL
+        || (dz->brksize  = (int    *)realloc(dz->brksize  ,brkcnt * sizeof(int)    ))==NULL
+        || (dz->firstval = (double  *)realloc(dz->firstval ,brkcnt * sizeof(double)  ))==NULL
+        || (dz->lastind  = (double  *)realloc(dz->lastind  ,brkcnt * sizeof(double)  ))==NULL
+        || (dz->lastval  = (double  *)realloc(dz->lastval  ,brkcnt * sizeof(double)  ))==NULL
+        || (dz->brkinit  = (int     *)realloc(dz->brkinit  ,brkcnt * sizeof(int)     ))==NULL) {
+            sprintf(errstr,"establish_additional_brktable(): 1\n");
+            return(MEMORY_ERROR);
+        }
+    } else {
+        if((dz->brk      = (double **)malloc(brkcnt * sizeof(double *)))==NULL
+        || (dz->brkptr   = (double **)malloc(brkcnt * sizeof(double)  ))==NULL
+        || (dz->brksize  = (int    *)malloc(brkcnt * sizeof(int)    ))==NULL
+        || (dz->firstval = (double  *)malloc(brkcnt * sizeof(double)  ))==NULL
+        || (dz->lastind  = (double  *)malloc(brkcnt * sizeof(double)  ))==NULL
+        || (dz->lastval  = (double  *)malloc(brkcnt * sizeof(double)  ))==NULL
+        || (dz->brkinit  = (int     *)malloc(brkcnt * sizeof(int)     ))==NULL) {
+            sprintf(errstr,"establish_additional_brktable(): 2\n");
+            return(MEMORY_ERROR);
+        }
+    }
+    dz->brk[dz->extrabrkno]       = (double *)0;
+    dz->brkptr[dz->extrabrkno]    = (double *)0;
+    dz->brksize[dz->extrabrkno]   = 0;
+    dz->brkinit[dz->extrabrkno]   = 0;
+    return(FINISHED);
+}
+
+/**************************** GET_CHANNEL_CORRESPONDING_TO_FRQ ***************************/
+
+int get_channel_corresponding_to_frq(int *chan,double thisfrq,dataptr dz)
+{   
+    if(dz->chwidth <= 0.0) {
+        sprintf(errstr,"chwidth not set in get_channel_corresponding_to_frq()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(thisfrq < 0.0) {
+        sprintf(errstr,"-ve frequency in get_channel_corresponding_to_frq()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(thisfrq > dz->nyquist) {
+        sprintf(errstr,"frequency beyond nyquist in get_channel_corresponding_to_frq()\n");
+        return(PROGRAM_ERROR);
+    }
+    *chan = (int)((fabs(thisfrq) + dz->halfchwidth)/dz->chwidth);  /* TRUNCATE */
+    if(*chan >= dz->clength) {
+        sprintf(errstr,"chan (%d) beyond clength-1 (%d) returned: get_channel_corresponding_to_frq()\n",
+        *chan,(dz->clength)-1);
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/**************************** RESET_FILEDATA_COUNTERS **************************/
+
+void reset_filedata_counters(dataptr dz)
+{
+    dz->total_samps_written = 0;
+    dz->samps_left = dz->insams[0];
+    dz->total_samps_read = 0;
+}
+
+/**********************************************************************************/
+/**************************** ITEMS FORMERLY IN FILETYPE **************************/
+/**********************************************************************************/
+
+/****************************** IS_A_VALID_INPUT_FILETYPE *********************************/
+
+int is_a_valid_input_filetype(int filetype)
+{
+    switch(filetype) {
+    case(SNDFILE):
+    case(ANALFILE):
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+    case(FORMANTFILE):
+    case(ENVFILE):
+    case(TRANSPOS_OR_NORMD_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(TRANSPOS_OR_NORMD_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(TRANSPOS_OR_UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(TRANSPOS_OR_UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(NORMD_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(NORMD_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(DB_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(DB_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(PITCH_POSITIVE_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(PITCH_POSITIVE_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(POSITIVE_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(POSITIVE_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(NUMLIST_OR_WORDLIST):
+    case(SNDLIST_OR_SYNCLIST_LINELIST_OR_WORDLIST):
+    case(SNDLIST_OR_SYNCLIST_OR_WORDLIST):
+    case(SNDLIST_OR_LINELIST_OR_WORDLIST):
+    case(SNDLIST_OR_WORDLIST):
+    case(MIXLIST_OR_LINELIST_OR_WORDLIST):
+    case(MIXLIST_OR_WORDLIST):
+    case(SYNCLIST_OR_LINELIST_OR_WORDLIST):
+    case(SYNCLIST_OR_WORDLIST):
+    case(LINELIST_OR_WORDLIST):
+    case(WORDLIST):
+        return(TRUE);
+    }
+    return(FALSE);
+}
+
+/****************************** IS_A_TEXT_INPUT_FILETYPE *********************************/
+
+int is_a_text_input_filetype(int filetype)
+{
+    if(filetype & IS_A_TEXTFILE)
+        return(TRUE);
+    return(FALSE);
+}
+
+/****************************** COULD_BE_TRANSPOS_AND_OR_PITCH_INFILETYPE *********************************/
+
+int could_be_transpos_and_or_pitch_infiletype(int filetype)
+{
+    if(filetype & IS_A_TRANSPOS_BRKFILE || filetype & IS_A_PITCH_BRKFILE)
+        return(TRUE);
+    return(FALSE);
+}
+
+/****************************** IS_BRKFILE_INFILETYPE *********************************/
+
+int is_brkfile_infiletype(int filetype)
+{
+    if(filetype & IS_A_BRKFILE)
+        return(TRUE);
+    return(FALSE);
+}
+
+/****************************** IS_NUMLIST_INFILETYPE *********************************/
+
+int is_numlist_infiletype(int filetype)
+{
+    if(filetype & IS_A_NUMLIST)
+        return(TRUE);
+    return(FALSE);
+}
+
+/****************************** IS_NUMLIST_INFILETYPE *********************************/
+
+int is_transpos_infiletype(int filetype)
+{
+    if(filetype & IS_A_TRANSPOS_BRKFILE)
+        return(TRUE);
+    return(FALSE);
+}
+
+/****************************** IS_PITCH_INFILETYPE *********************************/
+
+int is_pitch_infiletype(int filetype)
+{
+    if(filetype & IS_A_PITCH_BRKFILE)
+        return(TRUE);
+    return(FALSE);
+}
+
+/****************************** IS_SNDLIST_ONLY_INFILETYPE *********************************/
+
+int is_sndlist_only_infiletype(int filetype)
+{
+    switch(filetype) {
+    case(SNDLIST_OR_LINELIST_OR_WORDLIST):
+    case(SNDLIST_OR_WORDLIST):
+        return(TRUE);
+    }
+    return(FALSE);
+}
+
+/******************************* FILE_HAS_INVALID_STARTCHAR ****************************/
+/* RWD 4:2002 need this until readdata is fixed (reading numbers as text filenames) */
+
+int file_has_invalid_startchar(char *filename)
+{
+    char *p;
+    int filenamelen = strlen(filename);
+//TW AGREED TO DELETION n, has_point
+    if(filenamelen <= 0)
+        return 1;
+    p = filename + filenamelen - 1;
+    switch(filename[0]) {
+    case(ENDOFSTR): 
+        return 1;
+    case('.'):
+        if(filenamelen <3)
+            return 1;
+        switch(filename[1]) {
+        case('/'):                                  /* allow ".\" 'current directory' shorthand */
+        case('\\'):
+            p = get_last_slash(filename,filenamelen);
+            p++;
+//TW MODIFIED TO ALLOW NUMERIC FILENAMES
+//          if(strlen(p) <=0 || isdigit(*p) || (*p == '-'))
+            if(strlen(p) <=0 || (*p == '-'))
+                return 1;
+            break;
+        case('.'):
+            if(filenamelen <4)
+                return 1;
+            switch(filename[2]) {
+            case('/'):                              /* allow "..\ 'other directory' shorthand */
+            case('\\'):
+                p = get_last_slash(filename,filenamelen);
+                p++;
+//TW MODIFIED TO ALLOW NUMERIC FILENAMES
+//              if(strlen(p) <=0  || isdigit(*p) || (*p == '-'))
+                if(strlen(p) <=0 || (*p == '-'))
+                    return 1;
+                break;
+            default:
+                return 1;
+            }
+            break;
+        default:
+            return 1;
+        }
+        break;
+//TW MODIFIED TO ALLOW NUMERIC FILENAMES, but stop '-' (which playcmd may interpet as flag)
+    case('-'):
+        return 1;
+    }
+    return 0;
+}
+
+/******************************* GET_LAST_SLASH ****************************/
+
+char *get_last_slash(char *filename,int filenamelen)
+{
+    char *p = filename;
+    p += filenamelen - 1;
+    while(p >= filename) {
+        if(*p == '/' || *p == '\\')
+            return p;
+        p--;
+    }
+    return p;   /* NOTREACHED */
+}
+
+/******************************* DERIVED_FILETYPE ****************************/
+
+int derived_filetype(int filetype)
+{
+    switch(filetype) {
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+    case(FORMANTFILE):
+        return(TRUE);
+    }
+    return(FALSE);
+}
+
+/******************************* FILE_HAS_RESERVED_EXTENSION ****************************/
+
+int file_has_reserved_extension(char *filename)
+{
+    char *p = strrchr(filename, '.');
+    if(p == NULL)
+        return 0;
+    p++;
+    if(!_stricmp(p,"frq") 
+    || !_stricmp(p,"for") 
+    || !_stricmp(p,"trn") 
+    || !_stricmp(p,"evl") 
+    || !_stricmp(p,"ana") 
+    || !_stricmp(p,"wav") 
+    || !_stricmp(p,"aiff") 
+    || !_stricmp(p,"aifc") 
+    || !_stricmp(p,"aif"))
+        return 1;
+    while(*p != ENDOFSTR) { /* numeric extensions are patches */
+        if(!isdigit(*p))
+            return 0;
+        p++;
+    }
+    return 1;
+}
+
+/****************************** IS_A_TEXTFILE_TYPE *******************************/
+
+int is_a_textfile_type(int filetype)    /* after type conversion: not at input */
+{
+    if(filetype==BRKFILE
+    || filetype==DB_BRKFILE
+    || filetype==UNRANGED_BRKFILE
+    || filetype==NUMLIST
+    || filetype==SNDLIST
+    || filetype==SYNCLIST
+    || filetype==MIXFILE
+    || filetype==LINELIST
+    || filetype==WORDLIST)
+        return(TRUE);
+    return(FALSE);
+}
+
+/***************************** FILE_HAS_INVALID_EXTENSION ****************************************/
+
+int file_has_invalid_extension(char *filename)
+{
+    char *p;
+    int len = strlen(filename);
+    if(len <=0)
+        return 0;
+    p = strrchr(filename, '.');
+    if(p == 0)
+        return 0;
+    p++;
+    if(*p == '\\' || *p == '/')     /*  allow .\abc OR ../abc */
+        return 0;
+    while(*p != ENDOFSTR) {
+        if(!isdigit(*p))            /* .123 is a patchfile : not permitted */
+            return 0;
+        p++;
+    }
+    return 1;
+}
+
+/**********************************************************************************/
+/*********************** ITEMS FORMERLY IN DEFAULTS.C tklib2 **********************/
+/**********************************************************************************/
+
+/****************************** INITIALISE_PARAM_VALUES *********************************/
+/*RWD NB we ignore infilesize and use insams ONLY */
+int initialise_param_values(int process,int mode,int channels,double nyquist,float frametime,
+    int insams,int srate,int wanted,int linecnt,double duration,double *default_val,int filetype,aplptr ap)
+{
+    int    n;
+    int    clength       = (int)(wanted/2);
+    double chwidth       = nyquist/(double)(clength-1);
+    double halfchwidth   = chwidth/2.0;
+    double sr            = (double)srate;
+
+        /******************************* SPEC *******************************/
+        /******************************* SPEC *******************************/
+        /******************************* SPEC *******************************/
+
+    switch(process) {
+    case(ACCU):
+        default_val[ACCU_DINDEX]    = 1.0;
+        default_val[ACCU_GINDEX]    = 0.0;
+        break;
+    case(ALT):      
+        break;
+    case(ARPE):
+        default_val[ARPE_WTYPE]     = SIN;
+        default_val[ARPE_ARPFRQ]    = 1.0;
+
+        if(mode==ABOVE_BOOST || mode==ONCE_ABOVE)
+            default_val[ARPE_PHASE] = 0.51;
+        else
+            default_val[ARPE_PHASE] = 0.0;
+
+
+
+        default_val[ARPE_LOFRQ]     = PITCHZERO;
+        default_val[ARPE_HIFRQ]     = nyquist;
+        default_val[ARPE_HBAND]     = nyquist/(double)(clength-1);
+        default_val[ARPE_AMPL]      = DEFAULT_ARPE_AMPLIF;
+        if(mode==ON
+        || mode==BOOST
+        || mode==BELOW_BOOST
+        || mode==ABOVE_BOOST) {
+            default_val[ARPE_NONLIN]= 1.0;
+            default_val[ARPE_SUST]  = DEFAULT_ARPE_SUSTAIN;
+        }
+        break;
+    case(AVRG):
+        default_val[AVRG_AVRG]      = DEFAULT_AVRG;
+        break;
+    case(BARE):
+        break;
+    case(BLUR):
+        default_val[BLUR_BLURF]     = DEFAULT_BLUR;
+        break;
+    case(BLTR):
+        default_val[BLUR_BLURF]     = DEFAULT_BLUR;
+        default_val[BLTR_TRACE]     = DEFAULT_TRACE;
+        break;
+    case(BRIDGE):
+        default_val[BRG_OFFSET]     = 0.0;
+        default_val[BRG_SF2]        = 0.0;
+        default_val[BRG_SA2]        = 0.0;
+        default_val[BRG_EF2]        = 1.0;
+        default_val[BRG_EA2]        = 1.0;
+        default_val[BRG_STIME]      = 0.0;
+        default_val[BRG_ETIME]      = frametime * 2.0;
+        break;
+    case(CHANNEL):
+        default_val[CHAN_FRQ]       = CONCERT_A;
+        break;
+    case(CHORD):
+    case(MULTRANS):
+        default_val[CHORD_HIFRQ]    = nyquist;
+        default_val[CHORD_LOFRQ]    = PITCHZERO;
+        break;
+    case(CHORUS):
+        if(mode==CH_AMP
+        || mode==CH_AMP_FRQ 
+        || mode==CH_AMP_FRQ_UP 
+        || mode==CH_AMP_FRQ_DN)
+            default_val[CHORU_AMPR] = DEFAULT_CHORU_AMPSPREAD;
+        if(mode==CH_FRQ
+        || mode==CH_FRQ_UP
+        || mode==CH_FRQ_DN
+        || mode==CH_AMP_FRQ
+        || mode==CH_AMP_FRQ_UP
+        || mode==CH_AMP_FRQ_DN)
+            default_val[CHORU_FRQR] = DEFAULT_CHORU_FRQSPREAD;
+        break;
+    case(CLEAN):
+        switch(mode) {
+        case(FROMTIME):
+        case(ANYWHERE):
+            default_val[CL_SKIPT]   = 0.0;
+            break;
+        case(FILTERING):
+            default_val[CL_FRQ]     = PITCHZERO;
+            break;
+        }
+        default_val[CL_GAIN]        = DEFAULT_NOISEGAIN;
+        break;
+    case(CROSS):
+        default_val[CROS_INTP]      = 1.0;
+        break;
+    case(CUT):
+        default_val[CUT_STIME]      = 0.0;
+        default_val[CUT_ETIME]      = duration;
+        break;
+    case(DIFF):
+        default_val[DIFF_CROSS]     = 1.0;
+        break;
+    case(DRUNK):
+        default_val[DRNK_RANGE]     = DEFAULT_MAX_DRUNK_STEP;
+        default_val[DRNK_STIME]     = 0.0;
+        default_val[DRNK_DUR]       = DEFAULT_DURATION;
+        break;
+    case(EXAG):
+        default_val[EXAG_EXAG]      = DEFAULT_EXAG;
+        break;
+    case(FILT):
+        switch(mode) {
+        case(F_HI): 
+        case(F_HI_NORM):
+            default_val[FILT_FRQ1]  = SPEC_MINFRQ;
+            default_val[FILT_QQ]    = DEFAULT_Q; 
+            break;
+        case(F_LO): 
+        case(F_LO_NORM):
+            default_val[FILT_FRQ1]  = DEFAULT_FILT_FRQ;
+            default_val[FILT_QQ]    = DEFAULT_Q; 
+            break;
+        case(F_HI_GAIN):
+            default_val[FILT_FRQ1]  = SPEC_MINFRQ;
+            default_val[FILT_QQ]    = DEFAULT_Q; 
+            default_val[FILT_PG]    = 1.0;
+            break;
+        case(F_LO_GAIN):
+            default_val[FILT_FRQ1]  = DEFAULT_FILT_FRQ;
+            default_val[FILT_QQ]    = DEFAULT_Q; 
+            default_val[FILT_PG]    = 1.0;
+            break;
+        case(F_BND):
+        case(F_BND_NORM):
+        case(F_NOTCH):
+        case(F_NOTCH_NORM):
+            default_val[FILT_FRQ1]  = SPEC_MINFRQ;
+            default_val[FILT_FRQ2]  = DEFAULT_FILT_FRQ;
+            default_val[FILT_QQ]    = DEFAULT_Q; 
+            break;
+        case(F_BAND_GAIN):  
+        case(F_NOTCH_GAIN):
+            default_val[FILT_FRQ1]  = SPEC_MINFRQ;
+            default_val[FILT_FRQ2]  = DEFAULT_FILT_FRQ;
+            default_val[FILT_QQ]    = DEFAULT_Q; 
+            default_val[FILT_PG]    = 1.0;
+            break;
+        }
+        break;
+    case(FMNTSEE):  
+    case(FORMANTS): 
+    case(FORMSEE):  
+        break;
+    case(FOCUS):
+        default_val[FOCU_PKCNT]     = (double)MAXPKCNT;
+        default_val[FOCU_BW]        = DEFAULT_OCTAVE_BWIDTH;
+        default_val[FOCU_LOFRQ]     = PITCHZERO;
+        default_val[FOCU_HIFRQ]     = nyquist;
+        default_val[FOCU_STABL]     = DEFAULT_STABILITY;
+        break;
+    case(FOLD):
+        default_val[FOLD_LOFRQ]     = PITCHZERO;
+        default_val[FOLD_HIFRQ]     = nyquist;
+        break;
+    case(FORM):
+        default_val[FORM_FTOP]      = nyquist;
+        default_val[FORM_FBOT]      = PITCHZERO;
+        default_val[FORM_GAIN]      = 1.0;
+        break;
+    case(FREEZE):   
+    case(FREEZE2):  
+        break;
+    case(FREQUENCY):
+        default_val[FRQ_CHAN]       = 0;
+        break;
+    case(GAIN):
+        default_val[GAIN_GAIN]      = 1.0;
+        break;
+    case(GLIDE):
+        default_val[GLIDE_DUR]      = DEFAULT_DURATION;
+        break;
+    case(GLIS):
+        default_val[GLIS_RATE]      = DEFAULT_GLISRATE;
+        default_val[GLIS_HIFRQ]     = nyquist;
+        if(mode==INHARMONIC)
+            default_val[GLIS_SHIFT] = GLIS_SHIFT_DEFAULT;
+        break;                                                           
+    case(GRAB):
+        default_val[GRAB_FRZTIME]   = duration/2;
+        break;
+    case(GREQ):
+        break;
+    case(INVERT):
+        break;
+    case(LEAF):
+        default_val[LEAF_SIZE]      = 1.0;
+        break;
+    case(LEVEL):
+        break;
+    case(MAGNIFY):
+        default_val[MAG_FRZTIME]    = duration/2;
+        default_val[MAG_DUR]        = DEFAULT_DURATION;
+        break;
+    case(MAKE):
+        break;
+    case(MAX):
+        break;
+    case(MEAN):
+        default_val[MEAN_LOF]       = PITCHZERO;
+        default_val[MEAN_HIF]       = nyquist;
+        default_val[MEAN_CHAN]      = clength;
+        break;
+    case(MORPH):
+        default_val[MPH_ASTT]       = 0.0;
+        default_val[MPH_AEND]       = frametime * 2;
+        default_val[MPH_FSTT]       = 0.0;
+        default_val[MPH_FEND]       = frametime * 2;
+        default_val[MPH_AEXP]       = 1.0;
+        default_val[MPH_FEXP]       = 1.0;
+        default_val[MPH_STAG]       = 0.0;
+        break;
+    case(NOISE):
+        default_val[NOISE_NOIS]     = 0.0;
+        break;
+    case(OCT):
+        default_val[OCT_HMOVE]      = DEFAULT_OCT_TRANSPOS; 
+        default_val[OCT_BREI]       = 0.0;
+        break;
+    case(OCTVU):
+        default_val[OCTVU_TSTEP]    = DEFAULT_TIME_STEP;
+        default_val[OCTVU_FUND]     = max(halfchwidth,exp(log(nyquist/ROOT_2)/(double)DEFAULT_OCTBANDS));
+        break;
+    case(P_APPROX):
+        default_val[PA_PRANG]       = DEFAULT_PRANGE;
+        default_val[PA_TRANG]       = DEFAULT_TRANGE;
+        default_val[PA_SRANG]       = DEFAULT_SRANGE;
+        break;
+    case(P_CUT):
+        default_val[PC_STT]         = 0.0;
+        default_val[PC_END]         = duration;
+        break;
+    case(P_EXAG):
+        switch(mode) {
+        case(RANGE_ONLY_TO_P):
+        case(RANGE_ONLY_TO_T):
+        case(R_AND_C_TO_P):
+        case(R_AND_C_TO_T):
+            default_val[PEX_RANG]   = 1.0;
+            /* fall thro */
+        default:
+            default_val[PEX_MEAN]   = MIDIMIN;
+            default_val[PEX_CNTR]   = 0.0;
+        }
+        break;
+    case(P_FIX):
+        default_val[PF_SCUT]        = 0.0;
+        default_val[PF_ECUT]        = duration - FLTERR;
+        default_val[PF_LOF]         = PITCHZERO;
+        default_val[PF_HIF]         = nyquist;
+        default_val[PF_SMOOTH]      = 1.0;
+        default_val[PF_SMARK]       = SPEC_MINFRQ;
+        default_val[PF_EMARK]       = SPEC_MINFRQ;
+        break;
+    case(P_HEAR):
+        default_val[PH_GAIN]        = 1.0;
+        break;
+    case(P_INFO):
+        break;
+    case(P_INVERT):
+        hztomidi(&(default_val[PI_MEAN]),SPEC_MINFRQ);
+        default_val[PI_TOP]         = MIDIMAX;
+        hztomidi(&(default_val[PI_BOT]),SPEC_MINFRQ);
+        break;
+    case(P_QUANTISE):   
+        break;
+    case(P_RANDOMISE):
+        default_val[PR_MXINT]       = 1.0;
+        default_val[PR_TSTEP]       = (frametime * SECS_TO_MS) + FLTERR;
+        default_val[PR_SLEW]        = DEFAULT_SLEW;
+        break;
+    case(P_SEE):
+// TW Default Scaling value altered to give range 0-1 out
+//      default_val[PSEE_SCF]       = 1.0;
+        default_val[PSEE_SCF]       = 1.0/nyquist;
+        break;
+    case(P_SMOOTH):
+        default_val[PS_TFRAME]      = (frametime * SECS_TO_MS) + FLTERR;
+        hztomidi(&(default_val[PS_MEAN]),SPEC_MINFRQ);
+        break;
+//TW NEW CASES
+    case(P_INSERT):
+    case(P_SINSERT):
+    case(P_PTOSIL):
+    case(P_NTOSIL):
+    case(P_SYNTH):
+    case(ANALENV):
+    case(P_BINTOBRK):
+    case(MAKE2):
+    case(P_INTERP):
+        break;
+    case(P_VOWELS):
+        default_val[PV_HWIDTH] = V_HWIDTH;
+        default_val[PV_CURVIT] = CURVIT;
+        default_val[PV_PKRANG] = PEAK_RANGE;
+        default_val[PV_FUNBAS] = FUNDAMENTAL_BASE;
+        default_val[PV_OFFSET] = 0.0;
+        break;
+    case(VFILT):
+        default_val[PV_HWIDTH] = V_HWIDTH;
+        default_val[PV_CURVIT] = CURVIT;
+        default_val[PV_PKRANG] = PEAK_RANGE;
+        default_val[VF_THRESH] = 0.5;
+        break;
+    case(P_GEN):
+        default_val[PGEN_SRATE] = 48000;
+        default_val[PGEN_CHANS_INPUT] = 1024;
+        default_val[PGEN_WINOVLP_INPUT] = 3;
+        break;
+
+    case(P_TRANSPOSE):
+        default_val[PT_TVAL]        = 0.0;
+        break;
+    case(P_VIBRATO):
+        default_val[PV_FRQ]         = DEFAULT_VIBRATO_FRQ;
+        default_val[PV_RANG]        = DEFAULT_VIBRATO_RANGE;
+        break;
+    case(P_WRITE):
+        default_val[PW_DRED]        = LOG2(EIGHTH_TONE) * SEMITONES_PER_OCTAVE;
+        break;
+    case(P_ZEROS):      
+        break;
+    case(PEAK):
+        default_val[PEAK_CUTOFF]    = SPEC_MINFRQ;
+        default_val[PEAK_TWINDOW]   = DEFAULT_TWINDOW;
+        default_val[PEAK_FWINDOW]   = DEFAULT_FWINDOW;
+        break;
+    case(PICK):
+        default_val[PICK_FUND]      = SPEC_MINFRQ;
+        default_val[PICK_LIN]       = SPEC_MINFRQ;
+        default_val[PICK_CLAR]      = 1.0;
+        break;
+    case(PITCH):
+        default_val[PICH_RNGE]      = 1.0;
+        default_val[PICH_VALID]     = (double)BLIPLEN;
+        default_val[PICH_SRATIO]    = SILENCE_RATIO;
+        default_val[PICH_MATCH]     = (double)ACCEPTABLE_MATCH;
+        default_val[PICH_HILM]      = nyquist/MAXIMI;
+        default_val[PICH_LOLM]      = SPEC_MINFRQ;
+        if(mode==PICH_TO_BRK)
+            default_val[PICH_DATAREDUCE]= LOG2(EIGHTH_TONE) * SEMITONES_PER_OCTAVE;
+        break;
+    case(PLUCK):
+        default_val[PLUK_GAIN]      = 1.0;
+        break;
+    case(PRINT):
+        default_val[PRNT_STIME]     = 0.0;
+        default_val[PRNT_WCNT]      = 1.0;
+        break;
+    case(REPITCH):      
+        break;
+    case(REPITCHB):
+        default_val[RP_DRED]        = LOG2(EIGHTH_TONE) * SEMITONES_PER_OCTAVE;
+        break;
+    case(REPORT):
+        default_val[REPORT_PKCNT]   = (double)MAXPKCNT;
+        default_val[REPORT_LOFRQ]   = PITCHZERO;
+        default_val[REPORT_HIFRQ]   = nyquist;
+        default_val[REPORT_STABL]   = DEFAULT_STABILITY;
+        break;
+    case(SCAT):
+        default_val[SCAT_CNT]       = max((double)(clength/4),16.0);
+        default_val[SCAT_BLOKSIZE]  = chwidth;
+        break;
+    case(SHIFT):
+        default_val[SHIFT_SHIF]     = 0.0;
+        default_val[SHIFT_FRQ1]     = halfchwidth/2.0;
+        default_val[SHIFT_FRQ2]     = nyquist - (halfchwidth/2.0);
+        break;
+    case(SHIFTP):
+        default_val[SHIFTP_FFRQ]    = CONCERT_A;
+        default_val[SHIFTP_SHF1]    = 0.0;
+        default_val[SHIFTP_SHF2]    = 0.0;
+        default_val[SHIFTP_DEPTH]   = 1.0;
+        break;
+    case(SHUFFLE):
+        default_val[SHUF_GRPSIZE]   = 1.0;
+        break;
+    case(SPLIT):        
+        break;
+    case(SPREAD):
+        default_val[SPREAD_SPRD]    = 1.0;
+        break;
+    case(STEP):
+        default_val[STEP_STEP]      = DEFAULT_STEP;
+        break;
+    case(STRETCH):
+        default_val[STR_FFRQ]       = CONCERT_A;
+        default_val[STR_SHIFT]      = 1.4;
+        default_val[STR_EXP]        = 1.0;
+        default_val[STR_DEPTH]      = 1.0;
+        break;
+    case(SUM):
+        default_val[SUM_CROSS]      = 1.0;
+        break;
+    case(SUPR):
+        default_val[SUPR_INDX]      = DEFAULT_TRACE;
+        break;
+    case(S_TRACE):
+        default_val[TRAC_INDX]      = DEFAULT_TRACE;
+        default_val[TRAC_LOFRQ]     = PITCHZERO;
+        default_val[TRAC_HIFRQ]     = nyquist;
+        break;
+    case(TRACK):
+        default_val[TRAK_PICH]      = SPEC_MINFRQ;
+        default_val[TRAK_RNGE]      = 1.0;
+        default_val[TRAK_VALID]     = (double)BLIPLEN;
+        default_val[TRAK_SRATIO]    = SILENCE_RATIO;
+        default_val[TRAK_HILM]      = nyquist/MAXIMI;
+        if(mode==TRK_TO_BRK)
+            default_val[TRAK_DATAREDUCE]= LOG2(EIGHTH_TONE) * SEMITONES_PER_OCTAVE;
+        break;
+    case(TRNSF):
+        default_val[TRNSF_HIFRQ]    = nyquist;
+        default_val[TRNSF_LOFRQ]    = PITCHZERO;
+        break;
+    case(TRNSP):
+        default_val[TRNSP_HIFRQ]    = nyquist;
+        default_val[TRNSP_LOFRQ]    = PITCHZERO;
+        break;
+    case(TSTRETCH):
+        default_val[TSTR_STRETCH]   = 1.0;
+        break;
+    case(TUNE):
+        default_val[TUNE_FOC]       = 1.0;
+        default_val[TUNE_CLAR]      = 1.0;
+        default_val[TUNE_INDX]      = DEFAULT_TRACE;
+        default_val[TUNE_BFRQ]      = SPEC_MINFRQ;
+        break;
+    case(VOCODE):
+        default_val[VOCO_LOF]       = PITCHZERO;
+        default_val[VOCO_HIF]       = nyquist;
+        default_val[VOCO_GAIN]      = 1.0;
+        break;
+    case(WARP):
+        default_val[WARP_PRNG]      = DEFAULT_PRANGE;
+        default_val[WARP_TRNG]      = DEFAULT_TRANGE;
+        default_val[WARP_SRNG]      = DEFAULT_SRANGE;
+        break;
+    case(WAVER):
+        default_val[WAVER_VIB]      = DEFAULT_VIBRATO_FRQ;
+        default_val[WAVER_STR]      = 1.0;
+        default_val[WAVER_LOFRQ]    = PITCHZERO;
+        if(mode==WAVER_SPECIFIED)
+            default_val[WAVER_EXP]  = 1.0;
+        break;
+    case(WEAVE):    
+        break;
+    case(WINDOWCNT):
+        break;
+    case(LIMIT):
+        default_val[LIMIT_THRESH]   = 0.0;
+        break;
+
+        /******************************* GROUCHO *******************************/
+        /******************************* GROUCHO *******************************/
+        /******************************* GROUCHO *******************************/
+
+    case(DISTORT):
+        default_val[DISTORT_POWFAC]     = 2.0;
+        break;
+    case(DISTORT_ENV):
+        default_val[DISTORTE_CYCLECNT]  = 1.0;
+        default_val[DISTORTE_TROF]      = 0.0;
+        default_val[DISTORTE_EXPON]     = 1.0;
+        break;
+    case(DISTORT_AVG):
+        default_val[DISTORTA_CYCLECNT]  = 2.0;
+        default_val[DISTORTA_MAXLEN]    = MAXWAVELEN;
+        default_val[DISTORTA_SKIPCNT]   = 0.0;
+        break;
+    case(DISTORT_OMT):
+        default_val[DISTORTO_OMIT]      = 1.0;
+        default_val[DISTORTO_KEEP]      = 2.0;
+        break;
+    case(DISTORT_MLT):
+    case(DISTORT_DIV):
+        default_val[DISTORTM_FACTOR]    = 2.0;
+        break;
+    case(DISTORT_HRM):
+        default_val[DISTORTH_PRESCALE]  = 1.0;
+        break;
+    case(DISTORT_FRC):
+        default_val[DISTORTF_SCALE]     = MIN_SCALE;
+        default_val[DISTORTF_AMPFACT]   = 1.0;
+        default_val[DISTORTF_PRESCALE]  = 1.0;
+        break;
+    case(DISTORT_REV):
+        default_val[DISTORTR_CYCLECNT]  = 1.0;
+        break;
+    case(DISTORT_SHUF):
+        default_val[DISTORTS_CYCLECNT]  = 1.0;
+        default_val[DISTORTS_SKIPCNT]   = 0.0;
+        break;
+    case(DISTORT_RPTFL):
+        default_val[DISTRPT_CYCLIM]     = CYCLIM_DFLTFRQ;
+        /* fall thro */
+    case(DISTORT_RPT):
+    case(DISTORT_RPT2):
+        default_val[DISTRPT_MULTIPLY]   = 2.0;
+        default_val[DISTRPT_CYCLECNT]   = 1.0;
+        default_val[DISTRPT_SKIPCNT]    = 0.0;
+        break;
+    case(DISTORT_INTP):
+        default_val[DISTINTP_MULTIPLY]  = 2.0;
+        default_val[DISTINTP_SKIPCNT]   = 0.0;
+        break;
+    case(DISTORT_DEL):
+        default_val[DISTDEL_CYCLECNT]   = 2.0;
+        default_val[DISTDEL_SKIPCNT]    = 0.0;
+        break;
+    case(DISTORT_RPL):
+        default_val[DISTRPL_CYCLECNT]   = 2.0;
+        default_val[DISTRPL_SKIPCNT]    = 0.0;
+        break;
+    case(DISTORT_TEL):
+        default_val[DISTTEL_CYCLECNT]   = 2.0;
+        default_val[DISTTEL_SKIPCNT]    = 0.0;
+        break;
+    case(DISTORT_FLT):
+        default_val[DISTFLT_LOFRQ_CYCLELEN] = SPEC_MINFRQ;
+        default_val[DISTFLT_HIFRQ_CYCLELEN] = nyquist;
+        default_val[DISTFLT_SKIPCNT]          = 0.0;
+        break;
+    case(DISTORT_INT):
+        break;
+    case(DISTORT_CYCLECNT):
+        break;
+    case(DISTORT_PCH):
+        default_val[DISTPCH_OCTVAR]     = 1.0;
+        default_val[DISTPCH_CYCLECNT]   = DEFAULT_RSTEP;
+        default_val[DISTPCH_SKIPCNT]    = 0.0;
+        break;
+    case(DISTORT_OVERLOAD):
+        if(mode==OVER_SINE) {
+            default_val[DISTORTER_FRQ]  = CONCERT_A;
+        }
+        default_val[DISTORTER_MULT]     = DFLT_DISTORTER_MULT;
+        default_val[DISTORTER_DEPTH]    = DFLT_DISTORTER_DEPTH;
+        break;
+//TW NEW CASE
+    case(DISTORT_PULSED):
+        default_val[PULSE_STARTTIME]    = 0.0;  /* starttime of impulses in input-sound */
+        default_val[PULSE_DUR]          = 1.0;  /* duration of impulse stream */
+        default_val[PULSE_FRQ]          = 10.0; /* frq of impulses */
+        default_val[PULSE_FRQRAND]      = 0.0;  /* randomisation frq of impulses, in semitones */
+        default_val[PULSE_TIMERAND]     = 0.0;  /* randomisation of pulse shape, timewise */
+        default_val[PULSE_SHAPERAND]    = 0.0;  /* randomisation of pulse shape, ampwise  */
+        if(mode==PULSE_SYNI)
+            default_val[PULSE_WAVETIME] = 1.0;  /* number of wavesets to cycle-around, within impulse [synth2 option only] */
+        else
+            default_val[PULSE_WAVETIME] = .02;  /* duration of wavesets to cycle-around, within impulse [synth option only] */
+        default_val[PULSE_TRANSPOS]     = 0.0;  /* transposition envelope of material inside impulse */
+        default_val[PULSE_PITCHRAND]    = 0.0;  /* randomisation of transposition envelope */
+        break;
+
+    case(ZIGZAG):
+        default_val[ZIGZAG_START]       = 0.0;
+        default_val[ZIGZAG_END]         = duration;
+        default_val[ZIGZAG_DUR]         = duration * 2.0;
+        default_val[ZIGZAG_MIN]         = ((ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+        default_val[ZIGZAG_SPLEN]       = ZIG_SPLICELEN;
+        if(mode==ZIGZAG_SELF) {
+            default_val[ZIGZAG_MAX]     = min(2.0,duration - (2 * ZIG_SPLICELEN * MS_TO_SECS));
+            default_val[ZIGZAG_RSEED]   = 0.0;
+        }
+        break;
+    case(LOOP):
+        default_val[LOOP_OUTDUR]        = duration;
+        default_val[LOOP_REPETS]        = 2;
+        default_val[LOOP_START]         = 0.0;
+        default_val[LOOP_LEN]           = max(DEFAULT_LPSTEP,((ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED));
+        if(mode==LOOP_ALL)
+            default_val[LOOP_STEP]      = max(DEFAULT_LPSTEP/2,((ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED));
+        else
+            default_val[LOOP_STEP]      = 0.0;
+        default_val[LOOP_SPLEN]         = ZIG_SPLICELEN;
+        default_val[LOOP_SRCHF]         = 0.0;
+        break;
+    case(SCRAMBLE):
+        switch(mode) {
+        case(SCRAMBLE_RAND):
+            default_val[SCRAMBLE_MIN]   = ((2 * ZIG_SPLICELEN) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+            default_val[SCRAMBLE_MAX]   = max((duration/4.0),default_val[SCRAMBLE_MIN]);
+            break;
+        case(SCRAMBLE_SHRED):
+            default_val[SCRAMBLE_LEN]   = max((duration/4.0),((2 * ZIG_SPLICELEN) + ZIG_MIN_UNSPLICED) * MS_TO_SECS);
+            default_val[SCRAMBLE_SCAT]  = 0.0;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for SCRAMBLE: in initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }
+        default_val[SCRAMBLE_DUR]       = duration;
+        default_val[SCRAMBLE_SPLEN]     = ZIG_SPLICELEN;
+        default_val[SCRAMBLE_SEED]      = 0.0;
+        break;
+    case(ITERATE):
+        switch(mode) {
+        case(ITERATE_DUR):
+            default_val[ITER_DUR]       = duration * 2.0;
+            break;
+        case(ITERATE_REPEATS): 
+            default_val[ITER_REPEATS]   = 2.0;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for ITERATE: in initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }
+        default_val[ITER_DELAY]         = duration;
+        default_val[ITER_RANDOM]        = 0.0;
+        default_val[ITER_PSCAT]         = 0.0;
+        default_val[ITER_ASCAT]         = 0.0;
+        default_val[ITER_FADE]          = 0.0;
+        default_val[ITER_RSEED]         = 0.0;
+        default_val[ITER_GAIN]          = DEFAULT_ITER_GAIN; /* 0.0 */ 
+        break;
+    case(ITERATE_EXTEND):
+        switch(mode) {
+        case(ITERATE_DUR):     
+            default_val[ITER_DUR]       = duration * 2.0;
+            break;
+        case(ITERATE_REPEATS): 
+            default_val[ITER_REPEATS]   = 2.0;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for ITERATE_EXTEND: in initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }
+        default_val[ITER_DELAY]         = duration;
+        default_val[ITER_RANDOM]        = 0.0;
+        default_val[ITER_PSCAT]         = 0.0;
+        default_val[ITER_ASCAT]         = 0.0;
+        default_val[CHUNKSTART]         = 0.0;
+        default_val[CHUNKEND]           = duration;
+        default_val[ITER_LGAIN]         = 1.0;
+        default_val[ITER_RRSEED]        = 0.0;
+        break;
+    case(DRUNKWALK):
+        default_val[DRNK_TOTALDUR]      = duration;
+        default_val[DRNK_LOCUS]         = 0.0;
+        default_val[DRNK_AMBITUS]       = min(1.0,duration);
+        default_val[DRNK_GSTEP]         = DRNK_GRAIN * DRNK_DEFAULT_GSTEP;
+        default_val[DRNK_CLOKTIK]       = DRNK_SPLICE * MS_TO_SECS * DRNK_DEFAULT_CLOKTIK;
+        default_val[DRNK_MIN_DRNKTIK]   = DEFAULT_MIN_DRNKTIK;
+        default_val[DRNK_MAX_DRNKTIK]   = DEFAULT_MAX_DRNKTIK;
+
+        default_val[DRNK_SPLICELEN]     = DRNK_SPLICE;
+        default_val[DRNK_CLOKRND]       = 0.0;
+        default_val[DRNK_OVERLAP]       = 0.0;
+        default_val[DRNK_RSEED]         = 0.0;
+        if(mode==HAS_SOBER_MOMENTS) {
+            default_val[DRNK_MIN_PAUS]  = 0.25;
+            default_val[DRNK_MAX_PAUS]  = min(1.5,duration + FLTERR);
+        }
+        break;
+
+    case(SIMPLE_TEX):   case(TIMED):    case(GROUPS):   case(TGROUPS):
+    case(DECORATED):    case(PREDECOR): case(POSTDECOR):
+    case(ORNATE):       case(PREORNATE):case(POSTORNATE):
+    case(MOTIFS):       case(MOTIFSIN): case(TMOTIFS):  case(TMOTIFSIN):
+        default_val[TEXTURE_DUR]        = TEXTURE_DEFAULT_DUR;
+
+        switch(process) {
+        case(SIMPLE_TEX):   case(GROUPS):   case(MOTIFS):   case(MOTIFSIN):
+            default_val[TEXTURE_PACK]   = DENSITY_DEFAULT;
+            break;
+        case(TIMED):        case(TGROUPS):      case(TMOTIFS):      case(TMOTIFSIN):
+        case(DECORATED):    case(PREDECOR):     case(POSTDECOR):    
+        case(ORNATE):       case(PREORNATE):    case(POSTORNATE):
+            default_val[TEXTURE_SKIP]   = DEFAULT_SKIP;
+            break;
+        default:
+            sprintf(errstr,"Unknown process in initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }
+        default_val[TEXTURE_SCAT]       = 0.0;
+        default_val[TEXTURE_TGRID]      = 0.0;
+        default_val[TEXTURE_INSLO]      = 1.0;
+        default_val[TEXTURE_INSHI]      = 1.0;
+        default_val[TEXTURE_MAXAMP]     = 64.0;
+        default_val[TEXTURE_MINAMP]     = 64.0;
+        default_val[TEXTURE_MAXDUR]     = min(ap->hi[TEXTURE_MAXDUR],TEXTURE_MAX_DUR);
+        default_val[TEXTURE_MINDUR]     = max(ap->lo[TEXTURE_MINDUR],TEXTURE_MIN_DUR);
+        default_val[TEXTURE_MAXPICH]    = DEFAULT_PITCH;
+        default_val[TEXTURE_MINPICH]    = DEFAULT_PITCH;
+        default_val[TEX_PHGRID]         = 0.0;
+        default_val[TEX_GPSPACE]        = (double)IS_STILL;
+        default_val[TEX_GRPSPRANGE]     = 0.0;
+        default_val[TEX_AMPRISE]        = 0.0;
+        default_val[TEX_AMPCONT]        = 0.0;
+        default_val[TEX_GPSIZELO]       = DEFAULT_GPSIZE;
+        default_val[TEX_GPSIZEHI]       = DEFAULT_GPSIZE;
+        default_val[TEX_GPPACKLO]       = DENSITY_DEFAULT * SECS_TO_MS;
+        default_val[TEX_GPPACKHI]       = DENSITY_DEFAULT * SECS_TO_MS;
+        if(mode==TEX_NEUTRAL) { /* midipitches */
+            default_val[TEX_GPRANGLO]   = DEFAULT_PITCH - HALF_OCTAVE;
+            default_val[TEX_GPRANGHI]   = DEFAULT_PITCH + HALF_OCTAVE;
+        } else { /* notes of hfield */
+            default_val[TEX_GPRANGLO]   = DEFAULT_HF_GPRANGE;
+            default_val[TEX_GPRANGHI]   = DEFAULT_HF_GPRANGE;
+        }
+        default_val[TEX_MULTLO]         = 1.0;
+        default_val[TEX_MULTHI]         = 1.0;
+        default_val[TEX_DECPCENTRE]     = (double)DEC_CENTRED;
+        default_val[TEXTURE_ATTEN]      = 1.0;
+        default_val[TEXTURE_POS]        = TEX_CENTRE;
+        default_val[TEXTURE_SPRD]       = MAX_SPREAD;
+        default_val[TEXTURE_SEED]       = 0.0;
+        for(n=0;n<TEXTURE_SEED;n++) {
+            if(default_val[n] < 0.0) {
+                sprintf(errstr,"parameter %d has been preset to a -ve val: invalid in TEXTURE\n",n+1);
+                return(PROGRAM_ERROR);
+            }
+        }
+        break;
+
+    case(GRAIN_COUNT):      case(GRAIN_OMIT):       case(GRAIN_DUPLICATE):
+    case(GRAIN_REORDER):    case(GRAIN_REPITCH):    case(GRAIN_RERHYTHM):
+    case(GRAIN_REMOTIF):    case(GRAIN_TIMEWARP):   case(GRAIN_POSITION):
+    case(GRAIN_ALIGN):      case(GRAIN_GET):        case(GRAIN_REVERSE):
+        default_val[GR_BLEN]            = min(GR_MINDUR,duration);
+        default_val[GR_GATE]            =  GR_GATE_DEFAULT;
+        default_val[GR_MINTIME]         = (GRAIN_SPLICELEN + GRAIN_SAFETY) * MS_TO_SECS * 2.0;
+        default_val[GR_WINSIZE]         = 50.0;         
+        switch(process) {
+        case(GRAIN_OMIT):       
+            default_val[GR_KEEP]        = 1.0;
+            default_val[GR_OUT_OF]      = 2.0;
+            break;
+        case(GRAIN_DUPLICATE):  
+            default_val[GR_DUPLS]       = 2.0;
+            break;
+        case(GRAIN_TIMEWARP):
+            default_val[GR_TSTRETCH]    = 1.0;
+            break;
+        case(GRAIN_POSITION):
+            default_val[GR_OFFSET]      = 0.0;
+            break;
+        case(GRAIN_ALIGN):
+            default_val[GR_OFFSET]      = 0.0;
+            default_val[GR_GATE2]       = GR_GATE_DEFAULT;
+            break;
+        }
+        break;
+    case(RRRR_EXTEND):
+        if(mode == 1) {
+            default_val[RRR_GATE]    = 0.0;
+            default_val[RRR_GRSIZ]   = LOW_RRR_SIZE;
+            default_val[RRR_SKIP]    = 0;
+            default_val[RRR_AFTER]   = 0.0;
+            default_val[RRR_TEMPO]   = 1.0;
+            default_val[RRR_AT]      = 0;
+        } else {
+            default_val[RRR_START]   = 0.0;
+            default_val[RRR_END]     = duration;
+        }
+        default_val[RRR_SLOW]    = 1.0;
+        default_val[RRR_REGU]    = 0.0;
+        default_val[RRR_RANGE]   = 1.0;
+        default_val[RRR_GET]     = 3.0;
+        if(mode != 2) {
+            default_val[RRR_STRETCH] = 2.0;
+            default_val[RRR_REPET]   = 2.0;
+            default_val[RRR_ASCAT]   = 0.0;
+            default_val[RRR_PSCAT]   = 0.0;
+        }
+        break;
+    case(SSSS_EXTEND):
+        default_val[SSS_DUR]      = 10;
+        default_val[NOISE_MINFRQ] = NOIS_MIN_FRQ;
+        default_val[MIN_NOISLEN]  = 50.0;
+        default_val[MAX_NOISLEN]  = min(1.0,duration);
+        default_val[SSS_GATE]     = 0.0;
+        break;
+    case(ENV_CREATE):
+    case(ENV_BRKTOENV):
+    case(ENV_DBBRKTOENV):
+    case(ENV_IMPOSE):
+//TW NEW CASE
+    case(ENV_PROPOR):
+    case(ENV_REPLACE):
+        default_val[ENV_WSIZE]          = ENV_DEFAULT_WSIZE;
+        break;
+    case(ENV_EXTRACT):
+        default_val[ENV_WSIZE]          = ENV_DEFAULT_WSIZE;
+        if(mode==ENV_BRKFILE_OUT)
+            default_val[ENV_DATAREDUCE] = ENV_DEFAULT_DATAREDUCE;
+        break;
+    case(ENV_ENVTOBRK):
+    case(ENV_ENVTODBBRK):
+        default_val[ENV_DATAREDUCE]     = ENV_DEFAULT_DATAREDUCE;
+        break;
+    case(ENV_WARPING):
+    case(ENV_REPLOTTING):
+        default_val[ENV_WSIZE]          = ENV_DEFAULT_WSIZE;
+        /* fall thro */
+    case(ENV_RESHAPING):
+        switch(mode) {
+        case(ENV_NORMALISE):
+        case(ENV_REVERSE):
+        case(ENV_CEILING):
+            break;
+        case(ENV_DUCKED):
+            default_val[ENV_GATE]       = ENV_DEFAULT_GATE;
+            default_val[ENV_THRESHOLD]  = ENV_DEFAULT_THRESH;
+            break;
+        case(ENV_EXAGGERATING):
+            default_val[ENV_EXAG]       = ENV_DEFAULT_EXAGG;
+            break;
+        case(ENV_ATTENUATING):
+            default_val[ENV_ATTEN]      = ENV_DEFAULT_ATTEN;
+            break;
+        case(ENV_LIFTING):
+            default_val[ENV_LIFT]       = ENV_DEFAULT_LIFT;
+            break;
+        case(ENV_FLATTENING):
+            default_val[ENV_FLATN]      = ENV_DEFAULT_FLATN;
+            break;
+        case(ENV_TSTRETCHING):
+            default_val[ENV_TSTRETCH]   = ENV_DEFAULT_TSTRETCH;
+            break;
+        case(ENV_GATING):
+            default_val[ENV_GATE]       = ENV_DEFAULT_GATE;
+            default_val[ENV_SMOOTH]     = 0.0;
+            break;
+        case(ENV_INVERTING):
+            default_val[ENV_GATE]       = ENV_DEFAULT_GATE;
+            default_val[ENV_MIRROR]     = ENV_DEFAULT_MIRROR;
+            break;
+        case(ENV_LIMITING):
+            default_val[ENV_LIMIT]      = 1.0;
+            default_val[ENV_THRESHOLD]  = ENV_DEFAULT_GATE;
+            break;
+        case(ENV_CORRUGATING):
+            default_val[ENV_TROFDEL]    = ENV_DEFAULT_TROFDEL;
+            /* fall thro */
+        case(ENV_PEAKCNT):
+            default_val[ENV_PKSRCHWIDTH]= ENV_DEFAULT_PKSRCHWIDTH;
+            break;
+        case(ENV_EXPANDING):
+            default_val[ENV_GATE]       = ENV_DEFAULT_GATE;
+            default_val[ENV_THRESHOLD]  = ENV_DEFAULT_THRESH;
+            default_val[ENV_SMOOTH]     = 0.0;
+            break;
+        case(ENV_TRIGGERING):
+            default_val[ENV_GATE]       = ENV_DEFAULT_GATE;
+            default_val[ENV_TRIGRISE]   = ENV_DEFAULT_TRIGRISE;
+            default_val[ENV_TRIGDUR]    = ENV_DEFAULT_TRIGDUR;
+            break;
+        default:
+            sprintf(errstr,"Unknown case for ENVWARP,RESHAPING or REPLOTTING: initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }                 
+        if(process==ENV_REPLOTTING)
+            default_val[ENV_DATAREDUCE] = ENV_DEFAULT_DATAREDUCE;
+        break;
+    case(ENV_DOVETAILING):
+        default_val[ENV_STARTTRIM]      = 0.0;
+        default_val[ENV_ENDTRIM]        = 0.0;
+        default_val[ENV_STARTTYPE]      = ENVTYPE_EXP;
+        default_val[ENV_ENDTYPE]        = ENVTYPE_EXP;
+        default_val[ENV_TIMETYPE]       = ENV_TIMETYPE_SECS;
+        break;
+    case(ENV_CURTAILING):
+        default_val[ENV_STARTTIME]      = 0.0;
+        default_val[ENV_ENDTIME]        = duration;
+        default_val[ENV_ENVTYPE]        = ENVTYPE_EXP;
+        default_val[ENV_TIMETYPE]       = ENV_TIMETYPE_SECS;
+        break;
+    case(ENV_SWELL):
+        default_val[ENV_PEAKTIME]       = duration/2.0;
+        default_val[ENV_ENVTYPE]        = ENVTYPE_EXP;
+        break;
+    case(ENV_ATTACK):
+        switch(mode) {
+        case(ENV_ATK_GATED):
+            default_val[ENV_ATK_GATE]   = 0.5;
+            break;
+        case(ENV_ATK_TIMED):
+        case(ENV_ATK_XTIME):
+            default_val[ENV_ATK_ATTIME] = min(duration/2.0,0.5);
+            break;
+        case(ENV_ATK_ATMAX):
+            break;
+        default:
+            sprintf(errstr,"Unknown case for ENV_ATTACK: initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }
+        default_val[ENV_ATK_GAIN]       = ENV_DEFAULT_ATK_GAIN;
+        default_val[ENV_ATK_ONSET]      = ENV_DEFAULT_ATK_ONSET;
+        default_val[ENV_ATK_TAIL]       = ENV_DEFAULT_ATK_TAIL;
+        default_val[ENV_ATK_ENVTYPE]    = ENVTYPE_EXP;
+        break;
+    case(ENV_PLUCK):
+        default_val[ENV_PLK_ENDSAMP]    = 0.0;
+        default_val[ENV_PLK_WAVELEN]    = round(sr/ENV_PLK_FRQ_MAX);
+        default_val[ENV_PLK_CYCLEN]     = ENV_PLK_CYCLEN_DEFAULT;
+        default_val[ENV_PLK_DECAY]      = ENV_PLK_DECAY_DEFAULT;
+        break;
+    case(ENV_TREMOL):
+        default_val[ENV_TREM_FRQ]       = ENV_TREM_DEFAULT_FRQ;
+        default_val[ENV_TREM_DEPTH]     = ENV_TREM_DEFAULT_DEPTH;
+        default_val[ENV_TREM_AMP]       = 1.0;
+        break;
+    case(ENV_DBBRKTOBRK):
+    case(ENV_BRKTODBBRK):
+        break;
+
+    case(MIX):
+        default_val[MIX_ATTEN]          = 1.0;
+        /* fall thro */
+    case(MIXMAX):
+        default_val[MIX_START]          = 0.0;
+        default_val[MIX_END]            = duration;
+        break;
+    case(MIXTWO):       
+        default_val[MIX_STAGGER]        = 0.0;
+        default_val[MIX_SKIP]           = 0.0;
+        default_val[MIX_SKEW]           = 1.0;
+        default_val[MIX_STTA]           = 0.0;
+        default_val[MIX_DURA]           = 32767.0;
+        break;
+//TW NEW CASE
+    case(MIXMANY):
+        break;
+    case(MIXBALANCE):
+        default_val[MIX_STAGGER]        = 0.5;
+        default_val[MIX_SKIP]           = 0.0;
+        default_val[MIX_SKEW]           = duration;
+        break;
+    case(MIXCROSS):
+        default_val[MCR_STAGGER]        = 0.0;
+        default_val[MCR_BEGIN]          = 0.0;
+        default_val[MCR_END]            = 0.0;
+        if(mode==MCCOS)
+            default_val[MCR_POWFAC]     = 1.0;
+        break;
+    case(MIXINBETWEEN):
+        switch(mode) {
+        case(INBI_COUNT):
+            default_val[INBETW]         = (double)DEFAULT_BETWEEN;
+            break;
+        case(INBI_RATIO):
+            default_val[INBETW]         = 0.5;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for MIXINBETWEEN: initialise_param_values()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(CYCINBETWEEN):
+        default_val[INBETW]         = (double)DEFAULT_BETWEEN;
+        default_val[BTWN_HFRQ]      = (double)DEFAULT_BTWNFRQ;
+        break;
+    case(MIXTEST):
+    case(MIXFORMAT):
+    case(MIXDUMMY):
+    case(MIXINTERL):
+    case(MIXSYNC):
+//TW NEW CASE
+    case(ADDTOMIX):
+        break;
+    case(MIXSYNCATT):
+        default_val[MSY_WFAC]           = (double)MIN_WINFAC;
+        break;
+    case(MIXGAIN):
+        default_val[MIX_GAIN]           = 1.0;
+        default_val[MSH_STARTLINE]      = 1.0;
+        default_val[MSH_ENDLINE]        = (double)linecnt;
+        break;
+    case(MIXTWARP):
+        switch(mode) {
+        case(MTW_REVERSE_T):  case(MTW_REVERSE_NT):
+        case(MTW_FREEZE_T):   case(MTW_FREEZE_NT):
+        case(MTW_TIMESORT):
+            break;
+        case(MTW_SCATTER):
+            default_val[MTW_PARAM]      = 0.5;
+            break;
+        case(MTW_DOMINO):
+            default_val[MTW_PARAM]      = 0.0;
+            break;
+        case(MTW_ADD_TO_TG):
+        case(MTW_CREATE_TG_1):  case(MTW_CREATE_TG_2):  case(MTW_CREATE_TG_3):  case(MTW_CREATE_TG_4):
+        case(MTW_ENLARGE_TG_1): case(MTW_ENLARGE_TG_2): case(MTW_ENLARGE_TG_3): case(MTW_ENLARGE_TG_4):
+            default_val[MTW_PARAM]      = 0.1;
+            break;
+        }
+        if(mode!=MTW_TIMESORT) {
+            default_val[MSH_STARTLINE]  = 1.0;
+            default_val[MSH_ENDLINE]    = (double)linecnt;
+        }
+        break;
+    case(MIXSWARP):
+        switch(mode) {
+        case(MSW_TWISTALL):
+            break;
+        case(MSW_TWISTONE):
+            default_val[MSW_TWLINE]     = 1.0;
+            break;
+        case(MSW_NARROWED):
+            default_val[MSW_NARROWING]  = 0.5;
+            break;
+        case(MSW_LEFTWARDS):
+        case(MSW_RIGHTWARDS):
+        case(MSW_RANDOM):
+        case(MSW_RANDOM_ALT):
+            default_val[MSW_POS1]       = PAN_LEFT;
+            default_val[MSW_POS2]       = PAN_RIGHT;
+            break;
+        case(MSW_FIXED):
+            default_val[MSW_POS1]       = PAN_CENTRE;
+            break;
+        }
+        if(mode!=MSW_TWISTALL && mode!=MSW_TWISTONE) {
+            default_val[MSH_STARTLINE]  = 1.0;
+            default_val[MSH_ENDLINE]    = (double)linecnt;
+        }
+        break;
+    case(MIXSHUFL):
+        default_val[MSH_STARTLINE]      = 1.0;
+        default_val[MSH_ENDLINE]        = (double)linecnt;
+        break;
+//TW NEW CASES
+    case(MIX_ON_GRID):
+        break;
+    case(AUTOMIX):
+        default_val[0] = 1.0;
+        break;
+    case(MIX_PAN):
+        default_val[PAN_PAN]            = 0.0;
+        break;
+    case(MIX_AT_STEP):
+        default_val[MIX_STEP]           = 0.0;
+        break;
+    case(SHUDDER):
+        default_val[SHUD_STARTTIME]     = 0.0;
+        default_val[SHUD_FRQ]           = 6.0;
+        default_val[SHUD_SCAT]          = 1.0;
+        default_val[SHUD_SPREAD]        = 1.0;
+        default_val[SHUD_MINDEPTH]      = 0.0;
+        default_val[SHUD_MAXDEPTH]      = 1.0;
+        default_val[SHUD_MINWIDTH]      = 0.02;
+        default_val[SHUD_MAXWIDTH]      = 0.2;
+        break;
+
+    case(EQ):
+        switch(mode) {
+        case(FLT_PEAKING):
+            default_val[FLT_BW]         = FLT_DEFAULT_BW;
+            /* fall thro */
+        default:
+            default_val[FLT_BOOST]      = 0.0; /* dB */
+            default_val[FLT_ONEFRQ]     = FLT_DEFAULT_FRQ;
+            default_val[FLT_PRESCALE]   = 1.0;
+//TW NEW PARAM
+            default_val[FILT_TAIL]      = 1.0;
+            break;
+        }
+        break;
+    case(LPHP):
+        default_val[FLT_GAIN]           = FLT_DEFAULT_LOHI_ATTEN;
+        default_val[FLT_PRESCALE]       = FLT_DEFAULT_LPHP_PRESCALE;    /* as in orig prog */
+        switch(mode) {
+        case(FLT_HZ):
+            default_val[FLT_PASSFRQ]    = FLT_DEFAULT_LOHIPASS;
+            default_val[FLT_STOPFRQ]    = FLT_DEFAULT_LOHISTOP;
+            break;
+        case(FLT_MIDI):
+            default_val[FLT_PASSFRQ]    = FLT_DEFAULT_LOHIPASSMIDI;
+            default_val[FLT_STOPFRQ]    = FLT_DEFAULT_LOHISTOPMIDI;
+            break;
+        }
+//TW NEW PARAM
+        default_val[FILT_TAIL]      = 1.0;
+        break;
+    case(FSTATVAR):
+        default_val[FLT_Q]              = 1.0/FLT_DEFAULT_Q;    /* parameter is actually 1/Q */
+        default_val[FLT_GAIN]           = 1.0;
+        default_val[FLT_ONEFRQ]         = FLT_DEFAULT_FRQ;
+//TW NEW PARAM
+        default_val[FILT_TAIL]      = 1.0;
+        break;
+    case(FLTBANKN):
+        default_val[FLT_Q]              = FLT_DEFAULT_Q;
+        default_val[FLT_GAIN]           = 1.0;
+//TW NEW PARAM
+        default_val[FILT_TAIL]      = 1.0;
+        /* fall thro */
+    case(FLTBANKC):
+        default_val[FLT_LOFRQ]          = FLT_DEFAULT_LOFRQ;
+        default_val[FLT_HIFRQ]          = FLT_DEFAULT_HIFRQ;
+        switch(mode) {
+        case(FLT_LINOFFSET):
+            default_val[FLT_OFFSET]     = FLT_DEFAULT_OFFSET;
+            break;
+        case(FLT_EQUALSPAN):
+            default_val[FLT_INCOUNT]    = FLT_DEFAULT_INCOUNT;
+            break;
+        case(FLT_EQUALINT):
+            default_val[FLT_INTSIZE]    = FLT_DEFAULT_INTSIZE;
+            break;
+        }
+        default_val[FLT_RANDFACT]       = 0.0;
+        break;
+    case(FLTBANKU):     
+        default_val[FLT_Q]              = FLT_DEFAULT_Q;
+        default_val[FLT_GAIN]           = 1.0;
+//TW NEW PARAM
+        default_val[FILT_TAIL]          = 1.0;
+        break;
+    case(FLTBANKV):
+        default_val[FLT_Q]              = FLT_DEFAULT_Q;
+        default_val[FLT_GAIN]           = 1.0;
+        default_val[FLT_HARMCNT]        = FLT_DEFAULT_HCNT;
+        default_val[FLT_ROLLOFF]        = FLT_DEFAULT_ROLLOFF;
+        default_val[FILT_TAILV]         = 1.0;
+        break;
+    case(FLTBANKV2):
+        default_val[FLT_Q]              = FLT_DEFAULT_Q;
+        default_val[FLT_GAIN]           = 1.0;
+        default_val[FILT_TAILV]         = 1.0;
+        break;
+    case(FLTSWEEP):
+        default_val[FLT_Q]              = 1.0/FLT_DEFAULT_Q;
+        default_val[FLT_GAIN]           = 1.0; 
+        default_val[FLT_LOFRQ]          = FLT_DEFAULT_LOFRQ;
+        default_val[FLT_HIFRQ]          = FLT_DEFAULT_HIFRQ;
+        default_val[FLT_SWPFRQ]         = FLT_DEFAULT_SWPFRQ;
+        default_val[FLT_SWPPHASE]       = FLT_DEFAULT_SWPPHASE;
+//TW NEW PARAM
+        default_val[FILT_TAIL]          = 1.0;
+        break;
+    case(FLTITER):
+        default_val[FLT_Q]              = FLT_DEFAULT_Q;
+        default_val[FLT_GAIN]           = 1.0;
+        default_val[FLT_DELAY]          = FLT_DEFAULT_ITERDELAY;
+        default_val[FLT_OUTDUR]         = duration * 2.0;
+        default_val[FLT_PRESCALE]       = 0.0;
+        default_val[FLT_RANDDEL]        = 0.0;
+        default_val[FLT_PSHIFT]         = 0.0;
+        default_val[FLT_AMPSHIFT]       = 0.0;
+        break;
+    case(ALLPASS):      
+        default_val[FLT_GAIN]           = 1.0;
+        default_val[FLT_DELAY]          = FLT_DEFAULT_ALLPASSDELAY;
+        default_val[FLT_PRESCALE]       = 1.0;
+//TW NEW PARAM
+        default_val[FILT_TAIL]          = 1.0;
+        break;
+
+    case(MOD_LOUDNESS):
+        switch(mode) {
+        case(LOUDNESS_GAIN):
+            default_val[LOUD_GAIN]      = 1.0;
+            break;
+        case(LOUDNESS_DBGAIN):
+            default_val[LOUD_GAIN]      = 0.0;
+            break;
+        case(LOUDNESS_NORM):
+        case(LOUDNESS_SET):
+//TW NEW DEFAULT
+//          default_val[LOUD_LEVEL]     = 1.0;
+            default_val[LOUD_LEVEL]     = 0.9;
+            break;
+        }
+        break;
+
+    case(MOD_SPACE):
+        switch(mode) {
+        case(MOD_PAN):
+            default_val[PAN_PAN]        = 0.0;
+            default_val[PAN_PRESCALE]   = PAN_PRESCALE_DEFAULT;
+            break;
+        case(MOD_NARROW):
+            default_val[NARROW]         = 1.0;
+            break;
+        }
+        break;
+//TW NEW CASES
+        case(SCALED_PAN):
+        default_val[PAN_PAN]        = 0.0;
+        default_val[PAN_PRESCALE]   = PAN_PRESCALE_DEFAULT;
+        break;
+    case(FIND_PANPOS):
+        default_val[PAN_PAN]        = 0.0;
+        break;
+
+    case(MOD_PITCH):
+        switch(mode) {
+        case(MOD_TRANSPOS):
+        case(MOD_TRANSPOS_INFO):
+            default_val[VTRANS_TRANS]   = 1.0;
+            break;
+        case(MOD_TRANSPOS_SEMIT):
+        case(MOD_TRANSPOS_SEMIT_INFO):
+            default_val[VTRANS_TRANS]   = 0.0;
+            break;
+        case(MOD_ACCEL):
+            default_val[ACCEL_ACCEL]    = 1.0;
+// TW NEW DEFAULT
+//          default_val[ACCEL_GOALTIME] = 1.0;
+            default_val[ACCEL_GOALTIME] = min(1.0,duration);
+            default_val[ACCEL_STARTTIME]= 0.0;
+            break;
+        case(MOD_VIBRATO):
+            default_val[VIB_FRQ]        = DEFAULT_VIB_FRQ;
+            default_val[VIB_DEPTH]      = DEFAULT_VIB_DEPTH;
+            break;
+        }
+        break;
+    case(MOD_REVECHO):
+        switch(mode) {
+        case(MOD_STADIUM):
+            default_val[STAD_PREGAIN]   = STAD_PREGAIN_DFLT;
+            default_val[STAD_ROLLOFF]   = 1.0;
+            default_val[STAD_SIZE]      = 1.0;
+//TW NEW DEFAULT AFTER increasing number of possible echoes
+//          default_val[STAD_ECHOCNT]   = MAX_ECHOCNT;
+            default_val[STAD_ECHOCNT]   = REASONABLE_ECHOCNT;
+            break;
+        case(MOD_DELAY):
+        case(MOD_VDELAY):
+            default_val[DELAY_LFOMOD]   = 0.0;
+            default_val[DELAY_LFOFRQ]   = 0.0;
+            default_val[DELAY_LFOPHASE] = 0.0;
+            default_val[DELAY_LFODELAY] = 0.0;
+            default_val[DELAY_DELAY]    = DEFAULT_DELAY; /* milliseconds */
+            default_val[DELAY_MIX]      = 0.5;
+            default_val[DELAY_FEEDBACK] = 0.0;
+            default_val[DELAY_TRAILTIME]= 0.0;
+            default_val[DELAY_PRESCALE] = 1.0;
+            if(mode==MOD_VDELAY)
+                default_val[DELAY_SEED] = 0.0;
+            break;
+        }
+        break;
+    case(MOD_RADICAL):
+        switch(mode) {
+        case(MOD_REVERSE):  
+            break;
+        case(MOD_SHRED):
+            default_val[SHRED_CNT]      = 1.0;
+            default_val[SHRED_CHLEN]    = max((duration/8.0),((double)(SHRED_SPLICELEN * 3)/(double)srate));
+            default_val[SHRED_SCAT]     = 1.0;
+            break;
+        case(MOD_SCRUB):
+            default_val[SCRUB_TOTALDUR]     = duration;
+            default_val[SCRUB_MINSPEED]     = SCRUB_MINSPEED_DEFAULT;
+            default_val[SCRUB_MAXSPEED]     = SCRUB_MAXSPEED_DEFAULT;
+            default_val[SCRUB_STARTRANGE]   = 0.0;
+            default_val[SCRUB_ESTART]       = duration;
+            break;
+        case(MOD_LOBIT):
+            default_val[LOBIT_BRES]     = (double)MAX_BIT_DIV;
+            default_val[LOBIT_TSCAN]    = 1.0;
+            break;
+        case(MOD_LOBIT2):
+            default_val[LOBIT_BRES]     = (double)MAX_BIT_DIV;
+            break;
+        case(MOD_RINGMOD):
+            default_val[RM_FRQ]         = (double)MIDDLE_C_MIDI;
+            break;
+        case(MOD_CROSSMOD):
+            break;
+        }
+        break;
+    case(BRASSAGE):
+        default_val[GRS_VELOCITY]       = 1.0;
+        switch(mode) {
+        case(GRS_REVERB):
+            default_val[GRS_DENSITY]    = GRS_DEFAULT_REVERB_DENSITY;
+            break;
+        default:
+            default_val[GRS_DENSITY]    = GRS_DEFAULT_DENSITY;
+            break;
+        }
+        default_val[GRS_HVELOCITY]      = 1.0;
+        default_val[GRS_HDENSITY]       = GRS_DEFAULT_DENSITY;
+        default_val[GRS_GRAINSIZE]      = GRS_DEFAULT_GRAINSIZE;
+        default_val[GRS_PITCH]          = 0.0;
+        default_val[GRS_AMP]            = 1.0;
+        switch(mode) {
+        case(GRS_REVERB):
+            default_val[GRS_SPACE]      = 0.0;
+            break;
+        default:
+            default_val[GRS_SPACE]      = 0.5;
+            break;
+        }
+        default_val[GRS_BSPLICE]        = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_ESPLICE]        = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_HGRAINSIZE]     = GRS_DEFAULT_GRAINSIZE;
+        default_val[GRS_HPITCH]         = 0.0;
+        default_val[GRS_HAMP]           = 1.0;
+        switch(mode) {
+        case(GRS_REVERB):
+            default_val[GRS_HSPACE]     = 1.0;
+            break;
+        default:
+            default_val[GRS_HSPACE]     = 0.5;
+            break;
+        }
+        default_val[GRS_HBSPLICE]       = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_HESPLICE]       = GRS_DEFAULT_SPLICELEN;
+        switch(mode) {
+        case(GRS_BRASSAGE):
+        case(GRS_FULL_MONTY):
+            default_val[GRS_SCATTER]    = GRS_DEFAULT_SCATTER;
+            default_val[GRS_OUTLEN]     = 0.0;
+            default_val[GRS_CHAN_TO_XTRACT] = 0.0;
+            /* fall thro */
+        case(GRS_REVERB):
+        case(GRS_SCRAMBLE):
+            default_val[GRS_SRCHRANGE]  = 0.0;
+            break;
+        }
+        break;
+    case(SAUSAGE):
+        default_val[GRS_VELOCITY]       = 1.0;
+        default_val[GRS_DENSITY]        = GRS_DEFAULT_DENSITY;
+        default_val[GRS_HVELOCITY]      = 1.0;
+        default_val[GRS_HDENSITY]       = GRS_DEFAULT_DENSITY;
+        default_val[GRS_GRAINSIZE]      = GRS_DEFAULT_GRAINSIZE;
+        default_val[GRS_PITCH]          = 0.0;          
+        default_val[GRS_AMP]            = 1.0;
+        default_val[GRS_SPACE]          = 0.5;  
+        default_val[GRS_BSPLICE]        = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_ESPLICE]        = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_HGRAINSIZE]     = GRS_DEFAULT_GRAINSIZE;
+        default_val[GRS_HPITCH]         = 0.0;
+        default_val[GRS_HAMP]           = 1.0;
+        default_val[GRS_HSPACE]         = 0.5;
+        default_val[GRS_HBSPLICE]       = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_HESPLICE]       = GRS_DEFAULT_SPLICELEN;
+        default_val[GRS_SCATTER]        = GRS_DEFAULT_SCATTER;
+        default_val[GRS_OUTLEN]         = 0.0;
+        default_val[GRS_CHAN_TO_XTRACT] = 0.0;
+        default_val[GRS_SRCHRANGE]      = 0.0;
+        break;
+/* TEMPORARY TEST ROUTINE */
+    case(WORDCNT):
+        break;
+/* TEMPORARY TEST ROUTINE */
+
+
+    case(PVOC_ANAL):
+        default_val[PVOC_CHANS_INPUT]   = (double)DEFAULT_PVOC_CHANS;
+        default_val[PVOC_WINOVLP_INPUT] = (double)DEFAULT_WIN_OVERLAP;
+        break;
+    case(PVOC_SYNTH):
+        break;
+    case(PVOC_EXTRACT):
+        default_val[PVOC_CHANS_INPUT]   = (double)DEFAULT_PVOC_CHANS;
+        default_val[PVOC_WINOVLP_INPUT] = (double)DEFAULT_WIN_OVERLAP;
+        default_val[PVOC_CHANSLCT_INPUT]= 0.0;
+        default_val[PVOC_LOCHAN_INPUT]  = 0.0;
+        default_val[PVOC_HICHAN_INPUT]  = 0.0;
+        break;
+
+    case(EDIT_CUT):
+        default_val[CUT_CUT]            = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    default_val[CUT_END] = duration;                    break;
+        case(EDIT_SAMPS):   default_val[CUT_END] = (double)insams;              break;
+        case(EDIT_STSAMPS): default_val[CUT_END] = (double)(insams/channels);   break;
+        }
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        break;
+    case(EDIT_CUTEND):
+        default_val[CUT_CUT]            = 0.0;
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        break;
+    case(MANY_ZCUTS):
+        break;
+    case(EDIT_ZCUT):
+        default_val[CUT_CUT]            = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    default_val[CUT_END] = duration;                    break;
+        case(EDIT_SAMPS):   default_val[CUT_END] = (double)(insams);            break;
+        case(EDIT_STSAMPS): default_val[CUT_END] = (double)(insams/channels);   break;
+        }
+        break;
+    case(EDIT_EXCISE):
+        default_val[CUT_CUT]            = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    default_val[CUT_END] = duration;                    break;
+        case(EDIT_SAMPS):   default_val[CUT_END] = (double)(insams);            break;
+        case(EDIT_STSAMPS): default_val[CUT_END] = (double)(insams/channels);   break;
+        }
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        break;
+    case(EDIT_EXCISEMANY):
+    case(INSERTSIL_MANY):
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        break;
+    case(EDIT_INSERT):
+        default_val[CUT_CUT]            = 0.0;
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        default_val[INSERT_LEVEL]       = 1.0;
+        break;
+//TW NEW CASE
+    case(EDIT_INSERT2):
+        default_val[CUT_CUT]            = 0.0;
+        default_val[CUT_END]            = 0.0;
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        default_val[INSERT_LEVEL]       = 1.0;
+        break;
+
+    case(EDIT_INSERTSIL):
+        default_val[CUT_CUT]            = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    default_val[CUT_END] = duration;                    break;
+        case(EDIT_SAMPS):   default_val[CUT_END] = (double)(insams);            break;
+        case(EDIT_STSAMPS): default_val[CUT_END] = (double)(insams/channels);   break;
+        }
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        break;
+    case(JOIN_SEQ):
+        default_val[MAX_LEN]            = 32767;
+        /* fall thro */
+    case(EDIT_JOIN):
+    case(JOIN_SEQDYN):
+        default_val[CUT_SPLEN]          = EDIT_SPLICELEN;
+        break;
+    case(HOUSE_COPY):
+        switch(mode) {
+        case(COPYSF):   break;
+        case(DUPL):         default_val[COPY_CNT] = 1.0;                        break;
+        }
+        break;
+    case(HOUSE_DEL):
+        break;
+    case(HOUSE_CHANS):
+        switch(mode) {
+        case(HOUSE_CHANNEL):
+        case(HOUSE_ZCHANNEL):
+            default_val[CHAN_NO] = 1.0;
+            break;
+        case(HOUSE_CHANNELS):
+        case(STOM):
+        case(MTOS):
+            break;
+        }
+        break;
+    case(HOUSE_BUNDLE):
+        break;
+    case(HOUSE_SORT):
+        switch(mode) {
+        case(BY_DURATION):
+        case(BY_LOG_DUR):
+            default_val[SORT_SMALL] = SORT_SMALL_DEFAULT;
+            default_val[SORT_LARGE] = SORT_LARGE_DEFAULT;
+            if(mode==BY_DURATION)
+                default_val[SORT_STEP] = SORT_STEP_DEFAULT;
+            else
+                default_val[SORT_STEP] = SORT_LSTEP_DEFAULT;
+            break;
+        }
+        break;
+    case(HOUSE_SPEC):
+        switch(mode) {
+        case(HOUSE_REPROP):
+            default_val[HSPEC_CHANS] = (double)channels;
+            if(filetype==SNDFILE)
+                default_val[HSPEC_TYPE] = (double)SAMP_SHORT;
+            else
+            /*RWD what's going on here ? */
+                default_val[HSPEC_TYPE] = (double)SAMP_FLOAT;
+            /* fall thro */
+        case(HOUSE_RESAMPLE):
+            default_val[HSPEC_SRATE] = (double)srate;
+            break;
+        default:
+            break;
+        }
+        break;
+    case(HOUSE_EXTRACT):
+        switch(mode) {
+        case(HOUSE_CUTGATE):
+            default_val[CUTGATE_SPLEN]      = CUTGATE_SPLICELEN;
+            default_val[CUTGATE_SUSTAIN]    = 0.0;
+            /* fall thro */
+        case(HOUSE_ONSETS):
+            default_val[CUTGATE_GATE]       = 0.0;
+            default_val[CUTGATE_ENDGATE]    = 0.0;
+            default_val[CUTGATE_THRESH]     = 0.0;
+            default_val[CUTGATE_BAKTRAK]    = 0.0;
+            default_val[CUTGATE_INITLEVEL]  = 0.0;
+            default_val[CUTGATE_MINLEN]     = min(duration,2.0 * CUTGATE_SPLICELEN * MS_TO_SECS);
+            default_val[CUTGATE_WINDOWS] = 0.0;
+            break;
+        case(HOUSE_CUTGATE_PREVIEW):
+            break;
+        case(HOUSE_TOPNTAIL):
+            default_val[TOPN_GATE]   = 0.0;
+            default_val[TOPN_SPLEN]  = CUTGATE_SPLICELEN;
+            break;
+        case(HOUSE_RECTIFY):
+            default_val[RECTIFY_SHIFT] = 0.0;
+            break;
+        }
+        break;
+    case(TOPNTAIL_CLICKS):
+        default_val[TOPN_GATE]   = 0.0;
+        default_val[TOPN_SPLEN]  = TOPNTAIL_SPLICELEN;
+        break;
+    case(HOUSE_BAKUP):
+    case(HOUSE_GATE):
+        default_val[GATE_ZEROS]     = 4;
+        break;
+//UP TO HERE
+  case(HOUSE_DISK):
+        break;
+    case(INFO_PROPS):
+    case(INFO_SFLEN):
+    case(INFO_TIMELIST):
+    case(INFO_LOUDLIST):
+    case(INFO_TIMEDIFF):
+    case(INFO_LOUDCHAN):
+//TW    break;
+    case(INFO_MAXSAMP):
+        break;
+    case(INFO_MAXSAMP2):
+        default_val[MAX_STIME]  = 0.0;
+        default_val[MAX_ETIME]  = duration;
+        break;
+    case(INFO_TIMESUM):
+        default_val[TIMESUM_SPLEN]  = TIMESUM_DEFAULT_SPLEN;
+        break;  
+    case(INFO_SAMPTOTIME):
+        default_val[INFO_SAMPS]     = 0.0;
+        break;
+    case(INFO_TIMETOSAMP):
+        default_val[INFO_TIME]      = 0.0;
+        break;
+    case(INFO_FINDHOLE):
+        default_val[HOLE_THRESH]    = 0.0;
+        break;  
+    case(INFO_DIFF):
+    case(INFO_CDIFF):
+        default_val[SFDIFF_THRESH]  = 0.0;
+        default_val[SFDIFF_CNT]     = 1.0;
+        break;  
+    case(INFO_PRNTSND):
+        default_val[PRNT_START]     = 0.0;
+        default_val[PRNT_END]       = duration;
+        break;  
+    case(INFO_MUSUNITS):
+        switch(mode) {
+        case(MU_MIDI_TO_FRQ):
+        case(MU_MIDI_TO_NOTE):
+            default_val[0]  = MIDDLE_C_MIDI;
+            break;
+        case(MU_FRQ_TO_MIDI):
+        case(MU_FRQ_TO_NOTE):
+            default_val[0]  = CONCERT_A;
+            break;
+        case(MU_FRQRATIO_TO_SEMIT):
+        case(MU_FRQRATIO_TO_INTVL):
+        case(MU_FRQRATIO_TO_OCTS):
+        case(MU_FRQRATIO_TO_TSTRETH):
+            default_val[0]  = 2.0;
+            break;
+        case(MU_SEMIT_TO_FRQRATIO):
+        case(MU_SEMIT_TO_OCTS):
+        case(MU_SEMIT_TO_INTVL):
+        case(MU_SEMIT_TO_TSTRETCH):
+            default_val[0]  = 12.0;
+            break;
+        case(MU_OCTS_TO_FRQRATIO):
+        case(MU_OCTS_TO_SEMIT):
+        case(MU_OCTS_TO_TSTRETCH):
+            default_val[0]  = 1.0;
+            break;
+        case(MU_TSTRETCH_TO_FRQRATIO):
+        case(MU_TSTRETCH_TO_SEMIT):
+        case(MU_TSTRETCH_TO_OCTS):
+        case(MU_TSTRETCH_TO_INTVL):
+            default_val[0]  = 1.0;
+            break;
+        case(MU_GAIN_TO_DB):
+            default_val[0]  = 1.0;
+            break;
+        case(MU_DB_TO_GAIN):
+            default_val[0]  = 0.0;
+            break;
+        case(MU_NOTE_TO_FRQ):
+        case(MU_NOTE_TO_MIDI):
+        case(MU_INTVL_TO_FRQRATIO):
+        case(MU_INTVL_TO_TSTRETCH):
+            break;
+/*** NOW OPERATES THRO THE MUSIC CALCULATOR ***/
+        }
+        break;
+    case(SYNTH_WAVE):
+        default_val[SYN_TABSIZE]= (double)WAVE_TABSIZE;
+        default_val[SYN_FRQ]    = CONCERT_A;
+        /* fall thro */
+    case(SYNTH_NOISE):
+        default_val[SYN_AMP]    = 1.0;
+        /* fall thro */
+    case(SYNTH_SIL):
+        default_val[SYN_SRATE]  = (double)WAVE_DEFAULT_SR;
+        default_val[SYN_CHANS]  = 1;
+        default_val[SYN_DUR]    = 1.0;
+        break;
+    case(MULTI_SYN):
+        default_val[SYN_TABSIZE]= (WAVE_TABSIZE * 16);
+        default_val[SYN_AMP]    = 0.3;
+        default_val[SYN_SRATE]  = (double)WAVE_DEFAULT_SR;
+        default_val[SYN_CHANS]  = 1;
+        default_val[SYN_DUR]    = 4.0;
+        break;
+    case(SYNTH_SPEC):
+        default_val[SS_DUR]      = 1.0;
+        default_val[SS_CENTRFRQ] = CONCERT_A;
+        default_val[SS_SPREAD]   = 0.0;
+        default_val[SS_FOCUS]    = 1.0;
+        default_val[SS_FOCUS2]   = 1.0;
+        default_val[SS_TRAND]    = 0.0;
+        default_val[SS_SRATE]    = 44100;
+        break;
+    case(RANDCUTS):
+        default_val[RC_CHLEN]  = max((duration/8.0),((double)(SHRED_SPLICELEN * channels * 3)/(double)srate));
+        default_val[RC_SCAT]   = 1.0;
+        break;
+    case(RANDCHUNKS):
+        default_val[CHUNKCNT]  = 2;
+        default_val[MINCHUNK]  = MINOUTDUR;
+        default_val[MAXCHUNK]  = duration;
+        break;
+    case(TWIXT):
+    case(SPHINX):
+        default_val[IS_SPLEN]  = 2.7;
+        default_val[IS_WEIGHT] = 1;
+        default_val[IS_SEGCNT] = 1;
+        break;
+//TW NEW CASES
+    case(EDIT_CUTMANY):
+        default_val[CM_SPLICELEN] = EDIT_SPLICELEN;
+        break;
+    case(STACK):
+        default_val[STACK_CNT]    = 3;
+        default_val[STACK_LEAN]   = 1.0;
+        default_val[STACK_OFFSET] = 0.0;
+        default_val[STACK_GAIN]   = 1.0;
+        default_val[STACK_DUR]    = 1.0;
+        break;
+
+    case(SIN_TAB):
+        default_val[SIN_FRQ]   = 1.0;
+        default_val[SIN_AMP]   = 1;
+        default_val[SIN_DUR]   = 10;
+        default_val[SIN_QUANT] = .01;
+        default_val[SIN_PHASE] = 0;
+        break;
+    case(ACC_STREAM):
+        default_val[ACC_ATTEN] = 1.0;
+        break;
+    case(HF_PERM1):
+    case(HF_PERM2):
+        default_val[HP1_SRATE]    = 44100;
+        default_val[HP1_ELEMENT_SIZE] = 1.0;
+        default_val[HP1_GAP_SIZE] = 1.0;
+        default_val[HP1_GGAP_SIZE]= 1.0;
+        default_val[HP1_MINSET]   = 1.0;
+        default_val[HP1_BOTNOTE]  = 0.0;
+        default_val[HP1_BOTOCT]   = 0.0;
+        default_val[HP1_TOPNOTE]  = 0.0;
+        default_val[HP1_TOPOCT]   = 1.0;
+        default_val[HP1_SORT1]    = 0;
+        break;
+    case(DEL_PERM):
+        default_val[DP_SRATE]  = 44100;
+        default_val[DP_DUR]    = 1.0;
+        default_val[DP_CYCCNT] = 4;
+        break;
+    case(DEL_PERM2):
+        default_val[DP_CYCCNT] = 4;
+        break;
+//TW NEW CASES
+    case(NOISE_SUPRESS):
+        default_val[NOISE_SPLEN] = 2.0;
+        default_val[NOISE_MINFRQ] = 6000.0;
+        default_val[MIN_NOISLEN] = 0.0;
+        default_val[MIN_TONELEN] = 15.0;
+        break;
+    case(TIME_GRID):
+        default_val[GRID_COUNT]  = 4.0;
+        default_val[GRID_WIDTH]  = 0.1;
+        default_val[GRID_SPLEN]  = 3.0;
+        break;
+    case(SEQUENCER2):
+        default_val[SEQ_SPLIC]  = 2.0;
+        /* fall thro */
+    case(SEQUENCER):
+        default_val[SEQ_ATTEN]  = 1.0;
+        break;
+    case(CONVOLVE):
+        if(mode==CONV_TVAR)
+            default_val[CONV_TRANS]  = 0.0;
+        break;
+    case(BAKTOBAK):
+        default_val[BTOB_CUT]    = .015;
+        default_val[BTOB_SPLEN]  = 15.0;
+        break;
+    case(CLICK):
+        if(mode == CLICK_BY_LINE) {
+            default_val[CLIKSTART]  = 1.0;
+        } else {
+            default_val[CLIKSTART]  = 0.0;
+        }
+        default_val[CLIKOFSET]  = 1.0;
+        default_val[CLIKEND]  = 32767.0;
+        break;
+    case(DOUBLETS):
+        default_val[SEG_DUR]    = 0.1;
+        default_val[SEG_REPETS] = 2.0;
+        break;
+    case(SYLLABS):
+        default_val[SYLLAB_DOVETAIL]    = 5.0;
+        default_val[SYLLAB_SPLICELEN]   = 2.0;
+        break;
+    case(MAKE_VFILT):
+    case(MIX_MODEL):
+        break;
+    case(BATCH_EXPAND):
+        default_val[BE_INFILE]   = 1;
+        default_val[BE_OUTFILE]  = 1;
+        default_val[BE_PARAM]    = 1;
+        break;
+    case(ENVSYN):
+        default_val[ENVSYN_WSIZE]       = 50.0;
+        default_val[ENVSYN_DUR]         = 60.0;
+        default_val[ENVSYN_CYCLEN]      = 1.0;
+        default_val[ENVSYN_STARTPHASE]  = 0.0;
+        if(mode != ENVSYN_USERDEF) {
+            default_val[ENVSYN_TROF]        = 0.0;
+            default_val[ENVSYN_EXPON]       = 1.0;
+        }
+        break;
+    case(HOUSE_GATE2):
+        default_val[GATE2_DUR]      = 20.0;
+        default_val[GATE2_ZEROS]    = 4.0;
+        default_val[GATE2_LEVEL]    = 0.0;
+        default_val[GATE2_SPLEN]    = 2.0;
+        default_val[GATE2_FILT]     = 2.0;
+        break;
+    case(GRAIN_ASSESS):
+        break;
+    case(ZCROSS_RATIO):
+        default_val[ZC_START]   = 0.0;
+        default_val[ZC_END]     = duration;
+        break;
+    case(GREV):
+        default_val[GREV_WSIZE]      = 5;
+        default_val[GREV_TROFRAC]    = .2;
+        default_val[GREV_GPCNT]      = 1.0;
+        switch(mode) {
+        case(GREV_TSTRETCH):
+            default_val[GREV_TSTR]   = 2.0;
+            break;
+        case(GREV_DELETE):
+        case(GREV_OMIT):
+            default_val[GREV_KEEP]   = 63;
+            default_val[GREV_OUTOF]  = 64;
+            break;
+        case(GREV_REPEAT):
+            default_val[GREV_REPETS] = 2;
+            break;
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown case: initialise_param_values()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/**********************************************************************************/
+/*********************** ITEMS FORMERLY IN FORMTYPE.C tklib2 **********************/
+/**********************************************************************************/
+
+/**************************** DEAL_WITH_FORMANTS *************************/
+
+int deal_with_formants(int process,int mode,int channels,aplptr ap)
+{
+    int exit_status;
+    set_formant_flags(process,mode,ap);
+    if(ap->formant_flag) {
+        if((exit_status = establish_formant_band_ranges(channels,ap))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/**************************** SET_FORMANT_FLAGS *************************/
+
+void set_formant_flags(int process,int mode,aplptr ap)
+{
+    switch(process) {
+    case(CHORD):    ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(FOCUS):    ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(FORMANTS): ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(FORMSEE):  ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(GLIS):     ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(REPORT):   ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(SPREAD):   ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(TRNSF):    ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(VOCODE):   ap->formant_qksrch = TRUE;  ap->formant_flag = TRUE;    break;
+    case(FORM):     ap->formant_qksrch = TRUE;                              break;
+    case(OCT):      ap->formant_qksrch = TRUE;                              break;
+    }
+}
+
+/**************************** ESTABLISH_FORMANT_BAND_RANGE *************************/
+
+int establish_formant_band_ranges(int channels,aplptr ap)
+{
+    int clength = channels/2;
+    int clength_less_one = clength - 1;
+    if(clength_less_one < 0) {
+        sprintf(errstr,"Invalid call to process formants: establish_formant_band_ranges()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(clength_less_one < LOW_OCTAVE_BANDS) {
+        fprintf(stdout,"WARNING: Too few analysis channels for pitchwise formant extraction.\n");
+        fflush(stdout);
+        ap->no_pichwise_formants = TRUE;
+    } else
+        ap->max_pichwise_fbands = MAX_BANDS_PER_OCT;
+    ap->max_freqwise_fbands = (clength_less_one)/2;
+    return(FINISHED);
+}
+
+/**********************************************************************************/
+/*********************** ITEMS FORMERLY IN INTYPE.C tklib2 ************************/
+/**********************************************************************************/
+
+// TW assign_input_process_type REMOVED: REDUNDANT
+
+/******************************* DOES_PROCESS_ACCEPT_CONFLICTING_SRATES *******************************/
+
+int does_process_accept_conflicting_srates(int process)
+{
+    if(process==GRAIN_ALIGN
+    || process==ENV_IMPOSE
+//TW NEW CASE
+    || process==ENV_PROPOR
+    || process==ENV_REPLACE)
+        return(TRUE);
+    return(FALSE);
+}
+
+/**********************************************************************************/
+/*********************** ITEMS FORMERLY IN MAXMODE.C tklib2 ***********************/
+/**********************************************************************************/
+
+/************************************ GET_MAXMODE ************************************/
+
+int get_maxmode(int process)
+{
+    int maxmode;
+    switch(process) {
+    case(ACCU):             maxmode = 0;    break;
+    case(ALT):              maxmode = 2;    break;
+    case(ARPE):             maxmode = 8;    break;
+    case(AVRG):             maxmode = 0;    break;
+    case(BARE):             maxmode = 0;    break;
+    case(BLTR):             maxmode = 0;    break;
+    case(BLUR):             maxmode = 0;    break;
+    case(BRIDGE):           maxmode = 6;    break;
+    case(CHANNEL):          maxmode = 0;    break;
+    case(CHORD):            maxmode = 0;    break;
+    case(CHORUS):           maxmode = 7;    break;
+    case(CLEAN):            maxmode = 4;    break;
+    case(CROSS):            maxmode = 0;    break;
+    case(CUT):              maxmode = 0;    break;
+    case(DIFF):             maxmode = 0;    break;
+    case(DRUNK):            maxmode = 0;    break;
+    case(EXAG):             maxmode = 0;    break;
+    case(FILT):             maxmode = 12;   break;
+    case(FMNTSEE):          maxmode = 0;    break;
+    case(FOCUS):            maxmode = 0;    break;
+    case(FOLD):             maxmode = 0;    break;
+    case(FORM):             maxmode = 2;    break;
+    case(FORMANTS):         maxmode = 0;    break;
+    case(FORMSEE):          maxmode = 0;    break;
+    case(FREEZE):           maxmode = 3;    break;
+    case(FREEZE2):          maxmode = 0;    break;
+    case(FREQUENCY):        maxmode = 0;    break;
+    case(GAIN):             maxmode = 0;    break;
+    case(GLIDE):            maxmode = 0;    break;
+    case(GLIS):             maxmode = 3;    break;
+    case(GRAB):             maxmode = 0;    break;
+    case(GREQ):             maxmode = 2;    break;
+    case(INVERT):           maxmode = 2;    break;
+    case(LEAF):             maxmode = 0;    break;
+    case(LEVEL):            maxmode = 0;    break;
+    case(MAGNIFY):          maxmode = 0;    break;
+    case(MAKE):             maxmode = 0;    break;
+    case(MAX):              maxmode = 0;    break;
+    case(MEAN):             maxmode = 8;    break;
+    case(MORPH):            maxmode = 2;    break;
+    case(NOISE):            maxmode = 0;    break;
+    case(OCT):              maxmode = 3;    break;
+    case(OCTVU):            maxmode = 0;    break;
+    case(P_APPROX):         maxmode = 2;    break;
+    case(P_CUT):            maxmode = 3;    break;
+    case(P_EXAG):           maxmode = 6;    break;
+    case(P_FIX):            maxmode = 0;    break;
+    case(P_HEAR):           maxmode = 0;    break;
+    case(P_INFO):           maxmode = 0;    break;
+    case(P_INVERT):         maxmode = 2;    break;
+    case(P_QUANTISE):       maxmode = 2;    break;
+    case(P_RANDOMISE):      maxmode = 2;    break;
+    case(P_SEE):            maxmode = 2;    break;
+//TW NEW CASES
+    case(P_INSERT):         maxmode = 2;    break;
+    case(P_SINSERT):        maxmode = 2;    break;
+    case(P_PTOSIL):         maxmode = 0;    break;
+    case(P_NTOSIL):         maxmode = 0;    break;
+    case(P_SYNTH):          maxmode = 0;    break;
+    case(P_VOWELS):         maxmode = 0;    break;
+    case(VFILT):            maxmode = 0;    break;
+    case(P_GEN):            maxmode = 0;    break;
+    case(ANALENV):          maxmode = 0;    break;
+    case(P_BINTOBRK):       maxmode = 0;    break;
+    case(MAKE2):            maxmode = 0;    break;
+    case(P_INTERP):         maxmode = 2;    break;
+
+    case(P_SMOOTH):         maxmode = 2;    break;
+    case(P_TRANSPOSE):      maxmode = 0;    break;
+    case(P_VIBRATO):        maxmode = 2;    break;
+    case(P_WRITE):          maxmode = 0;    break;
+    case(P_ZEROS):          maxmode = 0;    break;
+    case(PEAK):             maxmode = 0;    break;
+    case(PICK):             maxmode = 5;    break;
+    case(PITCH):            maxmode = 2;    break;
+    case(PLUCK):            maxmode = 0;    break;
+    case(PRINT):            maxmode = 0;    break;
+    case(REPITCH):          maxmode = 3;    break;
+    case(REPITCHB):         maxmode = 3;    break;
+    case(REPORT):           maxmode = 4;    break;
+    case(SCAT):             maxmode = 0;    break;
+    case(SHIFT):            maxmode = 5;    break;
+    case(SHIFTP):           maxmode = 6;    break;
+    case(SHUFFLE):          maxmode = 0;    break;
+    case(SPLIT):            maxmode = 0;    break;
+    case(SPREAD):           maxmode = 0;    break;
+    case(STEP):             maxmode = 0;    break;
+    case(STRETCH):          maxmode = 2;    break;
+    case(SUM):              maxmode = 0;    break;
+    case(SUPR):             maxmode = 0;    break;
+    case(S_TRACE):          maxmode = 4;    break;
+    case(TRACK):            maxmode = 2;    break;
+    case(TRNSF):            maxmode = 4;    break;
+    case(TRNSP):            maxmode = 4;    break;
+    case(TSTRETCH):         maxmode = 2;    break;
+    case(TUNE):             maxmode = 2;    break;
+    case(VOCODE):           maxmode = 0;    break;
+    case(WARP):             maxmode = 0;    break;
+    case(WAVER):            maxmode = 2;    break;
+    case(WEAVE):            maxmode = 0;    break;
+    case(WINDOWCNT):        maxmode = 0;    break;
+    case(LIMIT):            maxmode = 0;    break;
+    case(MULTRANS):         maxmode = 0;    break;
+
+    case(DISTORT):          maxmode = 8;    break;
+    case(DISTORT_ENV):      maxmode = 4;    break;
+    case(DISTORT_AVG):      maxmode = 0;    break;
+    case(DISTORT_OMT):      maxmode = 0;    break;
+    case(DISTORT_MLT):      maxmode = 0;    break;
+    case(DISTORT_DIV):      maxmode = 0;    break;
+    case(DISTORT_HRM):      maxmode = 0;    break;
+    case(DISTORT_FRC):      maxmode = 0;    break;
+    case(DISTORT_REV):      maxmode = 0;    break;
+    case(DISTORT_SHUF):     maxmode = 0;    break;
+    case(DISTORT_RPTFL):
+    case(DISTORT_RPT2):
+    case(DISTORT_RPT):      maxmode = 0;    break;
+    case(DISTORT_INTP):     maxmode = 0;    break;
+    case(DISTORT_DEL):      maxmode = 3;    break;
+    case(DISTORT_RPL):      maxmode = 0;    break;
+    case(DISTORT_TEL):      maxmode = 0;    break;
+    case(DISTORT_FLT):      maxmode = 3;    break;
+    case(DISTORT_INT):      maxmode = 2;    break;
+    case(DISTORT_CYCLECNT): maxmode = 0;    break;
+    case(DISTORT_PCH):      maxmode = 0;    break;
+    case(DISTORT_OVERLOAD): maxmode = 2;    break;
+//TW NEW CASE
+    case(DISTORT_PULSED):   maxmode = 3;    break;
+
+    case(ZIGZAG):           maxmode = 2;    break;
+    case(LOOP):             maxmode = 3;    break;
+    case(SCRAMBLE):         maxmode = 2;    break;
+    case(ITERATE):          maxmode = 2;    break;
+    case(ITERATE_EXTEND):   maxmode = 2;    break;
+    case(DRUNKWALK):        maxmode = 2;    break;
+
+    case(SIMPLE_TEX):   case(TIMED):
+    case(DECORATED):case(PREDECOR): case(POSTDECOR):
+    case(ORNATE):   case(PREORNATE):case(POSTORNATE):
+    case(MOTIFS):   case(TMOTIFS):
+    case(GROUPS):   case(TGROUPS):
+                            maxmode = 5;    break;
+    case(MOTIFSIN):
+    case(TMOTIFSIN):        maxmode = 4;    break;
+
+    case(GRAIN_REPITCH):
+    case(GRAIN_RERHYTHM):
+    case(GRAIN_REMOTIF):    maxmode = 2;    break;
+
+    case(GRAIN_COUNT):      case(GRAIN_OMIT):       case(GRAIN_TIMEWARP):
+    case(GRAIN_GET):        case(GRAIN_DUPLICATE):  case(GRAIN_ALIGN):
+    case(GRAIN_POSITION):   case(GRAIN_REORDER):    case(GRAIN_REVERSE):
+                            maxmode = 0;    break;
+    case(RRRR_EXTEND):      maxmode = 3;    break;
+    case(SSSS_EXTEND):      maxmode = 0;    break;
+    case(ENV_CREATE):   case(ENV_EXTRACT):
+                            maxmode = 2;    break;
+    case(ENV_IMPOSE):   case(ENV_REPLACE):
+                            maxmode = 4;    break;
+    case(ENV_WARPING):  case(ENV_RESHAPING): case(ENV_REPLOTTING):
+                            maxmode = 16;   break;
+    case(ENV_CURTAILING):
+                            maxmode = 6;    break;
+    case(ENV_BRKTOENV):   case(ENV_ENVTOBRK):   case(ENV_ENVTODBBRK):
+    case(ENV_DBBRKTOENV): case(ENV_DBBRKTOBRK): case(ENV_BRKTODBBRK):
+//TW NEW CASE
+//  case(ENV_SWELL):      case(ENV_PLUCK):
+    case(ENV_SWELL):      case(ENV_PLUCK):      case(ENV_PROPOR):
+                            maxmode = 0;    break;
+
+    case(ENV_DOVETAILING):  maxmode = 2;    break;
+    case(ENV_TREMOL):       maxmode = 2;    break;
+    case(ENV_ATTACK):       maxmode = 4;    break;
+
+    case(MIX):
+    case(MIXTEST):
+    case(MIXFORMAT):
+    case(MIXGAIN):          maxmode = 0;    break;
+    case(MIXDUMMY):         maxmode = 3;    break;
+    case(MIXTWO):           maxmode = 0;    break;
+//TW NEW CASE
+    case(MIXMANY):          maxmode = 0;    break;
+    case(MIXBALANCE):       maxmode = 0;    break;
+
+    case(MIXCROSS):         maxmode = 2;    break;
+    case(MIXINTERL):        maxmode = 0;    break;
+    case(MIXINBETWEEN):     maxmode = 2;    break;
+    case(CYCINBETWEEN):     maxmode = 0;    break;
+    case(MIXSYNC):          maxmode = 3;    break;
+    case(MIXSYNCATT):       maxmode = 0;    break;
+    case(MIXMAX):           maxmode = 3;    break;
+    case(MIXTWARP):         maxmode = 16;   break;
+    case(MIXSWARP):         maxmode = 8;    break;
+    case(MIXSHUFL):         maxmode = 7;    break;
+//TW NEW CASES
+    case(MIX_ON_GRID):      maxmode = 0;    break;
+    case(AUTOMIX):          maxmode = 0;    break;
+    case(MIX_PAN):          maxmode = 0;    break;
+    case(MIX_AT_STEP):      maxmode = 0;    break;
+    case(ADDTOMIX):         maxmode = 0;    break;
+
+    case(EQ):               maxmode = 3;    break;
+    case(LPHP):             maxmode = 2;    break;
+    case(FSTATVAR):         maxmode = 4;    break;
+    case(FLTBANKN):         maxmode = 6;    break;
+    case(FLTBANKC):         maxmode = 6;    break;
+    case(FLTBANKU):         maxmode = 2;    break;
+    case(FLTBANKV):         maxmode = 2;    break;
+    case(FLTBANKV2):        maxmode = 2;    break;
+    case(FLTITER):          maxmode = 2;    break;
+    case(FLTSWEEP):         maxmode = 4;    break;
+    case(ALLPASS):          maxmode = 2;    break;
+
+    case(MOD_LOUDNESS):     maxmode = 12;   break;
+    case(MOD_SPACE):        maxmode = 4;    break;
+//TW NEW CASES
+    case(SCALED_PAN):       maxmode = 0;    break;
+    case(FIND_PANPOS):      maxmode = 0;    break;
+
+    case(MOD_PITCH):        maxmode = 6;    break;
+    case(MOD_REVECHO):      maxmode = 3;    break;
+    case(MOD_RADICAL):      maxmode = 7;    break;  
+    case(BRASSAGE):         maxmode = 7;    break;
+    case(SAUSAGE):          maxmode = 0;    break;
+
+    case(PVOC_ANAL):        maxmode = 3;    break;
+    case(PVOC_SYNTH):       maxmode = 0;    break;
+    case(PVOC_EXTRACT):     maxmode = 0;    break;
+
+    case(WORDCNT):          maxmode = 0;    break;
+
+    case(EDIT_CUT):         maxmode = 3;    break;
+    case(EDIT_CUTEND):      maxmode = 3;    break;
+    case(EDIT_ZCUT):        maxmode = 2;    break;
+    case(MANY_ZCUTS):       maxmode = 2;    break;
+    case(EDIT_EXCISE):      maxmode = 3;    break;
+    case(EDIT_EXCISEMANY):  maxmode = 3;    break;
+    case(INSERTSIL_MANY):   maxmode = 3;    break;
+    case(EDIT_INSERT):      maxmode = 3;    break;
+//TW NEW CASE
+    case(EDIT_INSERT2):     maxmode = 3;    break;
+    case(EDIT_INSERTSIL):   maxmode = 3;    break;
+    case(EDIT_JOIN):
+    case(JOIN_SEQDYN):
+    case(JOIN_SEQ):         maxmode = 0;    break;
+
+    case(HOUSE_COPY):       maxmode = 2;    break;
+    case(HOUSE_DEL):        maxmode = 0;    break;
+    case(HOUSE_CHANS):      maxmode = 5;    break;
+//TW NEW CASES REPLACING BRACKETED-OUT CODE (Dump & Recover abandoned)
+    case(HOUSE_BAKUP):      maxmode = 0;    break;
+    case(HOUSE_GATE):
+
+    case(HOUSE_BUNDLE):     maxmode = 5;    break;
+    case(HOUSE_SORT):       maxmode = 6;    break;
+    case(HOUSE_SPEC):       maxmode = 3;    break;
+    case(HOUSE_EXTRACT):    maxmode = 6;    break;
+    case(TOPNTAIL_CLICKS):  maxmode = 0;    break;
+    case(HOUSE_DISK):       maxmode = 0;    break;
+
+    case(INFO_PROPS):       maxmode = 0;    break;
+    case(INFO_SFLEN):       maxmode = 0;    break;
+    case(INFO_TIMELIST):    maxmode = 0;    break;
+    case(INFO_LOUDLIST):    maxmode = 0;    break;
+    case(INFO_TIMESUM):     maxmode = 0;    break;
+    case(INFO_TIMEDIFF):    maxmode = 0;    break;
+    case(INFO_SAMPTOTIME):  maxmode = 0;    break;
+    case(INFO_TIMETOSAMP):  maxmode = 0;    break;
+    case(INFO_MAXSAMP):     maxmode = 0;    break;
+    case(INFO_MAXSAMP2):    maxmode = 0;    break;
+    case(INFO_LOUDCHAN):    maxmode = 0;    break;
+    case(INFO_FINDHOLE):    maxmode = 0;    break;
+    case(INFO_DIFF):        maxmode = 0;    break;
+    case(INFO_CDIFF):       maxmode = 0;    break;
+    case(INFO_PRNTSND):     maxmode = 0;    break;
+    case(INFO_MUSUNITS):    maxmode = 31;   break;
+
+    case(SYNTH_WAVE):       maxmode = 4;    break;
+    case(MULTI_SYN):        maxmode = 3;    break;
+    case(SYNTH_NOISE):      maxmode = 0;    break;
+    case(SYNTH_SIL):        maxmode = 0;    break;
+    case(SYNTH_SPEC):       maxmode = 0;    break;
+
+    case(RANDCUTS):         maxmode = 0;    break;
+    case(RANDCHUNKS):       maxmode = 0;    break;
+    case(SIN_TAB):          maxmode = 0;    break;
+    case(ACC_STREAM):       maxmode = 0;    break;
+
+    case(HF_PERM1):         maxmode = 4;    break;
+    case(HF_PERM2):         maxmode = 4;    break;
+    case(DEL_PERM):         maxmode = 0;    break;
+    case(DEL_PERM2):        maxmode = 0;    break;
+    case(TWIXT):            maxmode = 4;    break;
+    case(SPHINX):           maxmode = 3;    break;
+//TW NEW CASES
+    case(EDIT_CUTMANY):     maxmode = 3;    break;
+    case(STACK):            maxmode = 0;    break;
+    case(SHUDDER):          maxmode = 0;    break;
+    case(NOISE_SUPRESS):    maxmode = 0;    break;
+    case(TIME_GRID):        maxmode = 0;    break;
+    case(SEQUENCER2):
+    case(SEQUENCER):        maxmode = 0;    break;
+    case(CONVOLVE):         maxmode = 2;    break;
+    case(BAKTOBAK):         maxmode = 0;    break;
+    case(CLICK):            maxmode = 2;    break;
+    case(DOUBLETS):         maxmode = 0;    break;
+    case(SYLLABS):          maxmode = 3;    break;
+    case(MAKE_VFILT):       maxmode = 0;    break;
+    case(MIX_MODEL):        maxmode = 0;    break;
+    case(BATCH_EXPAND):     maxmode = 2;    break;
+    case(ENVSYN):           maxmode = 4;    break;
+    case(HOUSE_GATE2):      maxmode = 0;    break;
+    case(GRAIN_ASSESS):     maxmode = 0;    break;
+    case(ZCROSS_RATIO):     maxmode = 0;    break;
+    case(GREV):             maxmode = 7;    break;
+    default:
+        sprintf(errstr,"Unknown case [%d] in get_maxmode()\n",process);
+        return(-1);
+    }
+    return(maxmode);
+}
+
+/**********************************************************************************/
+/*********************** ITEMS FORMERLY IN RANGES.C tklib2 ************************/
+/**********************************************************************************/
+
+/****************************** GET_PARAM_RANGES *********************************/
+
+int get_param_ranges
+(int process,int mode,int total_params,double nyquist,float frametime,float arate,int srate,
+int wlength,int insams,int channels,int wanted,
+int filetype,int linecnt,double duration,aplptr ap)
+{
+    int exit_status;
+    if((exit_status = setup_input_param_range_stores(total_params,ap))<0)
+        return(exit_status);
+    return set_param_ranges(process,mode,nyquist,frametime,arate,srate,wlength,
+                            insams,channels,wanted,filetype,linecnt,duration,ap);
+}       
+    
+/****************************** SETUP_INPUT_PARAM_RANGE_STORES *********************************/
+
+int setup_input_param_range_stores(int total_params,aplptr ap)
+{
+    if((ap->lo = (double *)malloc((total_params) * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY: range lo limits\n");
+        return(MEMORY_ERROR);
+    }
+    if((ap->hi = (double *)malloc((total_params) * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY: range hi limits\n");
+        return(MEMORY_ERROR);
+    }
+    return FINISHED;  /*RWD 9:2001 */
+}
+
+
+/****************************** SET_PARAM_RANGES *********************************/
+/*RWD we ignore infilesize and use insams */
+int set_param_ranges
+(int process,int mode,double nyquist,float frametime,float arate,int srate,
+int wlength,int insams,int channels,int wanted,
+int filetype,int linecnt,double duration,aplptr ap)
+{
+    int    n;
+    double infilesize_in_samps = 0.0;
+    int    clength     = (int)(wanted/2);
+    double chwidth     = nyquist/(double)(clength-1);
+    double halfchwidth = chwidth/2.0;
+    double sr          = (double)srate;
+
+    switch(filetype) {
+    case(SNDFILE):  
+        infilesize_in_samps = (double)(insams/channels);    break;
+    case(ENVFILE):
+//TW THIS NOW SEEMS BOTH CRAZY and (fortunately) REDUNDANT !!!
+        infilesize_in_samps = duration;                     break;
+    }
+    switch(process) {
+    case(ACCU):
+            /* variants */
+        ap->lo[ACCU_DINDEX] = ACCU_MIN_DECAY;
+        ap->hi[ACCU_DINDEX] = 1.0;
+        ap->lo[ACCU_GINDEX] = -MAXGLISRATE/frametime; /* 1/16th octaves per window : guess!! */
+        ap->hi[ACCU_GINDEX] = MAXGLISRATE/frametime;  /*     converted to 8vas per second    */
+        break;
+    case(ALT):
+        break;
+    case(ARPE):
+            /* params */
+        switch(mode) {
+        case(ABOVE_BOOST):
+        case(ONCE_ABOVE):
+            ap->lo[ARPE_WTYPE]  = (double)(DOWNRAMP);   /* 1 */
+            ap->hi[ARPE_WTYPE]  = (double)(SAW);        /* 3 */ /* i.e. NOT upramp */
+            break;
+        case(BELOW_BOOST):    
+        case(ONCE_BELOW):     
+            ap->lo[ARPE_WTYPE]  = (double)(SIN);        /* 2 */ /* i.e. NOT downramp */
+            ap->hi[ARPE_WTYPE]  = (double)(UPRAMP);     /* 4 */
+            break;
+        default:
+            ap->lo[ARPE_WTYPE]  = (double)(DOWNRAMP);   /* 1 */
+            ap->hi[ARPE_WTYPE]  = (double)(UPRAMP);     /* 4 */
+            break;
+        }
+        ap->lo[ARPE_ARPFRQ]     = 0.0;
+        ap->hi[ARPE_ARPFRQ]     = arate;
+            /* options */
+        ap->lo[ARPE_PHASE]      = 0.0;
+        ap->hi[ARPE_PHASE]      = 1.0;
+        ap->lo[ARPE_LOFRQ]      = PITCHZERO;
+        ap->hi[ARPE_LOFRQ]      = nyquist;
+        ap->lo[ARPE_HIFRQ]      = PITCHZERO;
+        ap->hi[ARPE_HIFRQ]      = nyquist;
+        ap->lo[ARPE_HBAND]      = chwidth;
+        ap->hi[ARPE_HBAND]      = nyquist;
+        ap->lo[ARPE_AMPL]       = 0.0;
+        ap->hi[ARPE_AMPL]       = ARPE_MAX_AMPL;
+        switch(mode) {
+        case(ON): case(BOOST): case(BELOW_BOOST): case(ABOVE_BOOST):
+                /* variants */
+            ap->lo[ARPE_SUST]   = 1.0;          /* 1 */
+            ap->hi[ARPE_SUST]   = wlength;
+            ap->lo[ARPE_NONLIN] = ARPE_MIN_NONLIN;
+            ap->hi[ARPE_NONLIN] = ARPE_MAX_NONLIN;
+            break;
+        }
+        break;
+    case(AVRG):
+            /* params */
+        ap->lo[AVRG_AVRG]       = (double)2.0;      /* 2 */
+        ap->hi[AVRG_AVRG]       = (double)clength;
+        break;
+    case(BARE):
+        break;
+    case(BLTR):
+            /* params */
+        ap->lo[BLUR_BLURF]      = 1.0;          /* 1 */ 
+        ap->hi[BLUR_BLURF]      = (double)wlength;
+        ap->lo[BLTR_TRACE]      = 1.0;          /* 1 */ 
+        ap->hi[BLTR_TRACE]      = (double)clength;
+        break;
+    case(BLUR):
+            /* params */
+        ap->lo[BLUR_BLURF]      = 1.0;          /* 1 */ 
+        ap->hi[BLUR_BLURF]      = (double)wlength;
+        break;
+    case(BRIDGE):
+        if(insams <= 0) {
+            sprintf(errstr,"insams not set: set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        ap->lo[BRG_OFFSET]      = 0.0;
+        ap->hi[BRG_OFFSET]      = (wlength - 2) * frametime;
+        ap->lo[BRG_SF2]         = 0.0;
+        ap->hi[BRG_SF2]         = 1.0;
+        ap->lo[BRG_SA2]         = 0.0;
+        ap->hi[BRG_SA2]         = 1.0;
+        ap->lo[BRG_EF2]         = 0.0;
+        ap->hi[BRG_EF2]         = 1.0;
+        ap->lo[BRG_EA2]         = 0.0;
+        ap->hi[BRG_EA2]         = 1.0;
+        ap->lo[BRG_STIME]       = 0.0;
+        ap->hi[BRG_STIME]       = (wlength - 2) * frametime;
+        ap->lo[BRG_ETIME]       = frametime * 2.0;
+        ap->hi[BRG_ETIME]       = wlength * frametime;
+        break;
+    case(CHANNEL):
+        ap->lo[CHAN_FRQ]        = 0.0;
+        ap->hi[CHAN_FRQ]        = nyquist;
+        break;
+    case(CHORD):
+    case(MULTRANS):
+            /* variants */
+        ap->lo[CHORD_LOFRQ]     = PITCHZERO;
+        ap->hi[CHORD_LOFRQ]     = nyquist;
+        ap->lo[CHORD_HIFRQ]     = PITCHZERO;
+        ap->hi[CHORD_HIFRQ]     = nyquist;
+        break;
+    case(CHORUS):
+            /* params */
+        ap->lo[CHORU_AMPR]      = CHORU_MINAMP;
+        ap->hi[CHORU_AMPR]      = CHORU_MAXAMP;
+        ap->lo[CHORU_FRQR]      = CHORU_MINFRQ;
+        ap->hi[CHORU_FRQR]      = CHORU_MAXFRQ;
+        break;
+    case(CLEAN):
+        switch(mode) {
+        case(FROMTIME):
+        case(ANYWHERE):
+            ap->lo[CL_SKIPT]    = 0.0;
+            ap->hi[CL_SKIPT]    = (wlength - 1) * frametime;
+            break;
+        case(FILTERING):
+            ap->lo[CL_FRQ]      = PITCHZERO;
+            ap->hi[CL_FRQ]      = nyquist - halfchwidth;
+            break;
+        }
+        ap->lo[CL_GAIN]         = 1.0;
+        ap->hi[CL_GAIN]         = CL_MAX_GAIN;
+        break;
+    case(CROSS):
+        ap->lo[CROS_INTP]       = 0.0;
+        ap->hi[CROS_INTP]       = 1.0;
+        break;
+    case(CUT):
+        ap->lo[CUT_STIME]       = 0.0;
+        ap->hi[CUT_STIME]       = (wlength - 1) * frametime;
+        ap->lo[CUT_ETIME]       = frametime;
+        ap->hi[CUT_ETIME]       = wlength * frametime;
+        break;
+    case(DIFF):
+        ap->lo[DIFF_CROSS]      = 0.0;
+        ap->hi[DIFF_CROSS]      = 1.0;
+        break;
+    case(DRUNK):
+        ap->lo[DRNK_RANGE]      = 1.0;
+        ap->hi[DRNK_RANGE]      = (double)(wlength/2);
+        ap->lo[DRNK_STIME]      = 0.0;
+        ap->hi[DRNK_STIME]      = wlength * frametime;
+        ap->lo[DRNK_DUR]        = frametime;
+        ap->hi[DRNK_DUR]        = BIG_TIME;
+        break;
+    case(EXAG):
+            /* params */
+        ap->lo[EXAG_EXAG]       = 0.001;
+        ap->hi[EXAG_EXAG]       = 1000.0;
+        break;
+    case(FILT):
+            /* params */
+        ap->lo[FILT_FRQ1]       = SPEC_MINFRQ;
+        ap->hi[FILT_FRQ1]       = nyquist;
+        ap->lo[FILT_FRQ2]       = SPEC_MINFRQ;
+        ap->hi[FILT_FRQ2]       = nyquist;
+        ap->lo[FILT_QQ]         = 1.0;
+        ap->hi[FILT_QQ]         = nyquist;
+        ap->lo[FILT_PG]         = 0.0;
+        ap->hi[FILT_PG]         = FILT_MAX_PG;
+        break;
+    case(FMNTSEE):
+        break;
+    case(FOCUS):
+            /* params */
+        ap->lo[FOCU_PKCNT]      = 1.0;
+        ap->hi[FOCU_PKCNT]      = (double)MAXPKCNT;
+        ap->lo[FOCU_BW]         = OCTAVES_PER_SEMITONE;
+        ap->hi[FOCU_BW]         = LOG2(nyquist/halfchwidth);
+            /* options */
+        ap->lo[FOCU_LOFRQ]      = PITCHZERO;
+        ap->hi[FOCU_LOFRQ]      = nyquist;
+        ap->lo[FOCU_HIFRQ]      = PITCHZERO;
+        ap->hi[FOCU_HIFRQ]      = nyquist;
+        ap->lo[FOCU_STABL]      = 2.0;
+        ap->hi[FOCU_STABL]      = (double)MAXSTABIL;
+        break;
+    case(FOLD):
+            /* params */
+        ap->lo[FOLD_LOFRQ]      = PITCHZERO;
+        ap->hi[FOLD_LOFRQ]      = nyquist;
+        ap->lo[FOLD_HIFRQ]      = PITCHZERO;
+        ap->hi[FOLD_HIFRQ]      = nyquist;
+        break;
+    case(FORM):
+        ap->lo[FORM_FTOP]       = PITCHZERO;
+        ap->hi[FORM_FTOP]       = nyquist;
+        ap->lo[FORM_FBOT]       = PITCHZERO;
+        ap->hi[FORM_FBOT]       = nyquist;
+        ap->lo[FORM_GAIN]       = FLTERR;
+        ap->hi[FORM_GAIN]       = FORM_MAX_GAIN;
+        break;
+    case(FORMANTS):
+        break;
+    case(FORMSEE):
+        break;
+    case(FREEZE):
+    case(FREEZE2):
+        break;
+    case(FREQUENCY):
+        ap->lo[FRQ_CHAN]        = 0.0;
+        ap->hi[FRQ_CHAN]        = (double)(clength - 1);
+        break;
+    case(GAIN):
+            /* params */
+        ap->lo[GAIN_GAIN]       = 0.0;
+        ap->hi[GAIN_GAIN]       =  GAIN_MAX_GAIN;
+        break;
+    case(GLIDE):
+        ap->lo[GLIDE_DUR]       = frametime * 2.0;
+        ap->hi[GLIDE_DUR]       = BIG_TIME;
+        break;
+    case(GLIS):
+            /* params */
+        ap->lo[GLIS_RATE]       = -8.0/frametime;
+        ap->hi[GLIS_RATE]       =  8.0/frametime;
+        ap->lo[GLIS_SHIFT]      = chwidth;
+        ap->hi[GLIS_SHIFT]      = nyquist/2;
+            /* variants */
+        ap->lo[GLIS_HIFRQ]      = PITCHZERO;
+        ap->hi[GLIS_HIFRQ]      = nyquist;
+        break;
+    case(GRAB):
+        ap->lo[GRAB_FRZTIME]    = 0.0;
+        ap->hi[GRAB_FRZTIME]    = duration + 1.0;
+        break;
+    case(GREQ):
+        break;
+    case(INVERT):
+        break;
+    case(LEAF):
+        ap->lo[LEAF_SIZE]       = 1;
+        ap->hi[LEAF_SIZE]       = wlength;
+        break;
+    case(LEVEL):
+        break;
+    case(MAGNIFY):
+        ap->lo[MAG_FRZTIME]     = 0.0;
+        ap->hi[MAG_FRZTIME]     = duration;
+        ap->lo[MAG_DUR]         = frametime * 2.0;
+        ap->hi[MAG_DUR]         = BIG_TIME;
+        break;
+    case(MAKE):     
+        break;
+    case(MAX):  
+        break;
+    case(MEAN):
+        ap->lo[MEAN_LOF]        = PITCHZERO;
+        ap->hi[MEAN_LOF]        = nyquist - halfchwidth;
+        ap->lo[MEAN_HIF]        = PITCHZERO + chwidth;
+        ap->hi[MEAN_HIF]        = nyquist;
+        ap->lo[MEAN_CHAN]       = 2;
+        ap->hi[MEAN_CHAN]       = clength;
+        break;
+    case(MORPH):
+        ap->lo[MPH_STAG]        = 0.0;
+        ap->hi[MPH_STAG]        = (wlength-1) * frametime;
+        ap->lo[MPH_ASTT] = ap->lo[MPH_FSTT] = 0.0;
+        ap->hi[MPH_ASTT] = ap->hi[MPH_FSTT] = (wlength - 1) * frametime;
+        ap->lo[MPH_AEND] = ap->lo[MPH_FEND] = frametime * 2;
+        ap->hi[MPH_AEND] = ap->hi[MPH_FEND] = BIG_TIME;
+        ap->lo[MPH_AEXP] = ap->lo[MPH_FEXP] = MPH_MIN_EXP;
+        ap->hi[MPH_AEXP] = ap->hi[MPH_FEXP] = MPH_MAX_EXP;
+        break;
+    case(NOISE):
+        ap->lo[NOISE_NOIS]      =  0.0;
+        ap->hi[NOISE_NOIS]      =  1.0;
+        break;
+    case(OCT):
+        ap->lo[OCT_HMOVE]       = 2.0;
+        ap->hi[OCT_HMOVE]       = OCT_MAX_HMOVE;
+        ap->lo[OCT_BREI]        = 0.0;
+        ap->hi[OCT_BREI]        = OCT_MAX_BREI;
+        break;
+    case(OCTVU):
+        ap->lo[OCTVU_TSTEP]     = (double)round(frametime * SECS_TO_MS);
+        ap->hi[OCTVU_TSTEP]     = (double)round(wlength * frametime * SECS_TO_MS);
+        ap->lo[OCTVU_FUND]      = halfchwidth;
+        ap->hi[OCTVU_FUND]      = nyquist/ROOT_2;
+        break;
+    case(P_APPROX):
+        ap->lo[PA_PRANG]        = 0.0;
+        ap->hi[PA_PRANG]        = MAXINTRANGE;
+        ap->lo[PA_TRANG]        = frametime * SECS_TO_MS;
+        ap->hi[PA_TRANG]        = wlength * frametime * SECS_TO_MS;
+        ap->lo[PA_SRANG]        = frametime * BLOKCNT * 2 * SECS_TO_MS;
+        ap->hi[PA_SRANG]        = wlength * frametime * SECS_TO_MS;
+        break;
+    case(P_CUT):
+        ap->lo[PC_STT]          = 0.0;
+        ap->hi[PC_STT]          = (wlength - 1) * frametime;
+        ap->lo[PC_END]          = frametime;
+        ap->hi[PC_END]          = wlength * frametime;
+        break;
+    case(P_EXAG):
+        ap->lo[PEX_MEAN]        = MIDIMIN;
+        ap->hi[PEX_MEAN]        = MIDIMAX;
+        ap->lo[PEX_RANG]        = 0.0;
+        ap->hi[PEX_RANG]        = PEX_MAX_RANG;
+        ap->lo[PEX_CNTR]        = 0.0;
+        ap->hi[PEX_CNTR]        = 1.0;
+        break;
+    case(P_FIX):
+        ap->lo[PF_SCUT]         = 0.0;
+        ap->hi[PF_SCUT]         = wlength * frametime;
+        ap->lo[PF_ECUT]         = 0.0;
+        ap->hi[PF_ECUT]         = wlength * frametime;
+        ap->lo[PF_HIF]          = PITCHZERO;
+        ap->hi[PF_HIF]          = nyquist;
+        ap->lo[PF_LOF]          = PITCHZERO;
+        ap->hi[PF_LOF]          = nyquist;
+        ap->lo[PF_SMOOTH]       = 1.0;
+        ap->hi[PF_SMOOTH]       = (double)(MAXSMOOTH);
+        ap->lo[PF_SMARK]        = SPEC_MINFRQ;
+        ap->hi[PF_SMARK]        = nyquist;
+        ap->lo[PF_EMARK]        = SPEC_MINFRQ;
+        ap->hi[PF_EMARK]        = nyquist;
+        break;
+    case(P_HEAR):
+        ap->lo[PH_GAIN]         = FLTERR;
+        ap->hi[PH_GAIN]         = PH_MAX_GAIN;
+        break;
+    case(P_INFO):     
+        break;
+    case(P_INVERT):
+        ap->lo[PI_MEAN]         = MIDIMIN;
+        ap->hi[PI_MEAN]         = MIDIMAX;
+        ap->lo[PI_TOP]          = MIDIMIN;
+        ap->hi[PI_TOP]          = MIDIMAX;
+        ap->lo[PI_BOT]          = MIDIMIN;
+        ap->hi[PI_BOT]          = MIDIMAX;
+        break;
+    case(P_QUANTISE): 
+        break;
+    case(P_RANDOMISE):
+        ap->lo[PR_MXINT]        = 0.0;
+        ap->hi[PR_MXINT]        = MAXINTRANGE;
+        ap->lo[PR_TSTEP]        = frametime * SECS_TO_MS;
+        ap->hi[PR_TSTEP]        = wlength * frametime * SECS_TO_MS;
+        ap->lo[PR_SLEW]         = -(PR_MAX_SLEW);
+        ap->hi[PR_SLEW]         = PR_MAX_SLEW;
+        break;
+    case(P_SEE):
+        ap->lo[PSEE_SCF]        = FLTERR;
+        ap->hi[PSEE_SCF]        = PSEE_MAX_SCF;
+        break;
+    case(P_SMOOTH):
+        ap->lo[PS_TFRAME]       = frametime * SECS_TO_MS;
+        ap->hi[PS_TFRAME]       = wlength * frametime * SECS_TO_MS;
+        ap->lo[PS_MEAN]         = MIDIMIN;
+        ap->hi[PS_MEAN]         = MIDIMAX;
+        break;
+//TW NEW CASES
+    case(P_SYNTH):
+    case(P_INSERT):
+    case(P_SINSERT):
+    case(P_PTOSIL):
+    case(P_NTOSIL):
+    case(ANALENV):
+    case(MAKE2):
+    case(P_INTERP):
+    case(P_BINTOBRK):
+        break;
+    case(P_VOWELS):
+        ap->lo[PV_HWIDTH] = .01;
+        ap->hi[PV_HWIDTH] = 10.0;
+        ap->lo[PV_CURVIT] = .1;
+        ap->hi[PV_CURVIT] = 10;
+        ap->lo[PV_PKRANG] = 0;
+        ap->hi[PV_PKRANG] = 1;
+        ap->lo[PV_FUNBAS] = 0;
+        ap->hi[PV_FUNBAS] = 1;
+        ap->lo[PV_OFFSET] = 0.0;
+        ap->hi[PV_OFFSET] = 1.0;
+        break;
+    case(VFILT):
+        ap->lo[PV_HWIDTH] = .01;
+        ap->hi[PV_HWIDTH] = 10.0;
+        ap->lo[PV_CURVIT] = .1;
+        ap->hi[PV_CURVIT] = 10;
+        ap->lo[PV_PKRANG] = 0;
+        ap->hi[PV_PKRANG] = 1;
+        ap->lo[VF_THRESH] = 0.0;
+        ap->hi[VF_THRESH] = 1.0;
+        break;
+    case(P_GEN):
+        ap->lo[PGEN_SRATE] = 16000;
+        ap->hi[PGEN_SRATE] = /*48000*/96000;    /*RWD 4:05 */
+        ap->lo[PGEN_CHANS_INPUT]    = (double)2;
+        ap->hi[PGEN_CHANS_INPUT]    = (double)MAX_PVOC_CHANS;
+        ap->lo[PGEN_WINOVLP_INPUT]  = (double)1;
+        ap->hi[PGEN_WINOVLP_INPUT]  = (double)4;
+        break;
+
+    case(P_TRANSPOSE):
+        ap->lo[PT_TVAL]     = -MAXINTRANGE;
+        ap->hi[PT_TVAL]     = MAXINTRANGE;
+        break;
+    case(P_VIBRATO):
+        ap->lo[PV_FRQ]          = 0.0;
+        ap->hi[PV_FRQ]          = 1.0/frametime;
+        ap->lo[PV_RANG]         = 0.0;
+        ap->hi[PV_RANG]         = MAXINTRANGE;
+        break;
+    case(P_WRITE):
+        ap->lo[PW_DRED]         = PW_MIN_DRED;
+        ap->hi[PW_DRED]         = PW_MAX_DRED;
+        break;
+    case(P_ZEROS):  
+        break;
+    case(PEAK):
+        ap->lo[PEAK_CUTOFF]     = SPEC_MINFRQ;
+        ap->hi[PEAK_CUTOFF]     = nyquist - halfchwidth;
+        ap->lo[PEAK_TWINDOW]    = frametime;
+        ap->hi[PEAK_TWINDOW]    = (double)wlength * frametime;
+        ap->lo[PEAK_FWINDOW]    = MINFWINDOW;
+        ap->hi[PEAK_FWINDOW]    = LOG2(nyquist/SPEC_MINFRQ) * SEMITONES_PER_OCTAVE;
+        break;
+    case(PICK):
+            /* params */
+        ap->lo[PICK_FUND]       = SPEC_MINFRQ;
+        ap->hi[PICK_FUND]       = nyquist;
+        if(mode==PIK_DISPLACED_HARMS)
+            ap->lo[PICK_LIN]    = -nyquist;
+        else
+            ap->lo[PICK_LIN]    = SPEC_MINFRQ;
+        ap->hi[PICK_LIN]        = nyquist;
+            /* options */
+        ap->lo[PICK_CLAR]       =  0.0;
+        ap->hi[PICK_CLAR]       =  1.0;
+        break;
+    case(PITCH):
+        ap->lo[PICH_RNGE]       = 0.0;
+        ap->hi[PICH_RNGE]       = 6.0;
+        ap->lo[PICH_VALID]      = 0.0;
+        ap->hi[PICH_VALID]      = (double)wlength;
+        ap->lo[PICH_SRATIO]     = 0.0;
+        ap->hi[PICH_SRATIO]     = SIGNOIS_MAX;
+        ap->lo[PICH_MATCH]      = 1.0;
+        ap->hi[PICH_MATCH]      = (double)MAXIMI;
+        ap->lo[PICH_HILM]       = SPEC_MINFRQ;
+        ap->hi[PICH_HILM]       = nyquist/MAXIMI;
+        ap->lo[PICH_LOLM]       = SPEC_MINFRQ;
+        ap->hi[PICH_LOLM]       = nyquist/MAXIMI;
+        if(mode==PICH_TO_BRK) {
+            ap->lo[PICH_DATAREDUCE] = PW_MIN_DRED;
+            ap->hi[PICH_DATAREDUCE] = PW_MAX_DRED;
+        }
+        break;
+    case(PLUCK):
+            /* params */
+        ap->lo[PLUK_GAIN]       = 0.0;
+        ap->hi[PLUK_GAIN]       =  PLUK_MAX_GAIN;
+        break;
+    case(PRINT):
+        ap->lo[PRNT_STIME]      = 0.0;
+        ap->hi[PRNT_STIME]      = (wlength - 1) * frametime;
+        ap->lo[PRNT_WCNT]       = 1.0;
+        ap->hi[PRNT_WCNT]       = wlength;
+        break;
+    case(REPITCH):  
+        break;
+    case(REPITCHB):
+        ap->lo[RP_DRED]         = PW_MIN_DRED;
+        ap->hi[RP_DRED]         = PW_MAX_DRED;
+        break;
+    case(REPORT):
+            /* params */
+        ap->lo[REPORT_PKCNT]    = 1.0;
+        ap->hi[REPORT_PKCNT]    = (double)MAXPKCNT;
+            /* options */
+        ap->lo[REPORT_LOFRQ]    = PITCHZERO;
+        ap->hi[REPORT_LOFRQ]    = nyquist;
+        ap->lo[REPORT_HIFRQ]    = PITCHZERO;
+        ap->hi[REPORT_HIFRQ]    = nyquist;
+        ap->lo[REPORT_STABL]    = 2.0;
+        ap->hi[REPORT_STABL]    = (double)MAXSTABIL;
+        break;
+    case(SCAT):
+            /* params */
+        ap->lo[SCAT_CNT]        =  1.0;
+        ap->hi[SCAT_CNT]        =  (double)clength;
+            /* options */
+        ap->lo[SCAT_BLOKSIZE]   =  chwidth;
+        ap->hi[SCAT_BLOKSIZE]   =  nyquist/2.0;
+        break;
+    case(SHIFT):
+            /* params */
+        ap->lo[SHIFT_SHIF]      =  -nyquist;
+        ap->hi[SHIFT_SHIF]      =  nyquist;
+        ap->lo[SHIFT_FRQ1]      =  halfchwidth/2.0;
+        ap->hi[SHIFT_FRQ1]      =  nyquist - (halfchwidth/2.0);
+        ap->lo[SHIFT_FRQ2]      =  halfchwidth/2.0;
+        ap->hi[SHIFT_FRQ2]      =  nyquist - (halfchwidth/2.0);
+        break;
+    case(SHIFTP):
+            /* params */
+        ap->lo[SHIFTP_FFRQ]     = PITCHZERO;
+        ap->hi[SHIFTP_FFRQ]     = nyquist;
+        ap->lo[SHIFTP_SHF1]     = LOG2(SPEC_MINFRQ/nyquist) * SEMITONES_PER_OCTAVE;
+        ap->hi[SHIFTP_SHF1]     = LOG2(nyquist/SPEC_MINFRQ) * SEMITONES_PER_OCTAVE;
+        ap->lo[SHIFTP_SHF2]     = LOG2(SPEC_MINFRQ/nyquist) * SEMITONES_PER_OCTAVE;
+        ap->hi[SHIFTP_SHF2]     = LOG2(nyquist/SPEC_MINFRQ) * SEMITONES_PER_OCTAVE;
+            /* variants */
+        ap->lo[SHIFTP_DEPTH]    = 0.0;
+        ap->hi[SHIFTP_DEPTH]    = 1.0;
+        break;
+    case(SHUFFLE):
+        ap->lo[SHUF_GRPSIZE]    = 1.0;
+        ap->hi[SHUF_GRPSIZE]    = 32767.0;
+        break;
+    case(SPLIT): 
+        break;
+    case(SPREAD):
+            /* options */
+        ap->lo[SPREAD_SPRD]     = 0.0;
+        ap->hi[SPREAD_SPRD]     = 1.0;
+        break;
+    case(STEP):
+            /* params */
+        ap->lo[STEP_STEP]       = 2.0 * frametime;
+        ap->hi[STEP_STEP]       = wlength * frametime;
+        break;
+    case(STRETCH):
+            /* params */
+        ap->lo[STR_FFRQ]        = PITCHZERO;
+        ap->hi[STR_FFRQ]        = nyquist;
+        ap->lo[STR_SHIFT]       = SPEC_MINFRQ/nyquist;
+        ap->hi[STR_SHIFT]       = nyquist/SPEC_MINFRQ;
+        ap->lo[STR_EXP]         = STR_MIN_EXP;
+        ap->hi[STR_EXP]         = STR_MAX_EXP;
+            /* variants */
+        ap->lo[STR_DEPTH]       = 0.0;
+        ap->hi[STR_DEPTH]       = 1.0;
+        break;
+    case(SUM):
+        ap->lo[SUM_CROSS]       = 0.0;
+        ap->hi[SUM_CROSS]       = 1.0;
+        break;
+    case(SUPR):
+            /* params */
+        ap->lo[SUPR_INDX]       = 1.0;
+        ap->hi[SUPR_INDX]       = (double)clength;
+        break;
+    case(S_TRACE):
+            /* params */
+        ap->lo[TRAC_INDX]       = 1.0;
+        ap->hi[TRAC_INDX]       = (double)clength;
+        ap->lo[TRAC_LOFRQ]      = PITCHZERO;
+        ap->hi[TRAC_LOFRQ]      = nyquist;
+        ap->lo[TRAC_HIFRQ]      = PITCHZERO;
+        ap->hi[TRAC_HIFRQ]      = nyquist;
+        break;
+    case(TRACK):
+        ap->lo[TRAK_PICH]       = SPEC_MINFRQ;
+        ap->hi[TRAK_PICH]       = nyquist/MAXIMI;
+        ap->lo[TRAK_RNGE]       = 0.0;
+        ap->hi[TRAK_RNGE]       = 6.0;
+        ap->lo[TRAK_VALID]      = 1.0;
+        ap->hi[TRAK_VALID]      = (double)wlength;
+        ap->lo[TRAK_SRATIO]     = 0.0;
+        ap->hi[TRAK_SRATIO]     = SIGNOIS_MAX;;
+        ap->lo[TRAK_HILM]       = SPEC_MINFRQ + FLTERR;
+        ap->hi[TRAK_HILM]       = nyquist/MAXIMI;
+        if(mode==TRK_TO_BRK) {
+            ap->lo[TRAK_DATAREDUCE] = PW_MIN_DRED;
+            ap->hi[TRAK_DATAREDUCE] = PW_MAX_DRED;
+        }
+        break;
+    case(TRNSF):
+            /* variants */
+        ap->lo[TRNSF_HIFRQ]     = PITCHZERO;
+        ap->hi[TRNSF_HIFRQ]     = nyquist;
+        ap->lo[TRNSF_LOFRQ]     = PITCHZERO;
+        ap->hi[TRNSF_LOFRQ]     = nyquist;
+        break;
+    case(TRNSP):
+            /* variants */
+        ap->lo[TRNSP_HIFRQ]     = PITCHZERO;
+        ap->hi[TRNSP_HIFRQ]     = nyquist;
+        ap->lo[TRNSP_LOFRQ]     = PITCHZERO;
+        ap->hi[TRNSP_LOFRQ]     = nyquist;
+        break;
+    case(TSTRETCH):
+        ap->lo[TSTR_STRETCH]    = MINTSTR;
+        ap->hi[TSTR_STRETCH]    = MAXTSTR;
+        break;
+    case(TUNE):
+            /* options */
+        ap->lo[TUNE_FOC]        = 0.0;
+        ap->hi[TUNE_FOC]        = 1.0;
+        ap->lo[TUNE_CLAR]       = 0.0;
+        ap->hi[TUNE_CLAR]       = 1.0;
+            /* variants */
+        ap->lo[TUNE_INDX]       = 1.0;
+        ap->hi[TUNE_INDX]       = clength;
+        ap->lo[TUNE_BFRQ]       = MINPITCH;
+        ap->hi[TUNE_BFRQ]       = nyquist;
+        break;
+    case(VOCODE):
+        ap->lo[VOCO_LOF]        = PITCHZERO;
+        ap->hi[VOCO_LOF]        = nyquist;
+        ap->lo[VOCO_HIF]        = PITCHZERO;
+        ap->hi[VOCO_HIF]        = nyquist;
+        ap->lo[VOCO_GAIN]       = FLTERR;
+        ap->hi[VOCO_GAIN]       = VOCO_MAX_GAIN;
+        break;
+    case(WARP):
+        ap->lo[WARP_PRNG]       = 0.0;
+        ap->hi[WARP_PRNG]       = MAXPRANGE;
+        ap->lo[WARP_TRNG]       = frametime * SECS_TO_MS;
+        ap->hi[WARP_TRNG]       = wlength * frametime * SECS_TO_MS;
+        ap->lo[WARP_SRNG]       = (BLOKCNT * 2) * frametime * SECS_TO_MS;
+        ap->hi[WARP_SRNG]       = (wlength - (BLOKCNT * 2)) * frametime * SECS_TO_MS;
+        break;
+    case(WAVER):
+            /* params */
+        ap->lo[WAVER_VIB]       = 1.0/(wlength * frametime);
+        ap->hi[WAVER_VIB]       = 0.5/frametime;
+        ap->lo[WAVER_STR]       = 1.0;
+        ap->hi[WAVER_STR]       = nyquist/SPEC_MINFRQ;
+        ap->lo[WAVER_LOFRQ]     = PITCHZERO;
+        ap->hi[WAVER_LOFRQ]     = nyquist; 
+        ap->lo[WAVER_EXP]       =  WAVER_MIN_EXP;
+        ap->hi[WAVER_EXP]       =  WAVER_MAX_EXP;
+        break;
+    case(WEAVE):    
+        break;
+    case(WINDOWCNT):
+        break;
+    case(LIMIT):
+        ap->lo[LIMIT_THRESH]    =  0.0;
+        ap->hi[LIMIT_THRESH]    =  1.0;
+        break;
+                    /*********************** GROUCHO ***************************/
+
+    case(DISTORT):
+        ap->lo[DISTORT_POWFAC]      = FLTERR;
+        ap->hi[DISTORT_POWFAC]      = DISTORT_MAX_POWFAC;
+        break;
+    case(DISTORT_ENV):
+        ap->lo[DISTORTE_CYCLECNT]   = 1.0;
+        ap->hi[DISTORTE_CYCLECNT]   = 1000.0;
+        ap->lo[DISTORTE_TROF]       = 0.0;
+        ap->hi[DISTORTE_TROF]       = 1.0;
+        ap->lo[DISTORTE_EXPON]      = DISTORTE_MIN_EXPON;
+        ap->hi[DISTORTE_EXPON]      = DISTORTE_MAX_EXPON;
+        break;
+    case(DISTORT_AVG):
+        ap->lo[DISTORTA_CYCLECNT]   = 2.0;
+        ap->hi[DISTORTA_CYCLECNT]   = MAX_CYCLECNT;
+        ap->lo[DISTORTA_MAXLEN]     = MINWAVELEN/nyquist;
+        ap->hi[DISTORTA_MAXLEN]     = 1.0;
+        ap->lo[DISTORTA_SKIPCNT]    = 0.0;
+        ap->hi[DISTORTA_SKIPCNT]    = MAX_CYCLECNT;
+        break;
+    case(DISTORT_OMT):
+        ap->lo[DISTORTO_OMIT]       = 1.0;
+        ap->hi[DISTORTO_OMIT]       = MAX_CYCLECNT;
+        ap->lo[DISTORTO_KEEP]       = 2.0;
+        ap->hi[DISTORTO_KEEP]       = MAX_CYCLECNT + 1.0;
+        break;
+    case(DISTORT_MLT):
+    case(DISTORT_DIV):
+        ap->lo[DISTORTM_FACTOR]     = 2.0;
+        ap->hi[DISTORTM_FACTOR]     = 16.0;
+        break;
+    case(DISTORT_HRM):
+        ap->lo[DISTORTH_PRESCALE]   = FLTERR;
+        ap->hi[DISTORTH_PRESCALE]   = DISTORTH_MAX_PRESCALE;
+        break;
+    case(DISTORT_FRC):
+        ap->lo[DISTORTF_SCALE]      = MIN_SCALE;
+        ap->hi[DISTORTF_SCALE]      = MAXWAVELEN * sr;
+        ap->lo[DISTORTF_AMPFACT]    = 1.0/(double)MAXSHORT;
+        ap->hi[DISTORTF_AMPFACT]    = (double)MAXSHORT;
+        ap->lo[DISTORTF_PRESCALE]   = 1.0/(double)MAXSHORT;
+        ap->hi[DISTORTF_PRESCALE]   = (double)MAXSHORT;
+        break;
+    case(DISTORT_REV):
+        ap->lo[DISTORTR_CYCLECNT]   = 1.0;
+        ap->hi[DISTORTR_CYCLECNT]   = MAX_CYCLECNT;
+        break;
+    case(DISTORT_SHUF):
+        ap->lo[DISTORTS_CYCLECNT]   = 1.0;
+        ap->hi[DISTORTS_CYCLECNT]   = MAX_CYCLECNT;
+        ap->lo[DISTORTS_SKIPCNT]    = 0.0;
+        ap->hi[DISTORTS_SKIPCNT]    = MAX_CYCLECNT;
+        break;
+    case(DISTORT_RPTFL):
+        ap->lo[DISTRPT_CYCLIM]      = 440.0;
+        ap->hi[DISTRPT_CYCLIM]      = nyquist;
+        /* fall thro */
+    case(DISTORT_RPT):
+    case(DISTORT_RPT2):
+        ap->lo[DISTRPT_MULTIPLY]    = 2.0;
+        ap->hi[DISTRPT_MULTIPLY]    = BIG_VALUE;
+        ap->lo[DISTRPT_CYCLECNT]    = 1.0;
+        ap->hi[DISTRPT_CYCLECNT]    = MAX_CYCLECNT;
+        ap->lo[DISTRPT_SKIPCNT]     = 0.0;
+        ap->hi[DISTRPT_SKIPCNT]     = MAX_CYCLECNT;
+        break;
+    case(DISTORT_INTP):
+        ap->lo[DISTINTP_MULTIPLY]   = 2.0;
+        ap->hi[DISTINTP_MULTIPLY]   = BIG_VALUE;
+        ap->lo[DISTINTP_SKIPCNT]    = 0.0;
+        ap->hi[DISTINTP_SKIPCNT]    = MAX_CYCLECNT;
+        break;
+    case(DISTORT_DEL):
+        ap->lo[DISTDEL_CYCLECNT]    = 2.0;
+        ap->hi[DISTDEL_CYCLECNT]    = MAX_CYCLECNT;
+        ap->lo[DISTDEL_SKIPCNT]     = 0.0;
+        ap->hi[DISTDEL_SKIPCNT]     = MAX_CYCLECNT;
+        break;
+    case(DISTORT_RPL):
+        ap->lo[DISTRPL_CYCLECNT]    = 2.0;
+        ap->hi[DISTRPL_CYCLECNT]    = MAX_CYCLECNT;
+        ap->lo[DISTRPL_SKIPCNT]     = 0.0;
+        ap->hi[DISTRPL_SKIPCNT]     = MAX_CYCLECNT;
+        break;
+    case(DISTORT_TEL):
+        ap->lo[DISTTEL_CYCLECNT]    = 2.0;
+        ap->hi[DISTTEL_CYCLECNT]    = MAX_CYCLECNT;
+        ap->lo[DISTTEL_SKIPCNT]     = 0.0;
+        ap->hi[DISTTEL_SKIPCNT]     = MAX_CYCLECNT;
+        break;
+    case(DISTORT_FLT):
+        ap->lo[DISTFLT_LOFRQ_CYCLELEN] = SPEC_MINFRQ;
+        ap->hi[DISTFLT_LOFRQ_CYCLELEN] = nyquist;
+        ap->lo[DISTFLT_HIFRQ_CYCLELEN] = SPEC_MINFRQ;
+        ap->hi[DISTFLT_HIFRQ_CYCLELEN] = nyquist;
+        ap->lo[DISTFLT_SKIPCNT]        = 0.0;
+        ap->hi[DISTFLT_SKIPCNT]        = MAX_CYCLECNT;
+        break;
+    case(DISTORT_INT):
+        break;
+    case(DISTORT_CYCLECNT):
+        break;
+    case(DISTORT_PCH):
+        ap->lo[DISTPCH_OCTVAR]      = FLTERR;
+        ap->hi[DISTPCH_OCTVAR]      = MAXOCTVAR;
+        ap->lo[DISTPCH_CYCLECNT]    = 2.0;
+        ap->hi[DISTPCH_CYCLECNT]    = MAX_CYCLECNT;
+        ap->lo[DISTPCH_SKIPCNT]     = 0.0;
+        ap->hi[DISTPCH_SKIPCNT]     = MAX_CYCLECNT;
+        break;
+    case(DISTORT_OVERLOAD):
+        if(mode==OVER_SINE) {
+            ap->lo[DISTORTER_FRQ]   = 0.01;
+            ap->hi[DISTORTER_FRQ]   = nyquist;
+        }
+        ap->lo[DISTORTER_MULT]      = 0.0;
+        ap->hi[DISTORTER_MULT]      = 1.0;
+        ap->lo[DISTORTER_DEPTH]     = 0.0;
+        ap->hi[DISTORTER_DEPTH]     = 1.0;
+        break;
+//TW NEW CASE
+    case(DISTORT_PULSED):
+        ap->lo[PULSE_STARTTIME] = 0.0;  /* starttime of impulses in input-sound */
+        if(mode == PULSE_SYNI)
+            ap->hi[PULSE_STARTTIME] = (double)round(duration * sr); /* starttime of impulses in input-sound, in samples */
+        else
+            ap->hi[PULSE_STARTTIME] = duration; /* starttime of impulses in input-sound */
+        ap->lo[PULSE_DUR]       = (double)(ENDBIT_SPLICE * 2.0)/(double)srate;  /* duration of impulse stream */
+        if(mode == PULSE_IMP)
+            ap->hi[PULSE_DUR]   = duration; /* duration of impulse stream */
+        else
+            ap->hi[PULSE_DUR]   = AN_HOUR;
+        ap->lo[PULSE_FRQ]       = .1;   /* frq of impulses */
+        ap->hi[PULSE_FRQ]       = 50.0; /* frq of impulses */
+        ap->lo[PULSE_FRQRAND]   = 0.0;  /* randomisation of pulse frq, semitones */
+        ap->hi[PULSE_FRQRAND]   = 12.0; /* randomisation of pulse frq, semitones */
+        ap->lo[PULSE_TIMERAND]  = 0.0;  /* randomisation of pulse shape, timewise */
+        ap->hi[PULSE_TIMERAND]  = 1.0;  /* randomisation of pulse shape, timewise */
+        ap->lo[PULSE_SHAPERAND] = 0.0;  /* randomisation of pulse shape, ampwise  */
+        ap->hi[PULSE_SHAPERAND] = 1.0;  /* randomisation of pulse shape, ampwise  */
+        if(mode == PULSE_SYNI) {
+            ap->lo[PULSE_WAVETIME]  = 1.0;      /* no. of wavesets to cycle-around, within impulse [synth2 option only] */
+            ap->hi[PULSE_WAVETIME]  = 256.0;    /* no. of wavesets to cycle-around, within impulse [synth2 option only] */
+        } else {
+            ap->lo[PULSE_WAVETIME]  = .001; /* duration of wavesets to cycle-around, within impulse [synth option only] */
+            ap->hi[PULSE_WAVETIME]  = 4;    /* duration of wavesets to cycle-around, within impulse [synth option only] */
+        }
+        ap->lo[PULSE_TRANSPOS]  = -12.0;/* transposition envelope of material inside impulse */
+        ap->hi[PULSE_TRANSPOS]  = 12.0; /* transposition envelope of material inside impulse */
+        ap->lo[PULSE_PITCHRAND] = 0.0;  /* semitone range of randomisation of transposition envelope */
+        ap->hi[PULSE_PITCHRAND] = 12.0; /* semitone range of randomisation of transposition envelope */
+        break;
+
+    case(ZIGZAG):
+        ap->lo[ZIGZAG_START]        = 0.0;
+        ap->hi[ZIGZAG_START]        = duration - (ZIG_SPLICELEN * MS_TO_SECS);
+        ap->lo[ZIGZAG_END]          = ((ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+        ap->hi[ZIGZAG_END]          = duration;
+        ap->lo[ZIGZAG_DUR]          = duration + FLTERR;
+        ap->hi[ZIGZAG_DUR]          = BIG_TIME;
+        ap->lo[ZIGZAG_MIN]          = ((ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+        ap->hi[ZIGZAG_MIN]          = duration - (2 * ZIG_SPLICELEN * MS_TO_SECS);
+        ap->lo[ZIGZAG_SPLEN]        = MIN_ZIGSPLICE;
+        ap->hi[ZIGZAG_SPLEN]        = MAX_ZIGSPLICE;
+        if(mode==ZIGZAG_SELF) {
+            ap->lo[ZIGZAG_MAX]      = ((ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+            ap->hi[ZIGZAG_MAX]      = duration - (2 * ZIG_SPLICELEN * MS_TO_SECS);
+            ap->lo[ZIGZAG_RSEED]    = 0.0;
+            ap->hi[ZIGZAG_RSEED]    = MAXSHORT;
+        }
+        break;
+    case(LOOP):
+        ap->lo[LOOP_OUTDUR]         = 0.0;
+        ap->hi[LOOP_OUTDUR]         = BIG_TIME;
+        ap->lo[LOOP_REPETS]         = 1;
+        ap->hi[LOOP_REPETS]         = BIG_VALUE;
+        ap->lo[LOOP_START]          = 0.0;
+        ap->hi[LOOP_START]          = duration - (2 * ZIG_SPLICELEN * MS_TO_SECS);
+/* OLD
+        ap->lo[LOOP_LEN]            = (ZIG_SPLICELEN * 2) + ZIG_MIN_UNSPLICED;
+ NEW */
+        ap->lo[LOOP_LEN]            = (1.0/sr) * SECS_TO_MS;
+        ap->hi[LOOP_LEN]            = (duration * SECS_TO_MS) - (2 * ZIG_SPLICELEN);
+
+        
+        if(mode==LOOP_ALL)
+            ap->lo[LOOP_STEP]       = (1.0/sr) * SECS_TO_MS;
+        else
+            ap->lo[LOOP_STEP]       = 0.0;
+        ap->hi[LOOP_STEP]           = duration * SECS_TO_MS;
+        ap->lo[LOOP_SPLEN]          = MIN_ZIGSPLICE;
+        ap->hi[LOOP_SPLEN]          = MAX_ZIGSPLICE;
+        ap->lo[LOOP_SRCHF]          = 0.0;
+        ap->hi[LOOP_SRCHF]          = duration * SECS_TO_MS;
+        break;
+    case(SCRAMBLE):
+        switch(mode) {
+        case(SCRAMBLE_RAND):
+            ap->lo[SCRAMBLE_MIN]    = ((2 * ZIG_SPLICELEN) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+            ap->hi[SCRAMBLE_MIN]    = duration - (ZIG_SPLICELEN * MS_TO_SECS);
+            ap->lo[SCRAMBLE_MAX]    = ((2 * ZIG_SPLICELEN) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+            ap->hi[SCRAMBLE_MAX]    = duration - (ZIG_SPLICELEN * MS_TO_SECS);
+            break;
+        case(SCRAMBLE_SHRED):
+            ap->lo[SCRAMBLE_LEN]    = (4 * ZIG_SPLICELEN) * MS_TO_SECS;
+            ap->hi[SCRAMBLE_LEN]    = (duration/2.0) - (ZIG_SPLICELEN * MS_TO_SECS);
+            if(ap->hi[SCRAMBLE_LEN] <= ap->lo[SCRAMBLE_LEN]) {
+                sprintf(errstr,"infile too short for this process.\n");
+                return(DATA_ERROR);
+            }
+            ap->lo[SCRAMBLE_SCAT]   = 0.0;
+            ap->hi[SCRAMBLE_SCAT]   = BIG_VALUE;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for SCRAMBLE: in set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        ap->lo[SCRAMBLE_DUR]        = ((2 * ZIG_SPLICELEN) + ZIG_MIN_UNSPLICED) * MS_TO_SECS;
+        ap->hi[SCRAMBLE_DUR]        = (double)BIG_TIME;
+        ap->lo[SCRAMBLE_SPLEN]      = MIN_ZIGSPLICE;
+        ap->hi[SCRAMBLE_SPLEN]      = MAX_ZIGSPLICE;
+        ap->lo[SCRAMBLE_SEED]       = 0.0;
+        ap->hi[SCRAMBLE_SEED]       = MAXSHORT;
+        break;
+    case(ITERATE):
+        switch(mode) {
+        case(ITERATE_DUR):
+            ap->lo[ITER_DUR]        = duration;
+            ap->hi[ITER_DUR]        = BIG_TIME;
+            break;
+        case(ITERATE_REPEATS):
+            ap->lo[ITER_REPEATS]    = 1.0;
+            ap->hi[ITER_REPEATS]    = BIG_VALUE;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for ITERATE: in set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        ap->lo[ITER_DELAY]          = FLTERR;
+        ap->hi[ITER_DELAY]          = ITER_MAX_DELAY;
+        ap->lo[ITER_RANDOM]         = 0.0;
+        ap->hi[ITER_RANDOM]         = 1.0;
+        ap->lo[ITER_PSCAT]          = 0.0;
+        ap->hi[ITER_PSCAT]          = ITER_MAXPSHIFT;   
+        ap->lo[ITER_ASCAT]          = 0.0;
+        ap->hi[ITER_ASCAT]          = 1.0;
+        ap->lo[ITER_FADE]           = 0.0;
+        ap->hi[ITER_FADE]           = 1.0;
+        ap->lo[ITER_GAIN]           = 0.0;
+        ap->hi[ITER_GAIN]           = 1.0;
+        ap->lo[ITER_RSEED]          = 0.0;
+        ap->hi[ITER_RSEED]          = MAXSHORT;
+        break;
+    case(ITERATE_EXTEND):
+        switch(mode) {
+        case(ITERATE_DUR):
+            ap->lo[ITER_DUR]        = duration;
+            ap->hi[ITER_DUR]        = BIG_TIME;
+            break;
+        case(ITERATE_REPEATS):
+            ap->lo[ITER_REPEATS]    = 1.0;
+            ap->hi[ITER_REPEATS]    = BIG_VALUE;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for ITERATE_EXTEND: in set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        ap->lo[ITER_DELAY]          = FLTERR;
+        ap->hi[ITER_DELAY]          = ITER_MAX_DELAY;
+        ap->lo[ITER_RANDOM]         = 0.0;
+        ap->hi[ITER_RANDOM]         = 1.0;
+        ap->lo[ITER_PSCAT]          = 0.0;
+        ap->hi[ITER_PSCAT]          = ITER_MAXPSHIFT;   
+        ap->lo[ITER_ASCAT]          = 0.0;
+        ap->hi[ITER_ASCAT]          = 1.0;
+        ap->lo[CHUNKSTART]          = 0.0;
+        ap->hi[CHUNKSTART]          = duration;
+        ap->lo[CHUNKEND]            = 0.0;
+        ap->hi[CHUNKEND]            = duration;
+        ap->lo[ITER_LGAIN]           = 0.25;
+        ap->hi[ITER_LGAIN]           = 4.0;
+        ap->lo[ITER_RRSEED]          = 0.0;
+        ap->hi[ITER_RRSEED]          = MAXSHORT;
+        break;
+    case(DRUNKWALK):
+        ap->lo[DRNK_TOTALDUR]       = 0.0;
+        ap->hi[DRNK_TOTALDUR]       = BIG_VALUE;
+        ap->lo[DRNK_LOCUS]          = 0.0;
+        ap->hi[DRNK_LOCUS]          = duration;
+        ap->lo[DRNK_AMBITUS]        = 0.0;
+        ap->hi[DRNK_AMBITUS]        = duration;
+        ap->lo[DRNK_GSTEP]          = 0.0;
+        ap->hi[DRNK_GSTEP]          = duration;
+        ap->lo[DRNK_CLOKTIK]        = DRNK_SPLICE * MS_TO_SECS * 2.0;
+        ap->hi[DRNK_CLOKTIK]        = duration; /* ???? */
+        ap->lo[DRNK_MIN_DRNKTIK]    = 1.0;
+        ap->hi[DRNK_MIN_DRNKTIK]    = BIG_VALUE;
+        ap->lo[DRNK_MAX_DRNKTIK]    = 1.0;
+        ap->hi[DRNK_MAX_DRNKTIK]    = BIG_VALUE;
+        ap->lo[DRNK_SPLICELEN]      = DRNK_MIN_SPLICELEN;
+        ap->hi[DRNK_SPLICELEN]      = min(DRNK_MAX_SPLICELEN,(duration/2.0) * SECS_TO_MS);
+        ap->lo[DRNK_CLOKRND]        = 0.0;
+        ap->hi[DRNK_CLOKRND]        = 1.0;
+        ap->lo[DRNK_OVERLAP]        = 0.0;
+        ap->hi[DRNK_OVERLAP]        = DRNK_MAX_OVERLAP;
+        ap->lo[DRNK_RSEED]          = 0.0;
+        ap->hi[DRNK_RSEED]          = MAXSHORT;
+        if(mode==HAS_SOBER_MOMENTS) {
+            ap->lo[DRNK_MIN_PAUS]   = FLTERR;
+            ap->hi[DRNK_MIN_PAUS]   = duration + FLTERR;
+            ap->lo[DRNK_MAX_PAUS]   = FLTERR;
+            ap->hi[DRNK_MAX_PAUS]   = duration + FLTERR;
+        }
+        break;
+
+    case(SIMPLE_TEX):   case(TIMED):    case(GROUPS):   case(TGROUPS):
+    case(DECORATED):    case(PREDECOR): case(POSTDECOR):
+    case(ORNATE):       case(PREORNATE):case(POSTORNATE):
+    case(MOTIFS):       case(MOTIFSIN): case(TMOTIFS):  case(TMOTIFSIN):
+        ap->lo[TEXTURE_DUR]         = TEXTURE_MIN_DUR;
+        ap->hi[TEXTURE_DUR]         = BIG_TIME;
+        switch(process) {
+        case(SIMPLE_TEX):   case(GROUPS):   case(MOTIFS):   case(MOTIFSIN):
+            ap->lo[TEXTURE_PACK]    = 1.0/sr;
+            ap->hi[TEXTURE_PACK]    = MAX_PACKTIME;         
+            break;
+        case(DECORATED):    case(PREDECOR):     case(POSTDECOR):
+        case(ORNATE):       case(PREORNATE):    case(POSTORNATE):
+        case(TIMED):        case(TGROUPS):      case(TMOTIFS):      case(TMOTIFSIN):
+            ap->lo[TEXTURE_SKIP]    = FLTERR;
+            ap->hi[TEXTURE_SKIP]    = TEXTURE_MAX_SKIP;
+            break;
+        default:
+            sprintf(errstr,"Unknown process in set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        ap->lo[TEXTURE_SCAT]        = 0.0;
+        ap->hi[TEXTURE_SCAT]        = MAX_SCAT_TEXTURE;
+        ap->lo[TEXTURE_TGRID]       = 0.0;
+        ap->hi[TEXTURE_TGRID]       = TEXTURE_MAX_TGRID;
+        ap->lo[TEXTURE_INSLO]       = 1.0;
+        ap->hi[TEXTURE_INSLO]       = (double)SF_MAXFILES;
+        ap->lo[TEXTURE_INSHI]       = 1.0;
+        ap->hi[TEXTURE_INSHI]       = (double)SF_MAXFILES;
+        ap->lo[TEXTURE_MAXAMP]      = MIDIBOT;
+        ap->hi[TEXTURE_MAXAMP]      = MIDITOP; /* default 64 */
+        ap->lo[TEXTURE_MINAMP]      = MIDIBOT;
+        ap->hi[TEXTURE_MINAMP]      = MIDITOP; /* default 64 */
+        ap->lo[TEXTURE_MAXDUR]      = (TEXTURE_SPLICELEN + TEXTURE_SAFETY) * MS_TO_SECS;
+        ap->hi[TEXTURE_MAXDUR]      = BIG_TIME; 
+        ap->lo[TEXTURE_MINDUR]      = (TEXTURE_SPLICELEN + TEXTURE_SAFETY) * MS_TO_SECS;
+        ap->hi[TEXTURE_MINDUR]      = BIG_TIME; 
+        ap->lo[TEXTURE_MAXPICH]     = MIDIBOT;
+        ap->hi[TEXTURE_MAXPICH]     = MIDITOP;
+        ap->lo[TEXTURE_MINPICH]     = MIDIBOT;
+        ap->hi[TEXTURE_MINPICH]     = MIDITOP;
+        if(process == SIMPLE_TEX) {
+            ap->lo[TEX_PHGRID]          = 0;
+            ap->hi[TEX_PHGRID]          = 64;
+        } else {
+            ap->lo[TEX_PHGRID]          = 0.0;
+            ap->hi[TEX_PHGRID]          = TEXTURE_MAX_PHGRID;
+        }
+        ap->lo[TEX_GPSPACE]         = (double)IS_STILL;
+        ap->hi[TEX_GPSPACE]         = (double)IS_CONTRARY;
+        ap->lo[TEX_GRPSPRANGE]      = 0.0; /* default */
+        ap->hi[TEX_GRPSPRANGE]      = 1.0;
+        ap->lo[TEX_AMPRISE]         = 0.0;  /* default */
+        ap->hi[TEX_AMPRISE]         = MIDITOP; 
+        ap->lo[TEX_AMPCONT]         = 0.0; /* default */
+        if(process==ORNATE      || process==PREORNATE   || process==POSTORNATE 
+        || process==DECORATED   || process==PREDECOR    || process==POSTDECOR)
+            ap->hi[TEX_AMPCONT]     = 8.0;
+        else
+            ap->hi[TEX_AMPCONT]     = 6.0;
+        ap->lo[TEX_GPSIZELO]        = 1.0;
+        ap->hi[TEX_GPSIZELO]        = BIG_VALUE;
+        ap->lo[TEX_GPSIZEHI]        = 1.0;
+        ap->hi[TEX_GPSIZEHI]        = BIG_VALUE;
+        ap->lo[TEX_GPPACKLO]        = (double)SECS_TO_MS/sr;
+        ap->hi[TEX_GPPACKLO]        = MAX_PACKTIME  * SECS_TO_MS;
+        ap->lo[TEX_GPPACKHI]        = (double)SECS_TO_MS/sr;
+        ap->hi[TEX_GPPACKHI]        = MAX_PACKTIME  * SECS_TO_MS;
+        if(mode==TEX_NEUTRAL) { /* midipitches */
+            ap->lo[TEX_GPRANGLO]    = MIDIBOT;  /* default 60 */
+            ap->hi[TEX_GPRANGLO]    = MIDITOP;
+            ap->lo[TEX_GPRANGHI]    = MIDIBOT;  /* default 60 */ 
+            ap->hi[TEX_GPRANGHI]    = MIDITOP;
+        } else { /* notes of hfield */
+            ap->lo[TEX_GPRANGLO]    = 1.0;  /* default 8 */
+            ap->hi[TEX_GPRANGLO]    = MAX_GPRANGE;
+            ap->lo[TEX_GPRANGHI]    = 1.0;  /* default 8 */ 
+            ap->hi[TEX_GPRANGHI]    = MAX_GPRANGE;
+        }
+        ap->lo[TEX_MULTLO]          = MIN_MULT; /* default 1 */
+        ap->hi[TEX_MULTLO]          = MAX_MULT;
+        ap->lo[TEX_MULTHI]          = MIN_MULT; /* default 1 */
+        ap->hi[TEX_MULTHI]          = MAX_MULT;
+        ap->lo[TEX_DECPCENTRE]      = (double)DEC_CENTRED; /* default 0 */
+        ap->hi[TEX_DECPCENTRE]      = (double)DEC_C_A_B;
+        ap->lo[TEXTURE_ATTEN]       = FLTERR;
+        ap->hi[TEXTURE_ATTEN]       = 1.0;
+        ap->lo[TEXTURE_POS]         = TEX_LEFT;
+        ap->hi[TEXTURE_POS]         = TEX_RIGHT;
+        ap->lo[TEXTURE_SPRD]        = 0.0;
+        ap->hi[TEXTURE_SPRD]        = 1.0;
+        ap->lo[TEXTURE_SEED]        = 0.0;
+        ap->hi[TEXTURE_SEED]        = MAXSHORT;
+
+        for(n=0;n<TEXTURE_SEED;n++) {
+            if(n == TEXTURE_SCAT && process == SIMPLE_TEX)
+                continue;
+            if(ap->lo[n] <0.0 || ap->hi[n] <0.0) {
+                sprintf(errstr,"Range limit of parameter %d has -ve value: invalid in TEXTURE\n",n+1);
+                return(PROGRAM_ERROR);
+            }
+        }
+        break;
+
+    case(GRAIN_COUNT):      case(GRAIN_OMIT):       case(GRAIN_DUPLICATE):
+    case(GRAIN_REORDER):    case(GRAIN_REPITCH):    case(GRAIN_RERHYTHM):
+    case(GRAIN_REMOTIF):    case(GRAIN_TIMEWARP):   case(GRAIN_POSITION):
+    case(GRAIN_ALIGN):      case(GRAIN_GET):        case(GRAIN_REVERSE):
+        ap->lo[GR_BLEN]             = min(duration,GR_MINDUR);
+        ap->hi[GR_BLEN]             = duration;
+        ap->lo[GR_GATE]             = 0.0;
+        ap->hi[GR_GATE]             = 1.0;
+        /* min GR_MINTIME size guarantees grainsize cannot be less than 2 * splicelen */
+        /*  internal algorithms depend on this fact !! */
+        ap->lo[GR_MINTIME]          = (GRAIN_SPLICELEN + GRAIN_SAFETY) * MS_TO_SECS * 2.0;
+        ap->hi[GR_MINTIME]          = duration;
+        ap->lo[GR_WINSIZE]          = 0.0;
+        ap->hi[GR_WINSIZE]          = duration * SECS_TO_MS;
+        switch(process) {
+        case(GRAIN_OMIT):       
+            ap->lo[GR_KEEP]         = 1.0;
+            ap->hi[GR_KEEP]         = GR_MAX_OUT_OF - 1.0;
+            ap->lo[GR_OUT_OF]       = 2.0;
+            ap->hi[GR_OUT_OF]       = GR_MAX_OUT_OF;
+            break;
+        case(GRAIN_DUPLICATE):  
+            ap->lo[GR_DUPLS]        = 1.0;
+            ap->hi[GR_DUPLS]        = BIG_VALUE;
+            break;
+        case(GRAIN_TIMEWARP):
+            ap->lo[GR_TSTRETCH]     = GR_MIN_TSTRETCH;
+            ap->hi[GR_TSTRETCH]     = GR_MAX_TSTRETCH;
+            break;
+        case(GRAIN_POSITION):
+            ap->lo[GR_OFFSET]       = 0.0;
+            ap->hi[GR_OFFSET]       = GR_MAX_OFFSET;
+            break;
+        case(GRAIN_ALIGN):
+            ap->lo[GR_OFFSET]       = 0.0;
+            ap->hi[GR_OFFSET]       = GR_MAX_OFFSET;
+            ap->lo[GR_GATE2]        = 0.0;
+            ap->hi[GR_GATE2]        = 1.0;
+            break;
+        }
+        break;
+    case(RRRR_EXTEND):
+        if(mode == 1) {
+            ap->lo[RRR_GATE]   = 0.0;
+            ap->hi[RRR_GATE]   = 1.0;
+            ap->lo[RRR_GRSIZ]  = LOW_RRR_SIZE;
+            ap->hi[RRR_GRSIZ]  = SECS_TO_MS;
+            ap->lo[RRR_SKIP]   = 0;
+            ap->hi[RRR_SKIP]   = 8;
+            ap->lo[RRR_AFTER]   = 0.0;
+            ap->hi[RRR_AFTER]   = duration;
+            ap->lo[RRR_TEMPO]   = LOW_RRR_SIZE * MS_TO_SECS;
+            ap->hi[RRR_TEMPO]   = A_MINUTE;
+            ap->lo[RRR_AT]      = 0;
+            ap->hi[RRR_AT]      = AN_HOUR;
+        } else {
+            ap->lo[RRR_START]   = 0.0;
+            ap->hi[RRR_START]   = duration;
+            ap->lo[RRR_END]     = 0.0;
+            ap->hi[RRR_END]     = duration;
+        }
+        ap->lo[RRR_SLOW]    = 1.0;
+        ap->hi[RRR_SLOW]    = 100;
+        ap->lo[RRR_REGU]    = 0.0;
+        ap->hi[RRR_REGU]    = 1.0;
+        ap->lo[RRR_RANGE]   = 0.0;
+        ap->hi[RRR_RANGE]   = 4.0;
+        ap->lo[RRR_GET]     = 2.0;
+        ap->hi[RRR_GET]     = 100.0;
+        if (mode != 2) {
+            ap->lo[RRR_STRETCH] = 1.0;
+            ap->hi[RRR_STRETCH] = 32767.0;
+            ap->lo[RRR_REPET]   = 1.0;
+            ap->hi[RRR_REPET]   = 32767.0;
+            ap->lo[RRR_ASCAT]   = 0.0;
+            ap->hi[RRR_ASCAT]   = 1.0;
+            ap->lo[RRR_PSCAT]   = 0.0;
+            ap->hi[RRR_PSCAT]   = 24.0;
+        }
+        break;
+    case(SSSS_EXTEND):
+        ap->lo[SSS_DUR] = .01;
+        ap->hi[SSS_DUR] = 32767.0;
+        ap->lo[NOISE_MINFRQ] = MIN_SUPRESS;
+        ap->hi[NOISE_MINFRQ] = nyquist;
+        ap->lo[MIN_NOISLEN] = 0.0;
+        ap->hi[MIN_NOISLEN] = 50.0;
+        ap->lo[MAX_NOISLEN] = 0.0;
+        ap->hi[MAX_NOISLEN] = duration;
+        ap->lo[SSS_GATE]    = 0.0;
+        ap->hi[SSS_GATE]    = 1.0;
+        break;
+    case(ENV_CREATE):
+        ap->lo[ENV_WSIZE]           = ENV_MIN_WSIZE;                /* MSECS */
+        ap->hi[ENV_WSIZE]           = ENV_MAX_WSIZE;
+        break;
+    case(ENV_BRKTOENV):
+    case(ENV_DBBRKTOENV):
+    case(ENV_IMPOSE):
+//TW NEW CASE
+    case(ENV_PROPOR):
+    case(ENV_REPLACE):
+        ap->lo[ENV_WSIZE]           = ENV_MIN_WSIZE;                /* MSECS */
+        ap->hi[ENV_WSIZE]           = duration * SECS_TO_MS;
+        break;
+    case(ENV_EXTRACT):
+        ap->lo[ENV_WSIZE]           = ENV_MIN_WSIZE;                /* MSECS */
+        ap->hi[ENV_WSIZE]           = duration * SECS_TO_MS;
+        if(mode==ENV_BRKFILE_OUT) {
+            ap->lo[ENV_DATAREDUCE]  = 0.0;
+            ap->hi[ENV_DATAREDUCE]  = 1.0;
+        }
+        break;
+    case(ENV_ENVTOBRK):
+    case(ENV_ENVTODBBRK):
+        ap->lo[ENV_DATAREDUCE]      = 0.0;
+        ap->hi[ENV_DATAREDUCE]      = 1.0;
+        break;
+    case(ENV_WARPING):
+    case(ENV_REPLOTTING):
+        ap->lo[ENV_WSIZE]           = ENV_MIN_WSIZE;                /* MSECS */
+        ap->hi[ENV_WSIZE]           = duration * SECS_TO_MS;
+        /* fall thro */
+    case(ENV_RESHAPING):
+        switch(mode) {
+        case(ENV_NORMALISE):
+        case(ENV_REVERSE):
+        case(ENV_CEILING):
+            break;
+        case(ENV_DUCKED):
+            ap->lo[ENV_GATE]        = 0.0;
+            ap->hi[ENV_GATE]        = 1.0;
+            ap->lo[ENV_THRESHOLD]   = 0.0;
+            ap->hi[ENV_THRESHOLD]   = 1.0;
+            break;
+        case(ENV_EXAGGERATING):
+            ap->lo[ENV_EXAG]        = MIN_ENV_EXAG;
+            ap->hi[ENV_EXAG]        = MAX_ENV_EXAG;
+            break;
+        case(ENV_ATTENUATING):
+            ap->lo[ENV_ATTEN]       = MIN_ENV_ATTEN;
+            ap->hi[ENV_ATTEN]       = MAX_ENV_ATTEN;
+            break;
+        case(ENV_LIFTING):
+            ap->lo[ENV_LIFT]        = 0.0;
+            ap->hi[ENV_LIFT]        = 1.0;
+            break;
+        case(ENV_FLATTENING):
+            ap->lo[ENV_FLATN]       = 2.0;
+            ap->hi[ENV_FLATN]       = MAX_ENV_FLATN;
+            break;
+        case(ENV_TSTRETCHING):
+            ap->lo[ENV_TSTRETCH]    = MIN_ENV_TSTRETCH;
+            ap->hi[ENV_TSTRETCH]    = MAX_ENV_TSTRETCH;
+            break;
+        case(ENV_GATING):
+            ap->lo[ENV_GATE]        = 0.0;
+            ap->hi[ENV_GATE]        = 1.0;
+            ap->lo[ENV_SMOOTH]      = 0.0;
+            ap->hi[ENV_SMOOTH]      = MAX_ENV_SMOOTH;
+            break;
+        case(ENV_INVERTING):
+            ap->lo[ENV_GATE]        = 0.0;
+            ap->hi[ENV_GATE]        = 1.0;
+            ap->lo[ENV_MIRROR]      = 0.0;
+            ap->hi[ENV_MIRROR]      = 1.0;
+            break;
+        case(ENV_LIMITING):
+            ap->lo[ENV_LIMIT]       = 0.0;
+            ap->hi[ENV_LIMIT]       = 1.0;
+            ap->lo[ENV_THRESHOLD]   = 0.0;
+            ap->hi[ENV_THRESHOLD]   = 1.0;
+            break;
+        case(ENV_CORRUGATING):
+            ap->lo[ENV_TROFDEL]     = 1.0;
+            ap->hi[ENV_TROFDEL]     = BIG_VALUE;
+            /* fall thro */
+        case(ENV_PEAKCNT):
+            ap->lo[ENV_PKSRCHWIDTH] = 2.0;
+            ap->hi[ENV_PKSRCHWIDTH] = BIG_VALUE;
+            break;
+        case(ENV_EXPANDING):
+            ap->lo[ENV_GATE]        = 0.0;
+            ap->hi[ENV_GATE]        = 1.0;
+            ap->lo[ENV_THRESHOLD]   = 0.0;
+            ap->hi[ENV_THRESHOLD]   = 1.0;
+            ap->lo[ENV_SMOOTH]      = 0.0;
+            ap->hi[ENV_SMOOTH]      = MAX_ENV_SMOOTH;
+            break;
+        case(ENV_TRIGGERING):
+            ap->lo[ENV_GATE]        = 0.0;
+            ap->hi[ENV_GATE]        = 1.0;
+            ap->lo[ENV_TRIGRISE]    = 1.0/(double)MAXSHORT;
+            ap->hi[ENV_TRIGRISE]    = 1.0;
+            ap->lo[ENV_TRIGDUR]     = ENV_MIN_WSIZE;
+            ap->hi[ENV_TRIGDUR]     = duration * SECS_TO_MS;
+            break;
+        default:
+            sprintf(errstr,"Unknown case for ENVWARP,RESHAPING or REPLOTTING: set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }                 
+        switch(process) {
+        case(ENV_WARPING):
+            ap->lo[ENV_WSIZE]       = ENV_MIN_WSIZE;                /* MSECS */
+            ap->hi[ENV_WSIZE]       = duration * SECS_TO_MS;
+            break;
+        case(ENV_REPLOTTING):
+            ap->lo[ENV_WSIZE]       = ENV_MIN_WSIZE;                /* MSECS */
+            ap->hi[ENV_WSIZE]       = duration * SECS_TO_MS;
+            ap->lo[ENV_DATAREDUCE]  = 0.0;
+            ap->hi[ENV_DATAREDUCE]  = 1.0;
+        }
+        break;
+    case(ENV_DOVETAILING):
+        ap->lo[ENV_STARTTRIM]       = 0.0;
+        ap->hi[ENV_STARTTRIM]       = duration;
+        ap->lo[ENV_ENDTRIM]         = 0.0;
+        ap->hi[ENV_ENDTRIM]         = duration;
+        ap->lo[ENV_STARTTYPE]       = (double)ENVTYPE_LIN;
+        ap->hi[ENV_STARTTYPE]       = (double)ENVTYPE_EXP;
+        ap->lo[ENV_ENDTYPE]         = (double)ENVTYPE_LIN;
+        ap->hi[ENV_ENDTYPE]         = (double)ENVTYPE_EXP;
+        ap->lo[ENV_TIMETYPE]        = (double)ENV_TIMETYPE_SECS;
+        ap->hi[ENV_TIMETYPE]        = (double)ENV_TIMETYPE_STSMPS;
+        break;
+    case(ENV_CURTAILING):
+        ap->lo[ENV_STARTTIME]       = 0.0;
+        ap->hi[ENV_STARTTIME]       = duration;
+        ap->lo[ENV_ENDTIME]         = 0.0;
+        ap->hi[ENV_ENDTIME]         = duration;
+        ap->lo[ENV_ENVTYPE]         = (double)ENVTYPE_LIN;
+        ap->hi[ENV_ENVTYPE]         = (double)ENVTYPE_EXP;
+        ap->lo[ENV_TIMETYPE]        = (double)ENV_TIMETYPE_SECS;
+        ap->hi[ENV_TIMETYPE]        = (double)ENV_TIMETYPE_STSMPS;
+        break;
+    case(ENV_SWELL):
+        ap->lo[ENV_PEAKTIME]        = ENV_MIN_WSIZE * MS_TO_SECS;
+        ap->hi[ENV_PEAKTIME]        = duration - (ENV_MIN_WSIZE * MS_TO_SECS);
+        ap->lo[ENV_ENVTYPE]         = (double)ENVTYPE_LIN;
+        ap->hi[ENV_ENVTYPE]         = (double)ENVTYPE_EXP;
+        break;
+    case(ENV_ATTACK):
+        switch(mode) {
+        case(ENV_ATK_GATED):
+            ap->lo[ENV_ATK_GATE]    = 0.0;
+            ap->hi[ENV_ATK_GATE]    = 1.0;
+            break;
+        case(ENV_ATK_TIMED):
+        case(ENV_ATK_XTIME):
+            ap->lo[ENV_ATK_ATTIME]  = 0.0;
+            ap->hi[ENV_ATK_ATTIME]  = duration - (ENV_MIN_ATK_ONSET * MS_TO_SECS);
+            break;
+        case(ENV_ATK_ATMAX):
+            break;
+        }
+        ap->lo[ENV_ATK_GAIN]        = 1.0;
+        ap->hi[ENV_ATK_GAIN]        = (double)MAXSHORT;
+        ap->lo[ENV_ATK_ONSET]       = ENV_MIN_ATK_ONSET;
+        ap->hi[ENV_ATK_ONSET]       = (double)BIG_TIME;
+        ap->lo[ENV_ATK_TAIL]        = ENV_MIN_ATK_ONSET;
+        ap->hi[ENV_ATK_TAIL]        = (duration * SECS_TO_MS) - ENV_MIN_ATK_ONSET;
+        ap->lo[ENV_ATK_ENVTYPE]     = ENVTYPE_LIN;
+        ap->hi[ENV_ATK_ENVTYPE]     = ENVTYPE_EXP;
+        break;
+    case(ENV_PLUCK):
+        ap->lo[ENV_PLK_ENDSAMP]     = 0.0;
+        ap->hi[ENV_PLK_ENDSAMP]     = round(min(ENV_PLK_ENDSAMP_MAXTIME,duration)) * srate * channels;
+        ap->lo[ENV_PLK_WAVELEN]     = round(sr/ENV_PLK_FRQ_MAX);
+        ap->hi[ENV_PLK_WAVELEN]     = round(sr/ENV_PLK_FRQ_MIN);
+        ap->lo[ENV_PLK_CYCLEN]      = ENV_PLK_CYCLEN_MIN;
+        ap->hi[ENV_PLK_CYCLEN]      = ENV_PLK_CYCLEN_MAX;
+        ap->lo[ENV_PLK_DECAY]       = ENV_PLK_DECAY_MIN;
+        ap->hi[ENV_PLK_DECAY]       = ENV_PLK_DECAY_MAX;
+        break;
+    case(ENV_TREMOL):
+        ap->lo[ENV_TREM_FRQ]        = 0.0;
+        ap->hi[ENV_TREM_FRQ]        = ENV_TREM_MAXFRQ;
+        ap->lo[ENV_TREM_DEPTH]      = 0.0;
+        ap->hi[ENV_TREM_DEPTH]      = 1.0;
+        ap->lo[ENV_TREM_AMP]        = 0.0;
+        ap->hi[ENV_TREM_AMP]        = 1.0;
+        break;
+    case(ENV_DBBRKTOBRK):
+    case(ENV_BRKTODBBRK):
+        break;
+
+    case(MIX):
+        ap->lo[MIX_ATTEN]           = 0.0;
+        ap->hi[MIX_ATTEN]           = 1.0;
+        /* fall thro */
+    case(MIXMAX):
+        ap->lo[MIX_START]           = 0.0;
+        ap->hi[MIX_START]           = duration;
+        ap->lo[MIX_END]             = 0.0;
+        ap->hi[MIX_END]             = duration;
+        break;
+    case(MIXCROSS):
+        ap->lo[MCR_STAGGER]         = 0.0;
+        ap->hi[MCR_STAGGER]         = duration;
+        ap->lo[MCR_BEGIN]           = 0.0;
+        ap->hi[MCR_BEGIN]           = duration;
+        ap->lo[MCR_END]             = 0.0;
+        ap->hi[MCR_END]             = BIG_TIME;
+        if(mode==MCCOS) {
+            ap->lo[MCR_POWFAC]      = MIN_MCR_POWFAC;
+            ap->hi[MCR_POWFAC]      = MAX_MCR_POWFAC;
+        }
+        break;
+    case(MIXTWO):
+        ap->lo[MIX_STAGGER]         = 0.0;
+        ap->hi[MIX_STAGGER]         = duration;
+        ap->lo[MIX_SKIP]            = 0.0;
+        ap->hi[MIX_SKIP]            = BIG_TIME;
+        ap->lo[MIX_SKEW]            = 1.0/(double)MAXSHORT;
+        ap->hi[MIX_SKEW]            = (double)MAXSHORT;
+        ap->lo[MIX_DURA]            = 0.0;
+        ap->hi[MIX_DURA]            = 32767.0;
+        ap->lo[MIX_STTA]            = 0.0;
+        ap->hi[MIX_STTA]            = 32767.0;
+        break;
+//TW NEW CASE
+    case(MIXMANY):
+        break;
+    case(MIXBALANCE):
+        ap->lo[MIX_STAGGER]         = 0.0;
+        ap->hi[MIX_STAGGER]         = 1.0;
+        ap->lo[MIX_SKIP]            = 0.0;
+        ap->hi[MIX_SKIP]            = duration;
+        ap->lo[MIX_SKEW]            = 0.0;
+        ap->hi[MIX_SKEW]            = duration;
+        break;
+    case(MIXINBETWEEN):
+        switch(mode) {
+        case(INBI_COUNT):
+            ap->lo[INBETW]          = 1.0;
+            ap->hi[INBETW]          = (double)MAXBETWEEN;
+            break;
+        case(INBI_RATIO):   /* TW param read as special data */
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for MIXINBETWEEN: set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(CYCINBETWEEN):
+        ap->lo[INBETW]          = 1.0;
+        ap->hi[INBETW]          = (double)MAXBETWEEN;
+        ap->lo[BTWN_HFRQ]      = (double)10.0;
+        ap->hi[BTWN_HFRQ]      = (double)nyquist;
+        break;
+    case(MIXTEST):
+    case(MIXFORMAT):
+    case(MIXDUMMY):
+    case(MIXINTERL):
+    case(MIXSYNC):
+//TW NEW CASE
+    case(ADDTOMIX):
+        break;
+    case(MIXSYNCATT):
+        ap->lo[MSY_WFAC]            = (double)MIN_WINFAC;
+        ap->hi[MSY_WFAC]            = (double)MAX_WINFAC;
+        break;
+    case(MIXGAIN):         
+        ap->lo[MIX_GAIN]            = 0.0;
+        ap->hi[MIX_GAIN]            = (double)MAXSHORT;
+        ap->lo[MSH_ENDLINE]         = 1.0;
+        ap->hi[MSH_ENDLINE]         = (double)linecnt;
+        ap->lo[MSH_STARTLINE]       = 1.0;
+        ap->hi[MSH_STARTLINE]       = (double)linecnt;
+        break;
+    case(MIXTWARP):
+        switch(mode) {
+        case(MTW_TIMESORT):
+        case(MTW_REVERSE_T):
+        case(MTW_REVERSE_NT):
+        case(MTW_FREEZE_T):
+        case(MTW_FREEZE_NT):
+            break;
+        case(MTW_SCATTER):
+            ap->lo[MTW_PARAM]       = 0.0;
+            ap->hi[MTW_PARAM]       = 1.0;
+            break;
+        case(MTW_DOMINO):
+            ap->lo[MTW_PARAM]       = -BIG_TIME;
+            ap->hi[MTW_PARAM]       = BIG_TIME;
+            break;
+        case(MTW_ADD_TO_TG):
+            ap->lo[MTW_PARAM]       = -BIG_TIME;
+            ap->hi[MTW_PARAM]       = BIG_TIME;
+            break;
+        case(MTW_CREATE_TG_1):  case(MTW_CREATE_TG_2): case(MTW_CREATE_TG_3):   case(MTW_CREATE_TG_4):
+        case(MTW_ENLARGE_TG_1): case(MTW_ENLARGE_TG_2): case(MTW_ENLARGE_TG_3): case(MTW_ENLARGE_TG_4):
+            ap->lo[MTW_PARAM]       = 0.0;
+            ap->hi[MTW_PARAM]       = BIG_TIME;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for MIXTWARP: in set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(mode != MTW_TIMESORT) {
+            ap->lo[MSH_ENDLINE]     = 1.0;
+            ap->hi[MSH_ENDLINE]     = (double)linecnt;
+            ap->lo[MSH_STARTLINE]   = 1.0;
+            ap->hi[MSH_STARTLINE]   = (double)linecnt;
+        }
+        break;
+    case(MIXSWARP):
+        switch(mode) {
+        case(MSW_TWISTALL):
+            break;
+        case(MSW_TWISTONE):
+            ap->lo[MSW_TWLINE]      = 1.0;
+            ap->hi[MSW_TWLINE]      = (double)linecnt;
+            break;
+        case(MSW_NARROWED):
+            ap->lo[MSW_NARROWING]   = 0.0;
+            ap->hi[MSW_NARROWING]   = 1.0;
+            break;
+        case(MSW_LEFTWARDS): 
+        case(MSW_RIGHTWARDS): 
+        case(MSW_RANDOM): 
+        case(MSW_RANDOM_ALT):
+            ap->lo[MSW_POS2]        = PAN_LEFT;
+            ap->hi[MSW_POS2]        = PAN_RIGHT;
+            /* fall thro */
+        case(MSW_FIXED):
+            ap->lo[MSW_POS1]        = PAN_LEFT;
+            ap->hi[MSW_POS1]        = PAN_RIGHT;
+            break;
+        default:
+            sprintf(errstr,"Unknown mode for MIXSWARP: in set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(mode!=MSW_TWISTALL && mode!=MSW_TWISTONE) {
+            ap->lo[MSH_ENDLINE]     = 1.0;
+            ap->hi[MSH_ENDLINE]     = (double)linecnt;
+            ap->lo[MSH_STARTLINE]   = 1.0;
+            ap->hi[MSH_STARTLINE]   = (double)linecnt;
+        }
+        break;
+    case(MIXSHUFL):        
+        ap->lo[MSH_ENDLINE]         = 1.0;
+        ap->hi[MSH_ENDLINE]         = (double)linecnt;
+        ap->lo[MSH_STARTLINE]       = 1.0;
+        ap->hi[MSH_STARTLINE]       = (double)linecnt;
+        break;
+//TW NEW CASES
+    case(MIX_ON_GRID):
+        break;
+    case(AUTOMIX):
+        ap->lo[0]           = 0.0;
+        ap->hi[0]           = 256.0;
+        break;
+    case(MIX_PAN):
+        ap->lo[PAN_PAN]     = -MAX_PANNING;
+        ap->hi[PAN_PAN]     = MAX_PANNING;
+        break;
+    case(MIX_AT_STEP):
+        ap->lo[MIX_STEP]    = 0.0;
+        ap->hi[MIX_STEP]    = 10000.0;
+        break;
+    case(SHUDDER):
+        ap->lo[SHUD_STARTTIME]      = 0.0;
+        ap->hi[SHUD_STARTTIME]      = duration;
+        ap->lo[SHUD_FRQ]            = 0.1;
+        ap->hi[SHUD_FRQ]            = 100.0;
+        ap->lo[SHUD_SCAT]           = 0.0;
+        ap->hi[SHUD_SCAT]           = 1.0;
+        ap->lo[SHUD_SPREAD]         = 0.0;
+        ap->hi[SHUD_SPREAD]         = 1.0;
+        ap->lo[SHUD_MINDEPTH]       = 0.0;
+        ap->hi[SHUD_MINDEPTH]       = 1.0;
+        ap->lo[SHUD_MAXDEPTH]       = 0.0;
+        ap->hi[SHUD_MAXDEPTH]       = 1.0;
+        ap->lo[SHUD_MINWIDTH]       = 0.02;
+        ap->hi[SHUD_MINWIDTH]       = duration;
+        ap->lo[SHUD_MAXWIDTH]       = 0.02;
+        ap->hi[SHUD_MAXWIDTH]       = duration;
+        break;
+
+    case(EQ):
+        switch(mode) {
+        case(FLT_PEAKING):
+            ap->lo[FLT_BW]          = 0.001;
+            ap->hi[FLT_BW]          = nyquist;
+            /* fall thro */
+        default:
+            ap->lo[FLT_BOOST]       = FLT_MINDBGAIN;
+            ap->hi[FLT_BOOST]       = FLT_MAXDBGAIN;
+            ap->lo[FLT_ONEFRQ]      = FLT_MINFRQ;
+            ap->hi[FLT_ONEFRQ]      = FLT_MAXFRQ;
+            ap->lo[FLT_PRESCALE]    = FLT_MINEQPRESCALE;
+            ap->hi[FLT_PRESCALE]    = FLT_MAXEQPRESCALE;
+//TW NEW PARAM
+            ap->lo[FILT_TAIL]       = 0.0;
+            ap->hi[FILT_TAIL]       = FLT_TAIL;
+            break;
+        }
+        break;
+    case(LPHP):
+        ap->lo[FLT_GAIN]            = MIN_DB_ON_16_BIT;
+        ap->hi[FLT_GAIN]            = 0.0;
+        ap->lo[FLT_PRESCALE]        = FLT_MINEQPRESCALE;
+        ap->hi[FLT_PRESCALE]        = FLT_MAXEQPRESCALE;
+//TW NEW PARAM
+        ap->lo[FILT_TAIL]           = 0.0;
+        ap->hi[FILT_TAIL]           = FLT_TAIL;
+        switch(mode) {
+        case(FLT_HZ):
+            ap->lo[FLT_PASSFRQ]     = FLT_MINFRQ;
+            ap->hi[FLT_PASSFRQ]     = FLT_MAXFRQ;
+            ap->lo[FLT_STOPFRQ]     = FLT_MINFRQ;
+            ap->hi[FLT_STOPFRQ]     = FLT_MAXFRQ;
+            break;
+        case(FLT_MIDI):
+            ap->lo[FLT_PASSFRQ]     = unchecked_hztomidi(FLT_MINFRQ);
+            ap->hi[FLT_PASSFRQ]     = MIDIMAX;
+            ap->lo[FLT_STOPFRQ]     = unchecked_hztomidi(FLT_MINFRQ);
+            ap->hi[FLT_STOPFRQ]     = MIDIMAX;
+            break;
+        default:
+            sprintf(errstr,"Unknown case for LPHP: set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(FSTATVAR):
+        ap->lo[FLT_Q]               = MIN_ACUITY;   /* parametere is acutrally 1/Q */
+        ap->hi[FLT_Q]               = MAX_ACUITY;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+        ap->lo[FLT_ONEFRQ]          = FLT_MINFRQ;
+        ap->hi[FLT_ONEFRQ]          = FLT_MAXFRQ;
+//TW NEW PARAM
+        ap->lo[FILT_TAIL]           = 0.0;
+        ap->hi[FILT_TAIL]           = FLT_TAIL;
+        break;
+    case(FLTBANKN):     
+        ap->lo[FLT_Q]               = MINQ;
+        ap->hi[FLT_Q]               = MAXQ;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+//TW NEW PARAM
+        ap->lo[FILT_TAIL]           = 0.0;
+        ap->hi[FILT_TAIL]           = FLT_TAIL;
+        /* fall thro */
+    case(FLTBANKC):
+        ap->lo[FLT_LOFRQ]           = FLT_MINFRQ;
+        ap->hi[FLT_LOFRQ]           = FLT_MAXFRQ;
+        ap->lo[FLT_HIFRQ]           = FLT_MINFRQ;
+        ap->hi[FLT_HIFRQ]           = FLT_MAXFRQ;
+        switch(mode) {
+        case(FLT_LINOFFSET):
+            ap->lo[FLT_OFFSET]      = -FLT_MAXFRQ;
+            ap->hi[FLT_OFFSET]      = FLT_MAXFRQ;
+            break;
+        case(FLT_EQUALSPAN):
+            ap->lo[FLT_INCOUNT]     = 1.0;
+            ap->hi[FLT_INCOUNT]     = (double)FLT_MAX_FILTERS;
+            break;
+        case(FLT_EQUALINT):
+            ap->lo[FLT_INTSIZE]     = FLT_MININT;
+            ap->hi[FLT_INTSIZE]     = FLT_MAXINT;
+            break;
+        }
+        ap->lo[FLT_RANDFACT]        = 0.0;
+        ap->hi[FLT_RANDFACT]        = 1.0;
+        break;
+    case(FLTBANKU):     
+        ap->lo[FLT_Q]               = MINQ;
+        ap->hi[FLT_Q]               = MAXQ;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+        ap->lo[FILT_TAIL]           = 0.0;
+        ap->hi[FILT_TAIL]           = FLT_TAIL;
+        break;
+    case(FLTBANKV):
+        ap->lo[FLT_Q]               = MINQ;
+        ap->hi[FLT_Q]               = MAXQ;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+        ap->lo[FLT_HARMCNT]         = 1.0;
+        ap->hi[FLT_HARMCNT]         = FLT_MAXHARMS;
+        ap->lo[FLT_ROLLOFF]         = MIN_DB_ON_16_BIT;
+        ap->hi[FLT_ROLLOFF]         = 0.0;
+        ap->lo[FILT_TAILV]          = 0.0;
+        ap->hi[FILT_TAILV]          = FLT_TAIL;
+        break;
+    case(FLTBANKV2):
+        ap->lo[FLT_Q]               = MINQ;
+        ap->hi[FLT_Q]               = MAXQ;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+        ap->lo[FILT_TAILV]          = 0.0;
+        ap->hi[FILT_TAILV]          = FLT_TAIL;
+        break;
+    case(FLTSWEEP):
+        ap->lo[FLT_Q]               = MIN_ACUITY;
+        ap->hi[FLT_Q]               = MAX_ACUITY;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+        ap->lo[FLT_LOFRQ]           = FLT_MINFRQ;
+        ap->hi[FLT_LOFRQ]           = FLT_MAXFRQ;
+        ap->lo[FLT_HIFRQ]           = FLT_MINFRQ;
+        ap->hi[FLT_HIFRQ]           = FLT_MAXFRQ;
+        ap->lo[FLT_SWPFRQ]          = 0.0;
+        ap->hi[FLT_SWPFRQ]          = FLT_MAXSWEEP;
+        ap->lo[FLT_SWPPHASE]        = 0.0;
+        ap->hi[FLT_SWPPHASE]        = 1.0;
+//TW NEW PARAM
+        ap->lo[FILT_TAIL]           = 0.0;
+        ap->hi[FILT_TAIL]           = FLT_TAIL;
+        break;
+    case(FLTITER):
+        ap->lo[FLT_Q]               = MINQ;
+        ap->hi[FLT_Q]               = MAXQ;
+        ap->lo[FLT_GAIN]            = FLT_MINGAIN;
+        ap->hi[FLT_GAIN]            = FLT_MAXGAIN;
+        ap->lo[FLT_DELAY]           = FLTERR;
+        ap->hi[FLT_DELAY]           = FLT_MAXDELAY;
+        ap->lo[FLT_OUTDUR]          = duration;
+        ap->hi[FLT_OUTDUR]          = BIG_TIME;
+        ap->lo[FLT_PRESCALE]        = FLT_MINPRESCALE;
+        ap->hi[FLT_PRESCALE]        = FLT_MAXPRESCALE;
+        ap->lo[FLT_RANDDEL]         = 0.0;
+        ap->hi[FLT_RANDDEL]         = 1.0;
+        ap->lo[FLT_PSHIFT]          = 0.0;
+        ap->hi[FLT_PSHIFT]          = FLT_MAX_PSHIFT;   /* semitones */
+        ap->lo[FLT_AMPSHIFT]        = 0.0;
+        ap->hi[FLT_AMPSHIFT]        = 1.0;
+        break;
+    case(ALLPASS):      
+        ap->lo[FLT_GAIN]            = -1.0;
+        ap->hi[FLT_GAIN]            = 1.0;
+        ap->lo[FLT_DELAY]           = (1.0/sr) * SECS_TO_MS;
+        ap->hi[FLT_DELAY]           = (duration/2.0) * SECS_TO_MS;
+        ap->lo[FLT_PRESCALE]        = FLT_MINPRESCALE;
+        ap->hi[FLT_PRESCALE]        = FLT_MAXPRESCALE;
+//TW NEW PARAM
+        ap->lo[FILT_TAIL]           = 0.0;
+        ap->hi[FILT_TAIL]           = FLT_TAIL;
+        break;
+
+    case(MOD_LOUDNESS):
+        switch(mode) {
+        case(LOUDNESS_GAIN):
+            ap->lo[LOUD_GAIN]       = 0.0;
+            ap->hi[LOUD_GAIN]       = (double)MAXSHORT;
+            break;
+        case(LOUDNESS_DBGAIN):
+            ap->lo[LOUD_GAIN]       = MIN_DB_ON_16_BIT;
+            ap->hi[LOUD_GAIN]       = /*0.0*/MAX_DB_ON_16_BIT;
+            break;
+        case(LOUDNESS_NORM):
+        case(LOUDNESS_SET):
+            ap->lo[LOUD_LEVEL]      = 1.0/(double)MAXSHORT;
+            ap->hi[LOUD_LEVEL]      = 1.0;
+            break;
+        }
+        break;
+
+    case(MOD_SPACE):
+        switch(mode) {
+        case(MOD_PAN):
+            ap->lo[PAN_PAN]         = -MAX_PANNING;
+            ap->hi[PAN_PAN]         = MAX_PANNING;
+            ap->lo[PAN_PRESCALE]    = 1.0/(double)MAXSHORT;
+            ap->hi[PAN_PRESCALE]    = 2.0;
+            break;
+        case(MOD_NARROW):
+            ap->lo[NARROW]          = -1.0;
+            ap->hi[NARROW]          = 1.0;
+            break;
+        }
+        break;
+//TW NEW CASES
+        case(SCALED_PAN):
+        ap->lo[PAN_PAN]         = -MAX_PANNING;
+        ap->hi[PAN_PAN]         = MAX_PANNING;
+        ap->lo[PAN_PRESCALE]    = 1.0/(double)MAXSHORT;
+        ap->hi[PAN_PRESCALE]    = 2.0;
+        break;
+    case(FIND_PANPOS):
+        ap->lo[PAN_PAN]         = 0.0;
+        ap->hi[PAN_PAN]         = duration;
+        break;
+
+    case(MOD_PITCH):
+        switch(mode) {
+        case(MOD_TRANSPOS):
+        case(MOD_TRANSPOS_INFO):
+            ap->lo[VTRANS_TRANS]    = MIN_TRANSPOS;
+            ap->hi[VTRANS_TRANS]    = MAX_TRANSPOS;
+            break;
+        case(MOD_TRANSPOS_SEMIT):
+        case(MOD_TRANSPOS_SEMIT_INFO):
+            ap->lo[VTRANS_TRANS]    = EIGHT_8VA_DOWN;
+            ap->hi[VTRANS_TRANS]    = EIGHT_8VA_UP;
+            break;
+        case(MOD_ACCEL):
+            ap->lo[ACCEL_ACCEL]     = MIN_ACCEL;
+            ap->hi[ACCEL_ACCEL]     = MAX_ACCEL;
+            ap->lo[ACCEL_GOALTIME]  = MINTIME_ACCEL;
+            ap->hi[ACCEL_GOALTIME]  = duration;
+            ap->lo[ACCEL_STARTTIME] = 0.0;
+            ap->hi[ACCEL_STARTTIME] = duration - MINTIME_ACCEL;
+            break;
+        case(MOD_VIBRATO):
+            ap->lo[VIB_FRQ]         = 0.0;
+            ap->hi[VIB_FRQ]         = MAX_VIB_FRQ;
+            ap->lo[VIB_DEPTH]       = 0.0;
+            ap->hi[VIB_DEPTH]       = EIGHT_8VA_UP;
+            break;
+        }
+        break;
+
+    case(MOD_REVECHO):
+        switch(mode) {
+        case(MOD_STADIUM):
+            ap->lo[STAD_PREGAIN]    = 1.0/(double)MAXSHORT;
+            ap->hi[STAD_PREGAIN]    = 1.0;
+            ap->lo[STAD_ROLLOFF]    = 1.0/(double)MAXSHORT;
+            ap->hi[STAD_ROLLOFF]    = 1.0;
+            ap->lo[STAD_SIZE]       = (DFLT_STAD_DELTIME * 2.0)/srate;
+            ap->hi[STAD_SIZE]       = MAX_STAD_DELAY;   /* arbitrary */
+            ap->lo[STAD_ECHOCNT]    = (double)2;
+            ap->hi[STAD_ECHOCNT]    = (double)MAX_ECHOCNT;
+            break;
+        case(MOD_DELAY):
+        case(MOD_VDELAY):
+            ap->lo[DELAY_LFOMOD]    = 0.0;
+            ap->hi[DELAY_LFOMOD]    = 1.0;
+            ap->lo[DELAY_LFOFRQ]    = -50.0;
+            ap->hi[DELAY_LFOFRQ]    = 50.0;
+            ap->lo[DELAY_LFOPHASE]  = 0.0;
+            ap->hi[DELAY_LFOPHASE]  = 1.0;
+            ap->lo[DELAY_LFODELAY]  = 0.0;
+            ap->hi[DELAY_LFODELAY]  = duration;
+            ap->lo[DELAY_DELAY]     = (1.0/sr) * SECS_TO_MS;
+            ap->hi[DELAY_DELAY]     = MAX_DELAY;
+            ap->lo[DELAY_MIX]       = 0.0;
+            ap->hi[DELAY_MIX]       = 1.0;
+            ap->lo[DELAY_FEEDBACK]  = -1.0;
+            ap->hi[DELAY_FEEDBACK]  = 1.0;
+            ap->lo[DELAY_TRAILTIME] = 0.0;
+            ap->hi[DELAY_TRAILTIME] = 30.0;
+            ap->lo[DELAY_PRESCALE]  = 1.0/(double)MAXSHORT;
+            ap->hi[DELAY_PRESCALE]  = 1.0;
+            if(mode==MOD_VDELAY) {
+                ap->lo[DELAY_SEED]  = 0.0;
+                ap->hi[DELAY_SEED]  = 256.0;
+            }
+            break;
+        }
+        break;
+
+    case(MOD_RADICAL):
+        switch(mode) {
+        case(MOD_REVERSE):
+            break;
+        case(MOD_SHRED):
+            ap->lo[SHRED_CNT]       = 1.0;
+            ap->hi[SHRED_CNT]       = (double)MAXSHRED;
+            ap->lo[SHRED_CHLEN]     = (double)((SHRED_SPLICELEN  * 3)/(double)srate);
+            ap->hi[SHRED_CHLEN]     = (duration/2)-FLTERR;
+            ap->lo[SHRED_SCAT]      = 0.0;
+            ap->hi[SHRED_SCAT]      = (double)MAX_SHR_SCATTER;
+            break;
+        case(MOD_SCRUB):
+            ap->lo[SCRUB_TOTALDUR]      = (double)channels/(double)srate;
+            ap->hi[SCRUB_TOTALDUR]      = BIG_TIME;
+            ap->lo[SCRUB_MINSPEED]      = SCRUB_SPEED_MIN;
+            ap->hi[SCRUB_MINSPEED]      = SCRUB_SPEED_MAX;
+            ap->lo[SCRUB_MAXSPEED]      = SCRUB_SPEED_MIN;
+            ap->hi[SCRUB_MAXSPEED]      = SCRUB_SPEED_MAX;
+            ap->lo[SCRUB_STARTRANGE]    = 0.0;
+            ap->hi[SCRUB_STARTRANGE]    = duration - ((double)channels/(double)srate);
+            ap->lo[SCRUB_ESTART]        = (double)channels/(double)srate;
+            ap->hi[SCRUB_ESTART]        = duration;
+            break;
+        case(MOD_LOBIT):
+            ap->lo[LOBIT_BRES]      = 1.0;
+            ap->hi[LOBIT_BRES]      = (double)MAX_BIT_DIV;
+            ap->lo[LOBIT_TSCAN]     = 1.0;
+            ap->hi[LOBIT_TSCAN]     = (double)MAX_SRATE_DIV;
+            break;
+        case(MOD_LOBIT2):
+            ap->lo[LOBIT_BRES]      = 1.0;
+            ap->hi[LOBIT_BRES]      = (double)MAX_BIT_DIV;
+            break;
+        case(MOD_RINGMOD):
+            ap->lo[RM_FRQ]          = MIN_RING_MOD_FRQ;
+            ap->hi[RM_FRQ]          = nyquist;
+            break;
+        case(MOD_CROSSMOD): 
+            break;
+        }
+        break;
+
+    case(BRASSAGE):
+        ap->lo[GRS_VELOCITY]        = 0.0;
+        ap->hi[GRS_VELOCITY]        = GRS_MAX_VELOCITY;
+        switch(mode) {
+        case(GRS_REVERB):
+            ap->lo[GRS_DENSITY]     = GRS_DEFAULT_DENSITY;
+            ap->hi[GRS_DENSITY]     = GRS_MAX_DENSITY;
+            break;
+        case(GRS_GRANULATE):
+            ap->lo[GRS_DENSITY]     = FLTERR;
+            ap->hi[GRS_DENSITY]     = GRS_DEFAULT_DENSITY;
+            break;
+        default:
+            ap->lo[GRS_DENSITY]     = FLTERR;
+            ap->hi[GRS_DENSITY]     = GRS_MAX_DENSITY;
+            break;
+        }
+        ap->lo[GRS_HVELOCITY]       = 0.0;
+        ap->hi[GRS_HVELOCITY]       = MAX_GRS_HVELOCITY;
+        ap->lo[GRS_HDENSITY]        = (1.0/sr);
+        ap->hi[GRS_HDENSITY]        = (double)MAXSHORT/2.0;
+        switch(mode) {
+        case(GRS_PITCHSHIFT):   
+        case(GRS_TIMESTRETCH):  
+        case(GRS_SCRAMBLE): 
+            ap->lo[GRS_GRAINSIZE]   = GRS_DEFAULT_SPLICELEN * 2.0;
+            ap->lo[GRS_HGRAINSIZE]  = GRS_DEFAULT_SPLICELEN * 2.0;
+        default:
+            ap->lo[GRS_GRAINSIZE]   = GRS_MIN_SPLICELEN * 2.0;
+            ap->lo[GRS_HGRAINSIZE]  = GRS_MIN_SPLICELEN * 2.0;
+        }
+        ap->hi[GRS_GRAINSIZE]       = (infilesize_in_samps/sr) * SECS_TO_MS;
+        ap->hi[GRS_HGRAINSIZE]      = (infilesize_in_samps/sr) * SECS_TO_MS;
+        switch(mode) {
+        case(GRS_REVERB):
+            ap->lo[GRS_PITCH]       = -GRS_DEFAULT_REVERB_PSHIFT;
+            ap->hi[GRS_PITCH]       = GRS_DEFAULT_REVERB_PSHIFT;
+            break;
+        default:
+            ap->hi[GRS_PITCH]       = LOG2(nyquist/MIN_LIKELY_PITCH) * SEMITONES_PER_OCTAVE;
+            ap->lo[GRS_PITCH]       = -(ap->hi[GRS_PITCH]);
+            break;
+        }
+        ap->lo[GRS_AMP]             = 0.0;
+        ap->hi[GRS_AMP]             = 1.0;
+        ap->lo[GRS_SPACE]           = 0.0;
+        ap->hi[GRS_SPACE]           = 16.0;
+        ap->lo[GRS_BSPLICE]         = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_BSPLICE]         = ap->hi[GRS_GRAINSIZE]/2.0;
+        ap->lo[GRS_ESPLICE]         = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_ESPLICE]         = ap->hi[GRS_GRAINSIZE]/2.0;
+//TW UPDATE
+//      ap->hi[GRS_HPITCH]          = LOG2(nyquist/MIN_LIKELY_PITCH);
+        ap->hi[GRS_HPITCH]          = LOG2(nyquist/MIN_LIKELY_PITCH) * SEMITONES_PER_OCTAVE;
+        ap->lo[GRS_HPITCH]          = -(ap->hi[GRS_HPITCH]);
+        ap->lo[GRS_HAMP]            = 0.0;
+        ap->hi[GRS_HAMP]            = 1.0;
+        ap->lo[GRS_HSPACE]          = 0.0;
+        ap->hi[GRS_HSPACE]          = 16.0;
+        ap->lo[GRS_HBSPLICE]        = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_HBSPLICE]        = ap->hi[GRS_GRAINSIZE]/2.0;
+        ap->lo[GRS_HESPLICE]        = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_HESPLICE]        = ap->hi[GRS_GRAINSIZE]/2.0;
+        switch(mode) {
+        case(GRS_REVERB):
+            ap->lo[GRS_SRCHRANGE]   = 0.0;
+            ap->hi[GRS_SRCHRANGE]   = GRS_DEFAULT_REVERB_SRCHRANGE;
+            break;
+        case(GRS_SCRAMBLE):
+        case(GRS_BRASSAGE):
+        case(GRS_FULL_MONTY):
+            ap->lo[GRS_SRCHRANGE]   = 0.0;
+            ap->hi[GRS_SRCHRANGE]   = (duration * 2.0) * SECS_TO_MS;
+            break;
+        }
+        switch(mode) {
+        case(GRS_BRASSAGE):
+        case(GRS_FULL_MONTY):
+            ap->lo[GRS_SCATTER]         = 0.0;
+            ap->hi[GRS_SCATTER]         = 1.0;
+            ap->lo[GRS_OUTLEN]          = 0.0;
+            ap->hi[GRS_OUTLEN]          = BIG_TIME;
+            ap->lo[GRS_CHAN_TO_XTRACT]  = -16.0;
+            ap->hi[GRS_CHAN_TO_XTRACT]  = (double)16.0;
+            break;
+        }
+        break;
+    case(SAUSAGE):
+        ap->lo[GRS_VELOCITY]        = 0.0;
+        ap->hi[GRS_VELOCITY]        = GRS_MAX_VELOCITY;
+        ap->lo[GRS_DENSITY]         = FLTERR;
+        ap->hi[GRS_DENSITY]         = GRS_MAX_DENSITY;
+        ap->lo[GRS_HVELOCITY]       = 0.0;
+        ap->hi[GRS_HVELOCITY]       = MAX_GRS_HVELOCITY;
+        ap->lo[GRS_HDENSITY]        = (1.0/sr);
+        ap->hi[GRS_HDENSITY]        = (double)MAXSHORT/2.0;
+        ap->lo[GRS_GRAINSIZE]       = GRS_MIN_SPLICELEN * 2.0;
+        ap->lo[GRS_HGRAINSIZE]      = GRS_MIN_SPLICELEN * 2.0;
+        ap->hi[GRS_GRAINSIZE]       = (infilesize_in_samps/sr) * SECS_TO_MS;
+        ap->hi[GRS_HGRAINSIZE]      = (infilesize_in_samps/sr) * SECS_TO_MS;
+        ap->hi[GRS_PITCH]           = LOG2(nyquist/MIN_LIKELY_PITCH) * SEMITONES_PER_OCTAVE;
+        ap->lo[GRS_PITCH]           = -(ap->hi[GRS_PITCH]);
+        ap->lo[GRS_AMP]             = 0.0;
+        ap->hi[GRS_AMP]             = 1.0;
+        ap->lo[GRS_SPACE]           = 0.0;
+        ap->hi[GRS_SPACE]           = 16.0;
+        ap->lo[GRS_BSPLICE]         = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_BSPLICE]         = ap->hi[GRS_GRAINSIZE]/2.0;
+        ap->lo[GRS_ESPLICE]         = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_ESPLICE]         = ap->hi[GRS_GRAINSIZE]/2.0;
+//TW REVISION
+//      ap->hi[GRS_HPITCH]          = LOG2(nyquist/MIN_LIKELY_PITCH);
+        ap->hi[GRS_HPITCH]          = LOG2(nyquist/MIN_LIKELY_PITCH) * SEMITONES_PER_OCTAVE;
+        ap->lo[GRS_HPITCH]          = -(ap->hi[GRS_HPITCH]);
+        ap->lo[GRS_HAMP]            = 0.0;
+        ap->hi[GRS_HAMP]            = 1.0;
+        ap->lo[GRS_HSPACE]          = 0.0;
+        ap->hi[GRS_HSPACE]          = 16.0;
+        ap->lo[GRS_HBSPLICE]        = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_HBSPLICE]        = ap->hi[GRS_GRAINSIZE]/2.0;
+        ap->lo[GRS_HESPLICE]        = GRS_MIN_SPLICELEN;
+        ap->hi[GRS_HESPLICE]        = ap->hi[GRS_GRAINSIZE]/2.0;
+        ap->lo[GRS_SRCHRANGE]       = 0.0;
+        ap->hi[GRS_SRCHRANGE]       = (duration * 2.0) * SECS_TO_MS;
+        ap->lo[GRS_SCATTER]         = 0.0;
+        ap->hi[GRS_SCATTER]         = 1.0;
+        ap->lo[GRS_OUTLEN]          = 0.0;
+        ap->hi[GRS_OUTLEN]          = BIG_TIME;
+        ap->lo[GRS_CHAN_TO_XTRACT]  = -16.0;
+        ap->hi[GRS_CHAN_TO_XTRACT]  = 16.0;
+        break;
+    case(PVOC_ANAL):
+        ap->lo[PVOC_CHANS_INPUT]    = (double)2;
+        ap->hi[PVOC_CHANS_INPUT]    = (double)MAX_PVOC_CHANS;
+        ap->lo[PVOC_WINOVLP_INPUT]  = (double)1;
+        ap->hi[PVOC_WINOVLP_INPUT]  = (double)4;
+        break;
+    case(PVOC_SYNTH):
+        break;
+    case(PVOC_EXTRACT):
+        ap->lo[PVOC_CHANS_INPUT]    = (double)2;
+        ap->hi[PVOC_CHANS_INPUT]    = (double)MAX_PVOC_CHANS;
+        ap->lo[PVOC_WINOVLP_INPUT]  = (double)1;
+        ap->hi[PVOC_WINOVLP_INPUT]  = (double)4;
+        ap->lo[PVOC_CHANSLCT_INPUT] = 0.0;
+        ap->hi[PVOC_CHANSLCT_INPUT] = 2.0;
+        ap->lo[PVOC_LOCHAN_INPUT]   = 0.0;
+        ap->hi[PVOC_LOCHAN_INPUT]   = (double)(MAX_PVOC_CHANS/2);
+        ap->lo[PVOC_HICHAN_INPUT]   = 0.0;
+        ap->hi[PVOC_HICHAN_INPUT]   = (double)(MAX_PVOC_CHANS/2);
+        break;
+
+/* TEMPORARY TEST ROUTINE */
+    case(WORDCNT):
+        break;
+/* TEMPORARY TEST ROUTINE */
+
+    case(EDIT_CUT):
+        ap->lo[CUT_CUT]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_CUT] = duration;                break;
+        case(EDIT_SAMPS):   ap->hi[CUT_CUT] = (double)(insams);        break;
+        case(EDIT_STSAMPS): ap->hi[CUT_CUT] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_END]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_END] = duration;                 break;
+        case(EDIT_SAMPS):   ap->hi[CUT_END] = (double)(insams);        break;
+        case(EDIT_STSAMPS): ap->hi[CUT_END] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        break;
+    case(EDIT_CUTEND):
+        ap->lo[CUT_CUT]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_CUT] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_CUT] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_CUT] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        break;
+    case(MANY_ZCUTS):
+        break;
+    case(EDIT_ZCUT):
+        ap->lo[CUT_CUT]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_CUT] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_CUT] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_CUT] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_END]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_END] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_END] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_END] = (double)(insams/channels); break;
+        }
+        break;
+    case(EDIT_EXCISE):
+        ap->lo[CUT_CUT]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_CUT] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_CUT] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_CUT] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_END]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_END] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_END] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_END] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        break;
+    case(EDIT_EXCISEMANY):
+    case(INSERTSIL_MANY):
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        break;
+    case(EDIT_INSERT):
+        ap->lo[CUT_CUT]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_CUT] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_CUT] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_CUT] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        ap->lo[INSERT_LEVEL]    = FLTERR;
+        ap->hi[INSERT_LEVEL]    = EDIT_MAXGAIN;
+        break;
+//TW NEW CASE
+        case(EDIT_INSERT2):
+        ap->lo[CUT_CUT]         = 0.0;
+        ap->hi[CUT_CUT]         = duration;
+        ap->lo[CUT_END]         = 0.0;
+        ap->hi[CUT_END]         = duration;
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        ap->lo[INSERT_LEVEL]    = FLTERR;
+        ap->hi[INSERT_LEVEL]    = EDIT_MAXGAIN;
+        break;
+
+    case(EDIT_INSERTSIL):
+        ap->lo[CUT_CUT]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_CUT] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_CUT] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_CUT] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_END]         = 0.0;
+        switch(mode) {
+        case(EDIT_SECS):    ap->hi[CUT_END] = duration;                  break;
+        case(EDIT_SAMPS):   ap->hi[CUT_END] = (double)(insams);          break;
+        case(EDIT_STSAMPS): ap->hi[CUT_END] = (double)(insams/channels); break;
+        }
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        break;
+    case(JOIN_SEQ):
+        ap->lo[MAX_LEN]         = 1;
+        ap->hi[MAX_LEN]         = 32767;
+        /* fall thro */
+    case(EDIT_JOIN):
+    case(JOIN_SEQDYN):
+        ap->lo[CUT_SPLEN]       = 0.0;
+        ap->hi[CUT_SPLEN]       = EDIT_SPLICEMAX;
+        break;
+    case(HOUSE_COPY):
+        switch(mode) {
+        case(COPYSF):
+            break;
+        case(DUPL):
+            ap->lo[COPY_CNT] = 1.0;
+            ap->hi[COPY_CNT] = (double)MAXDUPL;
+            break;
+        }
+        break;
+    case(HOUSE_DEL):
+        break;
+    case(HOUSE_CHANS):
+        switch(mode) {
+        case(HOUSE_CHANNEL):
+            ap->lo[CHAN_NO] = 1.0;
+            ap->hi[CHAN_NO] = (double)channels;
+            break;
+        case(HOUSE_ZCHANNEL):
+            ap->lo[CHAN_NO] = 1.0;
+            ap->hi[CHAN_NO] = (double)channels;
+            break;
+        case(HOUSE_CHANNELS):
+        case(STOM):
+        case(MTOS):
+            break;
+        }
+        break;
+    case(HOUSE_BUNDLE):
+        break;
+    case(HOUSE_SORT):
+        switch(mode) {
+        case(BY_DURATION):
+        case(BY_LOG_DUR):
+            ap->lo[SORT_SMALL]  = MIN_SORT_DUR;
+            ap->hi[SORT_SMALL]  = MAX_SORT_DUR;
+            ap->lo[SORT_LARGE]  = MIN_SORT_DUR;
+            ap->hi[SORT_LARGE]  = MAX_SORT_DUR;
+            if(mode==BY_DURATION) {
+                ap->lo[SORT_STEP] = MIN_SORT_STEP;
+                ap->hi[SORT_STEP] = MAX_SORT_STEP;
+            } else {
+                ap->lo[SORT_STEP] = MIN_SORT_LSTEP;
+                ap->hi[SORT_STEP] = MAX_SORT_LSTEP;
+            }
+            break;
+        }
+        break;
+    case(HOUSE_SPEC):
+        switch(mode) {
+        case(HOUSE_REPROP):
+            ap->lo[HSPEC_CHANS] = (double)1;
+            ap->hi[HSPEC_CHANS] = (double)MAX_SNDFILE_OUTCHANS;
+            ap->lo[HSPEC_TYPE]  = (double)SAMP_SHORT;
+            ap->hi[HSPEC_TYPE]  = (double)SAMP_FLOAT;
+            /* fall thro */
+        case(HOUSE_RESAMPLE):
+            ap->lo[HSPEC_SRATE] = (double)16000;
+            ap->hi[HSPEC_SRATE] = (double)/*48000*/96000;         /*RWD 4:05 */
+            break;
+        default:
+            break;
+        }
+        break;
+    case(HOUSE_EXTRACT):
+        switch(mode) {
+        case(HOUSE_CUTGATE):
+            ap->lo[CUTGATE_SPLEN]   = CUTGATE_MINSPLICE;
+            ap->hi[CUTGATE_SPLEN]   = CUTGATE_MAXSPLICE;
+            ap->lo[CUTGATE_SUSTAIN] = 0.0;
+            ap->hi[CUTGATE_SUSTAIN] = (double)CUTGATE_MAX_SUSTAIN;
+            /* fall thro */
+        case(HOUSE_ONSETS):
+            ap->lo[CUTGATE_GATE]    = 0.0;
+            ap->hi[CUTGATE_GATE]    = 1.0;
+            ap->lo[CUTGATE_ENDGATE] = 0.0;
+            ap->hi[CUTGATE_ENDGATE] = 1.0;
+            ap->lo[CUTGATE_THRESH]  = 0.0;
+            ap->hi[CUTGATE_THRESH]  = 1.0;
+            ap->lo[CUTGATE_BAKTRAK] = 0.0;
+            ap->hi[CUTGATE_BAKTRAK] = (double)CUTGATE_MAXBAKTRAK;
+            ap->lo[CUTGATE_INITLEVEL]= 0.0;
+            ap->hi[CUTGATE_INITLEVEL]= 1.0;
+            ap->lo[CUTGATE_MINLEN]  = 0.0;
+            ap->hi[CUTGATE_MINLEN]  = duration;
+            ap->lo[CUTGATE_WINDOWS] = 0.0;
+            ap->hi[CUTGATE_WINDOWS] = (double)CUTGATE_MAXWINDOWS;
+            break;
+        case(HOUSE_CUTGATE_PREVIEW):
+            break;
+        case(HOUSE_TOPNTAIL):
+            ap->lo[TOPN_GATE]   = 0.0;
+            ap->hi[TOPN_GATE]   = 1.0;
+// TW Mar 21: 2011
+            ap->lo[TOPN_SPLEN]  = 0;
+            ap->hi[TOPN_SPLEN]  = CUTGATE_MAXSPLICE;
+            break;
+        case(HOUSE_RECTIFY):
+            ap->lo[RECTIFY_SHIFT] = -1.0;
+            ap->hi[RECTIFY_SHIFT] = 1.0;
+            break;
+        }
+        break;
+    case(TOPNTAIL_CLICKS):
+        ap->lo[TOPN_GATE]   = 0.0;
+        ap->hi[TOPN_GATE]   = 1.0;
+        ap->lo[TOPN_SPLEN]  = 0.0;
+        ap->hi[TOPN_SPLEN]  = CUTGATE_MAXSPLICE;
+        break;
+    case(HOUSE_BAKUP):
+        break;
+    case(HOUSE_GATE):
+        ap->lo[GATE_ZEROS]      = 1;
+        ap->hi[GATE_ZEROS]      = 33;
+        break;
+
+    case(HOUSE_DISK):
+        break;
+    case(INFO_PROPS):
+    case(INFO_SFLEN):
+    case(INFO_TIMELIST):
+    case(INFO_LOUDLIST):
+    case(INFO_TIMEDIFF):
+    case(INFO_LOUDCHAN):
+    case(INFO_MAXSAMP):
+        break;
+    case(INFO_MAXSAMP2):
+        ap->lo[MAX_STIME]   = 0.0;
+        ap->hi[MAX_STIME]   = duration;
+        ap->lo[MAX_ETIME]   = 0.0;
+        ap->hi[MAX_ETIME]   = duration;
+        break;
+    case(INFO_TIMESUM):
+        ap->lo[TIMESUM_SPLEN]   = 0.0;
+        ap->hi[TIMESUM_SPLEN]   = MAX_TIMESUM_SPLEN;
+        break;  
+    case(INFO_SAMPTOTIME):
+        ap->lo[INFO_SAMPS]      = 0.0;
+        ap->hi[INFO_SAMPS]      = insams;
+        break;
+    case(INFO_TIMETOSAMP):
+        ap->lo[INFO_TIME]       = 0.0;
+        ap->hi[INFO_TIME]       = duration;
+        break;
+    case(INFO_FINDHOLE):
+        ap->lo[HOLE_THRESH] = 0.0;
+        ap->hi[HOLE_THRESH] = 1.0;
+        break;  
+    case(INFO_CDIFF):
+        ap->lo[SFDIFF_CNT]      = 1.0;
+        ap->hi[SFDIFF_CNT]      = (double)MAX_SFDIFF_CNT;
+        ap->lo[SFDIFF_THRESH]   = 0.0;
+        ap->hi[SFDIFF_THRESH]   = 1.0;
+        break;  
+    case(INFO_DIFF):
+        ap->lo[SFDIFF_CNT]      = 1.0;
+        ap->hi[SFDIFF_CNT]      = (double)MAX_SFDIFF_CNT;
+        ap->lo[SFDIFF_THRESH]   = 0.0;
+        if(filetype==PITCHFILE)
+            ap->hi[SFDIFF_THRESH] = nyquist;
+        else if(filetype==TRANSPOSFILE)
+            ap->hi[SFDIFF_THRESH] = nyquist/SPEC_MINFRQ;
+        else
+            ap->hi[SFDIFF_THRESH] = 1.0;
+        break;  
+    case(INFO_PRNTSND):
+        ap->lo[PRNT_START]  = 0.0;
+        ap->hi[PRNT_START]  = duration;
+        ap->lo[PRNT_END]    = 0.0;
+        ap->hi[PRNT_END]    = duration;
+        break;  
+    case(INFO_MUSUNITS):
+        switch(mode) {
+        case(MU_MIDI_TO_FRQ):
+        case(MU_MIDI_TO_NOTE):
+            ap->lo[0]   = MIDIMIN;
+            ap->hi[0]   = MIDIMAX;
+            break;
+        case(MU_FRQ_TO_MIDI):
+        case(MU_FRQ_TO_NOTE):
+            ap->lo[0]   = miditohz(MIDIMIN);
+            ap->hi[0]   = miditohz(MIDIMAX);
+            break;
+        case(MU_FRQRATIO_TO_SEMIT):
+        case(MU_FRQRATIO_TO_INTVL):
+        case(MU_FRQRATIO_TO_OCTS):
+        case(MU_FRQRATIO_TO_TSTRETH):
+            ap->lo[0]   = pow(2.0,-MAX_OCTSHIFT);
+            ap->hi[0]   = pow(2.0,MAX_OCTSHIFT);
+            break;
+        case(MU_SEMIT_TO_FRQRATIO):
+        case(MU_SEMIT_TO_OCTS):
+        case(MU_SEMIT_TO_INTVL):
+        case(MU_SEMIT_TO_TSTRETCH):
+            ap->lo[0]   = -(MAX_OCTSHIFT * SEMITONES_PER_OCTAVE);
+            ap->hi[0]   = MAX_OCTSHIFT * SEMITONES_PER_OCTAVE;
+            break;
+        case(MU_OCTS_TO_FRQRATIO):
+        case(MU_OCTS_TO_SEMIT):
+        case(MU_OCTS_TO_TSTRETCH):
+            ap->lo[0]   = -MAX_OCTSHIFT;
+            ap->hi[0]   = MAX_OCTSHIFT;
+            break;
+        case(MU_TSTRETCH_TO_FRQRATIO):
+        case(MU_TSTRETCH_TO_SEMIT):
+        case(MU_TSTRETCH_TO_OCTS):
+        case(MU_TSTRETCH_TO_INTVL):
+            ap->lo[0]   = pow(2.0,-MAX_OCTSHIFT);
+            ap->hi[0]   = pow(2.0,MAX_OCTSHIFT);
+            break;
+        case(MU_GAIN_TO_DB):
+            ap->lo[0]   = 0.0;
+            ap->hi[0]   = MU_MAXGAIN;
+            break;
+        case(MU_DB_TO_GAIN):
+            ap->lo[0]   = MIN_DB_ON_16_BIT;
+            ap->hi[0]   = log10(MU_MAXGAIN) * 20.0;
+            break;
+        case(MU_NOTE_TO_FRQ):
+        case(MU_NOTE_TO_MIDI):
+        case(MU_INTVL_TO_FRQRATIO):
+        case(MU_INTVL_TO_TSTRETCH):
+            break;
+        case(MU_DELAY_TO_FRQ):
+        case(MU_DELAY_TO_MIDI):
+            ap->lo[0]   = MU_MIN_DELAY;
+            ap->hi[0]   = MU_MAX_DELAY;
+            break;
+        case(MU_MIDI_TO_DELAY):
+            ap->lo[0]   = MIDIMIN;
+            ap->hi[0]   = MIDIMAX;
+            break;
+        case(MU_FRQ_TO_DELAY):
+            ap->lo[0]   = SECS_TO_MS/MU_MAX_DELAY;
+            ap->hi[0]   = SECS_TO_MS/MU_MIN_DELAY;
+            break;
+        case(MU_DELAY_TO_TEMPO):
+            ap->lo[0]   = MU_MINTEMPO_DELAY;
+            ap->hi[0]   = MU_MAXTEMPO_DELAY;
+            break;
+        case(MU_TEMPO_TO_DELAY):
+            ap->lo[0]   = MU_MIN_TEMPO;
+            ap->hi[0]   = MU_MAX_TEMPO;
+            break;
+        case(MU_NOTE_TO_DELAY):
+            break;
+        default:
+// TW UPDATE
+//          sprintf(errstr,"Unknown mode for MUSUNITS: initialise_param_values()\n");
+            sprintf(errstr,"Unknown mode for MUSUNITS: set_param_ranges()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(SYNTH_WAVE):
+        ap->lo[SYN_TABSIZE]= (double)WAVE_TABSIZE;
+        ap->hi[SYN_TABSIZE]= (double)(WAVE_TABSIZE * 16);
+        ap->lo[SYN_FRQ] = MIN_SYNTH_FRQ;
+        ap->hi[SYN_FRQ] = MAX_SYNTH_FRQ;
+        /* fall thro */
+    case(SYNTH_NOISE):
+        ap->lo[SYN_AMP] = 0.0;
+        ap->hi[SYN_AMP] = 1.0;
+        ap->lo[SYN_SRATE] = 16000.0;
+        ap->hi[SYN_SRATE] = 192000.0;   /*RWD wayhay! */
+        ap->lo[SYN_CHANS] = 1.0;
+        ap->hi[SYN_CHANS] = 16.0;
+        ap->lo[SYN_DUR]   = MIN_SYN_DUR;
+        ap->hi[SYN_DUR]   = MAX_SYN_DUR;
+        break;
+    case(SYNTH_SIL):
+        ap->lo[SYN_SRATE] = 16000.0;
+        ap->hi[SYN_SRATE] = 192000.0;
+        ap->lo[SYN_CHANS] = 1.0;
+        ap->hi[SYN_CHANS] = 16.0;
+        ap->lo[SYN_DUR]   = FLTERR;
+        ap->hi[SYN_DUR]   = MAX_SYN_DUR;
+        break;
+    case(MULTI_SYN):
+        ap->lo[SYN_TABSIZE]= (double)WAVE_TABSIZE;
+        ap->hi[SYN_TABSIZE]= (double)(WAVE_TABSIZE * 16);
+        ap->lo[SYN_AMP] = 0.0;
+        ap->hi[SYN_AMP] = 1.0;
+        ap->lo[SYN_SRATE] = 16000.0;
+        ap->hi[SYN_SRATE] = /*48000.0*/96000.0; /*RWD 4:05 */
+        ap->lo[SYN_CHANS] = 1.0;
+        ap->hi[SYN_CHANS] = 16.0;
+        ap->lo[SYN_DUR]   = MIN_SYN_DUR;
+        ap->hi[SYN_DUR]   = MAX_SYN_DUR;
+        break;
+    case(SYNTH_SPEC):
+        ap->lo[SS_DUR]      = 0.1;
+        ap->hi[SS_DUR]      = 32767;
+        ap->lo[SS_SRATE]    = 16000;
+        ap->hi[SS_SRATE]    = /*48000*/96000;   /*RWD 4:05 */   /*RWD push this to 192000 as well????? */
+        ap->lo[SS_CENTRFRQ] = SPEC_MINFRQ;
+        ap->hi[SS_CENTRFRQ] = ap->hi[SS_SRATE]/2.0;
+        ap->lo[SS_SPREAD]   = 0.0;
+        ap->hi[SS_SPREAD]   = ap->hi[SS_SRATE]/4.0;
+        ap->lo[SS_FOCUS]    = 0.0;
+        ap->hi[SS_FOCUS]    = 1.0;
+        ap->lo[SS_FOCUS2]   = 0.0;
+        ap->hi[SS_FOCUS2]   = 1.0;
+        ap->lo[SS_TRAND]    = 0.0; 
+        ap->hi[SS_TRAND]    = 1.0; 
+        break;
+    case(RANDCUTS):
+        ap->lo[RC_CHLEN]  = (double)((SHRED_SPLICELEN * channels * 3)/(double)srate);
+        ap->hi[RC_CHLEN]  = (duration/2)-FLTERR;
+        ap->lo[RC_SCAT]   = 0.0;
+        ap->hi[RC_SCAT]   = (double)MAX_SHR_SCATTER;
+        break;
+    case(RANDCHUNKS):
+        ap->lo[CHUNKCNT]  = 2;
+        ap->hi[CHUNKCNT]  = 999;
+        ap->lo[MINCHUNK]  = MINOUTDUR;
+        ap->hi[MINCHUNK]  = duration;
+        ap->lo[MAXCHUNK]  = MINOUTDUR;
+        ap->hi[MAXCHUNK]  = duration;
+        break;
+    case(TWIXT):
+    case(SPHINX):
+        ap->lo[IS_SPLEN]  = 2;
+        ap->hi[IS_SPLEN]  = 15;
+        ap->lo[IS_WEIGHT] = 1;
+        ap->hi[IS_WEIGHT] = 10;
+        ap->lo[IS_SEGCNT] = 1;
+        ap->hi[IS_SEGCNT] = 10000;
+        break;
+//TW NEW CASES
+    case(EDIT_CUTMANY):
+        ap->lo[CM_SPLICELEN] = 0.0;
+        ap->hi[CM_SPLICELEN] = EDIT_SPLICEMAX;
+        break;
+    case(STACK):
+        ap->lo[STACK_CNT]    = 2;
+        ap->hi[STACK_CNT]    = 32;
+        ap->lo[STACK_LEAN]   = .01;
+        ap->hi[STACK_LEAN]   = 100.0;
+        ap->lo[STACK_OFFSET] = 0.0;
+        ap->hi[STACK_OFFSET] = duration;
+        ap->lo[STACK_GAIN]   = 0.1;
+        ap->hi[STACK_GAIN]   = 10.0;
+        ap->lo[STACK_DUR]    = 0.0;
+        ap->hi[STACK_DUR]    = 1.0;
+        break;
+
+    case(SIN_TAB):
+        ap->lo[SIN_FRQ]   = .01;
+        ap->hi[SIN_FRQ]   = 100;
+        ap->lo[SIN_AMP]   = 0;
+        ap->hi[SIN_AMP]   = 1;
+        ap->lo[SIN_DUR]   = 0;
+        ap->hi[SIN_DUR]   = 32767;
+        ap->lo[SIN_QUANT] = .005;
+        ap->hi[SIN_QUANT] = 1;
+        ap->lo[SIN_PHASE] = 0;
+        ap->hi[SIN_PHASE] = 360;
+        break;
+    case(ACC_STREAM):
+        ap->lo[ACC_ATTEN] = 0.0;
+        ap->hi[ACC_ATTEN] = 1.0;
+        break;
+    case(HF_PERM1):
+    case(HF_PERM2):
+        ap->lo[HP1_SRATE]   = 16000;
+        ap->hi[HP1_SRATE]   = /*48000*/96000;       /*RWD 4:05 */
+        ap->lo[HP1_ELEMENT_SIZE] = 0.04;
+        ap->hi[HP1_ELEMENT_SIZE] = 10.0;
+        ap->lo[HP1_GAP_SIZE]  = 0.02;
+        ap->hi[HP1_GAP_SIZE]  = 10.0;
+        ap->lo[HP1_GGAP_SIZE] = 0.02;
+        ap->hi[HP1_GGAP_SIZE] = 10.0;
+        ap->lo[HP1_MINSET]  = 1.0;
+        ap->hi[HP1_MINSET]  = MAX_HFPERMSET;
+        ap->lo[HP1_BOTNOTE] = 0;
+        ap->hi[HP1_BOTNOTE] = 11;
+        ap->lo[HP1_BOTOCT]  = -4;
+        ap->hi[HP1_BOTOCT]  = 4;
+        ap->lo[HP1_TOPNOTE] = 0;
+        ap->hi[HP1_TOPNOTE] = 11;
+        ap->lo[HP1_TOPOCT]  = -4;
+        ap->hi[HP1_TOPOCT]  = 4;
+        ap->lo[HP1_SORT1]     = 0;
+        ap->hi[HP1_SORT1]     = 4;
+        break;
+    case(DEL_PERM):
+        ap->lo[DP_SRATE]  = 16000;
+        ap->hi[DP_SRATE]  = /*48000*/96000;         /*RWD 4:05 */
+        ap->lo[DP_DUR]    = 0.1;
+        ap->hi[DP_DUR]    = 10.0;
+        ap->lo[DP_CYCCNT] = 2;
+        ap->hi[DP_CYCCNT] = 16;
+        break;
+    case(DEL_PERM2):
+        ap->lo[DP_CYCCNT] = 2;
+        ap->hi[DP_CYCCNT] = 16;
+        break;
+//TW NEW CASES
+    case(NOISE_SUPRESS):
+        ap->lo[NOISE_SPLEN] = 0.0;
+        ap->hi[NOISE_SPLEN] = 50.0;
+        ap->lo[NOISE_MINFRQ] = MIN_SUPRESS;
+        ap->hi[NOISE_MINFRQ] = nyquist;
+        ap->lo[MIN_NOISLEN] = 0.0;
+        ap->hi[MIN_NOISLEN] = 50.0;
+        ap->lo[MIN_TONELEN] = 0.0;
+        ap->hi[MIN_TONELEN] = 1000.0;
+        break;
+    case(TIME_GRID):
+        ap->lo[GRID_COUNT]  = 2.0;
+        ap->hi[GRID_COUNT]  = 32.0;
+        ap->lo[GRID_WIDTH]  = 0.002;
+        ap->hi[GRID_WIDTH]  = 10.0;
+        ap->lo[GRID_SPLEN]  = 2.0;
+        ap->hi[GRID_SPLEN]  = 1000.0;
+        break;
+    case(SEQUENCER2):
+        ap->lo[SEQ_SPLIC]  = 2.0;
+        ap->hi[SEQ_SPLIC]  = 200.0;
+        /* fall thro */
+    case(SEQUENCER):
+        ap->lo[SEQ_ATTEN]  = 0.0;
+        ap->hi[SEQ_ATTEN]  = 1.0;
+        break;
+    case(CONVOLVE):
+        if(mode==CONV_TVAR) {
+            ap->lo[CONV_TRANS]  = -48.0;
+            ap->hi[CONV_TRANS]  = 48.0;
+        }
+        break;
+    case(BAKTOBAK):
+        ap->lo[BTOB_CUT]    = 0.0;
+        ap->hi[BTOB_CUT]    = duration;
+        ap->lo[BTOB_SPLEN]  = 0.01;
+        ap->hi[BTOB_SPLEN]  = min(5.0,duration) * SECS_TO_MS;
+        break;
+    case(CLICK):
+        if(mode == CLICK_BY_LINE) {
+            ap->lo[CLIKSTART]   = 1.0;
+            ap->hi[CLIKSTART]   = 32767.0;
+            ap->lo[CLIKEND]     = 2.0;
+            ap->hi[CLIKEND]     = 32767.0;
+        } else {
+            ap->lo[CLIKSTART]   = 0.0;
+            ap->hi[CLIKSTART]   = 32767.0;
+            ap->lo[CLIKEND]     = 0.0;
+            ap->hi[CLIKEND]     = 32767.0;
+        }
+        ap->lo[CLIKOFSET]   = 1.0;
+        ap->hi[CLIKOFSET]   = 32767.0;
+        break;
+    case(DOUBLETS):
+        ap->lo[SEG_DUR]    = SPLICEDUR * 2.0;
+        ap->hi[SEG_DUR]    = max(ap->lo[SEG_DUR],min(10.0,duration));
+        ap->lo[SEG_REPETS] = 2.0;
+        ap->hi[SEG_REPETS] = 32.0;
+        break;
+    case(SYLLABS):
+        ap->lo[SYLLAB_DOVETAIL]    = 0.0;
+        ap->hi[SYLLAB_DOVETAIL]    = 20.0;
+        ap->lo[SYLLAB_SPLICELEN]    = 1.0;
+        ap->hi[SYLLAB_SPLICELEN]    = 20.0;
+        break;
+    case(MAKE_VFILT):
+    case(MIX_MODEL):
+        break;
+    case(BATCH_EXPAND):
+        ap->lo[BE_INFILE]   = 1;
+        ap->hi[BE_INFILE]   = 40;
+        ap->lo[BE_OUTFILE]  = 1;
+        ap->hi[BE_OUTFILE]  = 40;
+        ap->lo[BE_PARAM]    = 1;
+        ap->hi[BE_PARAM]    = 40;
+        break;
+    case(ENVSYN):
+        ap->lo[ENVSYN_WSIZE]        = ENV_MIN_WSIZE;
+        ap->hi[ENVSYN_WSIZE]        = ENV_MAX_WSIZE;
+        ap->lo[ENVSYN_DUR]          = ENV_MIN_WSIZE * MS_TO_SECS * 2.1; /* .1 is safety factor */
+        ap->hi[ENVSYN_DUR]          = 32767.0;
+        ap->lo[ENVSYN_CYCLEN]       = ENV_MIN_WSIZE * MS_TO_SECS * 2.1; /* .1 is safety factor */;
+        ap->hi[ENVSYN_CYCLEN]       = ap->hi[ENVSYN_DUR];
+        ap->lo[ENVSYN_STARTPHASE]   = 0.0;
+        ap->hi[ENVSYN_STARTPHASE]   = 1.0;
+        if(mode != ENVSYN_USERDEF) {
+            ap->lo[ENVSYN_TROF]     = 0.0;
+            ap->hi[ENVSYN_TROF]     = 1.0;
+            ap->lo[ENVSYN_EXPON]    = DISTORTE_MIN_EXPON;
+            ap->hi[ENVSYN_EXPON]    = DISTORTE_MAX_EXPON;
+        }
+        break;
+    case(HOUSE_GATE2):
+        ap->lo[GATE2_DUR]   = ((double)channels/(double)srate) * SECS_TO_MS;
+        ap->hi[GATE2_DUR]   = 1.0 * SECS_TO_MS;
+        ap->lo[GATE2_ZEROS] = 0.3;
+        ap->hi[GATE2_ZEROS] = 1.0 * SECS_TO_MS;
+        ap->lo[GATE2_LEVEL] = 0.0;
+        ap->hi[GATE2_LEVEL] = (double)F_MAXSAMP;
+        ap->lo[GATE2_SPLEN] = 0.0;
+        ap->hi[GATE2_SPLEN] = 50.0;
+        ap->lo[GATE2_FILT]  = ((double)channels/(double)srate) * SECS_TO_MS;
+        ap->hi[GATE2_FILT]  = 4.0;
+        break;
+    case(GRAIN_ASSESS):
+        break;
+    case(ZCROSS_RATIO):
+        ap->lo[ZC_START]        = 0.0;
+        ap->hi[ZC_START]        = duration;
+        ap->lo[ZC_END]          = 0.0;
+        ap->hi[ZC_END]          = duration;
+        break;
+    case(GREV):
+        ap->lo[GREV_WSIZE]      = (8.0/srate) * SECS_TO_MS;
+        ap->hi[GREV_WSIZE]      = (duration/3.0) * SECS_TO_MS;
+        ap->lo[GREV_TROFRAC]    = FLTERR;
+        ap->hi[GREV_TROFRAC]    = 1.0 - FLTERR;
+        ap->lo[GREV_GPCNT]      = 1.0;
+        ap->hi[GREV_GPCNT]      = 100.0;
+        switch(mode) {
+        case(GREV_TSTRETCH):
+            ap->lo[GREV_TSTR]   = .01;
+            ap->hi[GREV_TSTR]   = 100;
+            break;
+        case(GREV_DELETE):
+        case(GREV_OMIT):
+            ap->lo[GREV_KEEP]   = 1;
+            ap->hi[GREV_KEEP]   = 255;
+            ap->lo[GREV_OUTOF]  = 2;
+            ap->hi[GREV_OUTOF]  = 256;
+            break;
+        case(GREV_REPEAT):
+            ap->lo[GREV_REPETS] = 1;
+            ap->hi[GREV_REPETS] = 100;
+            break;
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown case: get_param_ranges()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/**********************************************************************************/
+/*********************** ITEMS FORMERLY IN HEADERS.C tklib3 ***********************/
+/**********************************************************************************/
+
+/***************************** READHEAD *******************************
+ *
+ * Header reader for sndfiles,envfiles,analfiles etc..
+ */
+
+int readhead(infileptr inputfile,int ifd,char *filename,double *maxamp,double *maxloc, int *maxrep,int getmax,int needmaxinfo)
+{
+    float peakval;
+    int peakpos;
+    SFPROPS props = {0};   // RWD NB on 64bit, alignment important here!
+    int isenv = 0;
+    int os;
+    
+    if(!snd_headread(ifd,&props)) {
+        fprintf(stdout,"INFO: Failure to read properties, in %s\n",filename);
+        fflush(stdout);
+        return(DATA_ERROR);
+    }
+    inputfile->srate = props.srate;
+    inputfile->channels = props.chans;
+
+    switch(props.samptype) {
+    case(SHORT16):  inputfile->stype = SAMP_SHORT;  break;
+    case(FLOAT32):  inputfile->stype = SAMP_FLOAT;  break;
+    case(SHORT8):   inputfile->stype = SAMP_BYTE;   break;
+    default:    
+        /* remaining symbols have same int value */ 
+        inputfile->stype = (int)props.samptype; /* RWD April 2005 */
+        break;
+    }
+//TW TEMPORARY SUBSTITUTION
+    inputfile->filetype = SNDFILE;
+    if(sndgetprop(ifd,"is an envelope",(char *) &isenv,sizeof(int)) >= 0)
+        inputfile->filetype = ENVFILE;
+    else if(sndgetprop(ifd,"is a formant file",(char *) &isenv,sizeof(int)) >= 0)
+        inputfile->filetype = FORMANTFILE;
+    else if(sndgetprop(ifd,"is a pitch file",(char *) &isenv,sizeof(int)) >= 0)
+        inputfile->filetype = PITCHFILE;
+    else if(sndgetprop(ifd,"is a transpos file",(char *) &isenv,sizeof(int)) >= 0)
+        inputfile->filetype = TRANSPOSFILE;
+    else if(sndgetprop(ifd,"original sampsize",(char *) &os,sizeof(int)) > 0)
+        inputfile->filetype = ANALFILE;
+
+/* THIS STILL DOESN'T WORK !!!!
+    switch(props.type) {
+    case(wt_wave):          inputfile->filetype = SNDFILE;      break;
+    case(wt_analysis):      inputfile->filetype = ANALFILE;     break;
+    case(wt_formant):       inputfile->filetype = FORMANTFILE;  break;
+    case(wt_transposition): inputfile->filetype = TRANSPOSFILE; break;
+    case(wt_pitch):         inputfile->filetype = PITCHFILE;    break;
+    case(wt_binenv):        inputfile->filetype = ENVFILE;      break;
+    default:
+        fprintf(stdout,"INFO: Unknown file type,\n");
+        return(DATA_ERROR);
+    }
+*/
+    switch(inputfile->filetype) {
+    case(SNDFILE):
+        if(needmaxinfo) {
+            *maxrep = (int)-1;  /* flags that maxinfo not got, unless it's got, below */
+            *maxloc = (int)0;
+            *maxamp = 0.0;
+            if(getmax) {
+                if(getpeakdata(ifd,&peakval,&peakpos,props) > 0) {
+                    *maxamp = (double)peakval;
+                    *maxloc = (double)peakpos;
+                    *maxrep = 0;
+                }
+            }
+        }
+#ifdef TEST_HEADREAD
+        if(headread_check(props,filename,ifd)<0)
+            return(PROGRAM_ERROR);
+#endif
+        return(FINISHED);
+    case(ENVFILE):
+// TW NOT WORKING
+//      inputfile->window_size = props.window_size;
+        if(sndgetprop(ifd,"window size",(char *)&(inputfile->window_size),sizeof(float)) < 0) {
+            fprintf(stdout,"Cannot read original window size: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+#ifdef TEST_HEADREAD
+        if(headread_check(props,filename,ifd)<0)
+            return(PROGRAM_ERROR);
+#endif
+        return(FINISHED);
+
+    case(FORMANTFILE):
+        inputfile->specenvcnt = props.specenvcnt;
+        /* fall through */
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+        if(inputfile->channels != 1) {
+            sprintf(errstr,"Channel count not equal to 1 in %s: readhead()\n"
+            "Implies failure to write correct header in another program.\n",
+            filename);
+            return(PROGRAM_ERROR);
+        }
+// TW NOT WORKING
+//      inputfile->origchans = props.origchans;
+// TW SUBSTITUTE FOR NOW
+        if(sndgetprop(ifd,"orig channels",(char *)&(inputfile->origchans),sizeof(int)) < 0) {
+            fprintf(stdout,"Cannot read original channels count: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+
+        /* fall through */
+    case(ANALFILE):
+// TW NOT WORKING
+//      inputfile->origstype = props.origsize;
+//      inputfile->origrate = props.origrate;
+//      inputfile->arate    = props.arate;
+//      inputfile->Mlen     = props.winlen;
+//      inputfile->Dfac     = props.decfac;
+// TW SUBSTITUTE FOR NOW
+        if(sndgetprop(ifd,"original sampsize",(char *)&(inputfile->origstype),sizeof(int)) < 0) {
+            fprintf(stdout,"Cannot read original sample type: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"original sample rate",(char *)&(inputfile->origrate),sizeof(int)) < 0) {
+            fprintf(stdout,"Cannot read original sample rate: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"arate",(char *)&(inputfile->arate),sizeof(float)) < 0) {
+            fprintf(stdout,"Cannot read analysis rate: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"analwinlen",(char *)&(inputfile->Mlen),sizeof(int)) < 0) {
+            fprintf(stdout,"Cannot read analysis window length: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"decfactor",(char *)&(inputfile->Dfac),sizeof(int)) < 0) {
+            fprintf(stdout,"Cannot read original decimation factor: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+
+
+#ifdef TEST_HEADREAD
+        if(headread_check(props,filename,ifd)<0)
+            return(PROGRAM_ERROR);
+#endif
+        break;
+    }
+    return(FINISHED);
+}
+
+/******************************* IS_A_PITCHFILE ****************************/
+
+int is_a_pitchfile(int fd)
+{
+    int pppp = 1;
+    if(sndgetprop(fd,"is a pitch file", (char *)&pppp, sizeof(int)) < 0)
+        return(FALSE);
+    return(TRUE);
+}   
+
+/******************************* IS_A_TRANSPOSFILE ****************************/
+
+int is_a_transposfile(int fd)
+{
+    int tttt = 1;
+    if(sndgetprop(fd,"is a transpos file", (char *)&tttt, sizeof(int)) < 0)
+        return(FALSE);
+    return(TRUE);
+}   
+
+/******************************* IS_A_FORMANTFILE ****************************/
+
+int is_a_formantfile(int fd)
+{   
+    int ffff = 1;
+    if(sndgetprop(fd,"is a formant file", (char *)&ffff, sizeof(int)) < 0)
+        return(FALSE);
+    return(TRUE);
+}   
+
+/************************************* REDEFINE_TEXTFILE_TYPES ******************************/
+
+int redefine_textfile_types(dataptr dz)
+{
+    switch(dz->infile->filetype) {
+    case(POSITIVE_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):   case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            break;
+        case(P_GEN):
+            dz->infile->filetype = POSITIVE_BRKFILE;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        default:
+            dz->infile->filetype = UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST;
+            break;
+        }
+        break;
+    case(POSITIVE_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            break;
+        case(P_GEN):
+            dz->infile->filetype = POSITIVE_BRKFILE;
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        default:
+            dz->infile->filetype = UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST;
+            break;
+        }
+        break;
+    case(PITCH_POSITIVE_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            break;
+        case(ENV_IMPOSE):
+//TW NEW CASE
+        case(ENV_PROPOR):
+            dz->infile->filetype = POSITIVE_BRKFILE;
+            break;
+        case(P_GEN):
+            dz->infile->filetype = POSITIVE_BRKFILE;
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        default:
+            dz->infile->filetype = PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST;
+            break;
+        }
+        break;
+    case(PITCH_POSITIVE_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):   case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            break;
+        case(ENV_IMPOSE):
+//TW NEW CASE
+        case(ENV_PROPOR):
+            dz->infile->filetype = POSITIVE_BRKFILE;
+            break;
+        case(P_GEN):
+            dz->infile->filetype = POSITIVE_BRKFILE;
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        default:
+            dz->infile->filetype = PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST;
+            break;
+        }
+        break;
+
+    
+    }
+
+    if(dz->process==INFO_DIFF) {
+        sprintf(errstr,"This process does not work with textfiles.\n");
+        return(GOAL_FAILED);
+    } else if(dz->process==HOUSE_COPY) {
+        dz->infile->filetype = WORDLIST;
+        return(FINISHED);
+    } else if(dz->input_data_type==NO_FILE_AT_ALL) {
+        dz->infile->filetype = WORDLIST; /* dummy */
+        return(FINISHED);
+    }
+
+    switch(dz->infile->filetype) {
+    case(TRANSPOS_OR_NORMD_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(REPITCH):
+        case(REPITCHB):
+            dz->infile->filetype = TEXTFILE;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(NORMD_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(ENV_REPLOTTING):
+        case(ENV_BRKTOENV):
+        case(ENV_BRKTODBBRK):
+        case(INFO_PROPS):
+            dz->infile->filetype = BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                return(FINISHED);
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(INFO_PROPS):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(TRANSPOS_OR_NORMD_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(REPITCH):
+        case(REPITCHB):
+            dz->infile->filetype = TEXTFILE;
+            return(FINISHED);
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall tro */
+    case(NORMD_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(ENV_REPLOTTING):
+        case(ENV_BRKTOENV):
+        case(ENV_BRKTODBBRK):
+        case(INFO_PROPS):
+            dz->infile->filetype = BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT): 
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        case(INFO_PROPS):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(DB_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(ENV_DBBRKTOENV):
+        case(ENV_DBBRKTOBRK):
+        case(INFO_PROPS):
+            dz->infile->filetype = DB_BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(INFO_PROPS):
+        case(HOUSE_SORT):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(DB_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(ENV_DBBRKTOENV):
+        case(ENV_DBBRKTOBRK):
+        case(INFO_PROPS):
+            dz->infile->filetype = DB_BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+            dz->infile->filetype = WORDLIST;    
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(TRANSPOS_OR_UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(REPITCH):
+        case(REPITCHB):
+            dz->infile->filetype = TEXTFILE;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(INFO_PROPS):
+            dz->infile->filetype = UNRANGED_BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+    /* fall thro */
+    case(NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):   case(MAKE_VFILT): 
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT): 
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(TRANSPOS_OR_UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(REPITCH):
+        case(REPITCHB):
+            dz->infile->filetype = TEXTFILE;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(INFO_PROPS):
+            dz->infile->filetype = UNRANGED_BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):  case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(MIXLIST_OR_LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(MIXLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(MIX):
+        case(MIXMAX):
+        case(MIXTEST):
+        case(MIXGAIN):
+        case(MIXSHUFL):
+        case(MIXTWARP):
+        case(MIXSWARP):
+        case(MIXSYNC):
+        case(MIXSYNCATT):
+//TW NEW CASES
+        case(ADDTOMIX):
+        case(MIX_MODEL):
+        case(MIX_PAN):
+        case(MIX_AT_STEP):
+
+        case(INFO_PROPS):
+            dz->infile->filetype = MIXFILE;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(SNDLIST_OR_LINELIST_OR_WORDLIST): /* implies different srates */
+        /* fall thro */
+    case(SNDLIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(SNDLIST_OR_SYNCLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(MIXDUMMY):
+        case(INFO_PROPS):
+            dz->infile->filetype = SNDLIST;
+            return(FINISHED);
+        case(MIXSYNC):
+        case(MIXSYNCATT):
+            dz->infile->filetype = SYNCLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(SNDLIST_OR_SYNCLIST_LINELIST_OR_WORDLIST):    /* list of snds AT SAME SRATE */
+        switch(dz->process) {
+        case(MIXDUMMY):
+        case(INFO_PROPS):
+            dz->infile->filetype = SNDLIST;
+            return(FINISHED);
+        case(MIXSYNC):
+        case(MIXSYNCATT):
+            dz->infile->filetype = SYNCLIST;
+            return(FINISHED);
+        }
+            /* fall thro */
+    case(LINELIST_OR_WORDLIST):
+            /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT): 
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(SYNCLIST_OR_LINELIST_OR_WORDLIST):   /* i.e. can't be a sndlist */
+        switch(dz->process) {
+        case(MIXSYNCATT): 
+        case(INFO_PROPS):
+            dz->infile->filetype = SYNCLIST;    
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(SYNCLIST_OR_WORDLIST):                /* i.e. can't be a sndlist */
+        switch(dz->process) {
+        case(MIXSYNCATT): 
+        case(INFO_PROPS):
+            dz->infile->filetype = SYNCLIST;    
+            return(FINISHED);
+        }
+            /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT): 
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(REPITCH):
+        case(REPITCHB):
+            dz->infile->filetype = TEXTFILE;
+            return(FINISHED);
+        case(INFO_PROPS):
+            dz->infile->filetype = UNRANGED_BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_LINELIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):   case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(LINELIST_OR_WORDLIST):
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+
+    switch(dz->infile->filetype) {
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+    case(PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(REPITCH):
+        case(REPITCHB):
+            dz->infile->filetype = TEXTFILE;
+            return(FINISHED);
+        case(INFO_PROPS):
+            dz->infile->filetype = UNRANGED_BRKFILE;
+            return(FINISHED);
+        case(MOD_SPACE):
+            if(dz->mode==MOD_MIRRORPAN) {
+                dz->infile->filetype = UNRANGED_BRKFILE;
+                return(FINISHED);
+            }
+            break;
+        case(MOD_LOUDNESS):
+            switch(dz->mode) {
+            case(LOUD_PROPOR):
+                dz->infile->filetype = POSITIVE_BRKFILE;
+                break;
+            case(LOUD_DB_PROPOR):
+                dz->infile->filetype = DB_BRKFILE;
+                break;
+            }
+            break;
+        }
+        /* fall thro */
+    case(NUMLIST_OR_WORDLIST):
+        switch(dz->process) {
+        case(HF_PERM1): case(HF_PERM2): case(DEL_PERM): case(DEL_PERM2):   case(MAKE_VFILT):
+            dz->infile->filetype = NUMLIST;
+            return(FINISHED);
+        }
+        /* fall thro */
+    case(WORDLIST):
+        switch(dz->process) {
+        case(WORDCNT):
+        case(HOUSE_DISK):
+        case(HOUSE_BUNDLE):
+        case(HOUSE_SORT):
+        case(INFO_PROPS):
+        case(INFO_SFLEN):
+        case(INFO_MAXSAMP):
+        case(INFO_MAXSAMP2):
+        case(UTILS_GETCOL):
+        case(UTILS_PUTCOL):
+        case(UTILS_JOINCOL):
+        case(UTILS_COLMATHS):
+        case(UTILS_COLMUSIC):
+        case(UTILS_COLRAND):
+        case(UTILS_COLLIST):
+        case(UTILS_COLGEN):
+        case(BATCH_EXPAND):
+            dz->infile->filetype = WORDLIST;
+            return(FINISHED);
+        default:
+            sprintf(errstr,"type_conversion not done for this process: redefine_textfile_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+    sprintf(errstr,"Unknown input textfile type: redefine_textfile_types()\n");
+    return(PROGRAM_ERROR);
+}
+
+/************************************* SOUND_LOOM_IN_USE ******************************/
+
+int sound_loom_in_use(int *argc, char **argv[]) {
+    char *p;
+    if(*argc>1) {
+        if(!strcmp((*argv)[1],"#")) {
+            (*argv)++;
+            (*argc)--;
+            return 1;
+        } else if (!strcmp((*argv)[1],"##")) {
+            p = (*argv)[0];
+            (*argc)--;
+            (*argv)++;
+            (*argv)[0] = p;
+            return 2;
+        }
+    }
+    return 0;
+}
+
+/************************ print_outmessage **********************/
+
+void print_outmessage(char *str) {
+
+    if(!sloom && !sloombatch)
+        fprintf(stdout,"%s",str);
+    else
+        fprintf(stdout,"INFO: %s",str);
+}
+
+/************************ print_outmessage_flush **********************/
+
+void print_outmessage_flush(char *str) {
+
+    if(!sloom && !sloombatch)
+        fprintf(stdout,"%s",str);
+    else {
+        fprintf(stdout,"INFO: %s",str);
+        fflush(stdout);
+    }
+}
+
+/********************** PRINT_OUTWARNING_FLUSH ***************************/
+
+void print_outwarning_flush(char *str)
+{
+    if(!sloom && !sloombatch)
+        fprintf(stdout,"%s",str);
+    else {
+        fprintf(stdout,"WARNING: %s",str);
+        fflush(stdout);
+    }
+}
+
+/**************************STRGETFLOAT **************************
+ * takes a pointer TO A POINTER to a string. If it succeeds in finding 
+ * a float it returns the float value (*val), and it's new position in the
+ * string (*str).
+ */
+
+int  strgetfloat(char **str,double *val)
+{   char *p, *q, *end;
+    double numero;
+    int point, valid;
+    for(;;) {
+        point = 0;
+        p = *str;
+        while(isspace(*p))
+            p++;
+        q = p;
+        if(!isdigit(*p) && *p != '.' && *p!='-')
+            return(0);
+        if(*p == '.'|| *p == '-') {
+            if(*p == '-') {
+                p++;
+            } else {
+                point++;
+                    p++;
+            }
+        }
+        for(;;) {
+            if(*p == '.') {
+                if(point)
+                    return(0);
+                else {
+                    point++;
+                    p++;
+                    continue;
+                }
+            }
+            if(isdigit(*p)) {
+                p++;
+                continue;
+            } else {
+                if(!isspace(*p) && *p!=ENDOFSTR)
+                    return(0);
+                else {
+                    end = p;
+                    p = q;
+                    valid = 0;
+                    while(p!=end) {
+                        if(isdigit(*p))
+                            valid++;
+                        p++;
+                    }
+                    if(valid) {
+                        if(sscanf(q,"%lf",&numero)!=1)
+                            return(0);
+                        *val = numero;
+                       *str = end;
+                        return(1);
+                    }
+                    return(0);
+                }
+            }
+        }
+    }
+    return(0);              /* NOTREACHED */
+}
+
+//TW: NEW FUNCTIONS BELOW
+
+/********************************** STRGETFLOAT_WITHIN_STRING ***********************************
+ *
+ * Differs from strgetfloat, in that float in string need not be terminated by space or endofstring
+ */
+
+int  strgetfloat_within_string(char **str,double *val)
+{   char *p, *q, c;
+    int point = 0, digit = 0;
+    p = *str;
+    while(isspace(*p))
+        p++;
+    q = p;  
+    for(;;) {
+        if(*p == '-') {
+            if (p != q)
+                return(0);  /* negative sign only at start */
+        } else if (*p == '.') {
+            if(point)
+                return(0);  /* only one decimal point */
+            point++;
+        } else if(isdigit(*p))
+            digit++;
+        else 
+            break;
+        p++;
+    }
+    if(!digit)
+        return(0);
+    c = *p;
+    *p = ENDOFSTR;
+    if(sscanf(q,"%lf",val)!=1) {
+        *p = c;
+        return(0);
+    }
+    *p = c;
+    *str = p;
+    return(1);
+}
+
+/********************* VALUE_IS_NUMERIC *********************/
+
+int value_is_numeric(char *str)
+{   char *p, *q, *end;
+    int point, valid;
+    for(;;) {
+        point = 0;
+        p = str;
+        while(isspace(*p))
+            p++;
+        q = p;  
+        if(!isdigit(*p) && *p != '.' && *p!='-')
+            return(0);
+        if(*p == '.'|| *p == '-') {
+            if(*p == '-') {
+                p++;
+            } else {
+                point++;
+                p++;
+            }
+        }
+        for(;;) {
+            if(*p == '.') {
+                if(point)
+                    return(0);
+                else {
+                    point++;
+                    p++;
+                    continue;
+                }
+            }
+            if(isdigit(*p)) {
+                p++;
+                continue;
+            } else {
+                if(!isspace(*p) && *p!=ENDOFSTR)
+                    return(0);
+                else {
+                    end = p;
+                    p = q;
+                    valid = 0;
+                    while(p!=end) {
+                        if(isdigit(*p))
+                            valid++;
+                        p++;
+                    }
+                    if(valid)
+                        return(1);
+                    return(0);
+                }
+            }
+        }
+    }
+    return(0);              /* NOTREACHED */
+}
+
+#ifdef TEST_HEADREAD
+int headread_check(SFPROPS props,char *filename,int ifd)
+{
+    infileptr inputfile;
+    int dummy;
+    if((inputfile = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
+        sprintf(errstr,"Insufficient memory for headread_check on file %s.\n",filename);
+        return(MEMORY_ERROR);
+    }
+    if(sndgetprop(ifd,"sample rate", (char *)&(inputfile->srate), sizeof(int)) < 0){
+        fprintf(stdout,"INFO: Cannot read sample rate in file: %s\n",filename);
+        fflush(stdout);
+        return(DATA_ERROR);
+    }
+    if(props.srate != inputfile->srate) {
+        fprintf(stdout,"INFO: snd_headread gives srate %ld: correct val = %ld: file %s\n",props.srate,inputfile->srate,filename);
+        fflush(stdout);
+    }
+    if(sndgetprop(ifd,"channels", (char *)&(inputfile->channels), sizeof(int)) < 0){
+        fprintf(stdout,"INFO: Cannot read channel count in file: %s\n",filename);
+        fflush(stdout);
+        return(DATA_ERROR);
+    }
+    if(props.chans != inputfile->channels) {
+        fprintf(stdout,"INFO: snd_headread gives channels %ld: correct val = %ld: file %s\n",props.chans,inputfile->channels,filename);
+        fflush(stdout);
+    }
+    inputfile->filetype = SNDFILE;
+    if(sndgetprop(ifd,"is an envelope",(char *)&dummy,sizeof(int)) >= 0)
+        inputfile->filetype = ENVFILE;
+    else if(sndgetprop(ifd,"is a pitch file",(char *)&dummy,sizeof(int)) >= 0)
+        inputfile->filetype = PITCHFILE;
+    else if(sndgetprop(ifd,"is a transpos file",(char *)&dummy,sizeof(int)) >= 0)
+        inputfile->filetype = TRANSPOSFILE;
+    else if(sndgetprop(ifd,"is a formant file",(char *)&dummy,sizeof(int)) >= 0)
+        inputfile->filetype = FORMANTFILE;
+    else if(sndgetprop(ifd,"original sampsize", (char *)&(inputfile->origstype), sizeof(int)) >= 0)
+        inputfile->filetype = ANALFILE;
+    
+    switch(inputfile->filetype) {
+
+    case(SNDFILE):
+        return(FINISHED);
+    case(ENVFILE):
+        if(sndgetprop(ifd,"window size", (char *)&(inputfile->window_size), sizeof(float)) < 0){
+            fprintf(stdout,"INFO: Cannot read envelope sindow size in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(props.window_size != inputfile->window_size) {
+            fprintf(stdout,"INFO: snd_headread gives window_size %f: correct val = %f: file %s\n",props.window_size,inputfile->window_size,filename);
+            fflush(stdout);
+        }
+        return(FINISHED);
+
+    case(FORMANTFILE):
+        if(sndgetprop(ifd,"specenvcnt", (char *)&(inputfile->specenvcnt), sizeof(int)) < 0){
+            fprintf(stdout,"INFO: Cannot read specenvcnt in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(props.specenvcnt != inputfile->specenvcnt) {
+            fprintf(stdout,"INFO: snd_headread gives specenvcnt %ld: correct val = %ld: file %s\n",props.specenvcnt,inputfile->specenvcnt,filename);
+            fflush(stdout);
+        }
+        /* fall through */
+    case(PITCHFILE):
+    case(TRANSPOSFILE):
+        if(sndgetprop(ifd,"orig channels", (char *)&(inputfile->origchans), sizeof(int)) < 0){
+            fprintf(stdout,"INFO: Cannot read origchans in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(props.origchans != inputfile->origchans) {
+            fprintf(stdout,"INFO: snd_headread gives origchans %ld: correct val = %ld: file %s\n",props.origchans,inputfile->origchans,filename);
+            fflush(stdout);
+        }
+        /* fall through */
+    case(ANALFILE):
+        if(sndgetprop(ifd,"original sampsize", (char *)&(inputfile->origstype), sizeof(int)) < 0){
+            fprintf(stdout,"INFO: Cannot read original sample type in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"original sample rate", (char *)&(inputfile->origrate), sizeof(int)) < 0){
+            fprintf(stdout,"INFO: Cannot read original sample rate in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"arate",(char *)&(inputfile->arate),sizeof(float)) < 0){
+            fprintf(stdout,"INFO: Cannot read analysis rate in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"analwinlen",(char *)&(inputfile->Mlen),sizeof(int)) < 0){
+            fprintf(stdout,"INFO: Cannot read analysis window length in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(sndgetprop(ifd,"decfactor",(char *)&(inputfile->Dfac),sizeof(int)) < 0) {
+            fprintf(stdout,"INFO: Cannot read decimation factor in file: %s\n",filename);
+            fflush(stdout);
+            return(DATA_ERROR);
+        }
+        if(props.origsize != inputfile->origstype) {
+            fprintf(stdout,"INFO: snd_headread gives origstype %ld: correct val = %ld: file %s\n",props.origsize,inputfile->origstype,filename);
+            fflush(stdout);
+        }
+        if(props.origrate != inputfile->origrate) {
+            fprintf(stdout,"INFO: snd_headread gives origrate %ld: correct val = %ld: file %s\n",props.origrate,inputfile->origrate,filename);
+            fflush(stdout);
+        }
+        if(props.arate != inputfile->arate) {
+            fprintf(stdout,"INFO: snd_headread gives arate %f: correct val = %f: file %s\n",props.arate,inputfile->arate,filename);
+            fflush(stdout);
+        }
+        if(props.winlen != inputfile->Mlen) {
+            fprintf(stdout,"INFO: snd_headread gives Mlen %d: correct val = %d: file %s\n",props.winlen,inputfile->Mlen,filename);
+            fflush(stdout);
+        }
+        if(props.decfac != inputfile->Dfac) {
+            fprintf(stdout,"INFO: snd_headread gives Dfac %d: correct val = %d: file %s\n",props.decfac,inputfile->Dfac,filename);
+            fflush(stdout);
+        }
+        break;
+    }
+    return(FINISHED);
+}
+#endif
+
+/***************************************** COPY_TO_INFILEPTR ***********************************/
+
+void copy_to_fileptr(infileptr i, fileptr f)
+{
+f->filetype     = i->filetype;
+f->srate        = i->srate;
+f->stype        = i->stype;
+f->origstype    = i->origstype;
+f->origrate     = i->origrate;
+f->channels     = i->channels;
+f->origchans    = i->origchans;
+f->specenvcnt   = i->specenvcnt;
+f->Mlen         = i->Mlen;
+f->Dfac         = i->Dfac;
+f->arate        = i->arate;
+f->window_size  = i->window_size;
+}
+
+/***************************************** GETPEAKDATA ***********************************/
+
+//TW get peak val and position
+int getpeakdata(int ifd, float *peakval,int *peakpos,SFPROPS props)
+{
+    CHPEAK peaks[16];
+    int chans, peaktime, maxpos = -1, pos_set = 0;
+    float maxamp = -2.0f;
+    
+    chans = props.chans; 
+    if(sndreadpeaks(ifd,chans,peaks,&peaktime)){
+        int i;
+        for(i=0;i < chans;i++) {
+            if(peaks[i].value > maxamp) {
+                maxamp = peaks[i].value;
+                maxpos = peaks[i].position;
+                pos_set = 1;
+            } else if(smpflteq(peaks[i].value,maxamp)) {
+                if(pos_set && (peaks[i].position < (unsigned int)maxpos))
+                    maxpos = peaks[i].position;
+            }
+        }
+        if(maxpos < 0) {
+            return 0;
+        } else {
+            *peakval = maxamp;
+            *peakpos = maxpos;
+        }
+        return 1;
+    }
+    /* sf_headread error; but can't do much about it */
+    return 0;
+}
+

dev/cdp2k/tklib3.c

@@ -0,0 +1,2501 @@
+/*
+ * 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>
+#ifdef WIN32
+#include <malloc.h>
+#else
+#include <memory.h>
+#endif
+#include <ctype.h>
+#include <string.h>
+#include <structures.h>
+#include <flags.h>
+#include <speccon.h>
+#include <arrays.h>
+#include <special.h>
+#include <formants.h>
+#include <cdpmain.h>
+#include <tkglobals.h>
+#include <processno.h>
+#include <modeno.h>
+#include <globcon.h>
+#include <logic.h>
+#include <filetype.h>
+#include <stdlib.h>
+#include <mixxcon.h>
+#include <sfsys.h>
+#include <osbind.h>
+#include <math.h>
+#include <filetype.h>
+#include <pnames.h>
+#include <srates.h>
+#include <vowels.h>
+
+#ifdef unix
+#define round(x) lround((x))
+#endif
+
+/******************************************************************************/
+/************************* FORMERLY IN procspec.c *****************************/
+/******************************************************************************/
+
+static int  extend_ring(int change_in_size,dataptr dz);
+static int  shrink_ring(int change_in_size,dataptr dz);
+static int  zero_channels_between_partials(int *vvc,double frq_close_below_next_partial,dataptr dz);
+static int  eliminate_all_but_loudest_channel_near_this_partial_frq
+                (int *vvc,double frq_close_above_next_partial,dataptr dz);
+static int  keep_all_channels_near_partial_frq(int *vvc,double frq_close_above_next_partial,dataptr dz);
+static int  do_amplitude_poll(int bot,int top,dataptr dz);
+
+/******************************************************************************/
+/************************* FORMERLY IN aplinit.c ******************************/
+/******************************************************************************/
+
+static int  establish_application(dataptr dz);
+static int  application_init(dataptr dz);
+
+static int  initialise_vflags(dataptr dz);
+static int  setup_and_init_input_param_activity(dataptr dz,int tipc);
+static int  setup_and_init_input_brktable_constants(dataptr dz,int tipc);
+static int  setup_parameter_storage_and_constants(int storage_cnt,dataptr dz);
+static int  initialise_is_int_and_no_brk_constants(int storage_cnt,dataptr dz);
+static int  mark_parameter_types(dataptr dz,aplptr ap);
+
+static int  establish_infile_constants(dataptr dz);
+static int  setup_input_param_defaultval_stores(int tipc,aplptr ap);
+
+static int get_domain_and_image(char *str,char **domain, char **image);
+static int consistent_domain_and_image(int dmncnt,int imgcnt,char *domain,char *image,dataptr dz);
+static int make_map(int dmncnt,int imgcnt,int mapping,char *domain,char *image,dataptr dz);
+
+/**************************** SETUP_PARTICULAR_APPLICATION *******************************/
+
+int setup_particular_application(dataptr dz)
+{
+    int exit_status;
+    aplptr ap;
+    if((exit_status = establish_application(dz))<0)
+        return(exit_status);
+    ap = dz->application;
+    if((exit_status = set_legal_param_structure(dz->process,dz->mode,ap))<0)
+        return(exit_status);                                        /* GLOBAL LIBRARY */
+
+    if((exit_status = set_legal_option_and_variant_structure(dz->process,dz->mode,ap))<0)
+        return(exit_status);                                        /* GLOBAL LIBRARY */
+    set_formant_flags(dz->process,dz->mode,ap);                     /* GLOBAL LIBRARY */
+
+    if((exit_status = set_legal_internalparam_structure(dz->process,dz->mode,ap))<0)
+        return(exit_status);                                        /* LIBRARY */
+    set_legal_infile_structure(dz);                                 /* IN THIS FILE */
+    assign_process_logic(dz);                                       /* IN THIS FILE */
+
+    if((exit_status = application_init(dz))<0)                      /* IN THIS FILE */
+        return(exit_status);
+    return(FINISHED);
+}
+
+/****************************** ESTABLISH_APPLICATION *******************************/
+
+int establish_application(dataptr dz)
+{
+    aplptr ap;
+    if((dz->application = (aplptr)malloc(sizeof (struct applic)))==NULL) {
+        sprintf(errstr,"establish_application()\n");
+        return(MEMORY_ERROR);
+    }
+    ap = dz->application;
+    memset((char *)ap,0,sizeof(struct applic));
+    return(FINISHED);
+}
+
+/***************************** APPLICATION_INIT **************************/
+
+int application_init(dataptr dz)
+{
+    int exit_status;
+    int storage_cnt;
+    int tipc, brkcnt;
+    aplptr ap = dz->application;
+    if(ap->vflag_cnt>0)
+        initialise_vflags(dz);    
+    tipc  = ap->max_param_cnt + ap->option_cnt + ap->variant_param_cnt;
+    ap->total_input_param_cnt = (char)tipc;
+    if(tipc>0) {
+        if((exit_status = setup_input_param_range_stores(tipc,ap))<0)             
+            return(exit_status);
+        if((exit_status = setup_input_param_defaultval_stores(tipc,ap))<0)        
+            return(exit_status);
+        if((exit_status = setup_and_init_input_param_activity(dz,tipc))<0)    
+            return(exit_status);
+    }
+    brkcnt = tipc;
+
+    if(dz->input_data_type==BRKFILES_ONLY                      
+    || dz->input_data_type==UNRANGED_BRKFILE_ONLY 
+    || dz->input_data_type==DB_BRKFILES_ONLY 
+    || dz->input_data_type==SNDFILE_AND_BRKFILE 
+    || dz->input_data_type==SNDFILE_AND_UNRANGED_BRKFILE 
+    || dz->input_data_type==SNDFILE_AND_DB_BRKFILE 
+    || dz->input_data_type==ALL_FILES
+    || dz->input_data_type==ANY_NUMBER_OF_ANY_FILES
+    || dz->outfiletype==BRKFILE_OUT) {
+        dz->extrabrkno = brkcnt;              
+        brkcnt++;       /* extra brktable for input or output brkpntfile data */
+    }
+    if(brkcnt>0) {
+        if((exit_status = setup_and_init_input_brktable_constants(dz,brkcnt))<0)              
+            return(exit_status);
+    }
+
+    if((storage_cnt = tipc + ap->internal_param_cnt)>0) {         
+        if((exit_status = setup_parameter_storage_and_constants(storage_cnt,dz))<0)   
+            return(exit_status);
+        if((exit_status = initialise_is_int_and_no_brk_constants(storage_cnt,dz))<0)      
+            return(exit_status);
+    }                                                      
+    if((exit_status = mark_parameter_types(dz,ap))<0)     
+            return(exit_status);
+
+    if((exit_status = establish_infile_constants(dz))<0)
+        return(exit_status);
+    if((exit_status = establish_bufptrs_and_extra_buffers(dz))<0)   
+        return(exit_status);
+    if((exit_status = setup_internal_arrays_and_array_pointers(dz))<0)   
+        return(exit_status);
+    return(FINISHED);
+}
+
+/************************* INITIALISE_VFLAGS *************************/
+
+int initialise_vflags(dataptr dz)
+{
+    int n;
+    if((dz->vflag  = (char *)malloc(dz->application->vflag_cnt * sizeof(char)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY: vflag store,\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<dz->application->vflag_cnt;n++)
+        dz->vflag[n]  = FALSE;
+    return FINISHED;
+}
+
+/***************************** SETUP_AND_INIT_INPUT_PARAM_ACTIVITY **************************/
+
+int setup_and_init_input_param_activity(dataptr dz,int tipc)
+{
+    int n;
+    if((dz->is_active = (char   *)malloc((size_t)tipc))==NULL) {
+        sprintf(errstr,"setup_and_init_input_param_activity()\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<tipc;n++)
+        dz->is_active[n] = (char)0;
+    return(FINISHED);
+}
+
+/***************************** SETUP_AND_INIT_INPUT_BRKTABLE_CONSTANTS **************************/
+
+int setup_and_init_input_brktable_constants(dataptr dz,int brkcnt)
+{
+    int n;
+    if((dz->brk      = (double **)malloc(brkcnt * sizeof(double *)))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 1\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->brkptr   = (double **)malloc(brkcnt * sizeof(double *)))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 6\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->brksize  = (int    *)malloc(brkcnt * sizeof(int)    ))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 2\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->firstval = (double  *)malloc(brkcnt * sizeof(double)  ))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 3\n");
+        return(MEMORY_ERROR);                                                 
+    }
+    if((dz->lastind  = (double  *)malloc(brkcnt * sizeof(double)  ))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 4\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->lastval  = (double  *)malloc(brkcnt * sizeof(double)  ))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 5\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->brkinit  = (int     *)malloc(brkcnt * sizeof(int)     ))==NULL) {
+        sprintf(errstr,"setup_and_init_input_brktable_constants(): 7\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<brkcnt;n++) {
+        dz->brk[n]     = NULL;
+        dz->brkptr[n]  = NULL;
+        dz->brkinit[n] = 0;
+        dz->brksize[n] = 0;
+    }
+    return(FINISHED);
+}
+
+/********************** SETUP_PARAMETER_STORAGE_AND_CONSTANTS ********************/
+/* RWD malloc changed to calloc; helps debug verison run as release! */
+int setup_parameter_storage_and_constants(int storage_cnt,dataptr dz)
+{
+    // RWD Apr 20100 add extra element
+    storage_cnt += 1;
+    
+    if((dz->param       = (double *)calloc(storage_cnt, sizeof(double)))==NULL) {
+        sprintf(errstr,"setup_parameter_storage_and_constants(): 1\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->iparam      = (int    *)calloc(storage_cnt, sizeof(int)   ))==NULL) {
+        sprintf(errstr,"setup_parameter_storage_and_constants(): 2\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->is_int      = (char   *)calloc(storage_cnt, sizeof(char)))==NULL) {
+        sprintf(errstr,"setup_parameter_storage_and_constants(): 3\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->no_brk      = (char   *)calloc(storage_cnt, sizeof(char)))==NULL) {
+        sprintf(errstr,"setup_parameter_storage_and_constants(): 5\n");
+        return(MEMORY_ERROR);
+    }
+    return(FINISHED);
+}
+
+/************** INITIALISE_IS_INT_AND_NO_BRK_CONSTANTS *****************/
+
+int initialise_is_int_and_no_brk_constants(int storage_cnt,dataptr dz)
+{
+    int n;
+    for(n=0;n<storage_cnt;n++) {
+        dz->is_int[n] = (char)0;
+        dz->no_brk[n] = (char)0;
+    }
+    return(FINISHED);
+}
+
+/***************************** MARK_PARAMETER_TYPES **************************/
+
+int mark_parameter_types(dataptr dz,aplptr ap)
+{
+    int n, m;                           /* PARAMS */
+    for(n=0;n<ap->max_param_cnt;n++) {
+        switch(ap->param_list[n]) {
+        case('0'):  break; /* dz->is_active[n] = 0 is default */
+        case('i'):  dz->is_active[n] = (char)1; dz->is_int[n] = (char)1;dz->no_brk[n] = (char)1; break;
+        case('I'):  dz->is_active[n] = (char)1; dz->is_int[n] = (char)1;                         break;
+        case('d'):  dz->is_active[n] = (char)1;                         dz->no_brk[n] = (char)1; break;
+        case('D'):  dz->is_active[n] = (char)1; /* normal case: double val or brkpnt file */     break;
+        default:
+            sprintf(errstr,"Programming error: invalid parameter type in mark_parameter_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }                               /* OPTIONS */
+    for(n=0,m=ap->max_param_cnt;n<ap->option_cnt;n++,m++) {
+        switch(ap->option_list[n]) {
+//TW JULY 2006
+        case('0'): break;
+        case('i'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1; dz->no_brk[m] = (char)1; break;
+        case('I'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1;                          break;
+        case('d'): dz->is_active[m] = (char)1;                          dz->no_brk[m] = (char)1; break;
+        case('D'): dz->is_active[m] = (char)1;  /* normal case: double val or brkpnt file */     break;
+        default:
+            sprintf(errstr,"Programming error: invalid option type in mark_parameter_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }                               /* VARIANTS */
+    for(n=0,m=ap->max_param_cnt + ap->option_cnt;n < ap->variant_param_cnt; n++, m++) {
+        switch(ap->variant_list[n]) {
+        case('0'): break;
+        case('i'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1; dz->no_brk[m] = (char)1; break;
+        case('I'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1;                          break;
+        case('d'): dz->is_active[m] = (char)1;                          dz->no_brk[m] = (char)1; break;
+        case('D'): dz->is_active[m] = (char)1; /* normal case: double val or brkpnt file */      break;
+        default:
+            sprintf(errstr,"Programming error: invalid variant type in mark_parameter_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }                               /* INTERNAL */
+    for(n=0,
+    m=ap->max_param_cnt + ap->option_cnt + ap->variant_param_cnt; n<ap->internal_param_cnt; n++,m++) {
+        switch(ap->internal_param_list[n]) {
+        case('0'):  break;   /* dummy variables: variables not used: but important for internal paream numbering!! */
+        case('i'):  dz->is_int[m] = (char)1;    dz->no_brk[m] = (char)1;    break;
+        case('d'):                              dz->no_brk[m] = (char)1;    break;
+        default:
+            sprintf(errstr,"Programming error: invalid internal param type in mark_parameter_types()\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/******************** ESTABLISH_SPEC_BUFPTRS_AND_EXTRA_BUFFERS **************************/
+
+int establish_spec_bufptrs_and_extra_buffers(dataptr dz)
+{
+    int n;
+    if(dz->extra_bufcnt) {
+        if((dz->windowbuf = (float **)malloc(sizeof(float *) * dz->extra_bufcnt))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for extra float sample buffers.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n = 0; n < dz->extra_bufcnt;n++)
+            dz->windowbuf[n] = NULL;
+    }
+    if(dz->bptrcnt) {
+        if((dz->flbufptr = (float **)malloc(sizeof(float *) * dz->bptrcnt))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for float sample buffers.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n = 0;n <dz->bptrcnt; n++)
+            dz->flbufptr[n] = NULL;
+    }
+    return(FINISHED);
+}
+
+/******************** ESTABLISH_GROUCHO_BUFPTRS_AND_EXTRA_BUFFERS **************************/
+
+int establish_groucho_bufptrs_and_extra_buffers(dataptr dz)
+{
+    int n;
+    if(dz->bufcnt < 0)  {
+        sprintf(errstr,"bufcnt has not been set: establish_groucho_bufptrs_and_extra_buffers()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->extra_bufcnt < 0)    {
+        sprintf(errstr,"extrs_bufcnt has not been set: establish_groucho_bufptrs_and_extra_buffers()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->bufcnt) {
+        if((dz->sampbuf = (float **)malloc(sizeof(float *) * (dz->bufcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY establishing sample buffers.\n");
+            return(MEMORY_ERROR);
+        }
+        if((dz->sbufptr = (float **)malloc(sizeof(float *) * dz->bufcnt))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY establishing sample buffer pointers.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n = 0;n <dz->bufcnt; n++)
+            dz->sampbuf[n] = dz->sbufptr[n] = (float *)0;
+        dz->sampbuf[n] = (float *)0;
+    }
+    if(dz->extra_bufcnt) {
+        if((dz->extrabuf = (float **)malloc(sizeof(float *) * (dz->extra_bufcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY establishing extra buffers.\n");
+            return(MEMORY_ERROR);
+        }
+        if((dz->extrabufptr = (float **)malloc(sizeof(float *) * (dz->extra_bufcnt+1)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY establishing extrabuffer pointers.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n = 0;n <dz->extra_bufcnt; n++)
+            dz->extrabuf[n] = dz->extrabufptr[n] = (float *)0;
+        dz->extrabuf[n] = (float *)0;
+    }
+    return(FINISHED);
+}
+
+/***************************** ESTABLISH_INFILE_CONSTANTS **************************/
+
+int establish_infile_constants(dataptr dz)
+{
+    switch(dz->input_data_type) {
+
+    case(MIXFILES_ONLY):        case(SNDLIST_ONLY):         
+    case(SND_OR_MIXLIST_ONLY):  case(SND_SYNC_OR_MIXLIST_ONLY):
+    case(BRKFILES_ONLY):        case(DB_BRKFILES_ONLY):     case(UNRANGED_BRKFILE_ONLY):
+    case(WORDLIST_ONLY):
+        dz->infilecnt = ONE_NONSND_FILE;
+        break;
+    case(NO_FILE_AT_ALL):
+        dz->infilecnt = 0;
+        break;
+    case(ALL_FILES):            case(SNDFILES_ONLY):        case(ENVFILES_ONLY):
+    case(ANALFILE_ONLY):        case(PITCHFILE_ONLY):       case(PITCH_OR_TRANSPOS):
+    case(FORMANTFILE_ONLY):
+        dz->infilecnt = 1;
+        break;
+    case(TWO_SNDFILES):     
+    case(SNDFILE_AND_ENVFILE):  case(SNDFILE_AND_BRKFILE):  case(SNDFILE_AND_DB_BRKFILE):
+    case(TWO_ANALFILES):        case(ANAL_WITH_PITCHDATA):  case(ANAL_WITH_TRANSPOS):
+    case(ANAL_AND_FORMANTS):    case(PITCH_AND_FORMANTS):   case(PITCH_AND_PITCH):
+    case(PITCH_AND_TRANSPOS):   case(TRANSPOS_AND_TRANSPOS):case(SNDFILE_AND_UNRANGED_BRKFILE): 
+        dz->infilecnt = 2;
+        break;
+    case(THREE_ANALFILES):
+//TW NEW CASE
+    case(PFE):
+        dz->infilecnt = 3;
+        break;
+    case(MANY_ANALFILES):
+    case(MANY_SNDFILES):
+        dz->infilecnt = -2; /* flags 2 or more */
+        break;
+    case(ONE_OR_MANY_SNDFILES):
+//TW NEW CASE
+    case(ONE_OR_MORE_SNDSYS):
+    case(ANY_NUMBER_OF_ANY_FILES):
+        dz->infilecnt = -1; /* flags 1 or more */
+        break;
+    default:
+        sprintf(errstr,"Unknown input_process-type: establish_infile_constants()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/****************************** SETUP_PROCESS_LOGIC *********************************/
+
+void setup_process_logic(int input,int processing,int output,dataptr dz)
+{
+    dz->input_data_type = input;
+    dz->process_type    = processing;   
+    dz->outfiletype     = output;
+}
+
+/************************* SETUP_INPUT_PARAM_DEFAULTVALS *************************/
+// RWD Apr 2011 added extra element
+int setup_input_param_defaultval_stores(int tipc,aplptr ap)
+{
+    int n;
+    tipc += 1;
+    if((ap->default_val = (double *)malloc(tipc * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for application default values store\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<tipc;n++)
+        ap->default_val[n] = 0.0;
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN internal.c *****************************/
+/******************************************************************************/
+
+/******** SET_INTERNALPARAM_DATA ***********************/
+
+int set_internalparam_data(const char *this_paramlist,aplptr ap)
+{
+    int count;
+    if((count = (int)strlen(this_paramlist))>0) {
+        if((ap->internal_param_list = (char *)malloc((size_t)(count+1)))==NULL) {
+            sprintf(errstr,"set_internalparam_data()\n");
+            return(MEMORY_ERROR);
+        }
+        strcpy(ap->internal_param_list,this_paramlist); 
+    }
+    ap->internal_param_cnt = (char ) count;        /*RWD added cast */
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN sinlib.c *******************************/
+/******************************************************************************/
+
+ /************************* READ_SAMPS **************************/
+//TW removed NOTDEF: not certain how to get to not-NOTDEF option
+
+int read_samps(float *bbuf,dataptr dz)
+{
+    if((dz->ssampsread = fgetfbufEx(bbuf, dz->buflen,dz->ifd[0],0)) < 0) {
+        sprintf(errstr,"Can't read samples from input soundfile.\n");
+        return(SYSTEM_ERROR);
+    }
+    dz->samps_left -= dz->ssampsread;   
+    dz->total_samps_read += dz->ssampsread;
+
+
+    return(FINISHED);
+}
+
+/*************************** READ_VALUES_FROM_ALL_EXISTING_BRKTABLES **************************/
+
+int read_values_from_all_existing_brktables(double thistime,dataptr dz)
+{
+    int exit_status;
+    aplptr ap = dz->application;
+    int n;
+    for(n=0;n<ap->total_input_param_cnt;n++) {
+        if(dz->brksize[n]) {
+            if((exit_status = read_value_from_brktable(thistime,n,dz))<0)
+                return(exit_status);
+        }
+    }
+    return(FINISHED);
+}
+
+/**************************** READ_VALUE_FROM_BRKTABLE *****************************/
+
+int read_value_from_brktable(double thistime,int paramno,dataptr dz)
+{
+    double *endpair, *p, val;
+    double hival, loval, hiind, loind;
+    if(!dz->brkinit[paramno]) {
+        dz->brkptr[paramno]   = dz->brk[paramno];
+        dz->firstval[paramno] = *(dz->brk[paramno]+1);
+        endpair               = dz->brk[paramno] + ((dz->brksize[paramno]-1)*2);
+        dz->lastind[paramno]  = *endpair;
+        dz->lastval[paramno]  = *(endpair+1);
+        dz->brkinit[paramno] = 1;
+    }
+    p = dz->brkptr[paramno];
+    if(thistime <= *(dz->brk[paramno])) {
+        dz->param[paramno] = dz->firstval[paramno];
+        if(dz->is_int[paramno])                         
+            dz->iparam[paramno] = round(dz->param[paramno]);
+        return(FINISHED);
+    } else if(thistime >= dz->lastind[paramno]) {
+        dz->param[paramno] = dz->lastval[paramno];
+        if(dz->is_int[paramno])                         
+            dz->iparam[paramno] = round(dz->param[paramno]);
+        return(FINISHED);
+    } 
+    if(thistime > *(p)) {
+        while(*(p)<thistime)
+            p += 2;
+    } else {
+        while(*(p)>=thistime)
+            p -= 2;
+        p += 2;
+    }
+    hival  = *(p+1);
+    hiind  = *p;
+    loval  = *(p-1);
+    loind  = *(p-2);
+    val    = (thistime - loind)/(hiind - loind);
+    val   *= (hival - loval);
+    val   += loval;
+    dz->param[paramno] = val;
+    if(dz->is_int[paramno])                         
+        dz->iparam[paramno] = round(dz->param[paramno]);
+    dz->brkptr[paramno] = p;
+    return(FINISHED);
+}
+
+/************************** GET_TOTALAMP ***********************/
+
+int get_totalamp(double *totalamp,float *sbuf,int wanted)
+{
+    int vc;
+    *totalamp = 0.0;
+    for(vc = 0; vc < wanted; vc += 2)
+        *totalamp += sbuf[AMPP];
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN specialin.c ****************************/
+/******************************************************************************/
+
+/************** READ_NEW_FILENAME ***********/
+
+int read_new_filename(char *filename,dataptr dz)
+{
+    if(dz->wordstor!=NULL) {
+        if((dz->wordstor  = (char **)realloc(dz->wordstor,(dz->all_words+1) * sizeof(char *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY to reallocate word stores.\n");
+            return(MEMORY_ERROR);
+        }
+    } else {
+        if(dz->all_words!=0 || dz->extra_word!=-1) {
+            sprintf(errstr,"Array allocation error: read_new_filename().\n");
+            return(PROGRAM_ERROR);
+        }
+        if((dz->wordstor  = (char **)malloc((dz->all_words+1) * sizeof(char *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY to create word stores.\n");
+            return(MEMORY_ERROR);
+        }
+    }
+    dz->extra_word = dz->all_words;
+    dz->all_words++;
+    if((dz->wordstor[dz->extra_word] = (char *)malloc((strlen(filename)+1) * sizeof(char)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to create extra word store.\n");
+        return(MEMORY_ERROR);
+    }
+    strcpy(dz->wordstor[dz->extra_word],filename);
+    return(FINISHED);
+}
+
+/**************************** READ_SHUFFLE_DATA **************************/
+
+int read_shuffle_data(int dmnparam,int imgparam,int mapparam,char *str,dataptr dz)
+{
+    int exit_status;
+    char *domain, *image;
+    if((exit_status = get_domain_and_image(str,&domain,&image))<0)
+        return(exit_status);
+    dz->iparam[dmnparam] = (int)strlen(domain);
+    dz->iparam[imgparam] = (int)strlen(image);
+    if((exit_status = consistent_domain_and_image(dmnparam,imgparam,domain,image,dz))!=TRUE)
+        return(DATA_ERROR);
+    return make_map(dmnparam,imgparam,mapparam,domain,image,dz);
+}
+
+/************************** GET_DOMAIN_AND_IMAGE ********************************/
+
+int get_domain_and_image(char *str,char **domain, char **image)
+{
+    char *p = str, *q = str;
+
+    while(*p!='-' && *p != ':') {
+        if(*p == ENDOFSTR) {
+            sprintf(errstr,"Bad string for shuffle data: separator missing\n");
+            return(DATA_ERROR);
+        } else if(!isalpha(*p)) {
+            sprintf(errstr,"Invalid character ('%c') in string for shuffle data.\n",*p);
+            return(DATA_ERROR);
+        }
+        p++;
+    }
+    if(p-q <=0) {
+        sprintf(errstr,"Bad string for shuffle data: domain missing\n");
+        return(DATA_ERROR);
+    }
+    *p = ENDOFSTR;
+    *domain = q;
+    p++;
+    q = p;
+    while(*p!=ENDOFSTR) {
+        if(!isalpha(*p)) {
+            sprintf(errstr,"Invalid character ('%d') in string for shuffle data.\n",*p);
+            return(DATA_ERROR);
+        }
+        p++;
+    }
+    if(p-q <=0) {
+        sprintf(errstr,"Bad string for shuffle data: image missing\n");
+        return(DATA_ERROR);
+    }
+    *image = q;
+    return(FINISHED);
+}
+                                                                
+/************************** MAKE_MAP ********************************/
+
+int make_map(int dmncnt,int imgcnt,int mapping,char *domain,char *image,dataptr dz)
+{
+    int n, m, OK;
+    if((dz->iparray[mapping] = (int *)malloc(dz->iparam[imgcnt] * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for map.\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<dz->iparam[imgcnt];n++) {
+        OK = 0;
+        for(m=0;m<dz->iparam[dmncnt];m++) {
+            if(image[n] == domain[m]) {
+                dz->iparray[mapping][n] = m;
+                OK = 1;
+                break;
+            }
+        }
+        if(!OK) {
+            sprintf(errstr,"Programming Problem: no match in make_map().\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/************************** CONSISTENT_DOMAIN_AND_IMAGE ********************************/
+
+int consistent_domain_and_image(int dmncnt,int imgcnt,char *domain,char *image,dataptr dz)  
+{
+    int n, m, OK;
+    for(n=0;n<dz->iparam[dmncnt]-1;n++) {
+        for(m=n+1;m<dz->iparam[dmncnt];m++) {
+            if(domain[n]==domain[m]) {
+                sprintf(errstr,"Duplicated symbol [%c] in domain string.\n",domain[n]);
+                return(FALSE);
+            }
+        }
+    }
+    for(n=0;n<dz->iparam[imgcnt];n++) {
+        OK = 0;
+        for(m=0;m<dz->iparam[dmncnt];m++) {
+            if(image[n] == domain[m]) {
+                OK = 1;
+                break;
+            }
+        }
+        if(!OK) {
+            sprintf(errstr,"Image symbol [%c] not in domain.\n",image[n]);
+            return(FALSE);
+        }
+    }
+    return(TRUE);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN preprocess.c ***************************/
+/******************************************************************************/
+
+/***************************** FORCE_VALUE_AT_ZERO_TIME ******************************/
+
+int force_value_at_zero_time(int paramno,dataptr dz)
+{
+    double *p, *pend;
+    double thistime,lasttime,timediff,timeratio,thisval,lastval,valdiff,val;
+    int n;
+    if(flteq(dz->brk[paramno][0],0.0)) {
+        dz->brk[paramno][0] = 0.0;
+        return(FINISHED);
+    }
+    if(dz->brk[paramno][0] > 0.0) {
+        if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),(dz->brksize[paramno]+1) * 2 * sizeof(double)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY to reallocate to force zero-time value.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n = (dz->brksize[paramno] * 2) - 1; n>=0;n--)
+            dz->brk[paramno][n+2] = dz->brk[paramno][n];
+
+        dz->brk[paramno][0] = 0.0;
+        dz->brk[paramno][1] = dz->brk[paramno][3];
+        dz->brksize[paramno]++;
+    } else {
+        p = dz->brk[paramno];
+        pend = p + (dz->brksize[paramno] * 2);
+        while(*p < 0.0) {
+            p += 2;
+            if(p >= pend) {
+                p -= 2;
+                memmove((char *)(dz->brk[paramno]),(char *)p,2 * sizeof(double));
+                dz->brk[paramno][0] = 0.0;
+                if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),2 * sizeof(double)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY to reallocate to force zero-time value.\n");
+                    return(MEMORY_ERROR);
+                }
+                dz->brksize[paramno] = 1;
+                return(FINISHED);
+            }
+        }
+        if(*p > 0.0) {
+            thistime  = *p;
+            lasttime  = *(p-2);
+            timediff  = thistime - lasttime;
+            timeratio = -(lasttime)/timediff;   /* lasttime is -ve */
+            thisval   = *(p+1);
+            lastval   = *(p-1);
+            valdiff   = thisval - lastval;
+            val       = lastval + (valdiff * timeratio);
+            p -= 2;
+            *p     = 0.0;
+            *(p+1) = val;
+        }
+        dz->brksize[paramno] = (pend - p)/2;
+        memmove((char *)(dz->brk[paramno]),(char *)p,dz->brksize[paramno] * 2 * sizeof(double));
+        if((dz->brk[paramno] = (double *)realloc((char *)(dz->brk[paramno]),dz->brksize[paramno] * 2 * sizeof(double)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY to reallocate to force zero-time value.\n");
+            return(MEMORY_ERROR);
+        }
+    }
+    dz->brkptr[paramno] = dz->brk[paramno];
+    return(FINISHED);
+}
+
+/***************************** INITIALISE_RANDOM_SEQUENCE ***************************/
+
+void initialise_random_sequence(int seed_flagno,int seed_paramno,dataptr dz)
+{
+    if(dz->vflag[seed_flagno])
+        srand((int)dz->iparam[seed_paramno]);
+    else
+        initrand48();
+}
+
+/******************** CONVERT_MSECS_TO_SECS **********************/
+
+int convert_msecs_to_secs(int brktableno,dataptr dz)
+{
+    double *p, *pend;
+    if(dz->brksize[brktableno]) {
+        p = dz->brk[brktableno];
+        pend = p + (dz->brksize[brktableno] * 2);
+        while(p < pend) {
+            *p *= MS_TO_SECS;
+            p+=2;
+        }
+    } else
+        dz->param[brktableno] *= MS_TO_SECS;
+    return(FINISHED);
+}
+
+/***************************** ESTABLISH_BOTTOM_FRQS_OF_CHANNELS **************/
+
+int establish_bottom_frqs_of_channels(dataptr dz)
+{
+    int cc;
+    if((dz->windowbuf[CHBOT] = (float *)    realloc((char *)dz->windowbuf[CHBOT],dz->clength * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for channel bottom frqs array.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->windowbuf[CHBOT][0] = 0.0f;
+    dz->windowbuf[CHBOT][1] = (float)dz->halfchwidth;
+    for(cc = 2 ;cc < dz->clength; cc++)
+        dz->windowbuf[CHBOT][cc] = (float)(dz->windowbuf[CHBOT][cc-1] + dz->chwidth);
+    return(FINISHED);
+}
+
+/***************************** ESTABLISH_TESTTONE_AMPS *************************/
+
+int establish_testtone_amps(dataptr dz)
+{
+    int n;
+    if((dz->windowbuf[TESTPAMP] = 
+    (float *)realloc((char *)dz->windowbuf[TESTPAMP],PARTIALS_IN_TEST_TONE * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for testtone amp array.\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->windowbuf[TOTPAMP]  = 
+    (float *)realloc((char *)dz->windowbuf[TOTPAMP],PARTIALS_IN_TEST_TONE * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for testtone totalamp array.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->windowbuf[TOTPAMP][0] = dz->windowbuf[TESTPAMP][0] = 1.0f;
+    for(n = 1; n < PARTIALS_IN_TEST_TONE; n++)    /* ACTUAL PARTIAL AMPS */
+        dz->windowbuf[TESTPAMP][n] 
+                = (float)(dz->windowbuf[TESTPAMP][n-1] * PARTIAL_DECIMATION);
+    for(n = 1; n < PARTIALS_IN_TEST_TONE; n++)    /* SUM OF PARTIAL AMPS */
+        dz->windowbuf[TOTPAMP][n] = 
+            (float)(dz->windowbuf[TOTPAMP][n-1] + dz->windowbuf[TESTPAMP][n]);
+    return(FINISHED);
+}
+
+/************************** SETUP_RING ******************************/
+
+int setup_ring(dataptr dz)
+{
+    chvptr /*last,*/ head;                  
+    if((dz->ringhead = (chvptr)malloc(sizeof(struct chanval)))==NULL)    {
+        sprintf(errstr,"INSUFFICIENT MEMORY for ring buffer.\n");
+        return(MEMORY_ERROR);
+    }
+    head = dz->ringhead;
+    head->next = head;                         /* Initialise its pointers to self-point */
+    head->last = head;     
+//  last = head;                                /* Mark current end of ring at ringhead */
+    dz->ringsize = 1;
+    return(FINISHED);
+}
+
+/************ SETUP_INTERNAL_BITFLAGS *************/
+
+int setup_internal_bitflags(int bflag_array_no,int longpow,int divmask, dataptr dz)
+{
+    int exit_status;
+     if((exit_status = log2_of_the_number_which_is_a_power_of_2(&(dz->iparam[longpow]),sizeof(int) * CHARBITSIZE))<0)
+        return(exit_status);                                                    /* sizeof(int) in bytes as pow of 2 */
+    dz->iparam[divmask]  = (int)(two_to_the_power_of(dz->iparam[longpow]) - 1); /* mask to calc MOD(longpow2) */
+    return init_bitflags_to_zero(bflag_array_no,dz);                            /* Create and set-to-zero bitflags */
+}
+
+/********** LOG2_OF_THE_NUMBER_WHICH_IS_A_POWER_OF_2 *********/
+
+int log2_of_the_number_which_is_a_power_of_2(int *n,int k)
+{
+    int mask = 1;
+    int m = 0;
+    if(k < 0) {
+        sprintf(errstr,"-ve number submiited to log2_of_the_number_which_is_a_power_of_2()\n");
+        return(PROGRAM_ERROR);
+    }
+    while(!(mask & k)) {
+        mask <<= 1;
+        m++;
+    }
+    *n = m;
+    return(FINISHED);
+}
+
+/*********************** TWO_TO_THE_POWER_OF **********************
+ *
+ * Find 2-to-power-of-k.
+ */
+
+int two_to_the_power_of(int k)
+{
+    int n = 1;
+    n <<= k;
+    return(n);
+}
+
+/***************************** INIT_BITFLAGS_TO_ZERO ***************************/
+
+int init_bitflags_to_zero(int bflag_array_no,dataptr dz)
+{
+    int n;
+    int flgsize = (dz->clength/(sizeof(int) * CHARBITSIZE)) + 1;
+    if((dz->lparray[bflag_array_no] = (int *)malloc(flgsize * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for bitflags.\n");
+        return(MEMORY_ERROR);
+    }
+    for(n=0;n<flgsize;n++)
+        dz->lparray[bflag_array_no][n] = 0;
+    return(FINISHED);
+}
+
+/****************************** SETUP_STABILITY_ARRAYS_AND_CONSTANTS **************/
+
+int setup_stability_arrays_and_constants(int stability_val,int sval_less_one,dataptr dz)
+{
+    int n;
+    if((dz->stable = (stabptr)malloc(sizeof(struct stability)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability array.\n");
+        return(MEMORY_ERROR);
+    }
+    if(dz->wlength < dz->iparam[stability_val]) {
+        sprintf(errstr,"File too short to use this program option.\nTry smaller value with '-s' (stability) flag.\n");
+        return(DATA_ERROR);
+    }
+    dz->stable->offset = dz->iparam[stability_val]/2;   /* stabl is always ODD : gives middle window of windows buffer */
+
+    if((dz->stable->sbufstore = (float *)malloc(((dz->wanted*dz->iparam[stability_val])+1) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability buffer store.\n");
+        return(MEMORY_ERROR);
+    }
+    /* baktraking windows buf */
+    if((dz->stable->sbuf = (float **)malloc((dz->iparam[stability_val]+1) * sizeof(float *)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability backtracking buffer.\n");
+        return(MEMORY_ERROR);
+    }
+    /* ptrs to wndws within it */
+    dz->stable->sbuf[0]   = dz->stable->sbufstore;
+    for(n=1;n<dz->iparam[stability_val]+1;n++)
+        dz->stable->sbuf[n] = dz->stable->sbuf[n-1] + dz->wanted;
+    if((dz->stable->specstore = 
+    (float *)malloc(((dz->infile->specenvcnt * dz->iparam[stability_val])+1) * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability spectral store.\n");
+        return(MEMORY_ERROR);
+    }
+    if((dz->stable->spec      = (float **)malloc((dz->iparam[stability_val]+1) * sizeof(float*)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability spectrum store.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->stable->spec[0]   = dz->stable->specstore;
+    for(n=1;n<dz->iparam[stability_val]+1;n++)
+        dz->stable->spec[n] = dz->stable->spec[n-1] + dz->infile->specenvcnt;
+    if((dz->stable->fpkstore  = 
+    (int *)malloc(((dz->iparam[stability_val] * dz->infile->specenvcnt)+1)*sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability peaks store.\n");
+        return(MEMORY_ERROR);
+    }
+    /* baktraking spectral-peaks buf */
+    if((dz->stable->fpk = (int **)malloc((dz->iparam[stability_val]+1) * sizeof(int *)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability peaks backtrack store.\n");
+        return(MEMORY_ERROR);
+    }
+    /* pointers to peakstores within it */
+    dz->stable->fpk[0]    = dz->stable->fpkstore;
+    for(n=1;n<dz->iparam[stability_val]+1;n++)
+        dz->stable->fpk[n] = dz->stable->fpk[n-1] + dz->infile->specenvcnt;
+    if((dz->stable->total_pkcnt  = (int *)malloc((dz->iparam[stability_val]+1) * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability peakcount store.\n");
+        return(MEMORY_ERROR);
+    }
+    /* cnt of total peaks found per baktrak buf */
+    if((dz->stable->design_score = (int *)malloc((dz->infile->specenvcnt+1) * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability design score store.\n");
+        return(MEMORY_ERROR);
+    }
+    /* array for designing filter */
+    if((dz->stable->des = (desptr *)malloc((dz->infile->specenvcnt+1) * sizeof(desptr)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for stability design store.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->iparam[sval_less_one] = dz->iparam[stability_val]- 1;
+            /* SET SAFETY VALUES */
+    dz->stable->specstore[dz->infile->specenvcnt * dz->iparam[stability_val]] = 0.0f;
+    dz->stable->spec[dz->iparam[stability_val]] = (float *)0;
+    dz->stable->fpkstore[dz->iparam[stability_val] * dz->infile->specenvcnt] = 0;
+    dz->stable->fpk[dz->iparam[stability_val]] = (int *)0; 
+    dz->stable->total_pkcnt[dz->iparam[stability_val]] = 0;
+    dz->stable->design_score[dz->infile->specenvcnt] = 0;  /* array for designing filter */
+    dz->stable->des[dz->infile->specenvcnt] = (desptr)0;
+    dz->stable->sbufstore[dz->wanted * dz->iparam[stability_val]] = 0.0f;
+    dz->stable->sbuf[dz->iparam[stability_val]] = 0L;
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN procgrou.c *****************************/
+/******************************************************************************/
+
+/***************************** ZERO_SOUND_BUFFERS **************************/
+
+int zero_sound_buffers(dataptr dz)
+{
+    int n;
+    for(n=0;n<dz->bufcnt;n++)
+        memset((char *)dz->sampbuf[n],0,(size_t)(dz->buflen * sizeof(float)));
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN procspec.c *****************************/
+/******************************************************************************/
+
+/***************************** RECTIFY_WINDOW ******************************/
+
+void rectify_window(float *flbuf,dataptr dz)
+{
+    int vc;
+    for(vc = 0; vc < dz->wanted; vc += 2) {
+        if(flbuf[FREQ] < 0.0) {
+            flbuf[FREQ] = -flbuf[FREQ];
+// FEB 2010 TW
+//          if(dz->is_rectified==FALSE) {
+//              fprintf(stdout,"WARNING: Negative frq(s) in source data: rectified.\n");
+//              fflush(stdout);
+//              dz->is_rectified = TRUE;
+//          }
+        }
+    }
+}
+
+/**************************** OUTER_LOOP ****************************/
+
+int outer_loop(dataptr dz)
+{
+    int exit_status;
+    int samps_read, got, windows_in_buf,peakscore = 0, pitchcnt = 0;
+    int  in_start_portion = TRUE, least = 0, descnt = 0;
+    dz->time = 0.0f;
+    if(dz->bptrcnt <= 0) {
+        sprintf(errstr,"flbufptr[0] not established by outer_loop()\n");
+        return(PROGRAM_ERROR);
+    }
+    while((samps_read = fgetfbufEx(dz->bigfbuf, dz->buflen,dz->ifd[0],0)) > 0) {
+        got = samps_read;
+        dz->flbufptr[0] = dz->bigfbuf;
+        windows_in_buf = got/dz->wanted;
+        if((exit_status = inner_loop(&peakscore,&descnt,&in_start_portion,&least,&pitchcnt,windows_in_buf,dz))<0)
+            return(exit_status);
+        if((exit_status = write_exact_samps(dz->bigfbuf,samps_read,dz))<0)
+            return(exit_status);
+    }
+    if(samps_read < 0) {
+        sprintf(errstr,"Sound read error.\n");
+        return(SYSTEM_ERROR);
+    }  
+    return(FINISHED);
+}
+
+/*********************** INITIALISE_WINDOW_FRQS **********************
+ *
+ * Give start values for channel frqs in zero-amp 1st window.
+ */
+
+int initialise_window_frqs(dataptr dz)
+{   int cc, vc;
+    double thisfrq = GLIS_REFERENCE_FRQ;                 
+    if(dz->mode!=SELFGLIS) {
+        do {
+            cc = (int)((thisfrq + dz->halfchwidth)/dz->chwidth);    /* TRUNCATE */
+            vc = cc * 2;
+            dz->flbufptr[0][FREQ] = (float)thisfrq;
+            thisfrq += dz->chwidth;
+        } while (thisfrq < dz->nyquist);
+    }
+    return(FINISHED);
+}
+
+/******************************** GET_AMP_AND_FRQ ******************************/
+
+int get_amp_and_frq(float *floatbuf,dataptr dz)
+{
+    int cc, vc;
+
+    for( cc = 0 ,vc = 0; cc < dz->clength; cc++, vc += 2){
+        dz->amp[cc]  = floatbuf[AMPP];
+        dz->freq[cc] = floatbuf[FREQ];
+    }
+    return(FINISHED);
+}
+
+/******************************** PUT_AMP_AND_FRQ ******************************/
+
+int put_amp_and_frq(float *floatbuf,dataptr dz)
+{
+    int cc, vc;
+
+    for(cc = 0, vc = 0; cc < dz->clength; cc++, vc += 2){
+        floatbuf[AMPP] = dz->amp[cc];
+        floatbuf[FREQ] = dz->freq[cc];
+    }
+    return(FINISHED);
+}
+
+/**************************** NORMALISE ***************************/
+
+int normalise(double pre_totalamp,double post_totalamp,dataptr dz)
+{
+    double normaliser;
+    int vc;
+
+    if(post_totalamp < VERY_TINY_VAL) {
+        if(!dz->zeroset) {
+            fprintf(stdout,"WARNING: Zero-amp spectral window(s) encountered: orig window(s) substituted.\n");    
+            fflush(stdout);
+            dz->zeroset = TRUE;
+        }
+    } else {
+        normaliser = pre_totalamp/post_totalamp;    /* REMOVED a multiplier of 0.5 : APRIL 1998 */
+        for(vc = 0; vc < dz->wanted; vc += 2)
+            dz->flbufptr[0][AMPP] = (float)(dz->flbufptr[0][AMPP] * normaliser);
+    }
+    return(FINISHED);
+}
+
+/*************************** INITIALISE_RING_VALS ***************************/
+
+int initialise_ring_vals(int thissize,double initial_amp,dataptr dz)
+{
+    int exit_status;
+    chvptr tthis;
+    int change_in_size;
+    if((change_in_size = thissize - dz->ringsize)!=0) {
+        if(change_in_size>0) {
+            if((exit_status = extend_ring(change_in_size,dz))<0)    /* If ring gets bigger,   extend it */
+                return(exit_status); 
+        } else {
+             if((exit_status = shrink_ring(-change_in_size,dz))<0)  /* If ring gets smaller,  shrink it */
+                return(exit_status);
+        }
+    }
+    tthis = dz->ringhead;             
+    do {                          /* Enter initval at all ring locations */
+        tthis->val = (float)initial_amp;
+    } while ((tthis = tthis->next) != dz->ringhead);
+    dz->ringsize = thissize;
+    return(FINISHED);
+}
+
+/************************* EXTEND_RING *****************************/
+
+int extend_ring(int change_in_size,dataptr dz)
+{   int n;          
+    chvptr tthis, head, last;
+    head = dz->ringhead;
+    last = head->last;         /* Mark current end of ring  */
+    for(n=0;n<change_in_size;n++) {            /* create new ring locations */
+        if((tthis = (chvptr)malloc(sizeof(struct chanval)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY to create noew ring buffer location.\n");
+            return(MEMORY_ERROR);
+        }
+        last->next = tthis;  /* Connect new location to end of ring */
+        tthis->last = last;
+        tthis->next = head;/* Connect new location to start of ring */
+        head->last = tthis;
+        last = tthis;                    /* Mark curent end of ring */
+    }
+    return(FINISHED);
+}
+
+/************************* SHRINK_RING *****************************/
+
+int shrink_ring(int change_in_size,dataptr dz)
+{   int n;
+    chvptr tthat, head, tthis;
+    head = dz->ringhead;
+    tthis = head->last;
+    for(n=0;n<change_in_size;n++)
+        tthis = tthis->last;                 /* Find new end of ring */
+    tthat = tthis->next;        /* Point to start of redundant items */
+    while(tthat!=head) {
+        tthat = tthat->next;               /* Delete redundant items */
+        free(tthat->last);
+    }
+    tthis->next = head;       /* Connect new-end-of-ring to ringhead */
+    head->last = tthis;
+    return(FINISHED);
+}
+
+/************************** IF_ONE_OF_LOUDEST_CHANS_STORE_IN_RING *****************************/
+
+int if_one_of_loudest_chans_store_in_ring(int vc,dataptr dz)
+{
+    int exit_status;
+    chvptr loudest = dz->ringhead;      
+    do {                                          /* COMPARE LOUDNESS WITH THOSE IN RING  */
+        if(dz->flbufptr[0][vc] > loudest->val) {      /* IF LOUDER */
+            if((exit_status = rearrange_ring_to_allow_new_entry_and_return_entry_address(&loudest,dz))<0)
+                return(exit_status);
+            loudest->loc = vc;
+            loudest->val = dz->flbufptr[0][vc];
+            break;
+        }
+    } while((loudest = loudest->next)!=dz->ringhead);
+    return(FINISHED);
+}
+
+/************************** IF_ONE_OF_QUIETEST_CHANS_STORE_IN_RING *****************************/
+
+int if_one_of_quietest_chans_store_in_ring(int vc,dataptr dz)
+{
+    int exit_status;
+    chvptr quietest = dz->ringhead;  
+    do {                                           /* COMPARE QUIETNESS WITH THOSE IN RING */
+        if(dz->flbufptr[0][vc] < quietest->val) {   /* IF QUIETER */
+            if((exit_status = rearrange_ring_to_allow_new_entry_and_return_entry_address(&quietest,dz))<0)
+                return(exit_status);
+            quietest->loc = vc;           
+            quietest->val = dz->flbufptr[0][vc];
+            break;
+        }
+    } while((quietest = quietest->next)!=dz->ringhead);
+    return(FINISHED);
+}
+
+/**************** REARRANGE_RING_TO_ALLOW_NEW_ENTRY_AND_RETURN_ENTRY_ADDRESS *************
+ *
+ * Shuffle the items in the list of loudest/quietest chans.
+ */
+
+int rearrange_ring_to_allow_new_entry_and_return_entry_address(chvptr *here,dataptr dz)
+{
+    chvptr head = dz->ringhead;
+    chvptr this, prethis, prehere;
+    if(*here == head->last) /* If place of insertion is lastplace in ring */
+        return(FINISHED);   /* Final item in ring just gets written over. */
+    if(*here==head) {       /* IF place of insertion is start of ring.... */
+        dz->ringhead = head->last;   /* Move head of ring back one place. */
+        *here = dz->ringhead;        /* New value will be written there,  */
+        return(FINISHED);        
+    }              /* automatically deleting previous final item in ring. */
+            
+    this          = head->last;  /* OTHERWISE: unlink last item from ring */
+    prethis       = this->last;
+    head->last    = prethis;
+    prethis->next = head;
+    
+    prehere       = (*here)->last;/* Reuse adr-space ('this') by splicing */
+    this->last    = prehere;   /* it into ring at current position (here) */
+    prehere->next = this;
+    this->next    = *here;
+    (*here)->last = this;
+    *here = this;     /* Return address of new current position ('this') */
+    return(FINISHED);     
+}
+
+/****************************** CHOOSE_BITFLAG_AND_RESET_MASK_IF_NESS ****************************/
+
+int choose_bflagno_and_reset_mask_if_ness(int *bflagno,int cc,int *mask,int longpow2,int divmask)
+{
+    *bflagno = cc >> longpow2;      /* bflagno chooses which bitflag */
+    if(!(cc & divmask))             /* If cc divisible by bitflag length */
+        *mask = 1;                  /* reset bitmask to 1, for next bitflag */
+    return(FINISHED);
+}
+
+/******************* MOVE_DATA_INTO_APPROPRIATE_CHANNEL *****************
+ *
+ *  If there turns out to be more than one partial to a channel,
+ *  keep partial that was loudest in orig sound, retaining its
+ *  loudness for further comparison.
+ */
+
+int move_data_into_appropriate_channel(int vc,int truevc,float thisamp,float thisfrq,dataptr dz)    
+{
+    if(dz->flbufptr[0][AMPP] > dz->windowbuf[0][truevc]) {
+        dz->windowbuf[0][truevc++] = thisamp;
+        dz->windowbuf[0][truevc]   = thisfrq;
+    }
+    return(FINISHED);
+}
+
+/******************* MOVE_DATA_INTO_SOME_APPROPRIATE_CHANNEL *****************
+ *
+ * On assumption that frq does NOT have to be in exact channel!!
+ * Replace simpler idea....above....
+ * which tends to see several significant pieces of data disappear
+ * as they overwrite one another in the same channel... BY ....
+ *
+ * (1) Put in correct empty channel IF POSSIBLE
+ * (2) ELSE Put in an adj empty chan
+ * (3)       below
+ * (4)  ELSE above
+ * (5) ELSE Replace val in true chan
+ * (6) ELSE Replace val in adj chan
+ * (7)       below
+ * (8)  ELSE above
+ *
+ */
+
+int move_data_into_some_appropriate_channel(int truevc,float thisamp,float thisfrq,dataptr dz)
+{
+#define THISCHANSCAN    (4)
+
+    int minscan, maxscan, n;
+
+    if(dz->windowbuf[0][truevc] == 0.0f) {          /* 1 */
+        dz->windowbuf[0][truevc++] = thisamp;
+        dz->windowbuf[0][truevc]   = thisfrq;
+        return(FINISHED);
+    }
+    minscan = max(0,truevc - (THISCHANSCAN * 2));   /* 2 */
+    maxscan = min(dz->clength-1,truevc + (THISCHANSCAN * 2));   /* 3 */
+    for(n=truevc-2;n>minscan;n-=2) {
+        if(dz->windowbuf[0][n] == 0.0f) {
+            dz->windowbuf[0][n++] = thisamp;
+            dz->windowbuf[0][n]   = thisfrq;
+            return(FINISHED);
+        }
+    }
+    for(n=truevc+2;n<maxscan;n+=2) {            /* 4 */
+        if(dz->windowbuf[0][n] == 0.0f) {
+            dz->windowbuf[0][n++] = thisamp;
+            dz->windowbuf[0][n]   = thisfrq;
+            return(FINISHED);
+        }
+    }
+    if(thisamp > dz->flbufptr[0][truevc]) { /* 5 */
+        dz->windowbuf[0][truevc++] = thisamp;
+        dz->windowbuf[0][truevc]   = thisfrq;
+        return(FINISHED);
+    }
+    for(n=truevc-2;n>minscan;n-=2) {            /* 6 */
+        if(thisamp > dz->windowbuf[0][n]) { /* 7 */
+            dz->windowbuf[0][n++] = thisamp;
+            dz->windowbuf[0][n]   = thisfrq;
+            return(FINISHED);
+        }
+    }
+    for(n=truevc+2;n<maxscan;n+=2) {            /* 8 */
+        if(thisamp > dz->windowbuf[0][n]) {
+            dz->windowbuf[0][n++] = thisamp;
+            dz->windowbuf[0][n]   = thisfrq;
+            return(FINISHED);
+        }
+    }
+    return(FINISHED);
+}
+
+/******************** GET_AMP ********************/
+
+int get_amp(float *floatbuf,dataptr dz)
+{
+    int cc, vc;
+
+    for(cc = 0, vc = 0; cc < dz->clength; cc++, vc += 2)
+        dz->amp[cc] = floatbuf[vc];
+    return(FINISHED);
+}
+
+/******************** PUT_AMP ********************/
+
+int put_amp(float *floatbuf,dataptr dz)
+{
+    int cc, vc;
+
+    for(cc = 0, vc = 0; cc < dz->clength; cc++, vc += 2)
+        floatbuf[vc] = dz->amp[cc];
+    return(FINISHED);
+}
+
+/*************************** ADVANCE_ONE_2FILEINPUT_WINDOW ***********************/
+
+int advance_one_2fileinput_window(dataptr dz)
+{
+    dz->flbufptr[0] += dz->wanted;
+    dz->flbufptr[1] += dz->wanted;
+    dz->total_windows++;
+    dz->time = (float)(dz->time + dz->frametime);
+    return(FINISHED);
+}
+
+/***************************** SPECBARE *********************************/
+
+int specbare(int *pitchcnt,dataptr dz)
+{
+    int exit_status;
+    double  error_range = SPAN_FACTOR * SEMITONE_INTERVAL;  /* +or- error in finding pitch of partial */
+    double pitch;
+    double thisfrq /* = pitch */, frq_close_above_next_partial, frq_close_below_next_partial;
+    int n = 0;
+    int vc = 0;
+    double  one_over_error_range = 1.0/error_range;
+    double  upper_freqdiff,lower_freqdiff;
+
+    pitch = dz->pitches[(*pitchcnt)++];
+    if(pitch < 0.0)             /*   UNPITCHED WINDOW : marked in specpich */
+        return(FINISHED);
+    upper_freqdiff = (pitch * error_range) - pitch;
+    lower_freqdiff =  pitch - (pitch * one_over_error_range);    
+
+    while(vc < dz->wanted && (thisfrq = pitch * (double)++n) < dz->nyquist) {
+        frq_close_above_next_partial = thisfrq + upper_freqdiff;
+        frq_close_below_next_partial = thisfrq  - lower_freqdiff;
+        if((exit_status = zero_channels_between_partials(&vc,frq_close_below_next_partial,dz))<0)
+            return(exit_status);
+        if(vc >= dz->wanted)
+            break;
+        if(dz->flbufptr[0][FREQ]>frq_close_above_next_partial)
+            continue;
+        else if(dz->vflag[BARE_LESS_BODY]) {
+            if((exit_status = eliminate_all_but_loudest_channel_near_this_partial_frq
+            (&vc,frq_close_above_next_partial,dz))<0)
+                return(exit_status);
+        } else {
+            if((exit_status = keep_all_channels_near_partial_frq(&vc,frq_close_above_next_partial,dz))<0)
+                return(exit_status);
+        }
+    }
+    return(FINISHED);
+}
+
+/************** ZERO_CHANNELS_BETWEEN_PARTIALS ****************/
+
+int zero_channels_between_partials(int *vvc,double frq_close_below_next_partial,dataptr dz)
+{
+    int vc = *vvc;
+    while(dz->flbufptr[0][FREQ] < frq_close_below_next_partial) {
+        dz->flbufptr[0][AMPP] = 0.0f;
+        if((vc += 2) >= dz->wanted)
+            break;
+    }
+    *vvc = vc;
+    return(FINISHED);
+}
+
+/******** ELIMINATE_ALL_BUT_LOUDEST_CHANNEL_NEAR_THIS_PARTIAL_FRQ *********/
+
+int eliminate_all_but_loudest_channel_near_this_partial_frq(int *vvc,double frq_close_above_next_partial,dataptr dz)
+{
+    int vc = *vvc;
+    double maxamp = dz->flbufptr[0][AMPP];  /* SET MAXAMP TO 1ST IN-RANGE CH */
+    int k, maxloc  = vc;                    /* NOTE NO. OF THE CH THUS MARKD */
+    int   firstloc = vc;                    /* MARK FIRST CH IN SET          */
+    while((vc += 2) < dz->wanted) {
+        if(dz->flbufptr[0][FREQ]>frq_close_above_next_partial)      /* IF BEYOND CURRENT RANGE, STOP */
+            break;
+        if(dz->flbufptr[0][vc]>maxamp) {        /* IF LOUDER THAN MAX,RESET MAX  */
+            maxamp = dz->flbufptr[0][AMPP]; /* AND RESET MAXAMP CHANNEL NO.  */
+            maxloc = vc;
+        }
+    }
+    for(k=firstloc; k<vc; k+=2) {           /* FOR THE WHOLE SET THUS DONE  */
+        if(k!=maxloc)                       /* ZERO ALL CHS OTHER THAN MAX  */
+            dz->flbufptr[0][k] = 0.0f;
+    }
+    *vvc = vc;
+    return(FINISHED);
+}           
+
+/*********************** KEEP_ALL_CHANNELS_NEAR_PARTIAL_FRQ ******************/
+
+int keep_all_channels_near_partial_frq(int *vvc,double frq_close_above_next_partial,dataptr dz)
+{
+    int vc = *vvc;
+    while((vc += 2) < dz->wanted) {
+        if(dz->flbufptr[0][FREQ]>frq_close_above_next_partial)  /* IF BEYOND CURRENT RANGE, STOP */
+            break;
+    }
+    *vvc = vc;
+    return(FINISHED);
+}
+
+/****************************** GEN_AMPLITUDE_IN_LO_HALF_FILTERBAND ***************************/
+
+int gen_amplitude_in_lo_half_filterband(double *thisamp,double thisfrq,double filt_centre_frq,dataptr dz)
+{
+    double val;
+
+    val = -LOG2(thisfrq/filt_centre_frq); /* octave distance from filter centre-frq */
+    val *= dz->scalefact;                /* convert to a fraction of halfbwidth (range 0-1) &
+                                            convert to range 0-PI */
+    val = cos(val);                      /* get cos val between 1 & -1 */
+    val += 1.0;                          /* convert range to 2 -> 0 */
+    val /= 2.0;                          /* convert range to 1 -> 0 */
+    *thisamp = val;
+    return(FINISHED);
+}
+
+/****************************** GEN_AMPLITUDE_IN_HI_HALF_FILTERBAND ***************************/
+
+int gen_amplitude_in_hi_half_filterband(double *thisamp,double thisfrq,double filt_centre_frq,dataptr dz)
+{
+    double val;
+
+    val = LOG2(thisfrq/filt_centre_frq);     /* octave distance from filter centre-frq */
+    val *= dz->scalefact;                /* convert to a fraction of halfbwidth (range 0-1) &
+                                            convert to range 0-PI */
+    val = cos(val);                      /* get cos val between 1 & -1 */
+    val += 1.0;                          /* convert range to 2 -> 0 */
+    val /= 2.0;                          /* convert range to 1 -> 0 */
+    *thisamp = val;
+    return(FINISHED);
+}
+
+/****************************** FILTER_BAND_TEST ***************************
+ *
+ * CHeck that filter values are within range - and that there ARE values there!!!
+ */
+
+int filter_band_test(dataptr dz)
+{
+    int OK = 0, cc;
+    for(cc=0;cc<dz->clength;cc++) {
+        if(dz->fsampbuf[cc]>1.0 || dz->fsampbuf[cc]<0.0)  {
+            sprintf(errstr,"filter contour out of range. (item[%d] = %f): filter_band_test()\n",cc,dz->fsampbuf[cc]);
+            return(PROGRAM_ERROR);
+        }
+        if(dz->fsampbuf[cc] > 0.0)
+            OK = 1;
+    }
+    if(!OK && !dz->fzeroset) {
+            fprintf(stdout,"WARNING: ZERO filter contour at window %d time %lf\n",
+            dz->total_windows+1,dz->total_windows * dz->frametime);
+            fflush(stdout);
+            dz->fzeroset = TRUE;
+    } else
+        dz->fzeroset = FALSE;
+    return(FINISHED);
+}
+
+/************************** GET_STATECHANGES ************************/
+
+int get_statechanges(int avcnt,int scantableno,int avpitcharrayno,int statechangearrayno,
+                    double min_up_interval,double min_dn_interval,int datatype,dataptr dz)
+{
+#define RISING  (1)
+#define FALLING (2)
+#define ONLEVEL (3)
+
+    int exit_status;
+    int   n, window_cnt, pblok;
+    double ttime = 0.0, intvl = 0.0;
+    int    *bbrk;
+    if((bbrk = (int *)malloc(avcnt * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for statechange array.\n");
+        return(MEMORY_ERROR);
+    }
+    memset((char *)bbrk,0,avcnt * sizeof(int));
+    if(dz->brksize[scantableno]) {
+        if((exit_status = read_value_from_brktable(ttime,scantableno,dz))<0)
+            return(exit_status);
+    }
+    window_cnt = round(dz->param[scantableno]/dz->frametime);
+    if((pblok = round(window_cnt/BLOKCNT))<2) {
+        sprintf(errstr,"scanning-contour time_scale too short for this data.\n");
+        return(DATA_ERROR);
+    }
+    if(pblok >= avcnt) {
+        sprintf(errstr,"scanning-contour time_scale too long for this data.\n");
+        return(DATA_ERROR);
+    }
+    for(n=pblok;n<avcnt;n++) {
+        switch(datatype) {
+        case(IS_PITCH): intvl = dz->parray[avpitcharrayno][n] - dz->parray[avpitcharrayno][n-pblok];
+            break;
+        case(IS_FRQ):   intvl = dz->parray[avpitcharrayno][n]/dz->parray[avpitcharrayno][n-pblok];
+            break;
+        }
+        if(intvl > min_up_interval)
+            bbrk[n] = RISING;
+        else if(intvl < min_dn_interval)
+            bbrk[n] = FALLING;
+        else
+            bbrk[n] = ONLEVEL;
+        if(dz->brksize[scantableno]) {
+             /* move along by an (averaged) BLOK of windows */
+            ttime += dz->frametime * BLOKCNT;   
+            if((exit_status = read_value_from_brktable(ttime,scantableno,dz))<0)
+                return(exit_status);
+            window_cnt = round(dz->param[scantableno]/dz->frametime);
+            if((pblok = round(window_cnt/BLOKCNT))<2) {
+                sprintf(errstr,"scanning-contour time_scale too short for this data.\n");
+                return(DATA_ERROR);
+            }
+        }
+    }
+    n = 0;
+     /* Set types at very start, equal to actual first type already set */
+    while(!bbrk[n]) {         
+        if(++n >= avcnt)
+            break;
+    }
+    if(n<avcnt) {
+        n--;
+        while(n>=0) {
+            bbrk[n] = bbrk[n+1];
+            if(--n < 0)
+                break;
+        }
+    }
+    memset(dz->iparray[statechangearrayno],0,avcnt * sizeof(int));
+    dz->iparray[statechangearrayno][0] = 1; /* initial state change */
+    for(n=1;n<avcnt;n++) {
+        if(bbrk[n]!=bbrk[n-1])
+            dz->iparray[statechangearrayno][n] = 1;
+    }
+    free(bbrk);
+    return(FINISHED);
+}
+
+/**************************** RECTIFY_FRQS ****************************/
+
+int rectify_frqs(float *floatbuf,dataptr dz)
+{
+    int vc;
+    for(vc = 0; vc < dz->wanted; vc += 2) {
+        if(floatbuf[FREQ] < 0.0f)
+            floatbuf[FREQ] = (float)(-(floatbuf[FREQ]));
+    }
+    return(FINISHED);
+}
+
+/******************************* MOVE_ALONG_FORMANT_BUFFER ************************/
+
+int move_along_formant_buffer(dataptr dz)
+{
+    int samps_read;
+    if((dz->flbufptr[1]  += dz->infile->specenvcnt) >= dz->flbufptr[3]) {
+        if((samps_read = fgetfbufEx(dz->flbufptr[2],dz->buflen2,dz->ifd[1],0))<0) {
+            sprintf(errstr,"fgetfbufEx failure, move_along_formant_buffer()\n");
+            return(SYSTEM_ERROR);
+        }
+        if(samps_read <= 0)
+            return(FINISHED);
+        dz->flbufptr[1] = dz->flbufptr[2];
+    }
+    return(CONTINUE);
+}
+
+/*************************** GET_LONGER_FILE ***********************/
+
+int get_longer_file(dataptr dz)
+{
+    int file_to_keep = 1;
+    if(dz->insams[0] < dz->insams[1])
+        /* allows larger infile2 to be copied after infile1 finished */
+            file_to_keep = 2;
+    return(file_to_keep);
+}
+
+/*************************** READ_BOTH_FILES ***********************/
+
+int read_both_files(int *windows_in_buf,int *got,dataptr dz)
+{
+    int samps_read, samps_read2;
+    memset((char *)dz->bigfbuf,0,dz->buflen * sizeof(float));
+    if((samps_read = fgetfbufEx(dz->bigfbuf, dz->buflen,dz->ifd[0],0)) < 0) {
+        sprintf(errstr,"Failed to read data from first file.\n");
+        return(SYSTEM_ERROR);
+    }
+    memset((char *)dz->flbufptr[2],0,dz->buflen* sizeof(float));
+    if((samps_read2 = fgetfbufEx(dz->flbufptr[2], dz->buflen,dz->ifd[1],0)) < 0) {
+        sprintf(errstr,"Failed to read data from second file.\n");
+        return(SYSTEM_ERROR);
+    }
+    *got = max(samps_read,samps_read2);
+    dz->flbufptr[0] = dz->bigfbuf;
+    dz->flbufptr[1] = dz->flbufptr[2];
+    *windows_in_buf = *got/dz->wanted;    
+    return(FINISHED);
+}
+
+/*************************** KEEP_EXCESS_BYTES_FROM_CORRECT_FILE ***********************/
+#ifdef NOTDEF
+int keep_excess_bytes_from_correct_file(int *bytes_to_write,int file_to_keep,int got,int wc,dataptr dz)
+{
+    int floats_to_keep = got - ((wc+1) * dz->wanted);
+    if(file_to_keep) {
+        if(file_to_keep==2 && floats_to_keep > 0)
+            memmove((char *)dz->flbufptr[0],(char *)dz->flbufptr[1],floats_to_keep * sizeof(float));
+        dz->flbufptr[0] += floats_to_keep;
+    }
+    *bytes_to_write = (dz->flbufptr[0] - dz->bigfbuf) * sizeof(float);
+    return(FINISHED);
+}
+#else
+/*************************** KEEP_EXCESS_SAMPS_FROM_CORRECT_FILE ***********************/
+
+int keep_excess_samps_from_correct_file(int *samps_to_write,int file_to_keep,int got,int wc,dataptr dz)
+{
+    int floats_to_keep = got - ((wc+1) * dz->wanted);
+    if(file_to_keep) {
+        if(file_to_keep==2 && floats_to_keep > 0)
+            memmove((char *)dz->flbufptr[0],(char *)dz->flbufptr[1],floats_to_keep * sizeof(float));
+        dz->flbufptr[0] += floats_to_keep;
+    }
+//TW CORRECTED
+//  *samps_to_write = (dz->flbufptr[0] - dz->bigfbuf) * sizeof(float);
+    *samps_to_write =  dz->flbufptr[0] - dz->bigfbuf;
+    return(FINISHED);
+}
+
+
+
+
+#endif
+/*************************** READ_EITHER_FILE ***********************/
+
+int read_either_file(int *samps_read,int file_to_keep,dataptr dz)
+{
+    if(file_to_keep==2) {
+        if((*samps_read = fgetfbufEx(dz->bigfbuf, dz->buflen,dz->ifd[1],0))<0) {
+            sprintf(errstr,"Failed to read samples from file 2\n");
+            return(SYSTEM_ERROR);
+        }
+    } else {
+        if((*samps_read = fgetfbufEx(dz->bigfbuf, dz->buflen,dz->ifd[0],0))<0) {
+            sprintf(errstr,"Failed to read samples from file 1\n");
+            return(SYSTEM_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/****************************** SCORE_PEAKS ******************************/ 
+
+int score_peaks(int *peakscore,int sl1_var,int stabl_var,dataptr dz)
+{
+    int n, m;
+    if(dz->total_windows>dz->iparam[sl1_var]) {
+        for(n = 0;n < dz->stable->total_pkcnt[dz->iparam[sl1_var]]; n++) {      /* Add in the peaks in the last buf calcd */    
+            dz->stable->design_score[dz->stable->fpk[dz->iparam[sl1_var]][n]]++;            /* to the existing scores!! */
+            (*peakscore)++;                 
+        }
+    } else {
+        for(m=0;m<dz->iparam[stabl_var];m++) {                  /* For every stored array of peaks */
+            for(n = 0;n < dz->stable->total_pkcnt[m]; n++) {    /* For every peak within that store */
+                dz->stable->design_score[dz->stable->fpk[m][n]]++; /* Score a point for each occurence of a specenvchan */
+                (*peakscore)++;                     /* Check to see if there are ANY peaks at all */
+            }
+        }
+    }
+    return(FINISHED);
+ }
+
+ /****************************** COLLECT_SCORES ******************************
+ *
+ *  If any channel is used as a peak (score > 0),store channel-no and score
+ *  in a design_struct, and preset the amp_total to zero (see amplitude_poll).
+ *  Count the total number of such peaks.
+ */                    
+
+int collect_scores(int *cnt,int *descnt,dataptr dz)
+{
+    int n;
+    *cnt = 0;
+    for(n=0;n<dz->infile->specenvcnt;n++) {
+        if(dz->stable->design_score[n]) {
+            if(*cnt >= *descnt) {       /* If this number of design_structs don't exist, make another */
+                if((dz->stable->des[*cnt] = (desptr)malloc(sizeof(struct design)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY for scoring array.\n");
+                    return(MEMORY_ERROR);
+                }
+                (*descnt)++;
+            }
+            dz->stable->des[*cnt]->chan  = n;
+            dz->stable->des[*cnt]->score = dz->stable->design_score[n];
+            dz->stable->des[*cnt]->amp   = 0.0;
+            (*cnt)++;
+        }
+    }
+    return(FINISHED);
+}
+
+/****************************** SORT_DESIGN ***************************
+ *
+ * Sort peak channels into descending order ofabundance
+ */
+int sort_design(int no_of_design_elements,dataptr dz) 
+{
+    int n, m, a, b;   
+    for(n=1;n<no_of_design_elements;n++) {
+        a = dz->stable->des[n]->chan;
+        b = dz->stable->des[n]->score;
+        m = n-1;
+        while(m >= 0 && dz->stable->des[m]->score < b) {
+            dz->stable->des[m+1]->chan  = dz->stable->des[m]->chan;
+            dz->stable->des[m+1]->score = dz->stable->des[m]->score;
+            m--;
+        }
+        dz->stable->des[m+1]->chan  = a;
+        dz->stable->des[m+1]->score = b;
+    }
+    return(FINISHED);
+}
+
+/****************************** SORT_EQUIVALENT_SCORES ******************************
+ *
+ * For channels with equivalent scores. Find the bottom and top of the range of
+ * channels with equivalent scores. Save those below the bottom of the range as
+ * acceptable peaks (they have higher scores than those in the range).
+ * For the rest, select those channels having the maximum amplitude over the
+ * whole timespan of the stabilise buffers.
+ */
+
+int sort_equivalent_scores(int this_pkcnt,dataptr dz)
+{
+    int bot, top, n;
+    if(dz->stable->des[dz->itemcnt-1]->score < dz->stable->des[dz->itemcnt]->score) {
+        sprintf(errstr,"Problem in peak sorting: sort_equivalent_scores()\n");
+        return(PROGRAM_ERROR);
+    }
+    n = dz->itemcnt-1;
+    while(n >= 0) {
+        if(dz->stable->des[n]->score == dz->stable->des[dz->itemcnt]->score)
+            n--;
+        else
+            break;
+    }
+    bot = n+1;
+    n = dz->itemcnt+1;
+    while(n <this_pkcnt) {
+        if(dz->stable->des[n]->score == dz->stable->des[dz->itemcnt]->score)
+            n++;
+        else    
+            break;
+    }
+    top = n;
+    for(n=0;n<bot;n++)
+        dz->peakno[n] = dz->stable->des[n]->chan; /* keep peaks that have definitely higher scores */
+    return do_amplitude_poll(bot,top,dz);
+}
+
+/****************************** DO_AMPLITUDE_POLL ***************************/ 
+
+int do_amplitude_poll(int bot,int top,dataptr dz)
+{
+    int n, m, here = 0, thischan;
+    int nextpeak = bot;             /* peaknumber of first of peaks still to allocate */
+    double thisamp, ampmax;
+    for(n=bot;n<top;n++) {              /* For every channel in the set of possible channels */
+        thischan = dz->stable->des[n]->chan;
+        for(m=0;m<dz->iparam[FOCU_STABL];m++)       /* sum amplitudes in that chan across all specenv buffers */
+            dz->stable->des[n]->amp += dz->stable->spec[m][thischan];   /* and store in des-array assocd with channel */
+    }
+    while(nextpeak < dz->itemcnt) {         /* while there are still peaks to be chosen */
+        ampmax = 0.0;
+        for(n=bot;n<top;n++) {          /* Find maximum among these amplitude-totals */
+            if((thisamp = dz->stable->des[n]->amp)>ampmax) {
+                ampmax = thisamp;
+                here   = n;
+            }          
+        }
+        dz->peakno[nextpeak++] = dz->stable->des[here]->chan; /* Set next peak channel to this maxamp channel */
+        dz->stable->des[here]->amp = 0.0;             /* zero amptotal in chosen des, to eliminate from next search */ 
+    }
+    return(FINISHED);
+}
+ 
+/****************************** UNSCORE_PEAKS ******************************/ 
+
+int unscore_peaks(int *peakscore,dataptr dz)
+{
+    int n;
+    for(n = 0;n < dz->stable->total_pkcnt[0]; n++) {    /* Subtract score of peaks buffer no longer in use */   
+        dz->stable->design_score[dz->stable->fpk[0][n]]--;          /* from the existing scores!! */
+        (*peakscore)--;                 
+    }
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN pconsistency.c *************************/
+/******************************************************************************/
+
+static void setup_pitchzero(int paramno,dataptr dz);
+
+/************************** HANDLE_PITCH_ZEROS ********************************/
+
+void handle_pitch_zeros(dataptr dz)
+{
+    switch(dz->process) {
+    case(ARPE): 
+        setup_pitchzero(ARPE_LOFRQ,dz);
+        setup_pitchzero(ARPE_HIFRQ,dz);
+        break;
+    case(CHORD):
+        setup_pitchzero(CHORD_LOFRQ,dz);
+        setup_pitchzero(CHORD_HIFRQ,dz);
+        break;
+    case(CLEAN):
+        if(dz->mode==FILTERING)
+            setup_pitchzero(CL_FRQ,dz);
+        break;
+    case(FOCUS):
+        setup_pitchzero(FOCU_LOFRQ,dz);
+        setup_pitchzero(FOCU_HIFRQ,dz);
+        break;
+    case(FOLD):
+        setup_pitchzero(FOLD_LOFRQ,dz);
+        setup_pitchzero(FOLD_HIFRQ,dz);
+        break;
+    case(FORM):
+        setup_pitchzero(FORM_FTOP,dz);
+        setup_pitchzero(FORM_FBOT,dz);
+        break;
+    case(MEAN):
+        setup_pitchzero(MEAN_LOF,dz);
+        setup_pitchzero(MEAN_HIF,dz);
+        break;
+    case(P_FIX):
+        setup_pitchzero(PF_LOF,dz);
+        setup_pitchzero(PF_HIF,dz);
+        break;
+    case(PEAK):
+        setup_pitchzero(PEAK_CUTOFF,dz);
+        break;
+    case(REPORT):
+        setup_pitchzero(REPORT_LOFRQ,dz);
+        setup_pitchzero(REPORT_HIFRQ,dz);
+        break;
+    case(SHIFTP):
+        setup_pitchzero(SHIFTP_FFRQ,dz);
+        break;
+    case(STRETCH):
+        setup_pitchzero(STR_FFRQ,dz);
+        break;
+    case(S_TRACE):
+        setup_pitchzero(TRAC_LOFRQ,dz);
+        setup_pitchzero(TRAC_HIFRQ,dz);
+        break;
+    case(TRNSF):
+        setup_pitchzero(TRNSF_HIFRQ,dz);
+        setup_pitchzero(TRNSF_LOFRQ,dz);
+        break;
+    case(TRNSP):
+        setup_pitchzero(TRNSP_HIFRQ,dz);
+        setup_pitchzero(TRNSP_LOFRQ,dz);
+        break;
+    case(TUNE):
+        setup_pitchzero(TUNE_BFRQ,dz);
+        break;
+    case(VOCODE):
+        setup_pitchzero(VOCO_LOF,dz);
+        setup_pitchzero(VOCO_HIF,dz);
+        break;
+    case(WAVER):
+        setup_pitchzero(WAVER_LOFRQ,dz);
+        break;
+    }
+}
+
+/****************************** SETUP_PITCHZERO *******************************/
+
+void setup_pitchzero(int paramno,dataptr dz)
+{
+    double *p, *end;
+    if(dz->brksize[paramno]) {
+        p   = dz->brk[paramno] + 1;
+        end = dz->brk[paramno] + (dz->brksize[paramno] * 2);
+        while(p < end) {
+            if(*p < SPEC_MINFRQ)
+                *p = SPEC_MINFRQ;
+            p+=2;
+        }
+    } else if(dz->param[paramno] < SPEC_MINFRQ) 
+        dz->param[paramno] = 0.0;   
+}
+
+/************************************ CHECK_DEPTH_VALS *************************************/
+
+int check_depth_vals(int param_no,dataptr dz)
+{
+    double *p;
+    int n = 0;
+    if(dz->brksize[param_no]==0) {
+        if(flteq(dz->param[param_no],0.0)) {
+            sprintf(errstr,
+                "A non-varying depth value of zero will not change your source file.\n");
+            return(DATA_ERROR);
+        }
+    } else {
+        p = dz->brk[param_no]+1;
+        n = 0;
+        while(n < dz->brksize[param_no]) {
+            if(!flteq(*p,0.0))
+                return(FINISHED);
+            p += 2;
+            n++;
+        }
+        sprintf(errstr,
+            "A non-varying depth value of zero will not change your source file.\n");
+        return(DATA_ERROR);
+    }
+    return(FINISHED);
+}
+
+/*********************** CONVERT_SHIFTP_VALS ***********************/
+
+void convert_shiftp_vals(dataptr dz)
+{
+    switch(dz->mode) {
+    case(P_SHFT_UP_AND_DN):
+        dz->param[SHIFTP_SHF1] *= OCTAVES_PER_SEMITONE;
+        dz->param[SHIFTP_SHF1] = pow(2.0,dz->param[SHIFTP_SHF1]);
+        dz->param[SHIFTP_SHF2] *= OCTAVES_PER_SEMITONE;
+        dz->param[SHIFTP_SHF2] = pow(2.0,dz->param[SHIFTP_SHF2]);
+        break;
+    case(P_SHFT_DN):
+        dz->param[SHIFTP_SHF1] *= OCTAVES_PER_SEMITONE;
+        dz->param[SHIFTP_SHF1] = pow(2.0,dz->param[SHIFTP_SHF1]);
+        break;
+    case(P_SHFT_UP):
+        dz->param[SHIFTP_SHF1] *= OCTAVES_PER_SEMITONE;
+        dz->param[SHIFTP_SHF1] = pow(2.0,dz->param[SHIFTP_SHF1]);
+        break;
+    }
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN buffers.c ******************************/
+/******************************************************************************/
+
+
+/*************************** CREATE_SNDBUFS **************************/
+
+/* 2009 MULTICHANNEL */
+
+int create_sndbufs(dataptr dz)
+{
+    int n;
+    size_t bigbufsize;
+    int framesize;
+    framesize = F_SECSIZE * dz->infile->channels;
+    if(dz->sbufptr == 0 || dz->sampbuf==0) {
+        sprintf(errstr,"buffer pointers not allocated: create_sndbufs()\n");
+        return(PROGRAM_ERROR);
+    }
+    bigbufsize = (size_t) Malloc(-1);
+    bigbufsize /= dz->bufcnt;
+    if(bigbufsize <=0)
+        bigbufsize  = framesize * sizeof(float);
+
+    dz->buflen = (int)(bigbufsize / sizeof(float)); 
+    dz->buflen = (dz->buflen / framesize)  * framesize;
+    bigbufsize = dz->buflen * sizeof(float);
+    if((dz->bigbuf = (float *)malloc(bigbufsize  * dz->bufcnt)) == NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to create sound buffers.\n");
+        return(PROGRAM_ERROR);
+    }
+    for(n=0;n<dz->bufcnt;n++)
+        dz->sbufptr[n] = dz->sampbuf[n] = dz->bigbuf + (dz->buflen * n);
+    dz->sampbuf[n] = dz->bigbuf + (dz->buflen * n);
+    return(FINISHED);
+}
+
+/**************************** ALLOCATE_SINGLE_BUFFER ******************************/
+//TW REVISED: buffers no longer multiples of secsize
+int allocate_single_buffer(dataptr dz)
+{
+//  int bigbufsize;
+//  int exit_status;
+    unsigned int buffersize;
+    if(dz->bptrcnt <= 0) {
+        sprintf(errstr,"bufptr not established in allocate_single_buffer()\n");
+        return(PROGRAM_ERROR);
+    }
+//TW
+//  buffersize = dz->sampswanted * BUF_MULTIPLIER;
+    buffersize = dz->wanted * BUF_MULTIPLIER;
+//TW MOVED THIS LINE: to get correct value of buflen (NOT after the +1)
+    dz->buflen = buffersize;
+    buffersize += 1;
+    if((dz->bigfbuf = (float*) malloc(buffersize * sizeof(float)))==NULL) {  
+        sprintf(errstr,"INSUFFICIENT MEMORY for sound buffers.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->big_fsize = dz->buflen;
+    dz->bigfbuf[dz->big_fsize] = 0.0f;  /* safety value */
+    return(FINISHED);
+}
+
+/**************************** ALLOCATE_DOUBLE_BUFFER ******************************/
+/* RWD MUST recheck this! */
+
+int allocate_double_buffer(dataptr dz)
+{
+//  int exit_status;
+    unsigned int buffersize;
+    if(dz->bptrcnt < 4) {
+        sprintf(errstr,"Insufficient bufptrs established in allocate_double_buffer()\n");
+        return(PROGRAM_ERROR);
+    }
+//TW REVISED: buffers don't need to be multiples of secsize
+    buffersize = dz->wanted * BUF_MULTIPLIER;
+    dz->buflen = buffersize;
+    if((dz->bigfbuf = (float*)malloc(dz->buflen*2 * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for sound buffers.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->big_fsize = dz->buflen;
+    dz->flbufptr[2]  = dz->bigfbuf + dz->big_fsize;   
+    dz->flbufptr[3]  = dz->flbufptr[2] + dz->big_fsize;
+    return(FINISHED);
+}
+
+/**************************** ALLOCATE_TRIPLE_BUFFER ******************************/
+
+int allocate_triple_buffer(dataptr dz)
+{
+    unsigned int buffersize;
+    if(dz->bptrcnt < 5) {
+        sprintf(errstr,"Insufficient bufptrs established in allocate_triple_buffer()\n");
+        return(PROGRAM_ERROR);
+    }
+//TW REVISED: buffers don't need to be multiples of secsize
+    buffersize = dz->wanted;
+    dz->buflen = buffersize;
+    if((dz->bigfbuf = (float*)malloc(dz->buflen*3 * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for sound buffers.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->big_fsize = dz->buflen;
+    dz->flbufptr[2]  = dz->bigfbuf + dz->big_fsize;   
+    dz->flbufptr[3]  = dz->flbufptr[2] + dz->big_fsize;
+    dz->flbufptr[4]  = dz->flbufptr[3] + dz->big_fsize;
+    return(FINISHED);
+}
+
+/*************************** ALLOCATE_ANALDATA_PLUS_FORMANTDATA_BUFFER ****************************/
+
+int allocate_analdata_plus_formantdata_buffer(dataptr dz)
+{
+    int exit_status;
+    unsigned int buffersize;
+    /*int cnt = 0;*/
+    if(dz->bptrcnt < 4) {
+        sprintf(errstr,"Insufficient bufptrs established in allocate_analdata_plus_formantdata_buffer()\n");
+        return(PROGRAM_ERROR);
+    }
+    if(dz->infile->specenvcnt==0) {
+        sprintf(errstr,"specenvcnt not set: allocate_analdata_plus_formantdata_buffer()\n");
+        return(PROGRAM_ERROR);
+    }
+    if((exit_status = calculate_analdata_plus_formantdata_buffer(&buffersize,dz))<0)
+        return(exit_status);
+
+    if((dz->bigfbuf = (float*)malloc((size_t)buffersize * sizeof(float)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for sound buffers.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->big_fsize  = /*dz->bigbufsize/sizeof(float);*/dz->buflen;
+    dz->flbufptr[2] = dz->bigfbuf + dz->big_fsize;
+    dz->flbufptr[3] = dz->flbufptr[2] + /*(dz->bigbufsize2/sizeof(float));*/ dz->buflen2;
+    return(FINISHED);
+}
+
+/******************************* CALCULATE_ANALDATA_PLUS_FORMANTDATA_BUFFER **************************/
+
+int calculate_analdata_plus_formantdata_buffer(unsigned int *buffersize,dataptr dz)
+{
+//  int exit_status;
+    int cnt = 0;
+    unsigned int orig_buffersize = 0;
+    dz->buflen2 = 0;
+//TW REVISED: no secsize-multiple restriction on buffers
+    *buffersize = (dz->wanted + dz->infile->specenvcnt) * BUF_MULTIPLIER;
+    while(dz->buflen2 < dz->descriptor_samps) {
+        if(cnt == 0)
+            orig_buffersize = *buffersize;
+        else
+            *buffersize += orig_buffersize;
+        cnt++;
+        dz->buflen  = dz->wanted * BUF_MULTIPLIER * cnt;
+        dz->buflen2 = dz->infile->specenvcnt * BUF_MULTIPLIER * cnt;
+    }
+    return(FINISHED);
+}
+
+/******************************* ALLOCATE_SINGLE_BUFFER_PLUS_EXTRA_POINTER **************************/
+
+int allocate_single_buffer_plus_extra_pointer(dataptr dz)
+{
+    int exit_status;
+    if((exit_status = allocate_single_buffer(dz))<0)
+        return(exit_status);
+    if(dz->bptrcnt < 2) {
+        sprintf(errstr,"dz->flbufptr[1] not established: allocate_larger_buffers()\n");
+        return(PROGRAM_ERROR);
+    }
+    dz->flbufptr[1] = dz->bigfbuf + dz->big_fsize;
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN cmdline.c *****************************/
+/******************************************************************************/
+
+/************************** GET_PROCESS_AND_MODE_FROM_CMDLINE *****************************/
+
+int get_process_and_mode_from_cmdline(int *cmdlinecnt,char ***cmdline,dataptr dz)
+{
+    int exit_status;
+    if((exit_status = get_process_no((*cmdline)[0],dz))<0)
+        return(exit_status);
+    (*cmdline)++;
+    (*cmdlinecnt)--;
+    
+    if((dz->maxmode = get_maxmode(dz->process))<0)
+        return(PROGRAM_ERROR);
+    if(dz->maxmode > 0) {
+        if(*cmdlinecnt<=0) {
+            sprintf(errstr,"Too few commandline parameters.\n");
+            return(USAGE_ONLY);
+        }
+        if((exit_status = get_mode_from_cmdline((*cmdline)[0],dz))<0)
+            return(exit_status);
+        (*cmdline)++;
+        (*cmdlinecnt)--;
+    }
+    return(FINISHED);
+}
+
+/****************************** GET_MODE *********************************/
+
+int get_mode_from_cmdline(char *str,dataptr dz)
+{
+    if(sscanf(str,"%d",&dz->mode)!=1) {
+        sprintf(errstr,"Cannot read mode of program.\n");
+        return(USAGE_ONLY);
+    }
+    if(dz->mode <= 0 || dz->mode > dz->maxmode) {
+        sprintf(errstr,"Program mode value [%d] is out of range [1 - %d].\n",dz->mode,dz->maxmode);
+        return(USAGE_ONLY);
+    }
+    dz->mode--;     /* CHANGE TO INTERNAL REPRESENTATION OF MODE NO */
+    return(FINISHED);
+}
+
+/******************************************************************************/
+/************************* FORMERLY IN usage.c ********************************/
+/******************************************************************************/
+
+
+/******************************** USAGE1 ********************************/
+
+int usage(int argc,char *argv[])
+{
+    switch(argc) {
+    case(1): return usage1();
+    case(2): return usage2(argv[1]);
+    case(3): return usage3(argv[1],argv[2]);
+    }
+    sprintf(errstr,"Incorrect call to usage()\n");
+    return(PROGRAM_ERROR);
+}
+
+/******************************** USAGE1 ********************************/
+
+//TW NEW CODE BELOW
+/******************************** GET_THE_VOWELS ********************************/
+
+int get_the_vowels(char *filename,double **times,int **vowels,int *vcnt,dataptr dz)
+{
+    FILE *fp;
+    double *t, lasttime = 0.0, endtime;
+    int *v, vv;
+    int only_one_vowel = 0, non_zero_start = 0;
+    int arraysize = BIGARRAY, n = 0;
+    char temp[200], *q, *p;
+    int istime;
+
+    if((vv = get_vowel(filename))>=0) {
+        if((*times = (double *)malloc(2 * sizeof(double)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for time data.\n");
+            return(MEMORY_ERROR);
+        }
+        if((*vowels = (int *)malloc(2 * sizeof(int)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for vowels data.\n");
+            return(MEMORY_ERROR);
+        }
+        (*times)[0] = 0.0;
+        (*times)[1] = 0.0;
+        (*vowels)[0] = vv;
+        (*vowels)[1] = vv;
+        return(FINISHED);
+    }
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr, "Can't open textfile %s to read vowel data.\n",filename);
+        return(DATA_ERROR);
+    }
+    if((*times = (double *)malloc(arraysize * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for time data.\n");
+        return(MEMORY_ERROR);
+    }
+    if((*vowels = (int *)malloc(arraysize * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for vowels data.\n");
+        return(MEMORY_ERROR);
+    }
+    t = *times;
+    v = *vowels;
+    istime = 1;
+    while(fgets(temp,200,fp)==temp) {
+        q = temp;
+        while(get_word_from_string(&q,&p)) {
+            if(istime) {
+                if(sscanf(p,"%lf",t)!=1) {
+                    sprintf(errstr,"No time for time-vowel pair %d\n",n+1);
+                    return(DATA_ERROR);
+                }
+                if(n==0) {
+                    if(*t < 0.0) {
+                        sprintf(errstr,"First time is less than zero in vowel data\n");
+                        return(DATA_ERROR);
+                    } else if(*t > 0.0) {
+                        print_outwarning_flush("FIRST TIME in vowel data IS NOT ZERO : assuming first vowel runs from time zero\n");
+                        non_zero_start = 1;
+                        t++;
+                        *t = *(t-1);
+                        *(t-1) = 0.0;
+                    }
+                } else {
+                    if (*t <= lasttime) {
+                        sprintf(errstr,"Times do not advance (from %lf to %lf at pair %d) in vowel data\n",
+                        lasttime,*t,n+1);
+                        return(DATA_ERROR);
+                    }
+                }
+                lasttime = *t++;
+            } else {
+                if((*v = get_vowel(p))<0) {
+                    sprintf(errstr,"Unrecognised vowel string %s at pair %d in vowel datafile\n",p,n+1);
+                    return(DATA_ERROR);
+                }
+                if((n==0) && non_zero_start) {
+                    v++;
+                    *v = *(v-1);
+                    n++;
+                }
+                v++;
+                if(++n >= arraysize) {
+                    arraysize += BIGARRAY;
+                    if((*times = (double *)realloc((char *)(*times),arraysize * sizeof(double)))==NULL) {
+                        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate table of vowel-times.\n");
+                        return(MEMORY_ERROR);
+                    }
+                    if((*vowels = (int *)realloc((char *)(*vowels),arraysize * sizeof(int)))==NULL) {
+                        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate table of vowels.\n");
+                        return(MEMORY_ERROR);
+                    }
+                    t = *times + n;     
+                    v = *vowels + n;        
+                }
+            }
+            istime = !istime;
+        }
+    }
+    if(n == 0) {
+        sprintf(errstr,"No data in vowel datafile %s\n",filename);
+        return(DATA_ERROR);
+    }
+    if(!istime) {
+        sprintf(errstr,"data in  vowel datafile %s not paired correctly\n",filename);
+        return(DATA_ERROR);
+    }
+    endtime = (dz->wlength + 1) * dz->frametime;
+    if(n == 1) {
+        only_one_vowel = 1;
+        *t = endtime;
+        *v = *(v-1);
+        n = 2;
+    } else {
+        if(*(t-1) < endtime) {  /* Force a time-value beyond end of infile */
+            *t = endtime;
+            *v = *(v-1);
+            n++;
+        }
+    }
+    if((*times = (double *)realloc((char *)(*times),n * sizeof(double)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate vowel-time table.\n");
+        return(MEMORY_ERROR);
+    }
+    if((*vowels = (int *)realloc((char *)(*vowels),n * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate vowels table.\n");
+        return(MEMORY_ERROR);
+    }
+    if(fclose(fp)<0) {
+        fprintf(stdout,"WARNING: Failed to close input textfile %s.\n",filename);
+        fflush(stdout);
+    }
+    if(only_one_vowel)
+        *vcnt = 0;
+    else
+        *vcnt = n;
+    return(FINISHED);
+}
+
+/******************************** GET_VOWEL ********************************/
+
+int get_vowel (char *str)
+{
+    if     (!strcmp(str,"ee"))  return VOWEL_EE;
+    else if(!strcmp(str,"i"))   return VOWEL_I;
+    else if(!strcmp(str,"ai"))  return VOWEL_AI;
+    else if(!strcmp(str,"aii")) return VOWEL_AII;
+    else if(!strcmp(str,"e"))   return VOWEL_E;
+    else if(!strcmp(str,"a"))   return VOWEL_A;
+    else if(!strcmp(str,"ar"))  return VOWEL_AR;
+    else if(!strcmp(str,"o"))   return VOWEL_O;
+    else if(!strcmp(str,"oo"))  return VOWEL_OO;
+    else if(!strcmp(str,"oa"))  return VOWEL_OA;
+    else if(!strcmp(str,"or"))  return VOWEL_OR;
+    else if(!strcmp(str,"u"))   return VOWEL_U;
+    else if(!strcmp(str,"ui"))  return VOWEL_UI;
+    else if(!strcmp(str,"uu"))  return VOWEL_UU;
+    else if(!strcmp(str,"xx"))  return VOWEL_XX;
+    else if(!strcmp(str,"x"))   return VOWEL_X;
+    else if(!strcmp(str,"n"))   return VOWEL_N;
+    else if(!strcmp(str,"m"))   return VOWEL_M;
+    else if(!strcmp(str,"r"))   return VOWEL_R;
+    else if(!strcmp(str,"th"))  return VOWEL_TH;
+    return -1;
+}
+
+/************************** CLOSE_AND_DELETE_TEMPFILE ***************************
+ *
+ * The input file is a temporary file only: needs to be deleted
+ *
+ */
+
+int close_and_delete_tempfile(char *newfilename,dataptr dz) 
+{
+    /*RWD Nov 2003: use sndunlink before calling this for soundfiles! */
+    if(sndunlink(dz->ifd[0])){
+        fprintf(stdout, "WARNING: Can't delete temporary file %s.\n",newfilename);
+        fflush(stdout);
+    }
+
+    if(sndcloseEx(dz->ifd[0]) < 0) {
+        fprintf(stdout, "WARNING: Can't close temporary file %s\n",newfilename);
+        fflush(stdout);
+    } else {
+        dz->ifd[0] = -1;
+    }
+#ifdef NOTDEF
+    if(remove(newfilename) < 0) {
+        fprintf(stdout, "WARNING: Can't delete temporary file %s.\n",newfilename);
+        fflush(stdout);
+    }
+#endif
+    return FINISHED;
+}
+

dev/cdp2k/validate.c

@@ -0,0 +1,619 @@
+/*
+ * 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
+ *
+ */
+
+
+
+/* floatsam version */
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+/*RWD*/
+#include <memory.h>
+#include <structures.h>
+#include <globcon.h>
+#include <tkglobals.h>
+#include <processno.h>
+#include <filetype.h>
+
+
+
+void validate(int applicno,int *valid);
+
+/******************************* ALLOCATE_AND_INITIALISE_VALIDITY_FLAGS *******************************/
+
+int allocate_and_initialise_validity_flags(int **valid,int *validcnt)
+{
+    int k = sizeof(int) * CHARBITSIZE;
+    *validcnt = (MAX_PROCESS_NO + k - 1)/k;
+    if((*valid = (int *)malloc((*validcnt) * sizeof(int)))==NULL) {
+        sprintf(errstr,"ERROR: INSUFFICIENT MEMORY for validation flags\n");
+        return(MEMORY_ERROR);
+    }
+    memset((char *)(*valid),0,(*validcnt) * sizeof(int));
+    return(FINISHED);
+}
+
+/******************************* VALIDATE *******************************/
+
+void validate(int process,int *valid)
+{
+    int k = sizeof(int) * CHARBITSIZE;
+    int flagno = (process - 1) / k; /* TRUNCATE */  /* e.g. 36 -> flag 2 (counted from zero)  */
+    int bitno  = (process - 1) % k;                 /* e.g. 36 -> bit 3  (counted from zero) */
+    int mask = 1;
+    if(bitno > 0)
+        mask <<= bitno;
+    valid[flagno] |= mask;
+}
+
+/******************************* VALID_APPLICATION *******************************/
+
+int valid_application(int process,int *valid)
+{
+    int k = sizeof(int) * CHARBITSIZE;
+    int flagno = (process - 1) / k; /* TRUNCATE */  /* e.g. 36 -> flag 2 (counted from zero) */
+    int bitno  = (process - 1) % k;                 /* e.g. 36 -> bit 3  (counted from zero) */
+    int mask = 1;
+    if(bitno > 0)
+        mask <<= bitno;
+    return(valid[flagno] & mask);
+}
+
+/******************************* ESTABLISH_APPLICATION_VALIDITIES *******************************/
+
+int establish_application_validities(int filetype,int channels,int *valid)
+{
+    /* VALID REGARDLESS OF INFILE TYPE */
+    validate(ENV_CREATE,valid);
+    validate(MIXFORMAT,valid);
+    validate(HOUSE_DISK,valid); 
+    validate(HOUSE_BUNDLE,valid);   
+    validate(INFO_PROPS,valid);
+    validate(INFO_SFLEN,valid);
+    validate(INFO_MAXSAMP,valid);
+    validate(INFO_MAXSAMP2,valid);
+    validate(INFO_DIFF,valid);
+    validate(INFO_MUSUNITS,valid);
+    validate(SYNTH_WAVE,valid);
+    validate(MULTI_SYN,valid);
+    validate(SYNTH_NOISE,valid);
+    validate(SYNTH_SIL,valid);
+    validate(HOUSE_DEL,valid);
+//TW NEW CASES
+    validate(P_GEN,valid);  
+    validate(CLICK,valid);  
+    validate(ENVSYN,valid);
+    validate(SIN_TAB,valid);
+    validate(SYNTH_SPEC,valid);
+    /* VALIDITY DEPENDS ON INFILE TYPE */
+    switch(filetype) {
+    case(ANALFILE):
+
+        validate(HOUSE_COPY,valid); 
+        validate(ACCU,valid);
+        validate(ALT,valid);
+        validate(ARPE,valid);
+        validate(AVRG,valid);
+        validate(BARE,valid);
+        validate(BLTR,valid);
+        validate(BLUR,valid);
+        validate(BRIDGE,valid);
+        validate(CHANNEL,valid);
+        validate(CHORD,valid);
+        validate(CHORUS,valid);
+        validate(CLEAN,valid);
+        validate(CROSS,valid);
+        validate(CUT,valid);
+        validate(DIFF,valid);
+        validate(DRUNK,valid);
+        validate(EXAG,valid);
+        validate(FILT,valid);
+        validate(FOCUS,valid);
+        validate(FOLD,valid);
+        validate(FORM,valid);
+        validate(FORMANTS,valid);
+        validate(FORMSEE,valid);
+        validate(FREEZE,valid);
+        validate(FREEZE2,valid);
+        validate(FREQUENCY,valid);
+        validate(GAIN,valid);
+        validate(GLIDE,valid);
+        validate(GLIS,valid);
+        validate(GRAB,valid);
+        validate(GREQ,valid);
+        validate(INVERT,valid);
+        validate(LEAF,valid);
+        validate(LEVEL,valid);
+        validate(LIMIT,valid);
+        validate(MAGNIFY,valid);
+        validate(MAX,valid);
+        validate(MEAN,valid);
+        validate(MORPH,valid);
+        validate(MULTRANS,valid);
+        validate(NOISE,valid);
+        validate(OCT,valid);
+        validate(OCTVU,valid);
+        validate(PEAK,valid);
+        validate(PICK,valid);
+        validate(PITCH,valid);
+        validate(PLUCK,valid);
+        validate(PRINT,valid);
+        validate(REPORT,valid);
+        validate(SCAT,valid);
+        validate(SHIFT,valid);
+        validate(SHIFTP,valid);
+        validate(SHUFFLE,valid);    
+        validate(SPLIT,valid);      
+        validate(SPREAD,valid); 
+        validate(STEP,valid);       
+        validate(STRETCH,valid);    
+        validate(SUM,valid);        
+        validate(SUPR,valid);       
+        validate(S_TRACE,valid);        
+/***
+        validate(TRACK,valid);      
+***/
+        validate(TRNSF,valid);
+        validate(TRNSP,valid);      
+        validate(TSTRETCH,valid);   
+        validate(TUNE,valid);       
+        validate(VOCODE,valid); 
+/***
+        validate(WARP,valid);       
+***/
+        validate(WAVER,valid);      
+        validate(WEAVE,valid);      
+        validate(WINDOWCNT,valid);  
+        validate(PVOC_SYNTH,valid); 
+//TW NEW CASES
+        validate(ANALENV,valid);
+        validate(VFILT,valid);
+
+        break;
+    case(PITCHFILE):
+        validate(HOUSE_COPY,valid); 
+        validate(MAKE,valid);       
+        validate(P_FIX,valid);      
+        validate(P_APPROX,valid);   
+        validate(P_INVERT,valid);   
+        validate(P_QUANTISE,valid);  
+        validate(P_RANDOMISE,valid); 
+        validate(P_SMOOTH,valid);    
+//TW NEW CASES
+        validate(P_SYNTH,valid);
+        validate(P_VOWELS,valid);
+        validate(P_INSERT,valid);
+        validate(P_SINSERT,valid);
+        validate(P_PTOSIL,valid);
+        validate(P_NTOSIL,valid);
+        validate(MAKE2,valid);
+        validate(P_INTERP,valid);
+
+        validate(P_VIBRATO,valid);      
+        validate(P_EXAG,valid);     
+        validate(P_TRANSPOSE,valid);    
+        validate(P_HEAR,valid);     
+        validate(P_CUT,valid);      
+        validate(P_INFO,valid);     
+        validate(P_SEE,valid);       
+        validate(P_WRITE,valid);        
+        validate(P_ZEROS,valid);        
+        validate(REPITCH,valid);    
+        validate(REPITCHB,valid);
+        validate(P_BINTOBRK,valid);
+        break;
+    case(TRANSPOSFILE):
+        validate(HOUSE_COPY,valid); 
+        validate(P_SEE,valid);
+        validate(P_WRITE,valid);
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        break;
+    case(FORMANTFILE):
+        validate(HOUSE_COPY,valid); 
+        validate(FMNTSEE,valid);
+        break;
+    case(SNDFILE):
+//TW NEW CASES
+        validate(TOPNTAIL_CLICKS,valid);    
+        validate(DEL_PERM2,valid);  
+        validate(HOUSE_BAKUP,valid);    
+        validate(HOUSE_GATE,valid); 
+        validate(EDIT_CUTMANY,valid);   
+        validate(STACK,valid);  
+        validate(SHUDDER,valid);    
+
+        validate(RANDCUTS,valid);
+        validate(RANDCHUNKS,valid);
+        validate(HOUSE_COPY,valid); 
+        validate(HOUSE_CHANS,valid);    
+        if(channels==MONO) {
+            validate(DISTORT,valid);
+            validate(DISTORT_ENV,valid);
+            validate(DISTORT_AVG,valid);
+            validate(DISTORT_OMT,valid);
+            validate(DISTORT_MLT,valid);
+            validate(DISTORT_DIV,valid);
+            validate(DISTORT_HRM,valid);
+            validate(DISTORT_FRC,valid);
+            validate(DISTORT_REV,valid);
+            validate(DISTORT_SHUF,valid);
+            validate(DISTORT_RPT,valid);
+            validate(DISTORT_RPT2,valid);
+            validate(DISTORT_RPTFL,valid);
+            validate(DISTORT_INTP,valid);
+            validate(DISTORT_DEL,valid);
+            validate(DISTORT_RPL,valid);
+            validate(DISTORT_TEL,valid);
+            validate(DISTORT_FLT,valid);
+            validate(DISTORT_INT,valid);
+            validate(DISTORT_CYCLECNT,valid);
+            validate(DISTORT_PCH,valid);
+            validate(DISTORT_OVERLOAD,valid);
+//TW NEW CASES
+            validate(DISTORT_PULSED,valid);
+            validate(NOISE_SUPRESS,valid);
+            validate(CYCINBETWEEN,valid);
+            validate(GREV,valid);
+        }
+        validate(ZIGZAG,valid);
+        validate(LOOP,valid);
+        validate(SCRAMBLE,valid);
+        validate(ITERATE,valid);
+        validate(ITERATE_EXTEND,valid);
+        validate(DRUNKWALK,valid);
+//TW NEW CASES
+        validate(TIME_GRID,valid);
+        validate(SEQUENCER2,valid);
+        validate(SEQUENCER,valid);
+        validate(CONVOLVE,valid);
+        validate(BAKTOBAK,valid);
+
+        if(channels==MONO) {
+            validate(SIMPLE_TEX,valid);
+            validate(GROUPS,valid);
+            validate(MOTIFS,valid);
+            validate(MOTIFSIN,valid);
+            validate(DECORATED,valid);
+            validate(PREDECOR,valid);
+            validate(POSTDECOR,valid);
+            validate(ORNATE,valid);
+            validate(PREORNATE,valid);
+            validate(POSTORNATE,valid);
+            validate(TIMED,valid);
+            validate(TGROUPS,valid);
+            validate(TMOTIFS,valid);
+            validate(TMOTIFSIN,valid);
+            validate(PVOC_ANAL,valid);  
+            validate(PVOC_EXTRACT,valid);
+            validate(RRRR_EXTEND,valid);
+            validate(SSSS_EXTEND,valid);
+        }
+        validate(GRAIN_COUNT,valid);
+        validate(GRAIN_OMIT,valid);
+        validate(GRAIN_DUPLICATE,valid);
+        validate(GRAIN_REORDER,valid);
+        validate(GRAIN_REPITCH,valid);
+        validate(GRAIN_RERHYTHM,valid);
+        validate(GRAIN_REMOTIF,valid);
+        validate(GRAIN_TIMEWARP,valid);
+        validate(GRAIN_GET,valid);
+        validate(GRAIN_POSITION,valid);
+        validate(GRAIN_ALIGN,valid);
+        validate(GRAIN_REVERSE,valid);
+        validate(ENV_EXTRACT,valid);
+        validate(ENV_IMPOSE,valid);
+//TW NEW CASE
+        validate(ENV_PROPOR,valid);
+
+        validate(ENV_REPLACE,valid);
+        validate(ENV_WARPING,valid);
+        validate(ENV_DOVETAILING,valid);
+        validate(ENV_CURTAILING,valid);
+        validate(ENV_SWELL,valid);
+        validate(ENV_ATTACK,valid);
+        if(channels==1)
+            validate(ENV_PLUCK,valid);
+        validate(ENV_TREMOL,valid);
+        validate(MIXTWO,valid);
+//TW NEW CASES
+        validate(MIX_AT_STEP,valid);
+        validate(MIXMANY,valid);
+
+        validate(MIXBALANCE,valid);
+        validate(MIXCROSS,valid);
+        if(channels==1)
+            validate(MIXINTERL,valid);
+        validate(MIXINBETWEEN,valid);
+        validate(EQ,valid);     
+        validate(LPHP,valid);       
+        validate(FSTATVAR,valid);   
+        validate(FLTBANKN,valid);  
+        validate(FLTBANKC,valid);
+        validate(FLTBANKU,valid);   
+        validate(FLTBANKV,valid);   
+        validate(FLTBANKV2,valid);  
+        validate(FLTITER,valid);    
+        validate(FLTSWEEP,valid);   
+        validate(ALLPASS,valid);    
+        validate(MOD_LOUDNESS,valid);   
+        validate(MOD_SPACE,valid);  
+//TW NEW CASE
+        validate(SCALED_PAN,valid); 
+
+        validate(MOD_PITCH,valid);  
+        validate(MOD_REVECHO,valid);    
+        validate(MOD_RADICAL,valid);    
+        validate(BRASSAGE,valid);   
+        validate(SAUSAGE,valid);    
+        if(channels==MONO) {
+            validate(EDIT_ZCUT,valid);
+            validate(MANY_ZCUTS,valid);
+        }
+        validate(EDIT_CUT,valid);   
+        validate(EDIT_CUTEND,valid);    
+        validate(EDIT_EXCISE,valid);    
+        validate(EDIT_EXCISEMANY,valid);    
+        validate(INSERTSIL_MANY,valid); 
+        validate(EDIT_INSERT,valid);    
+//TW NEW CASE
+        validate(EDIT_INSERT2,valid);   
+
+        validate(EDIT_INSERTSIL,valid); 
+        validate(EDIT_JOIN,valid);
+        validate(JOIN_SEQ,valid);   
+        validate(JOIN_SEQDYN,valid);
+        validate(HOUSE_COPY,valid); 
+        validate(HOUSE_SPEC,valid); 
+        validate(HOUSE_EXTRACT,valid);  
+        validate(INFO_TIMELIST,valid);
+        validate(INFO_LOUDLIST,valid);
+        validate(INFO_TIMESUM,valid);
+        validate(INFO_TIMEDIFF,valid);
+        validate(INFO_SAMPTOTIME,valid);
+        validate(INFO_TIMETOSAMP,valid);
+        validate(INFO_LOUDCHAN,valid);
+        validate(INFO_FINDHOLE,valid);
+        validate(INFO_CDIFF,valid);
+        validate(INFO_PRNTSND,valid);
+        validate(TWIXT,valid);
+        validate(SPHINX,valid);
+        validate(MIXDUMMY,valid);
+//TW NEW CASES
+        validate(MIX_ON_GRID,valid);
+        validate(AUTOMIX,valid);
+        validate(DOUBLETS,valid);
+        validate(SYLLABS,valid);
+        validate(HOUSE_GATE2,valid);
+        if(channels==2)
+            validate(FIND_PANPOS,valid);
+        validate(GRAIN_ASSESS,valid);
+        validate(ZCROSS_RATIO,valid);
+        validate(ACC_STREAM,valid);
+        break;
+
+    case(ENVFILE):
+        validate(HOUSE_COPY,valid); 
+        validate(ENV_RESHAPING,valid);
+        validate(ENV_ENVTOBRK,valid);
+        validate(ENV_ENVTODBBRK,valid);
+        break;
+    case(SNDLIST_OR_SYNCLIST_LINELIST_OR_WORDLIST):    /* list of snds AT SAME SRATE */
+    case(SNDLIST_OR_SYNCLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid);
+        validate(MIXSYNC,valid);
+        validate(MIXSYNCATT,valid);
+        validate(HOUSE_SORT,valid); 
+        validate(WORDCNT,valid);
+        break;
+    case(SNDLIST_OR_LINELIST_OR_WORDLIST):   /* list of snds NOT ALL at same srate */
+    case(SNDLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(HOUSE_SORT,valid); 
+        validate(WORDCNT,valid);
+        break;
+    case(MIXLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(MIX,valid);
+        validate(MIX_MODEL,valid);
+        validate(MIXTEST,valid);
+        validate(MIXMAX,valid);
+        validate(MIXTWARP,valid);
+        validate(MIXSWARP,valid);
+        validate(MIXGAIN,valid);
+        validate(MIXSHUFL,valid);
+        validate(MIXSYNC,valid);
+        validate(MIXSYNCATT,valid);
+//TW NEW CASES
+        validate(ADDTOMIX,valid);
+
+        validate(WORDCNT,valid);
+//TW NEW CASES
+        validate(MIX_PAN,valid);
+
+        break;
+    case(MIXLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(MIX,valid);
+        validate(MIX_MODEL,valid);
+        validate(MIXTEST,valid);
+        validate(MIXMAX,valid);
+        validate(MIXTWARP,valid);
+        validate(MIXSWARP,valid);
+        validate(MIXGAIN,valid);
+        validate(MIXSHUFL,valid);
+        validate(MIXSYNC,valid);
+        validate(MIXSYNCATT,valid);
+//TW NEW CASE
+        validate(ADDTOMIX,valid);
+
+        validate(WORDCNT,valid);
+//TW NEW CASE
+        validate(MIX_PAN,valid);
+        
+        break;
+    case(SYNCLIST_OR_LINELIST_OR_WORDLIST):  /* i.e. NOT a sndlist */
+        validate(HOUSE_COPY,valid); 
+        validate(MIXSYNCATT,valid);
+        validate(HOUSE_SORT,valid); 
+        validate(WORDCNT,valid);
+        break;
+    case(SYNCLIST_OR_WORDLIST):              /* i.e. NOT a sndlist */
+        validate(HOUSE_COPY,valid); 
+        validate(MIXSYNCATT,valid);
+        validate(HOUSE_SORT,valid); 
+        validate(WORDCNT,valid);
+        break;
+    case(LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(HOUSE_SORT,valid); 
+        validate(WORDCNT,valid);
+        validate(BATCH_EXPAND,valid);
+        break;
+    case(WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(HOUSE_SORT,valid); 
+        validate(WORDCNT,valid);
+        break;
+    case(TRANSPOS_OR_NORMD_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(ENV_REPLOTTING,valid);
+        validate(ENV_BRKTOENV,valid);
+        validate(ENV_BRKTODBBRK,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(TRANSPOS_OR_NORMD_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(ENV_REPLOTTING,valid);
+        validate(ENV_BRKTOENV,valid);
+        validate(ENV_BRKTODBBRK,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(TRANSPOS_OR_PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(TRANSPOS_OR_UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(TRANSPOS_OR_UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(PITCH_POSITIVE_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HF_PERM1,valid);   
+        validate(HF_PERM2,valid);   
+        validate(DEL_PERM,valid);
+        validate(DEL_PERM2,valid);
+        validate(ENV_IMPOSE,valid); 
+        /* fall thro */
+    case(PITCH_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(PITCH_POSITIVE_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HF_PERM1,valid);   
+        validate(HF_PERM2,valid);   
+        validate(DEL_PERM,valid);   
+        validate(DEL_PERM2,valid);  
+        validate(ENV_IMPOSE,valid); 
+        /* fall thro */
+    case(PITCH_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(REPITCH,valid);
+        validate(REPITCHB,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(NORMD_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(ENV_REPLOTTING,valid);
+        validate(ENV_BRKTOENV,valid);
+        validate(ENV_BRKTODBBRK,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(DB_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(ENV_DBBRKTOENV,valid);
+        validate(ENV_DBBRKTOBRK,valid);
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(POSITIVE_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(POSITIVE_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HF_PERM1,valid);   
+        validate(HF_PERM2,valid);   
+        validate(DEL_PERM,valid);   
+        validate(DEL_PERM2,valid);  
+        /* fall thro */
+    case(UNRANGED_BRKFILE_OR_NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(UNRANGED_BRKFILE_OR_NUMLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(MOD_SPACE,valid);  
+        validate(WORDCNT,valid);
+        break;
+    case(NUMLIST_OR_LINELIST_OR_WORDLIST):
+    case(NUMLIST_OR_WORDLIST):
+        validate(HOUSE_COPY,valid); 
+        validate(WORDCNT,valid);
+        validate(HF_PERM1,valid);
+        validate(HF_PERM2,valid);
+        validate(DEL_PERM,valid);
+        validate(DEL_PERM2,valid);
+        validate(MAKE_VFILT,valid);
+        break;
+    default:
+        sprintf(errstr,"Unknown filetype [%d]: establish_application_validities()\n",filetype);
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+

dev/cdp2k/writedata.c

@@ -0,0 +1,1127 @@
+/*
+ * Copyright (c) 1983-2013 Trevor Wishart and Composers Desktop Project Ltd
+ * http://www.trevorwishart.co.uk
+ * http://www.composersdesktop.com
+ *
+ This file is part of the CDP System.
+
+    The CDP System is free software; you can redistribute it
+    and/or modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    The CDP System is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with the CDP System; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+    02111-1307 USA
+ *
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <processno.h>
+#include <modeno.h>
+#include <filtcon.h>
+#include <cdpmain.h>
+#include <globcon.h>
+#include <logic.h>
+#include <standalone.h>
+
+#include <pnames.h>
+#include <sfsys.h>
+//TW ADDED
+#include <limits.h>
+
+#ifdef unix
+#define round(x) lround((x))
+#endif
+
+static int  set_output_header_properties(dataptr dz);
+static int  pt_datareduce(double **q,double sharp,double flat,double *thisarray,int *bsize);
+static int  incremental_pt_datareduction(int array_no,int *bsize,double sharpness,dataptr dz);
+
+    /* OTHER */
+static int  print_screen_message(void);
+
+/* AUGUST 2000 */
+unsigned int superzargo;
+
+/***************************** COMPLETE_OUTPUT *******************************/
+
+int complete_output(dataptr dz)
+{
+    if(dz->process_type==PITCH_TO_PITCH || dz->process_type==PITCH_TO_BIGPITCH) {
+        if(dz->is_transpos)
+            dz->outfiletype = TRANSPOS_OUT;
+        else
+            dz->outfiletype = PITCH_OUT;
+    }
+    switch(dz->process_type) {
+    case(UNEQUAL_SNDFILE):
+    case(BIG_ANALFILE):
+    case(UNEQUAL_ENVFILE):
+    case(CREATE_ENVFILE):
+    case(EXTRACT_ENVFILE):
+    case(PITCH_TO_ANAL):
+    case(ANAL_TO_FORMANTS):
+    case(PITCH_TO_BIGPITCH):
+    case(PSEUDOSNDFILE):
+//TW No longer used:
+//      if((exit_status = truncate_outfile(dz))<0)
+//          return(exit_status);
+        /* fall thro */
+    case(EQUAL_ANALFILE):
+    case(MAX_ANALFILE):
+    case(MIN_ANALFILE):
+    case(EQUAL_FORMANTS):
+    case(EQUAL_SNDFILE):
+    case(EQUAL_ENVFILE):
+    case(PITCH_TO_PITCH):
+    case(PITCH_TO_PSEUDOSND):
+        return headwrite(dz->ofd,dz);
+        break;
+    case(SCREEN_MESSAGE):
+        return print_screen_message();
+    case(ANAL_TO_PITCH):
+        sprintf(errstr,"ANAL_TO_PITCH process_type (%d) in complete_output()\n",dz->process_type);
+        return(PROGRAM_ERROR);
+    case(TO_TEXTFILE):      
+        if(fclose(dz->fp)<0) {
+            fprintf(stdout,"WARNING: Failed to close output textfile.\n");
+            fflush(stdout);
+        }
+        break;
+    case(OTHER_PROCESS):        
+        break;
+    default:
+        sprintf(errstr,"Unknown process_type (%d) in complete_output()\n",dz->process_type);
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/***************************** TRUNCATE_OUTFILE *******************************/
+#ifdef NOTDEF
+int truncate_outfile(dataptr dz)
+{
+    if(sfadjust(dz->ofd,dz->total_bytes_written - dz->outfilesize)<0) {
+        sprintf(errstr,"Cannot truncate output file (Is hard-disk full?).\n");
+        return(SYSTEM_ERROR);
+    }
+    return(FINISHED);
+}
+#endif
+/***************************** HEADWRITE *******************************/
+
+int headwrite(int ofd,dataptr dz)
+{   
+    int   exit_status;
+    int   isenv = 1;
+    int  property_marker = 1;
+    int  samptype, srate, channels;
+    float window_size = 0.0f;
+
+    if(!(dz->process == PVOC_ANAL || dz->process == PVOC_EXTRACT || dz->process == PVOC_SYNTH)) {
+        if((exit_status = set_output_header_properties(dz))<0)
+            return(exit_status);
+    }
+    switch(dz->outfiletype) {
+    case(FORMANTS_OUT):
+        if(sndputprop(ofd,"specenvcnt", (char *)&(dz->outfile->specenvcnt), sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write specenvcnt: headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        /* drop through */
+    case(PITCH_OUT):
+    case(TRANSPOS_OUT):
+        if(sndputprop(ofd,"orig channels", (char *)&(dz->outfile->origchans), sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write original channel data: headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        /* drop through */
+    case(ANALFILE_OUT):
+        if(sndputprop(ofd,"original sampsize", (char *)&(dz->outfile->origstype), sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write original sample size. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(sndputprop(ofd,"original sample rate", (char *)&(dz->outfile->origrate), sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write original sample rate. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(sndputprop(ofd,"arate",(char *)&(dz->outfile->arate),sizeof(float)) < 0){
+            sprintf(errstr,"Failed to write analysis sample rate. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(sndputprop(ofd,"analwinlen",(char *)&(dz->outfile->Mlen),sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write analysis window length. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(sndputprop(ofd,"decfactor",(char *)&(dz->outfile->Dfac),sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write decimation factor. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        /* drop through */
+    case(SNDFILE_OUT):
+//TW these properties can either be created at the outset (sndcreat_formatted() 
+//  in which case they are not alterable here.
+//  or they can be left open (sndcreat e.g. for PITCH, or CUT for dz->otherfile)
+        sndputprop(ofd,"sample rate", (char *)&(dz->outfile->srate), sizeof(int));
+        sndputprop(ofd,"channels", (char *)&(dz->outfile->channels), sizeof(int));
+        break;
+    case(ENVFILE_OUT):  
+        samptype = SAMP_FLOAT;
+        srate = round(SECS_TO_MS/dz->outfile->window_size);
+        channels = 1;
+        window_size = dz->outfile->window_size;
+/* JUNE 2004
+        if(sndputprop(ofd,"sample rate", (char *)&srate, sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write sample rate. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(sndputprop(ofd,"channels", (char *)&channels, sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write channel data. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+*/
+        if(sndputprop(ofd,"is an envelope",(char *)&isenv, sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write envelope property. headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(sndputprop(ofd,"window size", (char *)(&window_size), sizeof(float)) < 0) {
+            sprintf(errstr,"Failure to write window size. headwrite()\n");
+            return(DATA_ERROR);
+        }
+        break;
+
+    default:
+        sprintf(errstr,"Unknown outfile type: headwrite()\n");
+        return(PROGRAM_ERROR);
+    }
+    switch(dz->outfiletype) {
+    case(PITCH_OUT):
+        if(sndputprop(ofd,"is a pitch file", (char *)&property_marker, sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write pitch property: headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(TRANSPOS_OUT):
+        if(sndputprop(ofd,"is a transpos file", (char *)&property_marker, sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write transposition property: headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    case(FORMANTS_OUT):
+        if(sndputprop(ofd,"is a formant file", (char *)&property_marker, sizeof(int)) < 0){
+            sprintf(errstr,"Failure to write formant property: headwrite()\n");
+            return(PROGRAM_ERROR);
+        }
+        break;
+    }
+    return(FINISHED);
+}
+
+/***************************** SET_OUTPUT_HEADER_PROPERTIES ******************************/         
+ 
+int set_output_header_properties(dataptr dz)
+{   
+    switch(dz->process_type) {
+    case(EQUAL_SNDFILE):
+    case(UNEQUAL_SNDFILE):
+    case(EQUAL_ENVFILE):
+    case(UNEQUAL_ENVFILE):
+        dz->outfile->channels = dz->infile->channels;
+        dz->outfile->srate    = dz->infile->srate;
+        dz->outfile->stype    = dz->infile->stype;
+        break;
+    case(EXTRACT_ENVFILE):
+    case(CREATE_ENVFILE):
+        break;
+    case(PSEUDOSNDFILE):     /* Assumption of conversion from anal,formant,pitch or transpos filetype */
+    case(PITCH_TO_PSEUDOSND):     
+        dz->outfile->channels = 1;
+        dz->outfile->srate    = dz->infile->origrate;
+        dz->outfile->stype    = SAMP_SHORT;
+        break;
+    case(ANAL_TO_FORMANTS):
+        dz->outfile->specenvcnt= dz->infile->specenvcnt;
+        /* fall through */
+    case(ANAL_TO_PITCH):
+        dz->outfile->origchans = dz->infile->channels;
+        dz->outfile->channels  = 1;
+        dz->outfile->origstype = dz->infile->origstype;
+        dz->outfile->origrate  = dz->infile->origrate;
+        dz->outfile->arate     = dz->infile->arate;
+        dz->outfile->Mlen      = dz->infile->Mlen;
+        dz->outfile->Dfac      = dz->infile->Dfac;
+        dz->outfile->srate     = dz->infile->srate;
+        dz->outfile->stype     = dz->infile->stype;
+        break;
+    case(EQUAL_FORMANTS):
+        dz->outfile->specenvcnt = dz->infile->specenvcnt;
+        /* fall through */
+    case(PITCH_TO_PITCH):
+    case(PITCH_TO_BIGPITCH):
+        dz->outfile->origchans = dz->infile->origchans;
+        /* fall through */
+    case(EQUAL_ANALFILE):
+    case(MAX_ANALFILE):
+    case(MIN_ANALFILE):
+    case(BIG_ANALFILE):
+    case(PITCH_TO_ANAL):
+        dz->outfile->origstype = dz->infile->origstype;
+        dz->outfile->origrate  = dz->infile->origrate;
+        dz->outfile->arate     = dz->infile->arate;
+        dz->outfile->Mlen      = dz->infile->Mlen;
+        dz->outfile->Dfac      = dz->infile->Dfac;
+        dz->outfile->srate     = dz->infile->srate;
+        dz->outfile->stype     = dz->infile->stype;
+        if(dz->process_type==PITCH_TO_ANAL)
+            dz->outfile->channels = dz->infile->origchans;
+        else
+            dz->outfile->channels = dz->infile->channels;
+        break;
+    case(TO_TEXTFILE):
+    case(SCREEN_MESSAGE):
+        break;
+    default:
+        sprintf(errstr,"Unknown process: set_output_header_properties()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/***************************** WRITE_EXACT_SAMPS ******************************
+ *
+ * Writes a block of known length to file area of same length.
+ * Checks it has all been written.
+ */
+#ifdef NOTDEF
+int write_exact_bytes(char *buffer,int bytes_to_write,dataptr dz)
+{
+    int pseudo_bytes_to_write = bytes_to_write;
+    int secs_to_write = bytes_to_write/SECSIZE;
+    int bytes_written;
+    if((secs_to_write * SECSIZE)!=bytes_to_write) {
+        secs_to_write++;
+        pseudo_bytes_to_write = secs_to_write * SECSIZE;
+    }
+    if((bytes_written = sfwrite(dz->ofd, buffer, pseudo_bytes_to_write))<0) {
+        sprintf(errstr, "Can't write to output soundfile: (is hard-disk full?).\n");
+        return(SYSTEM_ERROR);
+    }
+    if(bytes_written != bytes_to_write) {
+        sprintf(errstr, "Incorrect number of bytes written\nbytes_written = %ld\n"
+                        "bytes_to_write = %ld\n (is hard-disk full?).\n",
+                        bytes_written,bytes_to_write);
+        return(SYSTEM_ERROR);
+    }
+    dz->total_bytes_written += bytes_to_write;
+    display_virtual_time(dz->total_bytes_written,dz);
+    return(FINISHED);
+}
+#else
+int write_exact_samps(float *buffer,int samps_to_write,dataptr dz)
+{
+    int i,j;
+    int samps_written;
+    float val;
+
+    if(dz->needpeaks){
+        for(i=0;i < samps_to_write; i += dz->outchans){
+            for(j = 0;j < dz->outchans;j++){
+                val = (float)fabs(buffer[i+j]);
+                /* this way, posiiton of first peak value is stored */
+                if(val > dz->outpeaks[j].value){
+                    dz->outpeaks[j].value = val;
+                    dz->outpeaks[j].position = dz->outpeakpos[j];
+                }
+            }
+            /* count framepos */
+            for(j=0;j < dz->outchans;j++)
+                dz->outpeakpos[j]++;
+        }
+    }
+    if((samps_written = fputfbufEx(buffer, samps_to_write,dz->ofd))<=0) {
+        sprintf(errstr, "Can't write to output soundfile: %s\n",sferrstr());
+        return(SYSTEM_ERROR);
+    }
+    if(samps_written != samps_to_write) {
+        sprintf(errstr, "Incorrect number of samples written\nsamps_written = %d\n"
+                        "samps_to_write = %d\n (is hard-disk full?).\n",
+                        samps_written,samps_to_write);
+        return(SYSTEM_ERROR);
+    }
+    dz->total_samps_written += samps_to_write;
+    display_virtual_time(dz->total_samps_written,dz);
+    return(FINISHED);
+}
+
+#endif
+
+
+#ifdef NOTDEF
+/*************************** WRITE_SAMPS ***********************/
+
+int write_bytes(char *bbuf,int bytes_to_write,dataptr dz)
+{
+    int pseudo_bytes_to_write = bytes_to_write;
+    int secs_to_write = bytes_to_write/SECSIZE;
+    int bytes_written;
+    if((secs_to_write * SECSIZE)!=bytes_to_write) {
+        secs_to_write++;
+        pseudo_bytes_to_write = secs_to_write * SECSIZE;
+    }
+    if((bytes_written = sfwrite(dz->ofd,bbuf,pseudo_bytes_to_write))<0) {
+        sprintf(errstr,"Can't write to output soundfile: (is hard-disk full?).\n");
+        return(SYSTEM_ERROR);
+    }
+    dz->total_bytes_written += bytes_to_write;
+    dz->total_samps_written  = dz->total_bytes_written/sizeof(short);  /* IRRELEVANT TO SPEC */
+    display_virtual_time(dz->total_bytes_written,dz);
+    return(FINISHED);
+
+}
+#else
+int write_samps(float *bbuf,int samps_to_write,dataptr dz)
+{
+    
+    int samps_written;
+    int i,j;
+    float val;
+
+    if(dz->needpeaks){
+        for(i=0;i < samps_to_write; i += dz->outchans){
+            for(j = 0;j < dz->outchans;j++){
+                val = (float)fabs(bbuf[i+j]);
+                /* this way, posiiton of first peak value is stored */
+                if(val > dz->outpeaks[j].value){
+                    dz->outpeaks[j].value = val;
+                    dz->outpeaks[j].position = dz->outpeakpos[j];
+                }
+            }
+            /* count framepos */
+            for(j=0;j < dz->outchans;j++)
+                dz->outpeakpos[j]++;
+        }
+    }
+    if((samps_written = fputfbufEx(bbuf,samps_to_write,dz->ofd))<=0) {
+        sprintf(errstr,"Can't write to output soundfile: %s\n",sferrstr());
+        return(SYSTEM_ERROR);
+    }
+    dz->total_samps_written += samps_written;   
+    display_virtual_time(dz->total_samps_written,dz);
+    return(FINISHED);
+}
+
+
+#endif
+/*************************** WRITE_SAMPS_NO_REPORT ***********************/
+#ifdef NOTDEF
+int write_bytes_no_report(char *bbuf,int bytes_to_write,dataptr dz)
+{
+    int pseudo_bytes_to_write = bytes_to_write;
+    int secs_to_write = bytes_to_write/SECSIZE;
+    int bytes_written;
+    if((secs_to_write * SECSIZE)!=bytes_to_write) {
+        secs_to_write++;
+        pseudo_bytes_to_write = secs_to_write * SECSIZE;
+    }
+    if((bytes_written = sfwrite(dz->ofd,bbuf,pseudo_bytes_to_write))<0) {
+        sprintf(errstr,"Can't write to output soundfile: (is hard-disk full?).\n");
+        return(SYSTEM_ERROR);
+    }
+    dz->total_bytes_written += bytes_to_write;
+    dz->total_samps_written  = dz->total_bytes_written/sizeof(short);  /* IRRELEVANT TO SPEC */
+    return(FINISHED);
+}
+#else
+int write_samps_no_report(float *bbuf,int samps_to_write,int *samps_written,dataptr dz)
+{
+    
+    int i;
+    int j;
+    float val;
+    if(dz->needpeaks){
+        for(i=0;i < samps_to_write; i += dz->outchans){
+            for(j = 0;j < dz->outchans;j++){
+                val = (float)fabs(bbuf[i+j]);
+                /* this way, posiiton of first peak value is stored */
+                if(val > dz->outpeaks[j].value){
+                    dz->outpeaks[j].value = val;
+                    dz->outpeaks[j].position = dz->outpeakpos[j];
+                }
+            }
+            /* count framepos */
+            for(j=0;j < dz->outchans;j++)
+                dz->outpeakpos[j]++;
+        }
+    }
+    if((*samps_written = fputfbufEx(bbuf,samps_to_write,dz->ofd))<=0) {
+        sprintf(errstr,"Can't write to output soundfile: %s\n",sferrstr());
+        return(SYSTEM_ERROR);
+    }
+    dz->total_samps_written += samps_to_write;
+    
+    return(FINISHED);
+}
+
+
+#endif
+/*********************** DISPLAY_VIRTUAL_TIME *********************/
+
+void display_virtual_time(int samps_sent,dataptr dz)
+{
+    int mins;
+    double  secs = 0.0;
+    int startwindow, endwindow, windows_to_write, total_samps_to_write = 0, maxlen, minlen, offset;
+    unsigned int zargo = 0;
+    int n, display_time;
+    double float_time = 0.0;
+    if(sloombatch)
+        return;
+    if(!sloom) {
+        if(dz->process==HOUSE_COPY && dz->mode==COPYSF)
+            secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels);
+        else {
+            switch(dz->outfiletype) {
+            case(NO_OUTPUTFILE):
+                if(dz->process==MIXMAX)
+                    secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels);
+                else
+                    return;
+            case(SNDFILE_OUT):
+                secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels);
+                break;
+            case(ANALFILE_OUT):
+                secs = (double)(samps_sent/dz->wanted) * dz->frametime;
+                break;
+            case(PITCH_OUT):                       
+            case(TRANSPOS_OUT):
+                secs = (double)(samps_sent) * dz->frametime;
+                break;
+            case(FORMANTS_OUT):
+                secs = (double)((samps_sent - dz->descriptor_samps)/dz->infile->specenvcnt) * dz->frametime;
+                break;
+            case(ENVFILE_OUT):
+                secs = (double)(samps_sent) * dz->outfile->window_size * MS_TO_SECS;
+                break;
+            case(TEXTFILE_OUT):
+                switch(dz->process) {
+                case(INFO_PRNTSND):
+                    secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels);
+                    break;
+                }   
+                break;
+    
+            }
+        }
+        mins = (int)(secs/60.0);    /* TRUNCATE */
+        secs -= (double)(mins * 60);
+        fprintf(stdout,"\r%d min %5.2lf sec", mins, secs);
+        fflush(stdout);
+
+    } else {
+        switch(dz->process_type) {
+        case(EQUAL_ANALFILE):
+            float_time   = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+            break;
+        case(MAX_ANALFILE):
+            switch(dz->process) {
+                case(MAX):  /* file 0 is forced to be largest by program */
+                    float_time = (double)samps_sent/(double)dz->insams[0];
+                    break;
+            default:
+                maxlen = dz->insams[0];
+                for(n=1;n<dz->infilecnt;n++)
+                    maxlen = max(maxlen,dz->insams[n]);
+                float_time = (double)samps_sent/(double)maxlen;
+                break;
+            }
+            break;
+        case(MIN_ANALFILE):
+            minlen = dz->insams[0];
+            for(n=1;n<dz->infilecnt;n++)
+                minlen = min(minlen,dz->insams[n]);
+            float_time = (double)samps_sent/(double)minlen;
+            break;
+        case(BIG_ANALFILE):
+            switch(dz->process) {
+            case(CUT):
+                startwindow = (int)(dz->param[CUT_STIME]/dz->frametime);
+                endwindow   = (int)(dz->param[CUT_ETIME]/dz->frametime);
+                endwindow   = min(endwindow,dz->wlength);
+                windows_to_write = endwindow - startwindow;
+                total_samps_to_write = windows_to_write * dz->wanted;
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(GRAB):
+                total_samps_to_write = dz->wanted;
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(MAGNIFY):
+                windows_to_write = dz->total_windows + 1;
+                total_samps_to_write = windows_to_write * dz->wanted;
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(TSTRETCH): case(SHUFFLE): case(WEAVE): case(WARP): case(FORM):     
+                float_time = (double)dz->total_samps_read/(double)dz->insams[0];
+                break;
+            case(DRUNK):        
+                total_samps_to_write = round((dz->param[DRNK_DUR]/dz->frametime) * dz->wanted);
+                float_time = min((double)samps_sent/(double)total_samps_to_write,1.0);
+                break;
+            case(GLIDE):        
+//TW            total_samps_to_write = dz->wlength * dz->sampswanted;
+                total_samps_to_write = dz->wlength * dz->wanted;
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(BRIDGE):       
+                offset = round(dz->param[BRG_OFFSET]/dz->frametime) * dz->wanted;
+                switch(dz->iparam[BRG_TAILIS]) {
+                case(0):
+                case(1):    total_samps_to_write = dz->insams[0];                               break;
+                case(2):    total_samps_to_write = offset + dz->insams[1];                      break;
+                case(3):    total_samps_to_write = min(dz->insams[0],offset + dz->insams[1]);   break;
+                }
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(MORPH):        
+                total_samps_to_write = (dz->iparam[MPH_STAGW] * dz->wanted) + dz->insams[1];
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(SYNTH_SPEC):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            case(CLICK):
+                if(samps_sent < 0)
+                    samps_sent = INT_MAX;
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            default:
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            }
+            break;
+        case(ANAL_TO_FORMANTS):
+            float_time = (double)dz->total_samps_read/(double)dz->insams[0];
+            break;
+        case(PSEUDOSNDFILE):
+            switch(dz->process) {
+            case(FMNTSEE):
+            case(FORMSEE):
+            case(LEVEL):
+                float_time = (double)dz->total_samps_read/(double)dz->insams[0];
+                break;
+            }
+            break;
+        case(PITCH_TO_ANAL):
+            switch(dz->process) {
+            case(MAKE):
+//TW NEW CASE
+            case(MAKE2):
+                /* windows_to_write = dz->wlength, in this case based on specenvcnt-len formant-windows */
+                total_samps_to_write = dz->wlength * (dz->infile->origchans);
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+//TW NEW CASES ADDED, therefore
+//          case(P_HEAR):
+            default:
+                /* windows_to_write = dz->insams[0] as each pitch is converted to a window */
+                total_samps_to_write = dz->insams[0] * dz->wanted;
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            }
+            break;
+        case(PITCH_TO_PSEUDOSND):
+            total_samps_to_write = dz->insams[0];
+            float_time = (double)samps_sent/(double)total_samps_to_write;
+            break;
+        case(UNEQUAL_SNDFILE):
+            switch(dz->process) {
+            case(DISTORT_AVG):  case(DISTORT_MLT):  case(DISTORT_DIV):  case(DISTORT_HRM):  case(DISTORT_FRC):
+            case(DISTORT_REV):  case(DISTORT_SHUF): case(DISTORT_RPT):  case(DISTORT_INTP): case(DISTORT_DEL):
+            case(DISTORT_RPL):  case(DISTORT_TEL):  case(DISTORT_FLT):  case(DISTORT_PCH):  
+//TW NEW CASE
+            case(DISTORT_OVERLOAD): case(DISTORT_RPT2):
+            case(GRAIN_OMIT):       case(GRAIN_DUPLICATE):  case(GRAIN_REORDER):    case(GRAIN_REPITCH):
+            case(GRAIN_RERHYTHM):   case(GRAIN_REMOTIF):    case(GRAIN_TIMEWARP):
+            case(GRAIN_POSITION):   case(GRAIN_ALIGN):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+//TW NEW CASE
+            case(DISTORT_PULSED):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            case(GRAIN_REVERSE):
+                float_time = (double)dz->total_samps_written/(double)dz->insams[0];
+                break;
+            case(TOPNTAIL_CLICKS):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->tempsize);
+                break;
+            case(DISTORT_INT):  
+                total_samps_to_write = (dz->insams[0] + dz->insams[1]) >> 1;/* averaged,as is bytes_read !! */
+                float_time = min(1.0,(double)dz->total_samps_read/(double)total_samps_to_write);
+                break;
+            case(HF_PERM1): case(HF_PERM2):
+                zargo = superzargo + samps_sent;
+                float_time = min(1.0,(double)zargo/(double)dz->tempsize);
+                break;
+            case(SCRAMBLE):
+                total_samps_to_write = dz->iparam[SCRAMBLE_OUTLEN];
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(DRUNKWALK):
+                total_samps_to_write = dz->iparam[DRNK_TOTALDUR];
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(SIMPLE_TEX):   case(TIMED):    case(GROUPS):    case(TGROUPS):     case(DECORATED):  case(PREDECOR):   
+            case(POSTDECOR):    case(ORNATE):   case(PREORNATE): case(POSTORNATE):  case(MOTIFS):     case(TMOTIFS):    
+            case(MOTIFSIN):     case(TMOTIFSIN):
+                total_samps_to_write = round(dz->param[TEXTURE_DUR] * dz->infile->srate) * STEREO;
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(TEX_MCHAN):
+                total_samps_to_write = round(dz->param[TEXTURE_DUR] * dz->infile->srate) * dz->iparam[TEXTURE_OUTCHANS];
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(ENV_CURTAILING):
+                total_samps_to_write = 
+                round(dz->param[ENV_ENDTIME] * dz->infile->srate) * dz->infile->channels;
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(ENV_IMPOSE):   /* In these cases the 'bytes_sent' may be bytes_written or bytes_read */
+            case(ENV_REPLACE):  
+//TW NEW CASE
+            case(ENV_PROPOR):   
+                float_time = (double)samps_sent/(double)dz->insams[0];
+                break;
+            case(ENV_PLUCK):    
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+            case(EQ):           case(LPHP):     case(FSTATVAR):     case(FLTBANKN):
+//TW UPDATE
+            case(FLTBANKU):     case(FLTSWEEP):     case(ALLPASS):
+                total_samps_to_write = dz->insams[0] + 
+                (round(FLT_TAIL * (double)dz->infile->srate) * dz->infile->channels);
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(FLTBANKV):
+                total_samps_to_write = dz->insams[0] + 
+                (round(dz->param[FILT_TAILV] * (double)dz->infile->srate) * dz->infile->channels);
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(FLTITER):
+                total_samps_to_write = dz->iparam[FLT_OUTDUR];
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(MIXCROSS):
+                float_time = min(1.0,(double)samps_sent/(double)(dz->iparam[MCR_STAGGER] + dz->insams[1]));
+                break;
+            case(MIXINTERL):
+                total_samps_to_write = dz->insams[0];
+                for(n=0;n<dz->infilecnt;n++)
+                    total_samps_to_write = max(total_samps_to_write,dz->insams[n]);
+                total_samps_to_write *= dz->infilecnt;
+                float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write);
+                break;
+            case(MIX):
+            case(MIXMULTI):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+//TW NEW CASES
+            case(HOUSE_BAKUP):
+            case(SEQUENCER):
+            case(SEQUENCER2):
+            case(RRRR_EXTEND):
+            case(CONVOLVE):
+            case(BAKTOBAK):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+
+            case(MOD_PITCH):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+            case(MOD_REVECHO):
+                if(dz->mode==MOD_STADIUM)
+                    float_time = min(1.0,(double)samps_sent/(double)(dz->insams[0] * 2));
+                else 
+                    float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+                break;
+            case(MOD_SPACE):
+                if(dz->mode==MOD_PAN)
+                    float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                else
+                    float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+                break;
+//TW NEW CASE
+            case(SCALED_PAN):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+            case(MOD_RADICAL):
+                switch(dz->mode) {
+                case(MOD_SCRUB):
+                    float_time = min(1.0,(double)dz->total_samps_written/(double)dz->iparam[SCRUB_TOTALDUR]);
+                    break;
+                case(MOD_CROSSMOD):
+                    float_time = (double)samps_sent/(double)dz->tempsize;
+                    break;
+                default:
+                    float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+                    break;
+                }
+                break;
+            case(PVOC_SYNTH):
+            case(EDIT_CUT):         case(EDIT_CUTEND):      case(EDIT_ZCUT):        case(EDIT_EXCISE):  
+            case(EDIT_EXCISEMANY):  case(EDIT_INSERT):      case(EDIT_INSERTSIL):   case(EDIT_JOIN):    
+            case(HOUSE_CHANS):      case(HOUSE_ZCHANNEL):   case(STOM):             case(MTOS):
+            case(ZIGZAG):           case(LOOP):             case(ITERATE): /*  case(HOUSE_BAKUP): */
+            case(DEL_PERM):         case(DEL_PERM2):        case(MIXTWO):           case(MIXBALANCE):
+            case(HOUSE_SPEC):       case(SYNTH_SPEC):       case(JOIN_SEQ):         case(JOIN_SEQDYN):
+            case(ACC_STREAM):       case(ITERATE_EXTEND):
+
+            case(STACK):
+            case(SYNTH_WAVE):
+            case(SYNTH_NOISE):
+            case(SYNTH_SIL):
+            case(MULTI_SYN):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            case(DOUBLETS):
+                if(samps_sent < 0)
+                    samps_sent = INT_MAX;
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            case(AUTOMIX):          case(MIXMANY):          case(EDIT_INSERT2):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            case(BRASSAGE):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+            case(TWIXT):
+            case(SPHINX):
+                float_time = min(1.0,(double)superzargo/(double)dz->tempsize);
+                break;
+            case(EDIT_CUTMANY):
+            case(MANY_ZCUTS):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            case(GREV):
+                float_time = min(1.0,(double)dz->total_samps_written/(double)dz->tempsize);
+                break;
+            default:
+                float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+                break;
+            }
+            break;
+        case(EQUAL_SNDFILE):
+            switch(dz->process) {
+            case(HOUSE_CHANS):
+//TW NEW CASE
+            case(TIME_GRID):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+//TW NEW CASE
+            case(SHUDDER):
+                float_time = min(1.0,(double)dz->total_samps_written/(double)dz->tempsize);
+                break;
+            case(MOD_RADICAL):
+                if(dz->mode == MOD_SHRED) { /* based on number of shreds completed */
+                    /*RWD NB: SHRED_CNT was in bytes --- make sure it is now in samps */
+                    float_time = min(1.0,(double)samps_sent/(double)dz->iparam[SHRED_CNT]);
+                }
+                /* fall thro */
+            default:
+                float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+                break;
+            }
+            break;
+        case(EXTRACT_ENVFILE):  /* In these cases the 'bytes_sent' is bytes_read */
+            float_time = (double)samps_sent/(double)dz->insams[0];
+            break;
+        case(OTHER_PROCESS):
+            switch(dz->process) {
+            case(HOUSE_EXTRACT):
+            case(HOUSE_GATE):
+                float_time = (double)samps_sent/(double)dz->insams[0];
+                break;
+            case(MIXINBETWEEN):
+            case(CYCINBETWEEN):
+                total_samps_to_write = max(dz->insams[0],dz->insams[1]);
+                float_time = (double)samps_sent/(double)total_samps_to_write;
+                break;
+            case(HOUSE_COPY):
+                switch(dz->mode) {
+                case(COPYSF):
+                    float_time = (double)samps_sent/(double)dz->insams[0];
+                    break;
+                case(DUPL):
+                    superzargo += samps_sent;
+                    float_time = min(1.0,(double)superzargo/(double)dz->tempsize);
+                    break;
+                }
+                break;
+    /* NEW */
+            case(INFO_DIFF):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+            }
+            break;
+        case(TO_TEXTFILE):
+            switch(dz->process) {
+            case(INFO_PRNTSND):
+                zargo = (dz->iparam[PRNT_END] - dz->iparam[PRNT_START]);
+                float_time = min(1.0,(double)samps_sent/(double)zargo);
+                break;
+            case(HOUSE_EXTRACT):
+                float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]);
+                break;
+            case(GRAIN_GET):
+                float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]);
+                break;
+            }   
+            break;
+        case(SCREEN_MESSAGE):
+            switch(dz->process) {
+            case(MIXMAX):
+            case(FIND_PANPOS):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            }   
+            break;
+        case(CREATE_ENVFILE):
+            switch(dz->process) {
+            case(ENVSYN):
+                float_time = min(1.0,(double)samps_sent/(double)dz->tempsize);
+                break;
+            }
+        }
+        display_time = round(float_time * PBAR_LENGTH);
+        fprintf(stdout,"TIME: %d\n",display_time);
+        fflush(stdout);
+    }
+}
+
+/***************************** PRINT_SCREEN_MESSAGE **************************/
+
+int print_screen_message(void)
+{
+    if(!sloom && !sloombatch)           /*TW May 2001 */
+        fprintf(stdout,"%s",errstr);
+    else
+        splice_multiline_string(errstr,"INFO:");
+    fflush(stdout);
+    return(FINISHED);
+}
+
+/***************************** WRITE_SAMPS_TO_ELSEWHERE ******************************
+ *
+ * Allows bytes to be written to files other than standard outfile.
+ * No byte-count checking.
+ */
+#ifdef NOTDEF
+int write_bytes_to_elsewhere(int ofd, char *buffer,int bytes_to_write,dataptr dz)
+{
+    int pseudo_bytes_to_write = bytes_to_write;
+    int secs_to_write = bytes_to_write/SECSIZE;
+    int bytes_written;
+    if((secs_to_write * SECSIZE)!=bytes_to_write) {
+        secs_to_write++;
+        pseudo_bytes_to_write = secs_to_write * SECSIZE;
+    }
+    if((bytes_written = sfwrite(ofd, (char *)buffer, pseudo_bytes_to_write))<0) {
+        sprintf(errstr, "Can't write to output soundfile:  (is hard-disk full?).\n");
+        return(SYSTEM_ERROR);
+    }
+    dz->total_bytes_written += bytes_to_write;
+    return(FINISHED);
+}
+#else
+int write_samps_to_elsewhere(int ofd, float *buffer,int samps_to_write,dataptr dz)
+{
+    int i,j;
+    int samps_written;
+    if(dz->needotherpeaks){
+        for(i=0;i < samps_to_write; i += dz->otheroutchans){
+            for(j = 0;j < dz->otheroutchans;j++){
+                /* this way, posiiton of first peak value is stored */
+                if(buffer[i+j] > dz->outpeaks[j].value){
+                    dz->otherpeaks[j].value = buffer[i+j];
+                    dz->otherpeaks[j].position = dz->otherpeakpos[j];
+                }
+            }
+            /* count framepos */
+            for(j=0;j < dz->otheroutchans;j++)
+                dz->otherpeakpos[j]++;
+        }
+    }
+    
+    if((samps_written = fputfbufEx(buffer, samps_to_write,ofd))<=0) {
+        sprintf(errstr, "Can't write to output soundfile:  %s\n",sferrstr());
+        return(SYSTEM_ERROR);
+    }
+    dz->total_samps_written += samps_to_write;
+    return(FINISHED);
+}
+
+
+
+
+#endif
+/****************************** WRITE_BRKFILE *************************/
+
+int write_brkfile(FILE *fptext,int brklen,int array_no,dataptr dz)
+{
+    int n;
+    double *p = dz->parray[array_no];
+    for(n=0;n<brklen;n++) {
+        fprintf(fptext,"%lf \t%lf\n",*p,*(p+1));
+        p += 2;
+    }
+    return(FINISHED);
+}
+
+/***************** CONVERT_PCH_OR_TRANSPOS_DATA_TO_BRKPNTTABLE ***********************/
+
+#define TONE_CENT   (.01)   /* SEMITONES */
+
+int convert_pch_or_transpos_data_to_brkpnttable(int *brksize,float *floatbuf,float frametime,int array_no,dataptr dz)
+{
+    int exit_status;
+    double *q;
+    float *p = floatbuf;
+    float *endptab = floatbuf + dz->wlength;
+    int n, bsize;
+    double sharpness = TONE_CENT;   /* sharpness in semitones */
+
+    if(dz->wlength<2) {
+        sprintf(errstr,"Not enough pitchdata to convert to brktable.\n");
+        return(DATA_ERROR);
+    }
+    q = dz->parray[array_no];
+    n = 0;
+    *q++ = 0.0;
+    *q++ = (double)*p++;
+    *q++ = frametime;
+    *q++ = (double)*p++;
+    n = 2;
+    while(endptab-p > 0) {
+        *q++ = (double)n * frametime;
+        *q++ = (double)*p++;
+        n++;
+    }
+    bsize = q - dz->parray[array_no];
+
+    if((exit_status = incremental_pt_datareduction(array_no,&bsize,sharpness,dz))<0)
+        return(exit_status);
+    n = bsize;
+
+    if((dz->parray[array_no] = (double *)realloc((char *)dz->parray[array_no],n*sizeof(double)))==NULL) {
+        sprintf(errstr,"convert_pch_or_transpos_data_to_brkpnttable()\n");
+        return(MEMORY_ERROR);
+    }
+    *brksize = n/2;
+    return(FINISHED);
+}
+    
+/***************************** PT_DATAREDUCE **********************
+ *
+ * Reduce data on passing from pitch or transposition to brkpnt representation.
+ *
+ * Note, these are identical, becuase the root-pitch from which pitch-vals are measured
+ * cancels out in the maths (and doesn't of course occur in the transposition calc).
+ *
+ * Take last 3 points, and if middle point has (approx) same value as
+ * a point derived by interpolating between first and last points, then
+ * ommit midpoint from brkpnt representation.
+ */
+
+int pt_datareduce(double **q,double sharp,double flat,double *thisarray,int *bsize)
+{
+    double interval;
+    double *arrayend;
+    double *p = (*q)-6, *midpair = (*q)-4, *endpair = (*q)-2;
+    double startime = *p++;
+    double startval = LOG2(*p++);                               /* pitch = LOG(p/root) = LOG(p) - LOG(root) */
+    double midtime  = *p++;
+    double midval   = LOG2(*p++);                               /* pitch = LOG(p/root) = LOG(p) - LOG(root) */
+    double endtime  = *p++;
+    double endval   = LOG2(*p);
+    double valrange     = endval-startval;                      /* LOG(root) cancels out */
+    double midtimeratio = (midtime-startime)/(endtime-startime);
+    double guessval     = (valrange * midtimeratio) + startval;  /*  -LOG(root) reintroduced */
+
+    if((interval = (guessval - midval) * SEMITONES_PER_OCTAVE) < sharp && interval > flat) { /* but cancels again */
+        arrayend = thisarray + *bsize;
+        while(endpair < arrayend)
+            *midpair++ = *endpair++;
+        (*q) -= 2;
+        *bsize -= 2;
+    }
+    return(FINISHED);
+}
+
+/***************************** INCREMENTAL_PT_DATAREDUCTION ******************************/
+
+int incremental_pt_datareduction(int array_no,int *bsize,double sharp,dataptr dz)
+{
+    int exit_status;
+    double flat;
+    double *q;
+    double sharp_semitones = LOG2(dz->is_sharp) * SEMITONES_PER_OCTAVE; 
+    double *thisarray = dz->parray[array_no];
+    while(*bsize >= 6 && sharp < sharp_semitones) { 
+        flat = -sharp;
+        q = thisarray + 4;
+        while(q < thisarray + (*bsize) - 1) {
+            q +=2;
+            if((exit_status = pt_datareduce(&q,sharp,flat,thisarray,bsize))<0)
+                return(exit_status);
+        }
+        sharp *= 2.0;               /* interval-size doubles */
+    }
+    if(*bsize >= 6) { 
+        sharp = sharp_semitones;
+        flat = -sharp;
+        q = thisarray + 4;
+        while(q < thisarray + (*bsize) - 1) {
+            q +=2;
+            if((exit_status = pt_datareduce(&q,sharp,flat,thisarray,bsize))<0)
+                return(exit_status);
+        }
+    }
+    return(FINISHED);
+}
+
+/****************************** 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++;
+    }
+}