initial commit

dev/blur/CMakeLists.txt

@@ -0,0 +1,18 @@
+if(APPLE)
+  set(CMAKE_C_FLAGS "-O2 -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 -Dlinux -Dunix")
+  endif()
+endif()
+
+link_directories(../cdp2k ../sfsys)
+
+include_directories(../../include)
+
+add_executable(blur main.c ap_blur.c blur.c)
+
+target_link_libraries(blur cdp2k sfsys ${EXTRA_LIBRARIES})
+my_install(blur)

dev/blur/Makefiled.osx

@@ -0,0 +1,36 @@
+#
+#	OSX debug makefile (with PVOCEX support)  for blur � Richard Dobson, CDP Ltd 2014,2022
+#
+#
+CC=cc
+OPT = -g
+CFLAGS= $(OPT) -Wall -mmacosx-version-min=10.8 -Dunix -I ../newinclude -I ../include
+LIBDIR = ../../lib
+LIBS = -lsfsysd -lcdp2kd -lpvxio2d
+
+PROG=blur
+BINS= main.o ap_blur.o blur.o
+.c.o:
+	$(CC) $(CFLAGS) -c $<
+#
+#	targets
+#
+all:	$(PROG)
+
+$(PROG):	$(BINS)
+	$(CC) $(CFLAGS) $(BINS) -o $(PROG) -L$(LIBDIR) $(LIBS)
+
+clean:
+	rm -f $(PROG)
+
+veryclean:	clean
+	rm -f *.o
+
+install:	$(PROG)
+	cp $(PROG) ../Release
+#
+#	dependencies
+#
+
+
+

dev/blur/ap_blur.c

@@ -0,0 +1,1066 @@
+/*
+ * 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 <cdpmain.h>
+#include <tkglobals.h>
+#include <pnames.h>
+#include <blur.h>
+#include <processno.h>
+#include <modeno.h>
+#include <globcon.h>
+#include <logic.h>
+#include <filetype.h>
+#include <mixxcon.h>
+#include <flags.h>
+#include <speccon.h>
+#include <arrays.h>
+#include <special.h>
+#include <formants.h>
+#include <sfsys.h>
+#include <osbind.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <srates.h>
+
+/********************************************************************************************/
+/********************************** FORMERLY IN buffers.c ***********************************/
+/********************************************************************************************/
+
+static int      allocate_weave_buffer(dataptr dz);
+
+/********************************************************************************************/
+/********************************** FORMERLY IN pconsistency.c ******************************/
+/********************************************************************************************/
+
+static int      check_consistency_of_scat_params(dataptr dz);
+
+/********************************************************************************************/
+/********************************** FORMERLY IN preprocess.c ********************************/
+/********************************************************************************************/
+
+#define RSIZE           (4)             /* Number of windowfulls of rand numbers in CHORU */
+static int  avrg_preprocess(dataptr dz);
+static int  chor_preprocess(dataptr dz);
+static int  set_chorus_processing_type(dataptr dz);
+static int  setup_randtables_for_rapid_rand_processing(dataptr dz);
+static int  drnk_preprocess(dataptr dz);
+static int  scat_preprocess(dataptr dz);
+static int  convert_params_for_scat(dataptr dz);
+static int  setup_internal_arrays_and_preset_internal_variables_for_scat(dataptr dz);
+
+/********************************************************************************************/
+/********************************** FORMERLY IN specialin.c *********************************/
+/********************************************************************************************/
+
+//static int  read_specshuffle_data(char *str,dataptr dz);
+static int  read_specweave_data(char *filename,dataptr dz);
+static int  check_for_viable_weave(int *maxbaktrak,dataptr dz);
+static int  read_numeric_value_from_weavefile_text(char **str,int n,dataptr dz);
+
+/***************************************************************************************/
+/****************************** FORMERLY IN aplinit.c **********************************/
+/***************************************************************************************/
+
+/***************************** ESTABLISH_BUFPTRS_AND_EXTRA_BUFFERS **************************/
+
+int establish_bufptrs_and_extra_buffers(dataptr dz)
+{
+    //int is_spec = FALSE;
+    dz->extra_bufcnt = -1;  /* ENSURE EVERY CASE HAS A PAIR OF ENTRIES !! */
+    dz->bptrcnt = 0;
+    dz->bufcnt  = 0;
+    switch(dz->process) {
+    case(AVRG):                     dz->extra_bufcnt =  0; dz->bptrcnt = 1;         /*is_spec = TRUE;*/             break;
+    case(BLUR):                     dz->extra_bufcnt =  0; dz->bptrcnt = 4;         /*is_spec = TRUE;*/             break;
+    case(SUPR):                     dz->extra_bufcnt =  0; dz->bptrcnt = 1;         /*is_spec = TRUE;*/             break;
+    case(CHORUS):                   dz->extra_bufcnt =  1; dz->bptrcnt = 1;         /*is_spec = TRUE;*/             break;
+    case(DRUNK):                    dz->extra_bufcnt =  0; dz->bptrcnt = 4;         /*is_spec = TRUE;*/             break;
+    case(SHUFFLE):                  dz->extra_bufcnt =  0; dz->bptrcnt = 5;         /*is_spec = TRUE;*/             break;
+    case(WEAVE):                    dz->extra_bufcnt =  0; dz->bptrcnt = 5;         /*is_spec = TRUE;*/             break;
+    case(NOISE):                    dz->extra_bufcnt =  0; dz->bptrcnt = 1;         /*is_spec = TRUE;*/             break;
+    case(SCAT):                     dz->extra_bufcnt =  0; dz->bptrcnt = 1;         /*is_spec = TRUE;*/             break;
+    case(SPREAD):                   dz->extra_bufcnt =  0; dz->bptrcnt = 1;         /*is_spec = TRUE;*/             break;
+    default:
+        sprintf(errstr,"Unknown program type [%d] in establish_bufptrs_and_extra_buffers()\n",dz->process);
+        return(PROGRAM_ERROR);
+    }
+
+    if(dz->extra_bufcnt < 0) {
+        sprintf(errstr,"bufcnts have not been set: establish_bufptrs_and_extra_buffers()\n");
+        return(PROGRAM_ERROR);
+    }
+    return establish_spec_bufptrs_and_extra_buffers(dz);
+}
+
+/***************************** SETUP_INTERNAL_ARRAYS_AND_ARRAY_POINTERS **************************/
+
+int setup_internal_arrays_and_array_pointers(dataptr dz)
+{
+    int n;
+    dz->ptr_cnt    = -1;            /* base constructor...process */
+    dz->array_cnt  = -1;
+    dz->iarray_cnt = -1;
+    dz->larray_cnt = -1;
+    switch(dz->process) {
+    case(AVRG):     dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(BLUR):     dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(SUPR):     dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(CHORUS):   dz->array_cnt =2;  dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(DRUNK):    dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(SHUFFLE):  dz->array_cnt = 0; dz->iarray_cnt =1;  dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(WEAVE):    dz->array_cnt = 0; dz->iarray_cnt =1;  dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(NOISE):    dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(SCAT):     dz->array_cnt = 0; dz->iarray_cnt =1;  dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    case(SPREAD):   dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;   break;
+    }
+
+    /*** WARNING ***
+         ANY APPLICATION DEALING WITH A NUMLIST INPUT: MUST establish AT LEAST 1 double array: i.e. dz->array_cnt = at least 1
+         **** WARNING ***/
+
+
+    if(dz->array_cnt < 0 || dz->iarray_cnt < 0 || dz->larray_cnt < 0 || dz->ptr_cnt < 0 || dz->fptr_cnt < 0) {
+        sprintf(errstr,"array_cnt not set in setup_internal_arrays_and_array_pointers()\n");
+        return(PROGRAM_ERROR);
+    }
+
+    if(dz->array_cnt > 0) {
+        if((dz->parray  = (double **)malloc(dz->array_cnt * sizeof(double *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for internal double arrays.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<dz->array_cnt;n++)
+            dz->parray[n] = NULL;
+    }
+    if(dz->iarray_cnt > 0) {
+        if((dz->iparray = (int     **)malloc(dz->iarray_cnt * sizeof(int *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for internal int arrays.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<dz->iarray_cnt;n++)
+            dz->iparray[n] = NULL;
+    }
+    if(dz->larray_cnt > 0) {
+        if((dz->lparray = (int    **)malloc(dz->larray_cnt * sizeof(int *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for internal int arrays.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<dz->larray_cnt;n++)
+            dz->lparray[n] = NULL;
+    }
+    if(dz->ptr_cnt > 0)   {
+        if((dz->ptr     = (double  **)malloc(dz->ptr_cnt  * sizeof(double *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for internal pointer arrays.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<dz->ptr_cnt;n++)
+            dz->ptr[n] = NULL;
+    }
+    if(dz->fptr_cnt > 0)   {
+        if((dz->fptr = (float  **)malloc(dz->fptr_cnt * sizeof(float *)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for internal float-pointer arrays.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<dz->fptr_cnt;n++)
+            dz->fptr[n] = NULL;
+    }
+    return(FINISHED);
+}
+
+/****************************** ASSIGN_PROCESS_LOGIC *********************************/
+
+int assign_process_logic(dataptr dz)
+{
+    switch(dz->process) {
+    case(AVRG):                     setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    case(BLUR):                     setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    case(SUPR):                     setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    case(CHORUS):           setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    case(DRUNK):            setup_process_logic(ANALFILE_ONLY,                      BIG_ANALFILE,           ANALFILE_OUT,   dz);    break;
+    case(SHUFFLE):          setup_process_logic(ANALFILE_ONLY,                      BIG_ANALFILE,           ANALFILE_OUT,   dz);    break;
+    case(WEAVE):            setup_process_logic(ANALFILE_ONLY,                      BIG_ANALFILE,           ANALFILE_OUT,   dz);    break;
+    case(NOISE):            setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    case(SCAT):                     setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    case(SPREAD):           setup_process_logic(ANALFILE_ONLY,                      EQUAL_ANALFILE,         ANALFILE_OUT,   dz);    break;
+    default:
+        sprintf(errstr,"Unknown process: assign_process_logic()\n");
+        return(PROGRAM_ERROR);
+        break;
+    }
+    if(dz->has_otherfile) {
+        switch(dz->input_data_type) {
+        case(ALL_FILES):
+        case(TWO_SNDFILES):
+        case(SNDFILE_AND_ENVFILE):
+        case(SNDFILE_AND_BRKFILE):
+        case(SNDFILE_AND_UNRANGED_BRKFILE):
+        case(SNDFILE_AND_DB_BRKFILE):
+            break;
+        case(MANY_SNDFILES):
+            if(dz->process==INFO_TIMELIST)
+                break;
+            /* fall thro */
+        default:
+            sprintf(errstr,"Most processes accepting files with different properties\n"
+                    "can only take 2 sound infiles.\n");
+            return(PROGRAM_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/***************************** SET_LEGAL_INFILE_STRUCTURE **************************
+ *
+ * Allows 2nd infile to have different props to first infile.
+ */
+
+void set_legal_infile_structure(dataptr dz)
+{
+    switch(dz->process) {
+    default:
+        dz->has_otherfile = FALSE;
+        break;
+    }
+}
+
+/***************************************************************************************/
+/****************************** FORMERLY IN internal.c *********************************/
+/***************************************************************************************/
+
+/****************************** SET_LEGAL_INTERNALPARAM_STRUCTURE *********************************/
+
+int set_legal_internalparam_structure(int process,int mode,aplptr ap)
+{
+    int exit_status = FINISHED;
+    switch(process) {
+    case(AVRG):                     exit_status = set_internalparam_data("i",ap);                                   break;
+    case(BLUR):                     return(FINISHED);
+    case(SUPR):                     return(FINISHED);
+    case(CHORUS):           exit_status = set_internalparam_data("ii",ap);                                  break;
+    case(DRUNK):            exit_status = set_internalparam_data("i",ap);                                   break;
+    case(SHUFFLE):          exit_status = set_internalparam_data("iiiiii",ap);                              break;
+    case(WEAVE):            exit_status = set_internalparam_data("i",ap);                                   break;
+    case(NOISE):            return(FINISHED);
+    case(SCAT):                     exit_status = set_internalparam_data("ii",ap);                                  break;
+    case(SPREAD):           return(FINISHED);
+    default:
+        sprintf(errstr,"Unknown process in set_legal_internalparam_structure()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(exit_status);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN specialin.c *********************************/
+/********************************************************************************************/
+
+/********************** READ_SPECIAL_DATA ************************/
+
+int read_special_data(char *str,dataptr dz)
+{
+    aplptr ap = dz->application;
+
+    switch(ap->special_data) {
+    case(SHUFFLE_DATA):             return read_shuffle_data(SHUF_DMNCNT,SHUF_IMGCNT,SHUF_MAP,str,dz);
+    case(WEAVE_DATA):                       return read_specweave_data(str,dz);
+    default:
+        sprintf(errstr,"Unknown special_data type: read_special_data()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);       /* NOTREACHED */
+}
+
+/***************************** READ_SPECWEAVE_DATA ****************************/
+
+int read_specweave_data(char *filename,dataptr dz)
+{
+    int exit_status;
+    FILE *fp;
+    char temp[200], *p;
+    int arraysize = BIGARRAY, cnt = 0;
+    if((dz->iparray[WEAVE_WEAV] = (int *)malloc(arraysize * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for weave array.\n");
+        return(MEMORY_ERROR);
+    }
+    if((fp = fopen(filename,"r"))==NULL) {
+        sprintf(errstr,"Cannot open weave file '%s'\n",filename);
+        return(DATA_ERROR);
+    }
+    while(fgets(temp,200,fp)!=NULL) {
+        p = temp;
+        while((exit_status = read_numeric_value_from_weavefile_text(&p,cnt,dz))==CONTINUE) {
+            if(++cnt>=arraysize) {
+                arraysize += BIGARRAY;
+                if((dz->iparray[WEAVE_WEAV] =
+                    (int *)realloc((char *)dz->iparray[WEAVE_WEAV],arraysize * sizeof(int)))==NULL) {
+                    sprintf(errstr,"INSUFFICIENT MEMORY to reallocate weave array.");
+                    return(MEMORY_ERROR);
+                }
+            }
+        }
+        if(exit_status<0)
+            return(exit_status);
+    }
+    if(cnt==0) {
+        sprintf(errstr,"No data in weave file.\n");
+        return(DATA_ERROR);
+    }
+    if((dz->iparray[WEAVE_WEAV] = (int *)realloc((char *)dz->iparray[WEAVE_WEAV],cnt * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY to reallocate weave array.\n");
+        return(MEMORY_ERROR);
+    }
+    dz->itemcnt = cnt;
+    return check_for_viable_weave(&(dz->iparam[WEAVE_BAKTRAK]),dz);
+}
+
+/****************************** CHECK_FOR_VIABLE_WEAVE **************************/
+
+int check_for_viable_weave(int *maxbaktrak,dataptr dz)
+{
+    int n, m;
+    int weavhere   = 0;
+    int pos_relative_to_this_start;
+    int maxbaktrak_from_this_start;
+    *maxbaktrak = 0;
+    for(n=0; n<dz->itemcnt; n++) {
+        if((weavhere += dz->iparray[WEAVE_WEAV][n]) < 0) {
+            sprintf(errstr,"You cannot weave to before weave-start.\n");
+            return(DATA_ERROR);
+        }
+    }
+    if(weavhere <= 0) {
+        sprintf(errstr,"Weave must progress aint file.\n");
+        return(DATA_ERROR);
+    }
+    for(n=1; n<dz->itemcnt; n++) {
+        pos_relative_to_this_start = 0;
+        maxbaktrak_from_this_start = 0;
+        for(m=n; m<dz->itemcnt; m++) {
+            if((pos_relative_to_this_start += dz->iparray[WEAVE_WEAV][n]) < 0)
+                maxbaktrak_from_this_start = min(pos_relative_to_this_start,maxbaktrak_from_this_start);
+        }
+        *maxbaktrak = min(*maxbaktrak,maxbaktrak_from_this_start);
+    }
+    fprintf(stdout,"INFO: Output duration approx %.2lf times that of input.\n",
+            (double)dz->itemcnt/(double)weavhere);
+    fflush(stdout);
+    *maxbaktrak = -(*maxbaktrak);
+    return(FINISHED);
+}
+
+/************************** READ_NUMERIC_VALUE_FROM_WEAVEFILE_TEXT **************************
+ *
+ * takes a pointer TO A POINTER to a string. If it succeeds in finding
+ * a char it returns the char value (*val), and it's new position in the
+ * string (*str).
+ */
+
+int read_numeric_value_from_weavefile_text(char **str,int n,dataptr dz)
+{       char *p, *q, *digitstart, *end;
+    int numero;
+    p = *str;
+    while(isspace(*p))
+        p++;
+    q = p;
+    if(*p=='\0')
+        return(FINISHED);
+    if(!isdigit(*p) && *p!='-') {
+        sprintf(errstr,"Invalid character ('%c') in weave file.\n",*p);
+        return(DATA_ERROR);
+    }
+    if(*p == '-')
+        p++;
+    digitstart = p;
+    while(isdigit(*p))
+        p++;
+    if(p - digitstart <= 0) {
+        sprintf(errstr,"Invalid character sequence in weave file.\n");
+        return(DATA_ERROR);
+    }
+    if(!isspace(*p) && *p!='\0') {
+        sprintf(errstr,"Invalid character in weave file.\n");
+        return(DATA_ERROR);
+    }
+    end = p;
+    if(sscanf(q,"%d",&numero)!=1) {
+        sprintf(errstr,"Failed to read value from weave file.\n");
+        return(DATA_ERROR);
+    }
+    if(numero > dz->application->max_special || numero < dz->application->min_special) {
+        sprintf(errstr,"Weave value %d out of range (%.0lf to %.0lf) for this file.\n",
+                n+1,dz->application->min_special,dz->application->max_special);
+        return(USER_ERROR);
+    }
+    dz->iparray[WEAVE_WEAV][n] = numero;
+    *str = end;
+    return(CONTINUE);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN preprocess.c ********************************/
+/********************************************************************************************/
+
+
+/****************************** PARAM_PREPROCESS *********************************/
+
+int param_preprocess(dataptr dz)
+{
+    switch(dz->process) {
+    case(AVRG):                 return avrg_preprocess(dz);
+    case(SUPR):                     return setup_ring(dz);
+    case(CHORUS):           return chor_preprocess(dz);
+    case(DRUNK):            return drnk_preprocess(dz);
+    case(SCAT):                     return scat_preprocess(dz);
+
+    case(BLUR):     case(SHUFFLE):  case(WEAVE):    case(NOISE):    case(SPREAD):
+        return(FINISHED);
+    default:
+        sprintf(errstr,"PROGRAMMING PROBLEM: Unknown process in param_preprocess()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);       /* NOTREACHED */
+}
+
+/************************** AVRG_PREPROCESS ******************************/
+
+int avrg_preprocess(dataptr dz)
+{
+    if(dz->brksize[AVRG_AVRG]==0) {
+        dz->iparam[AVRG_AVRGSPAN] = dz->iparam[AVRG_AVRG]/2;
+        dz->iparam[AVRG_AVRG]     = (dz->iparam[AVRG_AVRGSPAN] * 2) + 1;/* ALWAYS ODD */
+    }
+    return(FINISHED);
+}
+
+/************************** CHOR_PREPROCESS ******************************/
+
+int chor_preprocess(dataptr dz)
+{
+    int exit_status;
+    dz->iparam[CHORU_RTABSIZE] = dz->wanted * RSIZE;
+    if((exit_status = set_chorus_processing_type(dz))<0)
+        return(exit_status);
+    return setup_randtables_for_rapid_rand_processing(dz);
+}
+
+/*************************** SET_CHORUS_PROCESSING_TYPE *************************/
+
+int set_chorus_processing_type(dataptr dz)
+{
+    switch(dz->mode) {
+    case(CH_AMP):
+        if(dz->brksize[CHORU_AMPR]==0)   dz->iparam[CHORU_SPRTYPE] = A_FIX;
+        else                                                     dz->iparam[CHORU_SPRTYPE] = A_VAR;
+        break;
+    case(CH_FRQ):
+    case(CH_FRQ_UP):
+    case(CH_FRQ_DN):
+        if(dz->brksize[CHORU_FRQR]==0)   dz->iparam[CHORU_SPRTYPE] = F_FIX;
+        else                                                     dz->iparam[CHORU_SPRTYPE] = F_VAR;
+        break;
+    case(CH_AMP_FRQ):
+    case(CH_AMP_FRQ_UP):
+    case(CH_AMP_FRQ_DN):
+        if(dz->brksize[CHORU_AMPR]==0) {
+            if(dz->brksize[CHORU_FRQR]==0)  dz->iparam[CHORU_SPRTYPE] = AF_FIX;
+            else                                                    dz->iparam[CHORU_SPRTYPE] = A_FIX_F_VAR;
+        } else {
+            if(dz->brksize[CHORU_FRQR]==0)  dz->iparam[CHORU_SPRTYPE] = A_VAR_F_FIX;
+            else                                                    dz->iparam[CHORU_SPRTYPE] = AF_VAR;
+        }
+        break;
+    default:
+        sprintf(errstr,"Unknown program mode in set_chorus_processing_type()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/****************** SETUP_RANDTABLES_FOR_RAPID_RAND_PROCESSING ***************/
+
+int setup_randtables_for_rapid_rand_processing(dataptr dz)
+{
+    int n;
+    double z;
+    if(dz->iparam[CHORU_SPRTYPE] & IS_A) {
+        if((dz->parray[CHORU_RTABA] = (double *)malloc(dz->iparam[CHORU_RTABSIZE] * sizeof(double)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for chorusing amplitude random table.\n");
+            return(MEMORY_ERROR);
+        }
+        for(n=0;n<dz->iparam[CHORU_RTABSIZE];n++) {
+            z  = drand48() * 2.0;
+            dz->parray[CHORU_RTABA][n] = z - 1.0;
+        }
+        if(dz->iparam[CHORU_SPRTYPE] & A_FIX) {
+            for(n=0;n<dz->iparam[CHORU_RTABSIZE];n++)
+                dz->parray[CHORU_RTABA][n] = (double)pow(dz->param[CHORU_AMPR],dz->parray[CHORU_RTABA][n]);
+        }
+    }
+    if(dz->iparam[CHORU_SPRTYPE] & IS_F) {
+        if((dz->parray[CHORU_RTABF] = (double *)malloc(dz->iparam[CHORU_RTABSIZE] * sizeof(double)))==NULL) {
+            sprintf(errstr,"INSUFFICIENT MEMORY for chorusing frq random table.\n");
+            return(MEMORY_ERROR);
+        }
+        switch(dz->mode) {
+        case(CH_FRQ_DN):
+        case(CH_AMP_FRQ_DN): /* downwards only  */
+            for(n=0;n<dz->iparam[CHORU_RTABSIZE];n++) {
+                z  = drand48();
+                dz->parray[CHORU_RTABF][n] = z - 1.0;
+            }
+            break;
+        case(CH_FRQ_UP):
+        case(CH_AMP_FRQ_UP):    /* upwards only */
+            for(n=0;n<dz->iparam[CHORU_RTABSIZE];n++)
+                dz->parray[CHORU_RTABF][n]  = drand48();
+            break;
+        default: /* normal */
+            for(n=0;n<dz->iparam[CHORU_RTABSIZE];n++) {
+                z  = drand48() * 2.0;
+                dz->parray[CHORU_RTABF][n] = z - 1.0;
+            }
+            break;
+        }
+        if(dz->iparam[CHORU_SPRTYPE] & F_FIX) {
+            for(n=0;n<dz->iparam[CHORU_RTABSIZE];n++)
+                dz->parray[CHORU_RTABF][n] = pow(dz->param[CHORU_FRQR],dz->parray[CHORU_RTABF][n]);
+        }
+    }
+    return(FINISHED);
+}
+
+/************************** DRNK_PREPROCESS ******************************/
+
+int drnk_preprocess(dataptr dz)
+{
+    initrand48();
+    dz->iparam[DRNK_TWICERANGE] = (dz->iparam[DRNK_RANGE] * 2) + 1;
+    return(FINISHED);
+}
+
+/************************** SCAT_PREPROCESS ******************************/
+
+int scat_preprocess(dataptr dz)
+{
+    int exit_status;
+    if((exit_status = convert_params_for_scat(dz))<0)
+        return(exit_status);
+    return setup_internal_arrays_and_preset_internal_variables_for_scat(dz);
+}
+
+/************ CONVERT_PARAMS_FOR_SCAT *************
+ *
+ * convert frq width input to channel cnt, for bloksize
+ */
+
+int convert_params_for_scat(dataptr dz)
+{
+    double *p;
+    int n;
+    if(dz->brksize[SCAT_BLOKSIZE]==0)
+        dz->iparam[SCAT_BLOKSIZE] = round(dz->param[SCAT_BLOKSIZE]/dz->chwidth);
+    else {
+        p = dz->brk[SCAT_BLOKSIZE] + 1;
+        for(n=0;n < dz->brksize[SCAT_BLOKSIZE];n++) {
+            *p /= dz->chwidth;
+            p  += 2;
+        }       /* AND ensure bloksize is now ROUNDED TO INT when read from brktable */
+        dz->is_int[SCAT_BLOKSIZE] = 1;
+    }
+    return(FINISHED);
+}
+
+/************ SETUP_INTERNAL_ARRAYS_AND_PRESET_INTERNAL_VARIABLES_FOR_SCAT *********/
+
+int setup_internal_arrays_and_preset_internal_variables_for_scat(dataptr dz)
+{
+    if((dz->iparray[SCAT_KEEP]
+        = (int *)malloc((dz->clength+1) * sizeof(int)))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for scatter keep table.\n");
+        return(MEMORY_ERROR);
+    }
+    if(dz->brksize[SCAT_CNT]==0)
+        dz->iparam[SCAT_THISCNT] = dz->iparam[SCAT_CNT];
+    if(dz->brksize[SCAT_BLOKSIZE]==0) {
+        dz->iparam[SCAT_BLOKS_PER_WINDOW] = dz->clength/dz->iparam[SCAT_BLOKSIZE];
+        if((dz->iparam[SCAT_BLOKS_PER_WINDOW]*dz->iparam[SCAT_BLOKSIZE])!=dz->clength)
+            dz->iparam[SCAT_BLOKS_PER_WINDOW]++;
+    }
+    if(dz->brksize[SCAT_BLOKSIZE]==0 && dz->brksize[SCAT_CNT]==0
+       && dz->iparam[SCAT_CNT] >= dz->iparam[SCAT_BLOKS_PER_WINDOW]) {
+        sprintf(errstr,"Block count exceeds number of blocks per window.\n");
+        return(USER_ERROR);
+    }
+    return(FINISHED);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN procspec.c **********************************/
+/********************************************************************************************/
+
+/**************************** SPEC_PROCESS_FILE ****************************/
+
+int spec_process_file(dataptr dz)
+{
+    dz->total_windows = 0;
+
+    display_virtual_time(0L,dz);
+
+    switch(dz->process) {
+    case(AVRG):             return outer_loop(dz);
+    case(SUPR):             return outer_loop(dz);
+    case(CHORUS):   return outer_loop(dz);
+    case(NOISE):    return outer_loop(dz);
+    case(SCAT):             return outer_loop(dz);
+    case(SPREAD):   return outer_loop(dz);
+
+    case(BLUR):             return spec_blur_and_bltr(dz);
+    case(DRUNK):    return specdrunk(dz);
+    case(SHUFFLE):  return specshuffle(dz);
+    case(WEAVE):    return specweave(dz);
+    default:
+        sprintf(errstr,"Unknown process in procspec()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);       /* NOTREACHED */
+}
+
+/**************************** INNER_LOOP ****************************/
+
+int inner_loop
+(int *peakscore,int *descnt,int *in_start_portion,int *least,int *pitchcnt,int windows_in_buf,dataptr dz)
+{
+    int exit_status;
+    int local_zero_set = FALSE;
+    int wc;
+
+    for(wc=0; wc<windows_in_buf; wc++) {
+        if(dz->total_windows==0) {
+            if((exit_status = skip_or_special_operation_on_window_zero(dz))<0)
+                return(exit_status);
+            if(exit_status==TRUE) {
+                dz->flbufptr[0] += dz->wanted;
+                dz->total_windows++;
+                dz->time = (float)(dz->time + dz->frametime);
+                continue;
+            }
+        }
+        if((exit_status = read_values_from_all_existing_brktables((double)dz->time,dz))<0)
+            return(exit_status);
+
+        switch(dz->process) {
+        case(AVRG):             exit_status = specavrg(dz);                                                     break;
+        case(CHORUS):   exit_status = specchorus(dz);                                           break;
+        case(NOISE):    exit_status = specnoise(dz);                                            break;
+        case(SCAT):             exit_status = specscat(dz);                                             break;
+        case(SPREAD):   exit_status = specspread(dz);                                           break;
+        case(SUPR):             exit_status = specsupr(dz);                                                     break;
+        default:
+            sprintf(errstr,"unknown process in inner_loop()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(exit_status<0)
+            return(exit_status);
+        dz->flbufptr[0] += dz->wanted;
+        dz->total_windows++;
+        dz->time = (float)(dz->time + dz->frametime);
+    }
+    if(!dz->zeroset && local_zero_set==TRUE) {
+        fprintf(stdout,"WARNING: Zero-amp spectral window(s) encountered: orig window(s) substituted.\n");
+        fflush(stdout);
+        dz->zeroset = TRUE;
+    }
+    return(FINISHED);
+}
+
+/***************** SKIP_OR_SPECIAL_OPERATION_ON_WINDOW_ZERO ************/
+
+int skip_or_special_operation_on_window_zero(dataptr dz)
+{
+    switch(dz->process) {
+    case(AVRG):
+    case(SPREAD):
+        return(TRUE);
+    }
+    return(FALSE);
+}
+
+/*********************************** SPEC_BLUR_AND_BLTR ***********************************/
+
+int spec_blur_and_bltr(dataptr dz)
+{
+    int exit_status;
+    int     blurcnt = 0, blurfactor = 0, samps_read, got, w_to_buf, wc;
+    int     last_total_windows = 0;
+    float   *ampdif, *freqdif;
+    dz->time = 0.0f;
+    if((exit_status = float_array(&ampdif,dz->clength))<0)
+        return(exit_status);
+    if((exit_status = float_array(&freqdif,dz->clength))<0)
+        return(exit_status);
+    dz->flbufptr[1] = dz->flbufptr[2];
+    if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)
+        return exit_status;
+
+    while((samps_read = dz->ssampsread) > 0) {
+        got                = samps_read;
+        dz->flbufptr[0] = dz->bigfbuf;
+        w_to_buf       = got/dz->wanted;
+        for(wc=0; wc<w_to_buf; wc++) {
+            if(blurcnt==0) {
+                if(dz->total_windows > 0) {
+                    if((exit_status = do_the_bltr(&last_total_windows,ampdif,freqdif,blurfactor,dz))<0)
+                        return(exit_status);
+                }
+                if(dz->brksize[BLUR_BLURF]) {
+                    if((exit_status = read_value_from_brktable((double)dz->time,BLUR_BLURF,dz))<0)
+                        return(exit_status);
+                }
+                blurfactor = dz->iparam[BLUR_BLURF];
+                if(dz->total_windows + blurfactor >= dz->wlength)         /* number of windows to skip */
+                    blurfactor = dz->wlength - dz->total_windows - 1; /* must not exceed total no of windows */
+
+                blurcnt = blurfactor;
+
+                /* SEPARATE THE AMP AND FREQ DATA IN (NEXT) INITIAL WINDOW */
+                if((exit_status = get_amp_and_frq(dz->flbufptr[0],dz))<0)
+                    return(exit_status);
+            }
+            blurcnt--;
+            dz->flbufptr[0] += dz->wanted;
+            dz->total_windows++;
+            dz->time = (float)(dz->time + dz->frametime);
+        }
+        if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)
+            return exit_status;
+    }
+    if((exit_status = put_amp_and_frq(dz->flbufptr[1],dz))<0) /* transfer last window to output buffer */
+        return(exit_status);
+    dz->flbufptr[1] += dz->wanted;
+    return write_exact_samps(dz->flbufptr[2],(dz->flbufptr[1] - dz->flbufptr[2]),dz);
+}
+
+/****************************** DO_THE_BLTR ***************************/
+
+int do_the_bltr(int *last_total_windows,float *ampdif,float *freqdif,int blurfactor,dataptr dz)
+{
+    int exit_status = FINISHED;
+    int thiswindow, j;
+    int cc, vc;
+    for( cc = 0 ,vc = 0; cc < dz->clength; cc++, vc += 2){
+        ampdif[cc]   = dz->flbufptr[0][AMPP] - dz->amp[cc];
+        ampdif[cc]  /= (float)blurfactor;
+        freqdif[cc]  = dz->flbufptr[0][FREQ] - dz->freq[cc];
+        freqdif[cc] /= (float)blurfactor;
+    }
+    for(thiswindow = *last_total_windows,j=0;thiswindow<dz->total_windows;thiswindow++,j++) {
+        for(cc = 0, vc = 0; cc < dz->clength; cc++, vc += 2){  /* BLUR amp AND freq */
+            dz->flbufptr[1][AMPP] = dz->amp[cc]  + ((float)j * ampdif[cc]);
+            dz->flbufptr[1][FREQ] = dz->freq[cc] + ((float)j * freqdif[cc]);
+        }
+        dz->flbufptr[1] += dz->wanted;
+        if(dz->flbufptr[1] >= dz->flbufptr[3]) {
+            if((exit_status = write_exact_samps(dz->flbufptr[2],dz->buflen,dz))<0)
+                return(exit_status);
+            dz->flbufptr[1] = dz->flbufptr[2];
+        }
+    }
+
+    *last_total_windows = dz->total_windows;
+    return(FINISHED);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN pconsistency.c ******************************/
+/********************************************************************************************/
+
+/****************************** CHECK_PARAM_VALIDITY_AND_CONSISTENCY *********************************/
+
+int check_param_validity_and_consistency(dataptr dz)
+{
+    handle_pitch_zeros(dz);
+    switch(dz->process) {
+    case(SCAT):                return check_consistency_of_scat_params(dz);
+    }
+    return(FINISHED);
+}
+
+/************ CHECK_CONSISTENCY_OF_SCAT_PARAMS *************/
+
+int check_consistency_of_scat_params(dataptr dz)
+{
+    int bloksize, bpw;
+    if(dz->brksize[SCAT_BLOKSIZE]==0 && dz->brksize[SCAT_CNT]==0) {
+        bloksize = round(dz->param[SCAT_BLOKSIZE]/dz->chwidth);
+        bpw = dz->clength/bloksize;
+        if((bpw * bloksize)!=dz->clength)
+            bpw++;
+        if(dz->iparam[SCAT_CNT] >= bpw) {
+            sprintf(errstr,"No. of blocks to keep exceeds number of blocks per window.\n");
+            return(USER_ERROR);
+        }
+    }
+    return(FINISHED);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN buffers.c ***********************************/
+/********************************************************************************************/
+
+/**************************** ALLOCATE_LARGE_BUFFERS ******************************/
+
+int allocate_large_buffers(dataptr dz)
+{
+    switch(dz->process) {
+    case(AVRG):             case(SUPR):             case(CHORUS):
+    case(NOISE):    case(SCAT):             case(SPREAD):
+        return allocate_single_buffer(dz);
+
+    case(BLUR):     case(DRUNK):    case(SHUFFLE):
+        return allocate_double_buffer(dz);
+
+    case(WEAVE):
+        return allocate_weave_buffer(dz);
+    default:
+        sprintf(errstr,"Unknown program no. in allocate_large_buffers()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);       /* NOTREACHED */
+}
+
+/*************************** ALLOCATE_WEAVE_BUFFER ****************************/
+
+int allocate_weave_buffer(dataptr dz)
+{
+    unsigned int buffersize;
+    if(dz->bptrcnt < 5) {
+        sprintf(errstr,"Insufficient bufptrs established in allocate_weave_buffer()\n");
+        return(PROGRAM_ERROR);
+    }
+    //TW CONVERTED FO FLT
+    buffersize = dz->wanted * BUF_MULTIPLIER;
+    dz->buflen = buffersize;
+    buffersize *= 2;
+    buffersize += (dz->iparam[WEAVE_BAKTRAK] * dz->wanted);
+    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->buflen;                                               /* BIGBUF is start of baktrak buf */
+    //TW ADDED
+    dz->flbufptr[0]   = dz->bigfbuf + (dz->iparam[WEAVE_BAKTRAK] * dz->wanted);             /* start of input buf */
+    dz->flbufptr[2] = dz->flbufptr[0] + dz->big_fsize;   /* start of outbuf (&& initially end of input buf) */
+    dz->flbufptr[3] = dz->flbufptr[2] + dz->big_fsize;                                                           /* end of output buf */
+    dz->flbufptr[4] = dz->flbufptr[2] - (dz->iparam[WEAVE_BAKTRAK] * dz->wanted);               /* wrap-around marker */
+    return(FINISHED);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN cmdline.c ***********************************/
+/********************************************************************************************/
+
+int get_process_no(char *prog_identifier_from_cmdline,dataptr dz)
+{
+    if     (!strcmp(prog_identifier_from_cmdline,"avrg"))                   dz->process = AVRG;
+    else if(!strcmp(prog_identifier_from_cmdline,"blur"))                   dz->process = BLUR;
+    else if(!strcmp(prog_identifier_from_cmdline,"suppress"))               dz->process = SUPR;
+    else if(!strcmp(prog_identifier_from_cmdline,"chorus"))                 dz->process = CHORUS;
+    else if(!strcmp(prog_identifier_from_cmdline,"drunk"))                  dz->process = DRUNK;
+    else if(!strcmp(prog_identifier_from_cmdline,"shuffle"))                dz->process = SHUFFLE;
+    else if(!strcmp(prog_identifier_from_cmdline,"weave"))                  dz->process = WEAVE;
+    else if(!strcmp(prog_identifier_from_cmdline,"noise"))                  dz->process = NOISE;
+    else if(!strcmp(prog_identifier_from_cmdline,"scatter"))                dz->process = SCAT;
+    else if(!strcmp(prog_identifier_from_cmdline,"spread"))                 dz->process = SPREAD;
+    else {
+        sprintf(errstr,"Unknown program identification string '%s'\n",prog_identifier_from_cmdline);
+        return(USAGE_ONLY);
+    }
+    //TW UPDATE
+    return(FINISHED);
+}
+
+/********************************************************************************************/
+/********************************** FORMERLY IN usage.c *************************************/
+/********************************************************************************************/
+
+/******************************** USAGE1 ********************************/
+
+int usage1(void)
+{
+    sprintf(errstr,
+            "\nBLURRING OPERATIONS ON A SPECTRAL FILE\n\n"
+            "USAGE: blur NAME (mode) infile outfile parameters: \n"
+            "\n"
+            "where NAME can be any one of\n"
+            "\n"
+            "avrg      blur      suppress    chorus      drunk\n"
+            "shuffle   weave     noise       scatter     spread\n\n"
+            "Type 'blur avrg' for more info on blur avrg..ETC.\n");
+    return(USAGE_ONLY);
+}
+
+int usage2(char *str)
+{
+    if(!strcmp(str,"avrg")) {
+        fprintf(stdout,
+                "blur avrg infile outfile N\n"
+                "\n"
+                "AVERAGE SPECTRAL ENERGY OVER N ADJACENT CHANNELS\n"
+                "\n"
+                "N must be ODD and <= half the -N param used in original analysis.\n"
+                "\n"
+                "N may vary over time.\n");
+    } else if(!strcmp(str,"blur")) {
+        fprintf(stdout,
+                "blur blur infile outfile blurring\n"
+                "\n"
+                "TIME-AVERAGE THE SPECTRUM\n"
+                "\n"
+                "blurring   is number of windows over which to average the spectrum.\n"
+                "\n"
+                "blurring may vary over time. \n");
+    } else if(!strcmp(str,"suppress")) {
+        fprintf(stdout,
+                "blur suppress infile outfile N\n"
+                "\n"
+                "SUPPRESS THE N LOUDEST PARTIALS (ON A WINDOW-BY-WINDOW BASIS)\n"
+                "\n"
+                "N   is number of spectral components to reject.\n"
+                "\n"
+                "N may vary over time.  \n");
+    } else if(!strcmp(str,"chorus")) {
+        fprintf(stdout,
+                "blur chorus 1   infile outfile aspread        \n"
+                "blur chorus 2-4 infile outfile         fspread\n"
+                "blur chorus 5-7 infile outfile aspread fspread\n"
+                "\n"
+                "CHORUSING BY RANDOMISING AMPLITUDES AND/OR FREQUENCIES OF PARTIALS\n"
+                "\n"
+                "MODES :-\n"
+                "1  Randomise partial amplitudes.\n"
+                "2  Randomise partial frequencies.\n"
+                "3  Randomise partial frequencies upwards only.\n"
+                "4  Randomise partial frequencies downwards only.\n"
+                "5  Randomise partial amplitudes AND frequencies.\n"
+                "6  Randomise partial amplitudes, and frequencies upwards only.\n"
+                "7  Randomise partial amplitudes, and frequencies downwards only.\n"
+                "\n"
+                "aspread   is maximum random scatter of partial-amps (Range 1-%.0lf)\n"
+                "fspread   is maximum random scatter of partial-frqs (Range 1-%.0lf)\n"
+                "\n"
+                "aspread and fspread may vary over time.\n",CHORU_MAXAMP,CHORU_MAXFRQ);
+    } else if(!strcmp(str,"drunk")) {
+        fprintf(stdout,
+                "blur drunk infile outfile range starttime duration [-z]\n\n"
+                "MODIFY SOUND BY DRUNKEN WALK ALONG ANALYSIS WINDOWS.\n\n"
+                "RANGE     is maximum step (in windows) for drunken walk.\n"
+                "STARTTIME is time (in secs) in file to begin walk.\n"
+                "DURATION  is required duration of outfile after resynthesis.\n"
+                "-z        eliminates zero steps (window-repeats) in the drunken walk.\n"
+                "\n");
+    } else if(!strcmp(str,"shuffle")) {
+        fprintf(stdout,
+                "blur shuffle infile outfile domain-image grpsize\n\n"
+                "SHUFFLE ORDER OF ANALYSIS WINDOWS IN FILE\n\n"
+                "domain-image is 2 strings of letters, separated by a '-'\n"
+                "The first string is the DOMAIN, and the 2nd, the IMAGE.\n\n"
+                "e.g. 'abc-abbabcc'\n\n"
+                "The DOMAIN letters represent a group of consecutive inputfile analysis_windows.\n\n"
+                "e.g. 'abcd'\n\n"
+                "The IMAGE is any permutation of, or selection from, these domain letters.\n"
+                "(domain letters may be omitted or repeated in the image string).\n\n"
+                "e.g. 'aaaaaaadaaa'\n\n"
+                "Inputfile windows are shuffled according to this same mapping.\n\n"
+                "grpsize Windows may be grouped in sets of GRPSIZE\n"
+                "        before being shuffled (as groups).\n"
+                "        In this case,each domain-letter represents a group of GRPSIZE windows.\n"
+                "\n");
+    } else if(!strcmp(str,"weave")) {
+        fprintf(stdout,
+                "blur weave infile outfile weavfile\n\n"
+                "MODIFY SOUND BY WEAVING AMONGST ANALYSIS WINDOWS.\n\n"
+                "WEAVFILE contains a list of integers which define successive steps (in windows)\n"
+                "through the input file. Steps may be forward or backwards.\n"
+                "The step sequence is repeated until end of infile is reached.\n\n"
+                "Weave must obey the following rules....\n\n"
+                "RULE 1:  NO step can exceed the length of the file, in windows, forwards or backwards.\n"
+                "RULE 2:  NO window reached in a weave can be BEFORE startwindow of the weave.\n"
+                "RULE 3:  FINAL window must be AFTER the weave startwindow.\n\n"
+                "Otherwise, weave may be forward or backward, or remain at same window.\n"
+                "\n");
+    } else if(!strcmp(str,"noise")) {
+        fprintf(stdout,
+                "blur noise infile outfile noise\n"
+                "\n"
+                "PUT NOISE IN THE SPECTRUM\n"
+                "\n"
+                "noise   Range 0 (no noise in spectrum) to 1 (spectrum saturated with noise).\n"
+                "\n"
+                "noise may vary over time.\n");
+    } else if(!strcmp(str,"scatter")) {
+        fprintf(stdout,
+                "blur scatter infile outfile keep [-bblocksize] [-r] [-n] \n"
+                "\n"
+                "RANDOMLY THIN OUT THE SPECTRUM\n"
+                "\n"
+                "keep      number of (randomly-chosen) blocks to keep, in each spectral window.\n"
+                "blocksize is freq range of each block (default is width of 1 analysis channel).\n"
+                "          (Rounded internally to a multiple of channel width).\n"
+                "-r        number of blocks actually selected is randomised between 1 & keep.\n"
+                "-n        Turn OFF normalisation of resulting sound.\n"
+                "\n"
+                "keep & blocksize may vary over time.\n");
+    } else if(!strcmp(str,"spread")) {
+        fprintf(stdout,
+                "blur spread infile outfile -fN|-pN [-i] [-sspread]\n"
+                "\n"
+                "SPREAD PEAKS OF SPECTRUM, INTRODUCING CONTROLLED NOISINESS\n"
+                "\n"
+                "-f   extract formant envelope linear frqwise,\n"
+                "     using 1 point for every N equally-spaced frequency-channels.\n"
+                "-p   extract formant envelope linear pitchwise,\n"
+                "     using N equally-spaced pitch-bands per octave.\n"
+                "-i   quicksearch for formants (less accurate).\n"
+                "\n"
+                "spread    degree of spreading of spectrum (Range 0-1 : Default 1).\n"
+                "\n"
+                "spread may vary over time.\n");
+    } else
+        fprintf(stdout,"Unknown option '%s'\n",str);
+    return(USAGE_ONLY);
+}
+
+/******************************** USAGE3 ********************************/
+
+int usage3(char *str1,char *str2)
+{
+    sprintf(errstr,"Insufficient parameters on command line.\n");
+    return(USAGE_ONLY);
+}

dev/blur/blur.c

@@ -0,0 +1,1391 @@
+/*
+ * Copyright (c) 1983-2013 Trevor Wishart and Composers Desktop Project Ltd
+ * http://www.trevorwishart.co.uk
+ * http://www.composersdesktop.com
+ *
+ This file is part of the CDP System.
+
+    The CDP System is free software; you can redistribute it
+    and/or modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    The CDP System is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with the CDP System; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+    02111-1307 USA
+ *
+ */
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <structures.h>
+#include <tkglobals.h>
+#include <globcon.h>
+#include <pnames.h>
+#include <modeno.h>
+#include <arrays.h>
+#include <flags.h>
+#include <blur.h>
+#include <cdpmain.h>
+#include <formants.h>
+#include <speccon.h>
+#include <sfsys.h>
+#include <osbind.h>
+#include <string.h>
+#include <blur.h>
+
+#define FIRST_ACCESS_OF_RANDTABLE_REACHES_END_FIRST   (1)
+#define SECOND_ACCESS_OF_RANDTABLE_REACHES_END_FIRST  (2)
+#define BOTH_ACCESSES_OF_RANDTABLE_REACH_END_TOGETHER (0)
+
+static int  randomly_select_blokstokeep_and_sort_in_ascending_order(dataptr dz);
+static int  delete_unwanted_bloks(dataptr dz);
+static int  insert(int k,int n,int *iarray,int permcnt);
+static int  shuflup(int n,int * iarray,int permcnt);
+static int  read_domain_samps(int *reached_end_of_file,int *ssampsread,int windows_wanted,dataptr dz);
+static int  copy_domain_to_domainbuf(int *reached_end_of_infile,int *ssampsread,int bufwlen,int permcnt,
+                                     int shuf_d_windows,float *dbufptr,float *dbufend,dataptr dz);
+static int  copywindows_from_domain_to_image(float *domainbuf,float * dbufend,dataptr dz);
+static int      get_randplace(int *randh,int *rande,dataptr dz);
+static int  get_other_randplace(int *order,int randh,int rande,int *randh2,int *rande2,dataptr dz);
+static int  chorusing(int cc,int cc2,int randend,int randend2,int order,dataptr dz);
+static int  do_afix_ffix(int *cc,int *cc2,int *vc,dataptr dz);
+static int  do_a(int cc,int vc,int randend,dataptr dz);
+static int  do_fvar(int cc,int vc,int randend,dataptr dz);
+static int  do_afix_f(int *cc,int *cc2,int *vc,dataptr dz);
+static int  do_a_ffix(int *cc,int *cc2,int *vc,dataptr dz);
+static int  do_a_f(int *cc,int *cc2,int *vc,dataptr dz);
+static int  do_afix(int cc,int vc,int randend, dataptr dz);
+static int  do_ffix(int cc,int vc,int randend,dataptr dz);
+static int  getnewfrq_choru(int cc,int vc,dataptr dz);
+static int  getnewfrq2_choru(int cc,int vc,dataptr dz);
+static int  get_sbufposition_corresponding_to_frq(int *channo,double frq,dataptr dz);
+static int  advance_to_starttime(float **inputbuf_end,int *samps_read,int *drnk_bufno,dataptr dz);
+static int  copy_window_to_outbuf(dataptr dz);
+static int  get_randstep(int *step,dataptr dz);
+static int  adjust_buffers(int *step,float **inputbuf_end,int *samps_read,int *drnk_bufno, dataptr dz);
+static int  flush_outbuf(dataptr dz);
+static int  invert_step_back_to_step_fwd_at_start_of_file(int *step,int reflect_off_end,dataptr dz);
+static int  place_sbufptr_in_bigbuf_range(int *bigbufs_baktrak,dataptr dz);
+static int  invert_step_back_to_step_fwd(int *step,float *orig_sbuf,int *samps_read,
+                                         float **inputbuf_end, int reflect_off_end,int drnk_bufno,dataptr dz);
+static int  baktrak_to_correct_bigbuf(int bigbufs_baktrak,int *samps_read,float **inputbuf_end,
+                                      int *drnk_bufno,dataptr dz);
+static int  invert_step_fwd_to_step_back_at_end_of_file(int *step,int reflect_off_start,int drnk_bufno,dataptr dz);
+static int  advance_to_correct_bigbuf(float **inputbuf_end,int *samps_read,int *drnk_bufno,dataptr dz);
+static int  invert_step_fwd_to_step_back(int *step,float *orig_sbuf,int *samps_read,
+                                         float **inputbuf_end,int reflect_off_start,int drnk_bufno,dataptr dz);
+static int  read_first_inbuf(dataptr dz);
+static int  wrap_samps(unsigned int wrapsamps,float **insbuf,dataptr dz);
+static int  copy_1st_window(dataptr dz);
+
+/********************************** SPECAVRG **********************************/
+
+int specavrg(dataptr dz)
+{
+    int exit_status;
+    int cc, vc, k=0, n, m, q;
+    if(dz->brksize[AVRG_AVRG]) {
+        dz->iparam[AVRG_AVRGSPAN] = dz->iparam[AVRG_AVRG]/2;
+        dz->iparam[AVRG_AVRG]     = (dz->iparam[AVRG_AVRGSPAN] * 2) + 1; /* always odd */
+    }
+    if(dz->iparam[AVRG_AVRGSPAN]>0) {
+        if((exit_status = get_amp(dz->flbufptr[0],dz))<0)
+            return(exit_status);
+        for(cc = 0, vc = 0; cc < dz->iparam[AVRG_AVRGSPAN]; cc++, vc+=2) {
+            dz->amp[cc] = 0.0f;
+            k = cc + dz->iparam[AVRG_AVRGSPAN] + 1;                         /* SMALL AVERAGE AT BOTTOM */
+            for(n = 0, m = 0; n < k; n++, m += 2)
+                dz->amp[cc] = (float)(dz->amp[cc] + dz->flbufptr[0][m]);
+            dz->amp[cc] = (float)(dz->amp[cc]/(double)(k));
+        }
+        q = dz->clength - dz->iparam[AVRG_AVRGSPAN];
+        m = dz->iparam[AVRG_AVRGSPAN] * 2;
+        for(cc = dz->iparam[AVRG_AVRGSPAN], vc = m; cc < q; cc++, vc += 2) {
+            dz->amp[cc] = 0.0f;                                                             /* TRUE AVERAGE */
+            for(n = vc - m;n <= vc + m; n += 2)
+                dz->amp[cc] = (float)(dz->amp[cc] + dz->flbufptr[0][n]);
+            dz->amp[cc] = (float)(dz->amp[cc]/(double)dz->iparam[AVRG_AVRG]);
+        }
+        for(cc = q, vc = k*q; cc < dz->clength; cc++, vc+=2) {
+            dz->amp[cc] = 0.0f;
+            k = cc - dz->iparam[AVRG_AVRGSPAN];                             /* SMALL AVERAGE AT TOP */
+            for(n = k, m = k*2; n < dz->clength; n++, m += 2)
+                dz->amp[cc] = (float)(dz->amp[cc] + dz->flbufptr[0][m]);
+            dz->amp[cc] = (float)(dz->amp[cc]/(double)(dz->clength-k));
+        }
+        if((exit_status = put_amp(dz->flbufptr[0],dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/************************** SPECSUPR *****************************/
+
+int specsupr(dataptr dz)
+{
+    int exit_status;
+    chvptr quietest, loudest;
+    int invtrindex, vc;
+    if(dz->iparam[SUPR_INDX]>(dz->clength/2)) {         /* IF MORE CHANS TO SUPPRESS THAN TO KEEP */
+        invtrindex = dz->clength - dz->iparam[SUPR_INDX];
+        if((exit_status = initialise_ring_vals(invtrindex,BIGAMP,dz))<0) /* PRESET RING VALS TO MAX */
+            return(exit_status);
+        for(vc = 0; vc < dz->wanted; vc += 2) {                 /* IF QUIETER THAN PREVIOUS CHANS, STORE */
+            if((exit_status = if_one_of_quietest_chans_store_in_ring(vc,dz))<0)
+                return(exit_status);
+            dz->flbufptr[0][vc] = 0.0f;                                     /* ZERO ALL CHANNELS AS WE GO */
+        }
+        quietest = dz->ringhead;
+        do {                                                                                    /* REINSERT AMP OF QUIETEST CHANS ONLY */
+            dz->flbufptr[0][quietest->loc] = quietest->val;
+        } while((quietest = quietest->next)!=dz->ringhead);
+    } else {                                                                                    /* IF MORE CHANS TO KEEP THAN TO SUPPRESS */
+        if((exit_status = initialise_ring_vals(dz->iparam[SUPR_INDX],-BIGAMP,dz))<0)
+            return(exit_status);                                            /* PRESET RING VALS TO MIN */
+        for(vc = 0; vc < dz->wanted; vc += 2) {
+            if((exit_status = if_one_of_loudest_chans_store_in_ring(vc,dz))<0)
+                return(exit_status);                                    /* IF LOUDER THAN PREVIOUS CHANS, STORE */
+        }
+        loudest = dz->ringhead;
+        do {
+            dz->flbufptr[0][loudest->loc] = 0.0f;           /* ZERO AMPLITUDE IN LOUDEST CHANNELS ONLY */
+        } while((loudest = loudest->next)!=dz->ringhead);
+    }
+    return(FINISHED);
+}
+
+/************************ SPECSCAT *****************************/
+
+int specscat(dataptr dz)
+{
+    int exit_status;
+    double pre_totalamp = 0.0, post_totalamp;
+    if(dz->brksize[SCAT_CNT])
+        dz->iparam[SCAT_THISCNT] = dz->iparam[SCAT_CNT];
+    if(dz->brksize[SCAT_BLOKSIZE]) {
+        dz->iparam[SCAT_BLOKS_PER_WINDOW] = dz->clength/dz->iparam[SCAT_BLOKSIZE];
+        if((dz->iparam[SCAT_BLOKS_PER_WINDOW]*dz->iparam[SCAT_BLOKSIZE])!=dz->clength)
+            dz->iparam[SCAT_BLOKS_PER_WINDOW]++;
+    }
+    if((dz->brksize[SCAT_CNT] || dz->brksize[SCAT_BLOKSIZE])
+       &&  dz->iparam[SCAT_CNT] >= dz->iparam[SCAT_BLOKS_PER_WINDOW]) {
+        sprintf(errstr,"Blokcnt exceeds number of blocks per window at %.4lf secs\n",
+                dz->time - dz->frametime);
+        return(USER_ERROR);
+    }
+
+    if(!dz->vflag[SCAT_NO_NORM]) {
+        if((exit_status = get_totalamp(&pre_totalamp,dz->flbufptr[0],dz->wanted))<0)
+            return(exit_status);
+    }
+    if(dz->vflag[SCAT_RANDCNT])
+        dz->iparam[SCAT_THISCNT] = (int)((drand48() * dz->iparam[SCAT_CNT]) + 1.0); /* TRUNCATE */
+    if((exit_status = randomly_select_blokstokeep_and_sort_in_ascending_order(dz))<0)
+        return(exit_status);
+    if((exit_status = delete_unwanted_bloks(dz))<0)
+        return(exit_status);
+    if(!dz->vflag[SCAT_NO_NORM]) {
+        if((exit_status = get_totalamp(&post_totalamp,dz->flbufptr[0],dz->wanted))<0)
+            return(exit_status);
+        if((exit_status = normalise(pre_totalamp,post_totalamp,dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/********** RANDOMLY_SELECT_BLOKSTOKEEP_AND_SORT_IN_ASCENDING_ORDER **********
+ *
+ * (1)  preset all SCAT_KEEP array vals to max.
+ * (2)  insert blokno between 0 and SCAT_BLOKS_PER_WINDOW in 1st position  in SCAT_KEEP array.
+ * (3)  insert blokno between 0 and SCAT_BLOKS_PER_WINDOW in next position in SCAT_KEEP array.
+ * (4)  ensure its a NEW value
+ * (5)  if it's not a new value, try again.
+ * (6)  order the existing new values
+ */
+
+int randomly_select_blokstokeep_and_sort_in_ascending_order(dataptr dz)
+{
+    int exit_status;
+    int n, m, k, keepcnt, bad_value, inserted;
+    for(n=0;n<dz->clength+1;n++)
+        dz->iparray[SCAT_KEEP][n] = dz->clength+1;                              /* 1 */
+    k = (int)(drand48() * dz->iparam[SCAT_BLOKS_PER_WINDOW]);/* TRUNC */
+    dz->iparray[SCAT_KEEP][0] = k;                                                      /* 2 */
+    keepcnt = 1;
+    for(n=1;n<dz->iparam[SCAT_THISCNT];n++) {
+        k = (int)(drand48() * dz->iparam[SCAT_BLOKS_PER_WINDOW]);/* TRUNC */    /* 3 */
+        bad_value = 0;
+        inserted  = 0;
+        for(m=0;m<keepcnt;m++) {                                                                /* 4 */
+            if(k==dz->iparray[SCAT_KEEP][m]) {
+                bad_value = 1;
+                break;
+            }
+        }                                                                                                               /* 5 */
+        if(bad_value) {
+            n--;
+            continue;
+        }
+        for(m=0;m<keepcnt;m++) {                                                                /* 6 */
+            if(k<dz->iparray[SCAT_KEEP][m]) {
+                if((exit_status = insert(k,m,dz->iparray[SCAT_KEEP],keepcnt))<0)
+                    return(exit_status);
+                inserted = 1;
+                break;
+            }
+        }
+        if(!inserted)
+            dz->iparray[SCAT_KEEP][keepcnt] = k;
+        keepcnt++;
+    }
+    if(keepcnt!=dz->iparam[SCAT_THISCNT]) {
+        sprintf(errstr,"Error in perm arithmetic.randomly_select_blokstokeep_and_sort_in_ascending_order()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/****************************** DELETE_UNWANTED_BLOKS *****************************/
+
+int delete_unwanted_bloks(dataptr dz)
+{
+    int this_blok = 0;              /* INDEX TO BLKS TO RETAIN */
+    int n, c_end, vc_end;
+    int cc = 0, vc;
+    for(n = 0; n < dz->iparam[SCAT_BLOKS_PER_WINDOW]; n++) {
+        if(n==dz->iparray[SCAT_KEEP][this_blok]) {                              /* If keeping it */
+            if((cc += dz->iparam[SCAT_BLOKSIZE]) >= dz->clength)/* Jump over it, and, if at window end, break */
+                break;
+            if(++this_blok >= dz->iparam[SCAT_THISCNT]) {           /* If at end of kept bloks */
+                vc = cc * 2;
+                while(vc < dz->wanted) {                                                /* zero any remaining chans */
+                    dz->flbufptr[0][AMPP] = 0.0F;
+                    vc += 2;
+                }
+                break;
+            }
+        } else {                                                                                                /* if NOT keeping it */
+            if((c_end = cc + dz->iparam[SCAT_BLOKSIZE]) >= dz->clength)
+                c_end = dz->clength;                                                    /* mark end of blok */
+            vc = cc * 2;
+            vc_end = c_end * 2;
+            while(vc < vc_end) {                                                            /* zero it */
+                dz->flbufptr[0][AMPP] = 0.0F;
+                vc += 2;
+            }
+            if(vc >= dz->wanted)                                                            /* If at window end, break */
+                break;
+        }
+    }
+    return(FINISHED);
+}
+
+/****************************** INSERT ***************************/
+
+int insert(int k,int n,int *iarray,int permcnt)
+{
+    int exit_status;
+    if((exit_status = shuflup(n,iarray,permcnt))<0)
+        return(exit_status);
+    iarray[n] = k;
+    return(FINISHED);
+}
+
+/****************************** SHUFLUP ***************************/
+
+int shuflup(int n,int * iarray,int permcnt)
+{
+    int z = permcnt;
+    while(z > n) {
+        iarray[z] = iarray[z-1];
+        z--;
+    }
+    return(FINISHED);
+}
+
+/**************************** SPECSPREAD ***************************/
+
+int specspread(dataptr dz)
+{
+    int exit_status;
+    int cc, vc;
+    double specenv_amp, ampdiff, pre_totalamp, post_totalamp;
+    rectify_window(dz->flbufptr[0],dz);
+    if((exit_status = extract_specenv(0,0,dz))<0)
+        return(exit_status);
+    if((exit_status = get_totalamp(&pre_totalamp,dz->flbufptr[0],dz->wanted))<0)
+        return(exit_status);
+    for( cc = 0 ,vc = 0; cc < dz->clength; cc++, vc += 2) {
+        if((exit_status = getspecenvamp(&specenv_amp,(double)dz->flbufptr[0][FREQ],0,dz))<0)
+            return(exit_status);
+        ampdiff              = specenv_amp - dz->flbufptr[0][AMPP];
+        dz->flbufptr[0][AMPP] = (float)(dz->flbufptr[0][AMPP] + (ampdiff * dz->param[SPREAD_SPRD]));
+    }
+    if((exit_status = get_totalamp(&post_totalamp,dz->flbufptr[0],dz->wanted))<0)
+        return(exit_status);
+    if((exit_status = normalise(pre_totalamp,post_totalamp,dz))<0)
+        return(exit_status);
+    return(FINISHED);
+}
+
+/******************************** SPECSHUFFLE *****************************/
+
+int specshuffle(dataptr dz)
+{
+    int   exit_status;
+    int  permcnt = 0, ssampsread;
+    int  shuf_d_windows = dz->iparam[SHUF_DMNCNT] * dz->iparam[SHUF_GRPSIZE];
+    int  bufwlen = dz->buflen/dz->wanted;
+    float *domainbuf, *dbufptr, *dbufend;
+    int   reached_end_of_infile = FALSE;
+    int  min_windows_to_get = min(shuf_d_windows+1,bufwlen);
+    dz->flbufptr[0] = dz->bigfbuf;
+    dz->flbufptr[1] = dz->flbufptr[2];
+    if(sloom)
+        dz->total_samps_read = 0;
+    if((domainbuf = (float *)malloc((size_t)(shuf_d_windows * (dz->wanted * sizeof(float)))))==NULL) {
+        sprintf(errstr,"INSUFFICIENT MEMORY for domain buffer.\n");
+        return(MEMORY_ERROR);
+    }
+    dbufptr = domainbuf;
+    dbufend = domainbuf + (shuf_d_windows * dz->wanted);
+
+    if((exit_status = read_domain_samps(&reached_end_of_infile,&ssampsread,min_windows_to_get,dz))<0)
+        return(exit_status);
+    if(exit_status == FINISHED) {
+        sprintf(errstr,"Insufficient data in soundfile to do this shuffle.\n");
+        return(GOAL_FAILED);
+    }
+
+    copy_1st_window(dz);
+    for(;;) {
+        dbufptr = domainbuf;
+        if((exit_status = copy_domain_to_domainbuf
+            (&reached_end_of_infile,&ssampsread,bufwlen,permcnt,shuf_d_windows,dbufptr,dbufend,dz))<0)
+            return(exit_status);
+        if(exit_status==FINISHED)
+            break;
+        copywindows_from_domain_to_image(domainbuf,dbufend,dz);
+        permcnt++;
+    }
+    if(dz->flbufptr[1] > dz->flbufptr[2])
+        return write_samps(dz->flbufptr[2],(dz->flbufptr[1] - dz->flbufptr[2]),dz);
+    return(FINISHED);
+
+}
+
+/********************** READ_DOMAIN_SAMPS *******************/
+
+int read_domain_samps(int *reached_end_of_file,int *ssampsread,int windows_wanted,dataptr dz)
+{
+    int exit_status;
+
+    if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)
+        return exit_status;
+    if(dz->ssampsread < windows_wanted * dz->wanted)
+        return(FINISHED);
+    *ssampsread = dz->ssampsread;
+    if(dz->ssampsread < dz->buflen)
+        *reached_end_of_file = TRUE;
+    return(CONTINUE);
+}
+
+/********************** COPY_DOMAIN_TO_DOMAINBUF *******************/
+
+int copy_domain_to_domainbuf
+(int *reached_end_of_infile,int *ssampsread,int bufwlen,int permcnt,int shuf_d_windows,
+ float *dbufptr,float *dbufend,dataptr dz)
+{
+    int exit_status;
+    int n, windows_needed;
+    float *data_end;
+    if(reached_end_of_infile)
+        data_end = dz->bigfbuf + *ssampsread;
+    else
+        data_end = dz->flbufptr[2];
+    for(n=0;n<shuf_d_windows;n++) {
+        if(dbufptr >= dbufend) {
+            sprintf(errstr,"Error in buffer arithmetic: specshuffle()\n");
+            return(PROGRAM_ERROR);
+        }
+        if(dz->flbufptr[0] >= data_end) {
+            if(!(*reached_end_of_infile)) {
+                windows_needed = min(shuf_d_windows-n,bufwlen);
+                if((exit_status = read_domain_samps(reached_end_of_infile,ssampsread,windows_needed,dz))<0)
+                    return(exit_status);
+                if(*reached_end_of_infile)
+                    data_end = dz->bigfbuf + *ssampsread;
+                dz->flbufptr[0] = dz->bigfbuf;
+            } else
+                exit_status = FINISHED;
+            if(exit_status==FINISHED) {
+                if(permcnt==0) {
+                    sprintf(errstr,"Insufficient data in soundfile to do this shuffle.\n");
+                    return(GOAL_FAILED);
+                }
+                return(FINISHED);
+            }
+        }
+        memmove((char *)dbufptr,(char *)dz->flbufptr[0],(size_t)(dz->wanted * sizeof(float)));
+        dbufptr        += dz->wanted;
+        dz->flbufptr[0] += dz->wanted;
+    }
+    return(CONTINUE);
+}
+
+/************************** COPYWINDOWS_FROM_DOMAIN_TO_IMAGE ********************************/
+
+int copywindows_from_domain_to_image(float *domainbuf,float * dbufend,dataptr dz)
+{
+    int exit_status;
+    int n, m;
+    float *srcptr;
+    for(n=0;n<dz->iparam[SHUF_IMGCNT];n++) {
+        srcptr  = domainbuf + (dz->iparray[SHUF_MAP][n] * dz->iparam[SHUF_GRPSIZE] * dz->wanted);
+        for(m=0;m < dz->iparam[SHUF_GRPSIZE]; m++) {
+            if(srcptr >= dbufend) {
+                sprintf(errstr,"Error in buffer arithmetic: copywindows_from_domain_to_image()\n");
+                return(PROGRAM_ERROR);
+            }
+            if(dz->flbufptr[1] >= dz->flbufptr[3]) {
+                if((exit_status = write_exact_samps(dz->flbufptr[2],dz->buflen,dz))<0)
+                    return(exit_status);
+                dz->flbufptr[1] = dz->flbufptr[2];
+            }
+            memmove((char *)dz->flbufptr[1],(char *)srcptr,(size_t)(dz->wanted * sizeof(float)));
+            srcptr         += dz->wanted;
+            dz->flbufptr[1] += dz->wanted;
+        }
+    }
+    return(FINISHED);
+}
+
+/************************* SPECCHORUS ***************************/
+
+int specchorus(dataptr dz)
+{
+    int exit_status;
+    //TW cc2 is never set for modes other than CH_AMP_FRQ, CH_AMP_FRQ_UP, CH_AMP_FRQ_DN
+    int cc, cc2 = 0, order = 0;
+    int randhere = 0, randhere2 = 0, randend = 0, randend2 = 0;
+    double pre_totalamp = 0.0, post_totalamp;
+    if((exit_status = get_randplace(&randhere,&randend,dz))<0)
+        return(exit_status);
+    cc = randhere;
+    if(dz->mode == CH_AMP_FRQ || dz->mode == CH_AMP_FRQ_UP || dz->mode == CH_AMP_FRQ_DN) {
+        if((exit_status = get_other_randplace(&order,randhere,randend,&randhere2,&randend2,dz))<0)
+            return(exit_status);
+        cc2 = randhere2;
+    }
+    if(dz->iparam[CHORU_SPRTYPE]!=F_VAR && dz->iparam[CHORU_SPRTYPE]!=F_FIX) {
+        if((exit_status = get_totalamp(&pre_totalamp,dz->flbufptr[0],dz->wanted))<0)
+            return(exit_status);
+    }
+    if((exit_status = chorusing(cc,cc2,randend,randend2,order,dz))<0)
+        return(exit_status);
+    if(dz->iparam[CHORU_SPRTYPE]!=F_VAR && dz->iparam[CHORU_SPRTYPE]!=F_FIX) {
+        if((exit_status = get_totalamp(&post_totalamp,dz->flbufptr[0],dz->wanted))<0)
+            return(exit_status);
+        if((exit_status = normalise(pre_totalamp,post_totalamp,dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/************************** GET_RANDPLACE *************************/
+
+int     get_randplace(int *randh,int *rande,dataptr dz)
+{
+    *randh = (int)(drand48() * dz->iparam[CHORU_RTABSIZE]);
+    if((*rande = *randh + dz->clength) >= dz->iparam[CHORU_RTABSIZE])
+        *rande = dz->iparam[CHORU_RTABSIZE];
+    return(FINISHED);
+}
+
+/************************** GET_OTHER_RANDPLACE **************************/
+
+int get_other_randplace(int *order,int randh,int rande,int *randh2,int *rande2,dataptr dz)
+{
+    int firstlen, firstlen2;
+    *randh2 = (int)(drand48() * dz->iparam[CHORU_RTABSIZE]);
+    if((*rande2 = *randh2 + dz->clength) > dz->iparam[CHORU_RTABSIZE])
+        *rande2 = dz->iparam[CHORU_RTABSIZE];
+    firstlen  = rande   - randh;
+    firstlen2 = *rande2 - *randh2;
+    if(firstlen<firstlen2)  /* 1 */
+        *order = FIRST_ACCESS_OF_RANDTABLE_REACHES_END_FIRST;
+    else if(firstlen2<firstlen)     /* 2 */
+        *order = SECOND_ACCESS_OF_RANDTABLE_REACHES_END_FIRST;
+    else
+        *order = BOTH_ACCESSES_OF_RANDTABLE_REACH_END_TOGETHER;                         /* 3 */
+    return(FINISHED);
+}
+
+/******************************* CHORUSING *****************************/
+
+int chorusing(int cc,int cc2,int randend,int randend2,int order,dataptr dz)
+{
+    int exit_status;
+    int vc;
+    switch(dz->iparam[CHORU_SPRTYPE]) {
+    case(A_FIX):
+        vc = 0;
+        if((exit_status = do_afix(cc,vc,randend,dz))<0)
+            return(exit_status);
+        break;
+    case(F_FIX):
+        vc = 1;
+        memset((char *)dz->windowbuf[0],0,(size_t)(dz->wanted * sizeof(float)));
+        if((exit_status = do_ffix(cc,vc,randend,dz))<0)
+            return(exit_status);
+        memmove((char *)dz->flbufptr[0],(char *)dz->windowbuf[0],(size_t)(dz->wanted * sizeof(float)));
+        break;
+    case(AF_FIX):
+        vc = 0;
+        memset((char *)dz->windowbuf[0],0,(size_t)(dz->wanted * sizeof(float)));
+        switch(order) {
+        case(BOTH_ACCESSES_OF_RANDTABLE_REACH_END_TOGETHER):
+            while(cc<randend) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(FIRST_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc<randend) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc  = 0;
+            while(cc2 < randend2) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(SECOND_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc2<randend2) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2  = 0;
+            while(cc < randend) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_afix_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        }
+        memmove((char *)dz->flbufptr[0],(char *)dz->windowbuf[0],(size_t)(dz->wanted * sizeof(float)));
+        break;
+    case(A_VAR):
+        vc = 0;
+        if((exit_status = do_a(cc,vc,randend,dz))<0)
+            return(exit_status);
+        break;
+    case(F_VAR):
+        vc = 1;
+        memset((char *)dz->windowbuf[0],0,(size_t)(dz->wanted * sizeof(float)));
+        if((exit_status = do_fvar(cc,vc,randend,dz))<0)
+            return(exit_status);
+        memmove((char *)dz->flbufptr[0],(char *)dz->windowbuf[0],(size_t)(dz->wanted * sizeof(float)));
+        break;
+    case(A_FIX_F_VAR):
+        vc = 0;
+        memset((char *)dz->windowbuf[0],0,(size_t)(dz->wanted * sizeof(float)));
+        switch(order) {
+        case(BOTH_ACCESSES_OF_RANDTABLE_REACH_END_TOGETHER):
+            while(cc<randend) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(FIRST_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc<randend) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc  = 0;
+            while(cc2 < randend2) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(SECOND_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc2<randend2) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2  = 0;
+            while(cc < randend) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_afix_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        default:
+            sprintf(errstr,"Impossible order value %d: chorusing()\n",order);
+            return(PROGRAM_ERROR);
+        }
+        memmove((char *)dz->flbufptr[0],(char *)dz->windowbuf[0],(size_t)(dz->wanted * sizeof(float)));
+        break;
+    case(A_VAR_F_FIX):
+        vc = 0;
+        memset((char *)dz->windowbuf[0],0,(size_t)(dz->wanted * sizeof(float)));
+        switch(order) {
+        case(BOTH_ACCESSES_OF_RANDTABLE_REACH_END_TOGETHER):
+            while(cc<randend) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(FIRST_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc<randend) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc  = 0;
+            while(cc2 < randend2) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(SECOND_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc2<randend2) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2  = 0;
+            while(cc < randend) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_a_ffix(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        default:
+            sprintf(errstr,"Impossible (2) order value %d: chorusing()\n",order);
+            return(PROGRAM_ERROR);
+        }
+        memmove((char *)dz->flbufptr[0],(char *)dz->windowbuf[0],(size_t)(dz->wanted * sizeof(float)));
+        break;
+    case(AF_VAR):
+        vc = 0;
+        memset((char *)dz->windowbuf[0],0,(size_t)(dz->wanted * sizeof(float)));
+        switch(order) {
+        case(BOTH_ACCESSES_OF_RANDTABLE_REACH_END_TOGETHER):
+            while(cc<randend)  {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(FIRST_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc<randend) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc  = 0;
+            while(cc2 < randend2) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2 = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        case(SECOND_ACCESS_OF_RANDTABLE_REACHES_END_FIRST):
+            while(cc2<randend2) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc2  = 0;
+            while(cc < randend) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            cc = 0;
+            while(vc < dz->wanted) {
+                if((exit_status = do_a_f(&cc,&cc2,&vc,dz))<0)
+                    return(exit_status);
+            }
+            break;
+        default:
+            sprintf(errstr,"Impossible (3) order value %d: chorusing()\n",order);
+            return(PROGRAM_ERROR);
+        }
+        memmove((char *)dz->flbufptr[0],(char *)dz->windowbuf[0],(size_t)(dz->wanted * sizeof(float)));
+        break;
+    default:
+        sprintf(errstr,"Impossible sprtype value %d in chorusing()\n",dz->iparam[CHORU_SPRTYPE]);
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/******************************* DO_AFIX_FFIX *********************/
+
+int do_afix_ffix(int *cc,int *cc2,int *vc,dataptr dz)
+{
+    int exit_status;
+    dz->flbufptr[0][*vc] = (float)(dz->flbufptr[0][*vc] * dz->parray[CHORU_RTABA][*cc]);
+    (*cc)++;
+    (*vc)++;
+    if((exit_status = getnewfrq_choru(*cc2,*vc,dz))<0)
+        return(exit_status);
+    (*cc2)++;
+    (*vc)++;
+    return(FINISHED);                                       /* number in flbufptr[0] */
+}
+
+/*************************** DO_A ****************************/
+
+int do_a(int cc,int vc,int randend,dataptr dz)
+{
+    while(cc < randend) {
+        dz->flbufptr[0][vc] = (float)(pow(dz->param[CHORU_AMPR],dz->parray[CHORU_RTABA][cc]) * dz->flbufptr[0][vc]);
+        cc++;
+        vc += 2;
+    }
+    cc = 0;
+    while(vc < dz->wanted) {
+        dz->flbufptr[0][vc] = (float)(pow(dz->param[CHORU_AMPR],dz->parray[CHORU_RTABA][cc]) * dz->flbufptr[0][vc]);
+        cc++;
+        vc += 2;
+    }
+    return(FINISHED);
+}
+
+/***************************** DO_FVAR *****************************/
+
+int do_fvar(int cc,int vc,int randend,dataptr dz)
+{
+    int exit_status;
+    while(cc < randend) {
+        if((exit_status = getnewfrq2_choru(cc,vc,dz))<0)
+            return(exit_status);
+        cc++;
+        vc += 2;
+    }
+    cc = 0;
+    while(vc < dz->wanted) {
+        if((exit_status = getnewfrq2_choru(cc,vc,dz))<0)
+            return(exit_status);
+        cc++;
+        vc += 2;
+    }
+    return(FINISHED);
+}
+
+/******************************* DO_AFIX_F *********************/
+
+int do_afix_f(int *cc,int *cc2,int *vc,dataptr dz)
+{
+    int exit_status;
+    dz->flbufptr[0][*vc] = (float)(dz->flbufptr[0][*vc] * dz->parray[CHORU_RTABA][*cc]);
+    (*cc)++;
+    (*vc)++;
+    if((exit_status = getnewfrq2_choru(*cc2,*vc,dz))<0)
+        return(exit_status);
+    (*cc2)++;
+    (*vc)++;
+    return(FINISHED);
+}
+
+/************************* DO_A_FFIX ***************************/
+
+int do_a_ffix(int *cc,int *cc2,int *vc,dataptr dz)
+{
+    int exit_status;
+    dz->flbufptr[0][*vc] = (float)(dz->flbufptr[0][*vc] * pow(dz->param[CHORU_AMPR],dz->parray[CHORU_RTABA][*cc]));
+    (*cc)++;
+    (*vc)++;
+    if((exit_status = getnewfrq_choru(*cc2,*vc,dz))<0)
+        return(exit_status);
+    (*cc2)++;
+    (*vc)++;
+    return(FINISHED);
+}
+
+/************************* DO_A_F ***************************/
+
+int do_a_f(int *cc,int *cc2,int *vc,dataptr dz)
+{
+    int exit_status;
+    dz->flbufptr[0][*vc] = (float)(dz->flbufptr[0][*vc] * pow(dz->param[CHORU_AMPR],dz->parray[CHORU_RTABA][*cc]));
+    (*cc)++;
+    (*vc)++;
+    if((exit_status = getnewfrq_choru(*cc2,*vc,dz))<0)
+        return(exit_status);
+    (*cc2)++;
+    (*vc)++;
+    return(FINISHED);
+}
+
+/***************************** DO_AFIX *************************/
+
+int do_afix(int cc,int vc,int randend, dataptr dz)
+{
+    while(cc < randend)     {
+        dz->flbufptr[0][vc] = (float)(dz->flbufptr[0][vc] * dz->parray[CHORU_RTABA][cc]);
+        cc++;
+        vc += 2;
+    }
+    cc = 0;
+    while(vc < dz->wanted) {
+        dz->flbufptr[0][vc] = (float)(dz->flbufptr[0][vc] * dz->parray[CHORU_RTABA][cc]);
+        cc++;
+        vc += 2;
+    }
+    return(FINISHED);
+}
+
+/*************************** DO_FFIX *************************/
+
+int do_ffix(int cc,int vc,int randend,dataptr dz)
+{
+    int exit_status;
+    while(cc < randend) {
+        if((exit_status = getnewfrq_choru(cc,vc,dz))<0)
+            return(exit_status);
+        cc++;
+        vc += 2;
+    }
+    cc = 0;
+    while(vc < dz->wanted) {
+        if((exit_status = getnewfrq_choru(cc,vc,dz))<0)
+            return(exit_status);
+        cc++;
+        vc += 2;
+    }
+    return(FINISHED);
+}
+
+/************************* GETNEWFRQ_CHORU ****************************
+ *
+ * (1)  If scatter takes frq > current chan, do the scatter     downwards instead.
+ * (1)  If scatter takes frq < current chan, do the scatter upwards instead.
+ * (3)  Otherwise, keep originally calculated value.
+ */
+
+int getnewfrq_choru(int cc,int vc,dataptr dz)
+{
+    int exit_status;
+    float amp;
+    double newval;
+    int new_chan;
+    newval = dz->flbufptr[0][vc] * dz->parray[CHORU_RTABF][cc];
+    if(newval > dz->nyquist || newval < dz->halfchwidth)
+        return(FINISHED);
+    if((exit_status = get_sbufposition_corresponding_to_frq(&new_chan,newval,dz))<0)
+        return(exit_status);
+    if((amp = dz->flbufptr[0][vc-1]) > dz->windowbuf[0][new_chan]) {
+        dz->windowbuf[0][new_chan++] = amp;
+        dz->windowbuf[0][new_chan]   = (float)newval;
+    }
+    return(FINISHED);
+}
+
+/************************** GETNEWFRQ2_CHORU *************************/
+
+int getnewfrq2_choru(int cc,int vc,dataptr dz)
+{
+    int exit_status;
+    float amp;
+    double newval, newscat = pow(dz->param[CHORU_FRQR],dz->parray[CHORU_RTABF][cc]);
+    int new_vc;
+    newval = dz->flbufptr[0][vc] * newscat;
+    if(newval > dz->nyquist || newval < dz->halfchwidth)
+        return(FINISHED);
+    if((exit_status = get_sbufposition_corresponding_to_frq(&new_vc,newval,dz))<0)
+        return(exit_status);
+    if((amp = dz->flbufptr[0][vc-1]) > dz->windowbuf[0][new_vc]) {
+        dz->windowbuf[0][new_vc++] = amp;
+        dz->windowbuf[0][new_vc]   = (float)newval;
+    }
+    return(FINISHED);
+}
+
+/****************************** GET_SBUFPOSITION_CORRESPONDING_TO_FRQ ****************************/
+
+int get_sbufposition_corresponding_to_frq(int *channo,double frq,dataptr dz)
+{
+    frq  += dz->halfchwidth;
+    *channo = (int)(frq/dz->chwidth);/* TRUNCATE */ /* find channel number */
+    *channo = min(dz->clength-1,max(0,*channo));    /* Outside range TRAP */
+    (*channo) *= 2;
+    return(FINISHED);                                       /* number in flbufptr[0] */
+}
+
+/**************************** SPECNOISE ***************************/
+
+int specnoise(dataptr dz)
+{
+    int exit_status;
+    int vc;
+    double totalamp;
+    if((exit_status = get_totalamp(&totalamp,dz->flbufptr[0],dz->wanted))<0)
+        return(exit_status);
+    totalamp /= dz->clength;
+    for(vc = 0; vc < dz->wanted; vc += 2)
+        dz->flbufptr[0][vc] =
+            (float)(((totalamp - dz->flbufptr[0][vc]) * dz->param[NOISE_NOIS]) + dz->flbufptr[0][vc]);
+    return(FINISHED);
+}
+
+/****************************** SPECDRUNK ***************************/
+
+int specdrunk(dataptr dz)
+{
+    int exit_status;
+    int samps_read=0, step;
+    float *inputbuf_end;
+    int drnk_bufno = -1;
+    dz->time = 0.0f;
+    if((exit_status = advance_to_starttime(&inputbuf_end,&samps_read,&drnk_bufno,dz))<0)
+        return(exit_status);
+    dz->flbufptr[1] = dz->flbufptr[2];
+    for(;;) {
+        if((exit_status = copy_window_to_outbuf(dz))<0)
+            return(exit_status);
+        if((dz->time = (float)(dz->time + dz->frametime)) >= dz->param[DRNK_DUR])
+            break;
+        if((exit_status = get_randstep(&step,dz))<0)
+            return(exit_status);
+        dz->flbufptr[0] += step * dz->wanted;
+        if(dz->flbufptr[0] < dz->bigfbuf || dz->flbufptr[0] >= inputbuf_end) {
+            if((exit_status = adjust_buffers(&step,&inputbuf_end,&samps_read,&drnk_bufno,dz))<0)
+                return(exit_status);
+        }
+    }
+    if((exit_status = flush_outbuf(dz))<0)
+        return(exit_status);
+    return(FINISHED);
+}
+
+/****************************** ADVANCE_TO_STARTTIME ***************************/
+
+int advance_to_starttime(float **inputbuf_end,int *samps_read,int *drnk_bufno,dataptr dz)
+{
+    int exit_status;
+    double  time_read = 0.0, previous_time_read = 0.0, time_in_buf;
+    int     startwindow_in_buf, w_to_buf;
+    while(time_read <= dz->param[DRNK_STIME]) {
+        if((exit_status = read_samps(dz->bigfbuf,dz)) < 0) {
+            sprintf(errstr,"No data found in input analysis file.\n");
+            return(SYSTEM_ERROR);
+        }
+        if(dz->ssampsread == 0) {
+            sprintf(errstr,"No data found in input analysis file.\n");
+            return(DATA_ERROR);
+        }
+        *samps_read = dz->ssampsread;
+
+        (*drnk_bufno)++;
+        w_to_buf                   = dz->ssampsread/dz->wanted;
+        previous_time_read = time_read;
+        time_read         += (w_to_buf * dz->frametime);
+    }
+    *inputbuf_end      = dz->bigfbuf + dz->ssampsread;
+    time_in_buf        = dz->param[DRNK_STIME] - previous_time_read;
+    startwindow_in_buf = round(time_in_buf/dz->frametime);
+    dz->flbufptr[0]     = dz->bigfbuf + (startwindow_in_buf * dz->wanted);
+    return(FINISHED);
+}
+
+/****************************** COPY_WINDOW_TO_OUTBUF ***************************/
+
+int copy_window_to_outbuf(dataptr dz)
+{
+    int exit_status;
+    int vc;
+    for(vc = 0; vc < dz->wanted; vc++)
+        dz->flbufptr[1][vc] = dz->flbufptr[0][vc];
+    if((dz->flbufptr[1] += dz->wanted) >= dz->flbufptr[3]) {
+        if((exit_status = write_exact_samps(dz->flbufptr[2],dz->buflen,dz))<0)
+            return(exit_status);
+        dz->flbufptr[1] = dz->flbufptr[2];
+    }
+    return(FINISHED);
+}
+
+/****************************** GET_RANDSTEP ***************************/
+
+int get_randstep(int *step,dataptr dz)
+{
+    switch(dz->vflag[DRNK_NO_ZEROSTEPS]) {
+    case(FALSE):
+        *step  = (int)(drand48() * dz->iparam[DRNK_TWICERANGE]);                        /* TRUNCATE */
+        *step -= dz->iparam[DRNK_RANGE];
+        break;
+    case(TRUE):
+        do {
+            *step  = (int)(drand48() * dz->iparam[DRNK_TWICERANGE]);                /* TRUNCATE */
+            *step -= dz->iparam[DRNK_RANGE];
+        } while(*step==0);
+        break;
+    default:
+        sprintf(errstr,"unknown case in get_randstep()\n");
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/****************************** ADJUST_BUFFERS ***********************/
+
+int adjust_buffers(int *step,float **inputbuf_end,int *samps_read,int *drnk_bufno, dataptr dz)
+{
+    //TW UPDATED
+    int exit_status;
+    int bigbufs_baktrak = 0;
+    int baksamps, total_samps_read, seektest;
+    int reflect_off_start = FALSE, reflect_off_end = FALSE;
+    if(*drnk_bufno < 0) {
+        sprintf(errstr,"ADJUST_BUFFERS START bufno = %d (less than zero)\n",*drnk_bufno);
+        return(PROGRAM_ERROR);
+    }
+    do {
+        if(dz->flbufptr[0] < dz->bigfbuf) {                     /* IF OFF START OF BUFFER */
+            if(*drnk_bufno == 0)    {               /* IF OFF START OF FILE */
+                if((exit_status = invert_step_back_to_step_fwd_at_start_of_file(step,reflect_off_end,dz))<0)
+                    return(exit_status);
+                reflect_off_start = TRUE;
+            } else {                                                                /* ELSE NOT OFF START OF FILE */
+                if((exit_status = place_sbufptr_in_bigbuf_range(&bigbufs_baktrak,dz))<0)
+                    return(exit_status);
+                baksamps = (bigbufs_baktrak * dz->buflen) + *samps_read;
+                if((seektest = sndseekEx(dz->ifd[0],-baksamps,1)) <= 0) {       /* IF FELL OF FILE START */
+                    if(seektest<0) {
+                        sprintf(errstr,"sndseekEx() failed.\n");
+                        return(SYSTEM_ERROR);
+                    }
+                    if((exit_status = invert_step_back_to_step_fwd
+                        (step,dz->flbufptr[0],samps_read,inputbuf_end,reflect_off_end,*drnk_bufno,dz))<0)
+                        return(exit_status);
+                    reflect_off_start = TRUE;
+                } else {
+                    if((exit_status = baktrak_to_correct_bigbuf(bigbufs_baktrak,samps_read,inputbuf_end,drnk_bufno,dz))<0)
+                        return(exit_status);
+                    reflect_off_start = FALSE;
+                }
+            }
+        } else
+            reflect_off_start = FALSE;
+        total_samps_read = min(dz->insams[0],(*drnk_bufno+1) * dz->buflen);
+
+        if(dz->flbufptr[0] >= *inputbuf_end) {                          /* IF OFF END OF BUFFER */
+            if(total_samps_read >= dz->insams[0]) { /* IF OFF END OF FILE */
+                if((exit_status = invert_step_fwd_to_step_back_at_end_of_file(step,reflect_off_start,*drnk_bufno,dz))<0)
+                    return(exit_status);
+                reflect_off_end = TRUE;
+            } else {                                                                        /* ELSE NOT END OF FILE */
+                if((exit_status = advance_to_correct_bigbuf(inputbuf_end,samps_read,drnk_bufno,dz))<0)
+                    return(exit_status);
+                if(dz->flbufptr[0] >= *inputbuf_end) {          /* IF FELL OFF END OF FILE */
+                    if((exit_status = invert_step_fwd_to_step_back
+                        (step,dz->flbufptr[0],samps_read,inputbuf_end,reflect_off_start,*drnk_bufno,dz))<0)
+                        return(exit_status);
+                    reflect_off_end = TRUE;
+                } else
+                    reflect_off_end = FALSE;
+            }
+        } else
+            reflect_off_end = FALSE;
+    } while(reflect_off_end);
+    if(*drnk_bufno < 0) {
+        sprintf(errstr,"ADJUST_BUFFERS END bufno = %d (less than zero)\n",*drnk_bufno);
+        return(PROGRAM_ERROR);
+    }
+    return(FINISHED);
+}
+
+/****************************** FLUSH_OUTBUF ***************************/
+
+int flush_outbuf(dataptr dz)
+{
+    int exit_status;
+    int samps_to_write;
+    if(dz->flbufptr[1] != dz->flbufptr[2]) {
+        samps_to_write = dz->flbufptr[1] - dz->flbufptr[2];
+        if((exit_status = write_samps(dz->flbufptr[2],samps_to_write,dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/****************************** INVERT_STEP_BACK_TO_STEP_FWD_AT_START_OF_FILE ***********************/
+
+int invert_step_back_to_step_fwd_at_start_of_file(int *step,int reflect_off_end,dataptr dz)
+{
+    if(reflect_off_end) {
+        sprintf(errstr,"Step turned out to be too large.\n");
+        return(DATA_ERROR);
+    }
+    *step = -(*step);                       /* REFLECT FROM START OF FILE */
+    dz->flbufptr[0] += (*step) * 2 * dz->wanted;
+    return(FINISHED);
+}
+
+/****************************** PLACE_SBUFPTR_IN_BIGBUF_RANGE ***********************/
+
+int place_sbufptr_in_bigbuf_range(int *bigbufs_baktrak,dataptr dz)
+{
+    while(dz->flbufptr[0] < dz->bigfbuf) {          /* GO BACK THROUGH BUFS */
+        dz->flbufptr[0] += dz->big_fsize;
+        (*bigbufs_baktrak)++;
+    }
+    return(FINISHED);
+}
+
+/****************************** INVERT_STEP_BACK_TO_STEP_FWD  ***********************/
+
+int invert_step_back_to_step_fwd
+(int *step,float *orig_sbuf,int *samps_read,float **inputbuf_end, int reflect_off_end,int drnk_bufno,dataptr dz)
+{
+    int exit_status;
+    if(reflect_off_end) {
+        sprintf(errstr,"Step turned out ot be too large.\n");
+        return(DATA_ERROR);
+    }
+    if(sndseekEx(dz->ifd[0],drnk_bufno * dz->buflen,0)<0) {
+        sprintf(errstr,"Seek problem in invert_step_back_to_step_fwd().\n");
+        return(SYSTEM_ERROR);
+    }
+    if((exit_status = read_samps(dz->bigfbuf,dz)) < 0) {
+        sprintf(errstr,"Problem reading buffer:in invert_step_back_to_step_fwd().\n");
+        return(SYSTEM_ERROR);
+    }
+    if(dz->ssampsread == 0) {
+        sprintf(errstr,"Problem reading buffer:in invert_step_back_to_step_fwd().\n");
+        return(DATA_ERROR);
+    }
+    *samps_read = dz->ssampsread;
+    *inputbuf_end  = dz->bigfbuf + dz->ssampsread;
+    *step              = -(*step);          /* REVERSE STEP */
+    dz->flbufptr[0] = orig_sbuf + ((*step) * 2 * dz->wanted);
+    return(FINISHED);
+}
+
+/****************************** BAKTRAK_TO_CORRECT_BIGBUF ***********************/
+
+int baktrak_to_correct_bigbuf(int bigbufs_baktrak,int *samps_read,float **inputbuf_end,int *drnk_bufno,dataptr dz)
+{
+    int exit_status;
+    *drnk_bufno -= bigbufs_baktrak;
+    if((exit_status = read_samps(dz->bigfbuf,dz)) < 0) {
+        sprintf(errstr,"Problem reading buffer in baktrak_to_correct_bigbuf().\n");
+        return(SYSTEM_ERROR);
+    }
+    if(dz->ssampsread == 0) {
+        sprintf(errstr,"Problem reading buffer in baktrak_to_correct_bigbuf().\n");
+        return(DATA_ERROR);
+    }
+    *samps_read = dz->ssampsread;
+    *inputbuf_end = dz->bigfbuf + dz->ssampsread;
+    return(FINISHED);
+}
+
+/****************************** INVERT_STEP_FWD_TO_STEP_BACK_AT_END_OF_FILE ***********************/
+
+int invert_step_fwd_to_step_back_at_end_of_file(int *step,int reflect_off_start,int drnk_bufno,dataptr dz)
+{
+    if(reflect_off_start) {         /* IF OFF END OF FILE */
+        sprintf(errstr,"Step turned out ot be too large.\n");
+        return(DATA_ERROR);              /* REFLECTED FROM BOTH ENDS !! */
+    }
+    *step      = -(*step);                  /* REFLECT FROM END OF FILE */
+    dz->flbufptr[0]  += (*step) * 2 * dz->wanted;
+    if(dz->flbufptr[0] < dz->bigfbuf && drnk_bufno == 0) {
+        sprintf(errstr,"Step turned out ot be too large.\n");
+        return(DATA_ERROR);             /* REFLECTED FROM BOTH ENDS !! */
+    }
+    return(FINISHED);
+}
+
+/****************************** ADVANCE_TO_CORRECT_BIGBUF ***********************/
+
+int advance_to_correct_bigbuf(float **inputbuf_end,int *samps_read,int *drnk_bufno,dataptr dz)
+{
+    int exit_status;
+    if(*drnk_bufno < 0) {
+        sprintf(errstr,"advance_to_correct_bigbuf: drnk_bufno = %d (less than zero)\n",*drnk_bufno);
+        return(PROGRAM_ERROR);
+    }
+    while(dz->flbufptr[0] >= *inputbuf_end) {       /* ADVANCE ALONG FILE */
+        if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)
+            return(exit_status);
+        *samps_read = dz->ssampsread;
+        if(dz->ssampsread == 0)
+            break;
+        *inputbuf_end = dz->bigfbuf + dz->ssampsread;
+        (*drnk_bufno)++;
+        dz->flbufptr[0] -= dz->big_fsize;
+    }
+    return(FINISHED);
+}
+
+/****************************** INVERT_STEP_FWD_TO_STEP_BACK ***********************/
+
+int invert_step_fwd_to_step_back
+(int *step,float *orig_sbuf,int *samps_read,float **inputbuf_end,int reflect_off_start,int drnk_bufno,dataptr dz)
+{
+    int exit_status;
+    if(reflect_off_start) {
+        sprintf(errstr,"Step turned out ot be too large.\n");
+        return(DATA_ERROR);             /* REFLECTED FROM BOTH ENDS!! */
+    }
+    if(sndseekEx(dz->ifd[0],drnk_bufno * dz->buflen,0)<0) {
+        sprintf(errstr,"Seek problem in invert_step_fwd_to_step_back().\n");
+        return(SYSTEM_ERROR);
+    }
+    if((exit_status = read_samps(dz->bigfbuf,dz)) < 0)  {
+        sprintf(errstr,"Problem reading buffer in invert_step_fwd_to_step_back().\n");
+        return exit_status;
+    }
+    if(dz->ssampsread == 0) {
+        sprintf(errstr,"Problem reading buffer in invert_step_fwd_to_step_back().\n");
+        return(PROGRAM_ERROR);
+    }
+    *samps_read = dz->ssampsread;
+    *inputbuf_end = dz->bigfbuf + dz->ssampsread;
+    *step             = -(*step);   /* REVERSE STEP */
+    dz->flbufptr[0] = orig_sbuf + ((*step) * 2 * dz->wanted);
+    return(FINISHED);
+}
+
+/****************************** SPECWEAVE ***************************/
+
+int specweave(dataptr dz)
+{
+    int exit_status;
+    int vc;
+    int samps_to_write, n = 0;
+    float *insbuf  = dz->flbufptr[0];
+    float *outsbuf = dz->flbufptr[2];
+    unsigned int wrapsamps = dz->iparam[WEAVE_BAKTRAK] * dz->wanted;
+    if((exit_status = read_first_inbuf(dz))<0)
+        return(exit_status);
+    for(;;) {
+        for(vc = 0; vc < dz->wanted; vc++)
+            outsbuf[vc] = insbuf[vc];
+        insbuf += dz->iparray[WEAVE_WEAV][n] * dz->wanted;
+        if(insbuf < dz->bigfbuf) {
+            sprintf(errstr,"Backtracking failure in specweave().\n");
+            return(PROGRAM_ERROR);
+        }
+        if(insbuf >= dz->flbufptr[1]) {
+            if((exit_status = wrap_samps(wrapsamps,&insbuf,dz))<0)
+                return(exit_status);
+            if(exit_status == FINISHED) {
+                outsbuf += dz->wanted;
+                break;
+            }
+        }
+        if(++n>=dz->itemcnt)
+            n = 0;
+        if((outsbuf += dz->wanted)>= dz->flbufptr[3]) { /* outbuf full */
+            if((exit_status = write_exact_samps(dz->flbufptr[2],dz->buflen,dz))<0)
+                return(exit_status);
+            outsbuf = dz->flbufptr[2];
+        }
+    }
+    if(outsbuf != dz->flbufptr[2]) {
+        samps_to_write = outsbuf - dz->flbufptr[2];
+        if((exit_status = write_samps(dz->flbufptr[2],samps_to_write,dz))<0)
+            return(exit_status);
+    }
+    return(FINISHED);
+}
+
+/****************************** READ_FIRST_INBUF ***************************/
+
+int read_first_inbuf(dataptr dz)
+{
+    int exit_status;
+    if((exit_status = read_samps(dz->flbufptr[0],dz)) < 0) {
+        sprintf(errstr,"Failed to read data from infile.\n");
+        return(exit_status);
+    }
+    dz->flbufptr[1]  = dz->flbufptr[0] + dz->ssampsread;    /* mark current end of inbuf */
+    return(FINISHED);
+}
+
+/****************************** WRAP_SAMPS ***************************/
+
+int wrap_samps(unsigned int wrapsamps,float **insbuf,dataptr dz)
+{
+    int exit_status;
+    memmove((char *)dz->bigfbuf,(char *)dz->flbufptr[4],(size_t)(wrapsamps * sizeof(float)));
+    if((exit_status = read_samps(dz->flbufptr[0],dz)) < 0)
+        return exit_status;
+    if(dz->ssampsread == 0)
+        return(FINISHED);                                               /* no more data in infile */
+    dz->flbufptr[1] = dz->flbufptr[0] + dz->ssampsread;                     /* mark current end of inbuf */
+    if((*insbuf -= dz->big_fsize) >= dz->flbufptr[1])/* must have weaved off end of infile */
+        return(FINISHED);
+    return(CONTINUE);
+}
+
+/*************************** COPY_1ST_WINDOW ***********************/
+
+int copy_1st_window(dataptr dz)
+{
+    memmove((char *)dz->flbufptr[1],(char *)dz->flbufptr[0],(size_t)(dz->wanted * sizeof(float)));
+    dz->flbufptr[0] += dz->wanted;
+    dz->flbufptr[1] += dz->wanted;
+    return(FINISHED);
+}

dev/blur/main.c

@@ -0,0 +1,238 @@
+/*
+ * 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 <blur.h>
+#include <filetype.h>
+#include <processno.h>
+#include <modeno.h>
+#include <formants.h>
+#include <cdpmain.h>
+#include <special.h>
+#include <logic.h>
+#include <globcon.h>
+#include <cdpmain.h>
+#include <sfsys.h>
+#include <ctype.h>
+
+#include <string.h>
+char errstr[2400];
+
+/*extern*/ int sloom = 0;
+/*extern*/ int  sloombatch = 0;
+/*extern*/ int anal_infiles = 1;
+/*extern*/ int is_converted_to_stereo = -1;
+
+/**************************************** MAIN *********************************************/
+
+const char* cdp_version = "7.1.0";
+
+int main(int argc,char *argv[])
+{
+    int exit_status;
+    /*      FILE *fp   = NULL;*/
+    dataptr dz = NULL;
+    //      char *special_data_string = NULL;
+    char **cmdline;
+    int  cmdlinecnt;
+    //aplptr ap;
+    int *valid = NULL;
+    int is_launched = FALSE;
+    int  validcnt = 0;
+
+    /* CHECK FOR SOUNDLOOM */
+    //TW UPDATE
+    if((argc==2) && strcmp(argv[1],"--version")==0) {
+        fprintf(stdout,"%s\n",cdp_version);
+        fflush(stdout);
+        return 0;
+    }
+    if((sloom = sound_loom_in_use(&argc,&argv)) > 1) {
+        sloom = 0;
+        sloombatch = 1;
+    }
+
+    if(!sloom) {
+        if((exit_status = allocate_and_initialise_validity_flags(&valid,&validcnt))<0) {
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+            return(FAILED);
+        }
+    }
+
+    if(sflinit("cdp")){
+        sfperror("cdp: initialisation\n");
+        return(FAILED);
+    }
+
+    /* SET UP THE PRINCIPLE DATASTRUCTURE */
+    if((exit_status = establish_datastructure(&dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    if(!sloom) {
+        /* INITIAL CHECK OF CMDLINE DATA */
+        if((exit_status = make_initial_cmdline_check(&argc,&argv))<0) {
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+            return(FAILED);
+        }
+        cmdline    = argv;      /* GET PRE_DATA, ALLOCATE THE APPLICATION, CHECK FOR EXTRA INFILES */
+        cmdlinecnt = argc;
+        if((exit_status = get_process_and_mode_from_cmdline(&cmdlinecnt,&cmdline,dz))<0) {
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+            return(FAILED);
+        }
+        if((exit_status = setup_particular_application(dz))<0) {
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+            return(FAILED);
+        }
+        if((exit_status = count_and_allocate_for_infiles(cmdlinecnt,cmdline,dz))<0) {
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+            return(FAILED);
+        }
+    } else {
+        if((exit_status = parse_tk_data(argc,argv,&cmdline,&cmdlinecnt,dz))<0) {        /* includes setup_particular_application()      */
+            exit_status = print_messages_and_close_sndfiles(exit_status,is_launched,dz);/* and cmdlinelength check = sees extra-infiles */
+            return(exit_status);
+        }
+    }
+
+    //ap = dz->application;
+
+    /*********************************************************************************************************************
+           cmdline[0]                                             2 vals                                                          ACTIVE
+TK              (infile) (more-infiles) (outfile) (flag val) (formantsqksrch) (special) params  options   variant-params  flags
+CMDLINE (infile) (more-infiles) (outfile) (formants) (formantsqksrch) (special) params  POSSIBLY  POSSIBLY              POSSIBLY
+                                                                                  1 val
+    *********************************************************************************************************************/
+
+    if((exit_status = parse_infile_and_hone_type(cmdline[0],valid,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    if((exit_status = setup_param_ranges_and_defaults(dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    /* OPEN FIRST INFILE AND STORE DATA, AND INFORMATION, APPROPRIATELY */
+
+    if(dz->input_data_type!=NO_FILE_AT_ALL) {
+        if((exit_status = open_first_infile(cmdline[0],dz))<0) {
+            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+            return(FAILED);
+        }
+        cmdlinecnt--;
+        cmdline++;
+    }
+
+    /*********************************************************************************************************************
+                cmdline[0]                                 2 vals                                                          ACTIVE
+TK              (more-infiles) (outfile) (flag val) (formantsqksrch) (special) params  options   variant-params  flags
+CMDLINE (more-infiles) (outfile) (formants) (formantsqksrch) (special) params  POSSIBLY  POSSIBLY                 POSSIBLY
+                                                                   1 val
+    *********************************************************************************************************************/
+
+    if((exit_status = handle_extra_infiles(&cmdline,&cmdlinecnt,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    /*********************************************************************************************************************
+                cmdline[0]        2                                                                 ACTIVE
+TK              (outfile) (flag val) (formantsqksrch) (special) params  options   variant-params  flags
+CMDLINE (outfile) (formants) (formantsqksrch) (special) params  POSSIBLY  POSSIBLY                 POSSIBLY
+                                          1
+    *********************************************************************************************************************/
+
+    if((exit_status = handle_outfile(&cmdlinecnt,&cmdline,is_launched,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    /****************************************************************************************
+                cmdline[0]                                                     ACTIVE
+TK              (flag val) (formantsqksrch) (special) params  options   variant-params  flags
+CMDLINE (formants) (formantsqksrch) (special) params  POSSIBLY  POSSIBLY                POSSIBLY
+    *****************************************************************************************/
+
+    if((exit_status = handle_formants(&cmdlinecnt,&cmdline,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+    if((exit_status = handle_formant_quiksearch(&cmdlinecnt,&cmdline,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+    if((exit_status = handle_special_data(&cmdlinecnt,&cmdline,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    /****************************************************************************************
+                cmdline[0]
+TK              active_params   options                 variant-params  flags
+CMDLINE active_params   POSSIBLY                POSSIBLY                POSSIBLY
+    *****************************************************************************************/
+
+    if((exit_status = read_parameters_and_flags(&cmdline,&cmdlinecnt,dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    if((exit_status = check_param_validity_and_consistency(dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    is_launched = TRUE;
+
+    if((exit_status = allocate_large_buffers(dz))<0){
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+    if((exit_status = param_preprocess(dz))<0){
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    if((exit_status = spec_process_file(dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+
+    if((exit_status = complete_output(dz))<0) {
+        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
+        return(FAILED);
+    }
+    exit_status = print_messages_and_close_sndfiles(FINISHED,is_launched,dz);
+    free(dz);
+    return(SUCCEEDED);
+}