ComposerDesktopProject/dev/standnew/fractal.c

/*
 * Copyright (c) 1983-2023 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
 *
 */

// see HEREH
//  TEST cmdline =
//  _cdprogs\fractal wave 1 sin_cycle.wav testfrac.wav fracshape.brk 4 -m2
//  Only getting 1/2-way through the pattern ... why??
//  look at "seedata.txt" to check times advance!!!!
//  _cdprogs\fractal spectrum zzz.ana testfrac.ana fracshape5.brk

#include <stdio.h>
#include <stdlib.h>
#include <structures.h>
#include <tkglobals.h>
#include <pnames.h>
#include <filetype.h>
#include <processno.h>
#include <modeno.h>
#include <logic.h>
#include <globcon.h>
#include <cdpmain.h>
#include <math.h>
#include <mixxcon.h>
#include <osbind.h>
#include <standalone.h>
#include <science.h>
#include <ctype.h>
#include <sfsys.h>
#include <string.h>
#include <srates.h>


#ifdef unix
#define round(x) lround((x))
#endif
#ifndef HUGE
#define HUGE 3.40282347e+38F
#endif

#define FRAC_SPLICELEN  50          //  Ms  
#define FRAC_FORMANTS   4           //  No of formants used

#define FRAC_SHRINK     0
#define FRAC_OUTIMES    1

#define  mintime        timemark            //  Minimum possible duration of any fractal element    
#define  startfrq       frametime           //  Frq of first pitch in (Mode 1) fractal_pitch-pattern
#define  maxtrnsp       is_flat             //  Maximum possible upward-transpostion of any fractal element
#define  arraysize      rampbrksize         //  Array size for totally fractalised pattern
#define  fracdur        minbrk              //  Input duration of the fractal template
#define  minstep        scalefact           //  Minimum element-duration in fractal template
#define  minfracratio   halfchwidth         //  Time shrinkage of smallest element in fractal template, when proceeding from one fractal level to next
#define  maxfractalise  ringsize            //  Maximum degree of fractalisation
#define  timevary       is_transpos         //  Inicates that fractal patterning varies through time
#define  fracsize       fzeroset            //  Number of elements in current totally-fractalised pattern
#define  convertor      chwidth
#define  total_splice   specenv_type        //  Total number of samples used in (any) end-splice
#define  splicesmps     deal_with_chan_data //  No of grouped-samples in (any) end-splice
#define  maxtransshrink is_sharp            //  Time-shrinkage of the element with maximum upward transposition, when proceeding from one fractal level to next
#define  mintransshrink minnum              //  Time-shrinkage of the element with maximum downward transposition, when proceeding from one fractal level to next

#define FRACDUR     0
#define FRACMAX     1
#define FRACTSTR    2
#define FRACISTR    3

char errstr[2400];

int anal_infiles = 1;
int sloom = 0;
int sloombatch = 0;

const char* cdp_version = "6.1.0";

//CDP LIB REPLACEMENTS
static int check_fractal_param_validity_and_consistency(dataptr dz);
static int setup_fractal_application(dataptr dz);
static int parse_sloom_data(int argc,char *argv[],char ***cmdline,int *cmdlinecnt,dataptr dz);
static int parse_infile_and_check_type(char **cmdline,dataptr dz);
static int setup_fractal_param_ranges_and_defaults(dataptr dz);
static int handle_the_outfile(int *cmdlinecnt,char ***cmdline,dataptr dz);
static int setup_and_init_input_param_activity(dataptr dz,int tipc);
static int setup_input_param_defaultval_stores(int tipc,aplptr ap);
static int establish_application(dataptr dz);
static int initialise_vflags(dataptr dz);
static int setup_parameter_storage_and_constants(int storage_cnt,dataptr dz);
static int initialise_is_int_and_no_brk_constants(int storage_cnt,dataptr dz);
static int mark_parameter_types(dataptr dz,aplptr ap);
static int assign_file_data_storage(int infilecnt,dataptr dz);
static int get_tk_cmdline_word(int *cmdlinecnt,char ***cmdline,char *q);
static int get_the_process_no(char *prog_identifier_from_cmdline,dataptr dz);
static int get_the_mode_from_cmdline(char *str,dataptr dz);
static int setup_and_init_input_brktable_constants(dataptr dz,int brkcnt);
static int handle_the_special_data(char *str,dataptr dz);
static int create_fractal_sndbufs(dataptr dz);
static void get_max_fractalisation(dataptr dz);
static int fractalise(dataptr dz);
static int fractal_initialise_specenv(int *arraycnt,dataptr dz);
static int fractal_set_specenv_frqs(int arraycnt,dataptr dz);
static int fractal_setup_octaveband_steps(double **interval,dataptr dz);
static int fractal_setup_low_octave_bands(int arraycnt,dataptr dz);
static int fractal_extract_specenv(dataptr dz);
static int fractal_tranpose_within_formant_envelope(int vc,double transpose,dataptr dz);
static int fractal_reposition_partials_in_appropriate_channels(double transpose,dataptr dz);
static int fractal_spectrnsf(double transpose,dataptr dz);
static int fractal_getspecenvamp(double *thisamp,double thisfrq,dataptr dz);
static int fractal_get_channel_corresponding_to_frq(int *chan,double thisfrq,dataptr dz);

/**************************************** MAIN *********************************************/

int main(int argc,char *argv[])
{
    int exit_status;
    dataptr dz = NULL;
    char **cmdline;
    int  cmdlinecnt;
    int arraycnt = 0;
    char specialname[1200];
//    aplptr ap;
    int is_launched = FALSE;
    if(argc==2 && (strcmp(argv[1],"--version") == 0)) {
        fprintf(stdout,"%s\n",cdp_version);
        fflush(stdout);
        return 0;
    }
                        /* CHECK FOR SOUNDLOOM */
    if((sloom = sound_loom_in_use(&argc,&argv)) > 1) {
        sloom = 0;
        sloombatch = 1;
    }
    if(sflinit("cdp")){
        sfperror("cdp: initialisation\n");
        return(FAILED);
    }
                          /* SET UP THE PRINCIPLE DATASTRUCTURE */
    if((exit_status = establish_datastructure(&dz))<0) {                    // CDP LIB
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    if(!sloom) {
        if(argc == 1) {
            usage1();   
            return(FAILED);
        } else if(argc == 2) {
            usage2(argv[1]);    
            return(FAILED);
        }
    }
    if(!sloom) {
        if((exit_status = make_initial_cmdline_check(&argc,&argv))<0) {     // CDP LIB
            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
            return(FAILED);
        }
        cmdline    = argv;
        cmdlinecnt = argc;
        if((get_the_process_no(argv[0],dz))<0)
            return(FAILED);
        cmdline++;
        cmdlinecnt--;
        if(dz->process == FRACTAL) {
            dz->maxmode = 2;
            if((exit_status = get_the_mode_from_cmdline(cmdline[0],dz))<0) {
                print_messages_and_close_sndfiles(exit_status,is_launched,dz);
                return(exit_status);
            }
            cmdline++;
            cmdlinecnt--;
        } else
            dz->maxmode = 0;
        // setup_particular_application =
        if((exit_status = setup_fractal_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) {       // CDP LIB
            print_messages_and_close_sndfiles(exit_status,is_launched,dz);
            return(FAILED);
        }
    } else {
        //parse_TK_data() =
        if((exit_status = parse_sloom_data(argc,argv,&cmdline,&cmdlinecnt,dz))<0) {
            exit_status = print_messages_and_close_sndfiles(exit_status,is_launched,dz);
            return(exit_status);         
        }
    }
//    ap = dz->application;

    // parse_infile_and_hone_type() = 
    if((exit_status = parse_infile_and_check_type(cmdline,dz))<0) {
        exit_status = print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    // setup_param_ranges_and_defaults() =
    if((exit_status = setup_fractal_param_ranges_and_defaults(dz))<0) {
        exit_status = print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    // open_first_infile        CDP LIB
    if((exit_status = open_first_infile(cmdline[0],dz))<0) {    
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);  
        return(FAILED);
    }
    cmdlinecnt--;
    cmdline++;
    if(dz->process == FRACSPEC) {
        dz->nyquist     = dz->infile->origrate/2.0;
        dz->frametime   = (float)(1.0/dz->infile->arate);
        dz->clength     = dz->wanted / 2;
        dz->chwidth     = dz->nyquist/(double)(dz->clength-1);
        dz->halfchwidth = dz->chwidth/2.0;
        if((exit_status = fractal_initialise_specenv(&arraycnt,dz))<0) {    
            print_messages_and_close_sndfiles(exit_status,is_launched,dz);  
            return(FAILED);
        }
        dz->formant_bands = FRAC_FORMANTS;
        if((exit_status = fractal_set_specenv_frqs(arraycnt,dz))<0) {   
            print_messages_and_close_sndfiles(exit_status,is_launched,dz);  
            return(FAILED);
        }
    }
//  handle_extra_infiles() : redundant
    // handle_outfile() = 
    if((exit_status = handle_the_outfile(&cmdlinecnt,&cmdline,dz))<0) {
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }

//  handle_formants()           redundant
//  handle_formant_quiksearch() redundant
//  handle_special_data()       redundant
 
    strcpy(specialname,cmdline[0]);
    cmdlinecnt--;
    cmdline++;
    if((exit_status = read_parameters_and_flags(&cmdline,&cmdlinecnt,dz))<0) {      // CDP LIB
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    if((exit_status = handle_the_special_data(specialname,dz))<0) {
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
//  check_param_validity_and_consistency ..
    if((exit_status = check_fractal_param_validity_and_consistency(dz))<0) {
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    is_launched = TRUE;
    if(dz->process == FRACTAL)
        dz->bufcnt = 4;
    else
        dz->bufcnt = 2;
    if((exit_status = create_fractal_sndbufs(dz))<0) {
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    //param_preprocess()                        redundant
    //spec_process_file =
    if((exit_status = fractalise(dz))<0) {
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    if((exit_status = complete_output(dz))<0) {                                     // CDP LIB
        print_messages_and_close_sndfiles(exit_status,is_launched,dz);
        return(FAILED);
    }
    exit_status = print_messages_and_close_sndfiles(FINISHED,is_launched,dz);       // CDP LIB
    free(dz);
    return(SUCCEEDED);
}

/**********************************************
        REPLACED CDP LIB FUNCTIONS
**********************************************/


/****************************** SET_PARAM_DATA *********************************/

int set_param_data(aplptr ap, int special_data,int maxparamcnt,int paramcnt,char *paramlist)
{
    ap->special_data   = (char)special_data;       
    ap->param_cnt      = (char)paramcnt;
    ap->max_param_cnt  = (char)maxparamcnt;
    if(ap->max_param_cnt>0) {
        if((ap->param_list = (char *)malloc((size_t)(ap->max_param_cnt+1)))==NULL) {    
            sprintf(errstr,"INSUFFICIENT MEMORY: for param_list\n");
            return(MEMORY_ERROR);
        }
        strcpy(ap->param_list,paramlist); 
    }
    return(FINISHED);
}

/****************************** SET_VFLGS *********************************/

int set_vflgs
(aplptr ap,char *optflags,int optcnt,char *optlist,char *varflags,int vflagcnt, int vparamcnt,char *varlist)
{
    ap->option_cnt   = (char) optcnt;           /*RWD added cast */
    if(optcnt) {
        if((ap->option_list = (char *)malloc((size_t)(optcnt+1)))==NULL) {
            sprintf(errstr,"INSUFFICIENT MEMORY: for option_list\n");
            return(MEMORY_ERROR);
        }
        strcpy(ap->option_list,optlist);
        if((ap->option_flags = (char *)malloc((size_t)(optcnt+1)))==NULL) {
            sprintf(errstr,"INSUFFICIENT MEMORY: for option_flags\n");
            return(MEMORY_ERROR);
        }
        strcpy(ap->option_flags,optflags); 
    }
    ap->vflag_cnt = (char) vflagcnt;           
    ap->variant_param_cnt = (char) vparamcnt;
    if(vflagcnt) {
        if((ap->variant_list  = (char *)malloc((size_t)(vflagcnt+1)))==NULL) {
            sprintf(errstr,"INSUFFICIENT MEMORY: for variant_list\n");
            return(MEMORY_ERROR);
        }
        strcpy(ap->variant_list,varlist);       
        if((ap->variant_flags = (char *)malloc((size_t)(vflagcnt+1)))==NULL) {
            sprintf(errstr,"INSUFFICIENT MEMORY: for variant_flags\n");
            return(MEMORY_ERROR);
        }
        strcpy(ap->variant_flags,varflags);

    }
    return(FINISHED);
}

/***************************** APPLICATION_INIT **************************/

int application_init(dataptr dz)
{
    int exit_status;
    int storage_cnt;
    int tipc, brkcnt;
    aplptr ap = dz->application;
    if(ap->vflag_cnt>0)
        initialise_vflags(dz);    
    tipc  = ap->max_param_cnt + ap->option_cnt + ap->variant_param_cnt;
    ap->total_input_param_cnt = (char)tipc;
    if(tipc>0) {
        if((exit_status = setup_input_param_range_stores(tipc,ap))<0)             
            return(exit_status);
        if((exit_status = setup_input_param_defaultval_stores(tipc,ap))<0)        
            return(exit_status);
        if((exit_status = setup_and_init_input_param_activity(dz,tipc))<0)    
            return(exit_status);
    }
    brkcnt = tipc;
    //THERE ARE NO INPUTFILE brktables USED IN THIS PROCESS
    if(brkcnt>0) {
        if((exit_status = setup_and_init_input_brktable_constants(dz,brkcnt))<0)              
            return(exit_status);
    }
    if((storage_cnt = tipc + ap->internal_param_cnt)>0) {         
        if((exit_status = setup_parameter_storage_and_constants(storage_cnt,dz))<0)   
            return(exit_status);
        if((exit_status = initialise_is_int_and_no_brk_constants(storage_cnt,dz))<0)      
            return(exit_status);
    }                                                      
    if((exit_status = mark_parameter_types(dz,ap))<0)     
        return(exit_status);
    
    // establish_infile_constants() replaced by
    dz->infilecnt = 1;
    //establish_bufptrs_and_extra_buffers():
    return(FINISHED);
}

/********************** SETUP_PARAMETER_STORAGE_AND_CONSTANTS ********************/
/* RWD mallo changed to calloc; helps debug verison run as release! */

int setup_parameter_storage_and_constants(int storage_cnt,dataptr dz)
{
    if((dz->param       = (double *)calloc(storage_cnt, sizeof(double)))==NULL) {
        sprintf(errstr,"setup_parameter_storage_and_constants(): 1\n");
        return(MEMORY_ERROR);
    }
    if((dz->iparam      = (int    *)calloc(storage_cnt, sizeof(int)   ))==NULL) {
        sprintf(errstr,"setup_parameter_storage_and_constants(): 2\n");
        return(MEMORY_ERROR);
    }
    if((dz->is_int      = (char   *)calloc(storage_cnt, sizeof(char)))==NULL) {
        sprintf(errstr,"setup_parameter_storage_and_constants(): 3\n");
        return(MEMORY_ERROR);
    }
    if((dz->no_brk      = (char   *)calloc(storage_cnt, sizeof(char)))==NULL) {
        sprintf(errstr,"setup_parameter_storage_and_constants(): 5\n");
        return(MEMORY_ERROR);
    }
    return(FINISHED);
}

/************** INITIALISE_IS_INT_AND_NO_BRK_CONSTANTS *****************/

int initialise_is_int_and_no_brk_constants(int storage_cnt,dataptr dz)
{
    int n;
    for(n=0;n<storage_cnt;n++) {
        dz->is_int[n] = (char)0;
        dz->no_brk[n] = (char)0;
    }
    return(FINISHED);
}

/***************************** MARK_PARAMETER_TYPES **************************/

int mark_parameter_types(dataptr dz,aplptr ap)
{
    int n, m;                           /* PARAMS */
    for(n=0;n<ap->max_param_cnt;n++) {
        switch(ap->param_list[n]) {
        case('0'):  break; /* dz->is_active[n] = 0 is default */
        case('i'):  dz->is_active[n] = (char)1; dz->is_int[n] = (char)1;dz->no_brk[n] = (char)1; break;
        case('I'):  dz->is_active[n] = (char)1; dz->is_int[n] = (char)1;                         break;
        case('d'):  dz->is_active[n] = (char)1;                         dz->no_brk[n] = (char)1; break;
        case('D'):  dz->is_active[n] = (char)1; /* normal case: double val or brkpnt file */     break;
        default:
            sprintf(errstr,"Programming error: invalid parameter type in mark_parameter_types()\n");
            return(PROGRAM_ERROR);
        }
    }                               /* OPTIONS */
    for(n=0,m=ap->max_param_cnt;n<ap->option_cnt;n++,m++) {
        switch(ap->option_list[n]) {
        case('i'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1; dz->no_brk[m] = (char)1; break;
        case('I'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1;                          break;
        case('d'): dz->is_active[m] = (char)1;                          dz->no_brk[m] = (char)1; break;
        case('D'): dz->is_active[m] = (char)1;  /* normal case: double val or brkpnt file */     break;
        default:
            sprintf(errstr,"Programming error: invalid option type in mark_parameter_types()\n");
            return(PROGRAM_ERROR);
        }
    }                               /* VARIANTS */
    for(n=0,m=ap->max_param_cnt + ap->option_cnt;n < ap->variant_param_cnt; n++, m++) {
        switch(ap->variant_list[n]) {
        case('0'): break;
        case('i'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1; dz->no_brk[m] = (char)1; break;
        case('I'): dz->is_active[m] = (char)1; dz->is_int[m] = (char)1;                          break;
        case('d'): dz->is_active[m] = (char)1;                          dz->no_brk[m] = (char)1; break;
        case('D'): dz->is_active[m] = (char)1; /* normal case: double val or brkpnt file */      break;
        default:
            sprintf(errstr,"Programming error: invalid variant type in mark_parameter_types()\n");
            return(PROGRAM_ERROR);
        }
    }                               /* INTERNAL */
    for(n=0,
    m=ap->max_param_cnt + ap->option_cnt + ap->variant_param_cnt; n<ap->internal_param_cnt; n++,m++) {
        switch(ap->internal_param_list[n]) {
        case('0'):  break;   /* dummy variables: variables not used: but important for internal paream numbering!! */
        case('i'):  dz->is_int[m] = (char)1;    dz->no_brk[m] = (char)1;    break;
        case('d'):                              dz->no_brk[m] = (char)1;    break;
        default:
            sprintf(errstr,"Programming error: invalid internal param type in mark_parameter_types()\n");
            return(PROGRAM_ERROR);
        }
    }
    return(FINISHED);
}

/************************ HANDLE_THE_OUTFILE *********************/

int handle_the_outfile(int *cmdlinecnt,char ***cmdline,dataptr dz)
{
    int exit_status;
    char *filename = (*cmdline)[0];
    if(filename[0]=='-' && filename[1]=='f') {
        dz->floatsam_output = 1;
        dz->true_outfile_stype = SAMP_FLOAT;
        filename+= 2;
    }
    if(!sloom) {
        if(file_has_invalid_startchar(filename) || value_is_numeric(filename)) {
            sprintf(errstr,"Outfile name %s has invalid start character(s) or looks too much like a number.\n",filename);
            return(DATA_ERROR);
        }
    }
    strcpy(dz->outfilename,filename);      
    if((exit_status = create_sized_outfile(filename,dz))<0)
        return(exit_status);
    (*cmdline)++;
    (*cmdlinecnt)--;
    return(FINISHED);
}

/***************************** ESTABLISH_APPLICATION **************************/

int establish_application(dataptr dz)
{
    aplptr ap;
    if((dz->application = (aplptr)malloc(sizeof (struct applic)))==NULL) {
        sprintf(errstr,"establish_application()\n");
        return(MEMORY_ERROR);
    }
    ap = dz->application;
    memset((char *)ap,0,sizeof(struct applic));
    return(FINISHED);
}

/************************* INITIALISE_VFLAGS *************************/

int initialise_vflags(dataptr dz)
{
    int n;
    if((dz->vflag  = (char *)malloc(dz->application->vflag_cnt * sizeof(char)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY: vflag store,\n");
        return(MEMORY_ERROR);
    }
    for(n=0;n<dz->application->vflag_cnt;n++)
        dz->vflag[n]  = FALSE;
    return FINISHED;
}

/************************* SETUP_INPUT_PARAM_DEFAULTVALS *************************/

int setup_input_param_defaultval_stores(int tipc,aplptr ap)
{
    int n;
    if((ap->default_val = (double *)malloc(tipc * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for application default values store\n");
        return(MEMORY_ERROR);
    }
    for(n=0;n<tipc;n++)
        ap->default_val[n] = 0.0;
    return(FINISHED);
}

/***************************** SETUP_AND_INIT_INPUT_PARAM_ACTIVITY **************************/

int setup_and_init_input_param_activity(dataptr dz,int tipc)
{
    int n;
    if((dz->is_active = (char   *)malloc((size_t)tipc))==NULL) {
        sprintf(errstr,"setup_and_init_input_param_activity()\n");
        return(MEMORY_ERROR);
    }
    for(n=0;n<tipc;n++)
        dz->is_active[n] = (char)0;
    return(FINISHED);
}

/************************* SETUP_FRACTAL_APPLICATION *******************/

int setup_fractal_application(dataptr dz)
{
    int exit_status;
    aplptr ap;
    if((exit_status = establish_application(dz))<0)     // GLOBAL
        return(FAILED);
    ap = dz->application;
    // SEE parstruct FOR EXPLANATION of next 2 functions
    if(dz->process == FRACTAL) {
        if (dz->mode == 0)
            exit_status = set_param_data(ap,FRACSHAPE,1,0,"0");
        else
            exit_status = set_param_data(ap,FRACSHAPE,1,1,"d");
    } else
        exit_status = set_param_data(ap,FRACSHAPE,1,0,"0");


    
    
    if(exit_status<0)
        return(FAILED);
    if(dz->process == FRACTAL) {
        if(dz->mode == 0) 
            exit_status = set_vflgs(ap,"mti",3,"IDD","so",2,0,"00");
        else
            exit_status = set_vflgs(ap,"mti",3,"IDD","s",1,0,"0");
    } else
        exit_status = set_vflgs(ap,"mti",3,"IDD","sn",2,0,"00");
    if(exit_status<0)
        return(FAILED);
    // set_legal_infile_structure -->
    dz->has_otherfile = FALSE;
    // assign_process_logic -->
    if(dz->process == FRACSPEC) {
        dz->input_data_type = ANALFILE_ONLY;
        dz->process_type    = BIG_ANALFILE;
        dz->outfiletype     = ANALFILE_OUT;
        dz->maxmode = 0;
    } else {
        dz->input_data_type = SNDFILES_ONLY;
        dz->process_type    = UNEQUAL_SNDFILE;  
        dz->outfiletype     = SNDFILE_OUT;
        dz->maxmode = 2;
    }
    return application_init(dz);    //GLOBAL
}

/************************* PARSE_INFILE_AND_CHECK_TYPE *******************/

int parse_infile_and_check_type(char **cmdline,dataptr dz)
{
    int exit_status;
    infileptr infile_info;
    if(!sloom) {
        if((infile_info = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
            sprintf(errstr,"INSUFFICIENT MEMORY for infile structure to test file data.");
            return(MEMORY_ERROR);
        }
        if((exit_status = cdparse(cmdline[0],infile_info))<0) {
            sprintf(errstr,"Failed to parse input file %s\n",cmdline[0]);
            return(PROGRAM_ERROR);
        }
        if(dz->process == FRACTAL) {
            if(infile_info->filetype != SNDFILE)  {
                sprintf(errstr,"File %s is not of correct type\n",cmdline[0]);
                return(DATA_ERROR);
            } 
            if(dz->mode == 1 && infile_info->channels != 1)  {
                sprintf(errstr,"File %s is not of correct type (must be mono for mode %d)\n",cmdline[0],dz->mode+1);
                return(DATA_ERROR);
            }
        } else if(infile_info->filetype != ANALFILE)  {
            sprintf(errstr,"File %s is not of correct type\n",cmdline[0]);
            return(DATA_ERROR);
        }
        if((exit_status = copy_parse_info_to_main_structure(infile_info,dz))<0) {
            sprintf(errstr,"Failed to copy file parsing information\n");
            return(PROGRAM_ERROR);
        }
        free(infile_info);
    }
    return(FINISHED);
}

/************************* SETUP_FRACTAL_PARAM_RANGES_AND_DEFAULTS *******************/

int setup_fractal_param_ranges_and_defaults(dataptr dz)
{
    int exit_status;
    aplptr ap = dz->application;
    // set_param_ranges()
    ap->total_input_param_cnt = (char)(ap->max_param_cnt + ap->option_cnt + ap->variant_param_cnt);
    // NB total_input_param_cnt is > 0 !!!
    if((exit_status = setup_input_param_range_stores(ap->total_input_param_cnt,ap))<0)
        return(FAILED);
    // get_param_ranges()
    if(dz->process == FRACTAL && dz->mode == 1) {
        ap->lo[FRACDUR] = 1;
        ap->hi[FRACDUR] = FRAC_MAXDUR;
        ap->default_val[FRACDUR] = 10;
    }
    ap->lo[FRACMAX] = 0;
    ap->hi[FRACMAX] = FRAC_MAXFRACT;
    ap->default_val[FRACMAX] = 0;
    ap->lo[FRACTSTR]    = 1;
    ap->hi[FRACTSTR]    = 2;
    ap->default_val[FRACTSTR] = 1;
    ap->lo[FRACISTR]    = 0;
    ap->hi[FRACISTR]    = 8;
    ap->default_val[FRACISTR] = 0;
    if(dz->process == FRACTAL)  
        dz->maxmode = 2;
    else
        dz->maxmode = 0;
    if(!sloom)
        put_default_vals_in_all_params(dz);
    return(FINISHED);
}

/********************************* PARSE_SLOOM_DATA *********************************/

int parse_sloom_data(int argc,char *argv[],char ***cmdline,int *cmdlinecnt,dataptr dz)
{
    int exit_status;
    int cnt = 1, infilecnt;
    int filesize, insams, inbrksize;
    double dummy;
    int true_cnt = 0;
//    aplptr ap;

    while(cnt<=PRE_CMDLINE_DATACNT) {
        if(cnt > argc) {
            sprintf(errstr,"Insufficient data sent from TK\n");
            return(DATA_ERROR);
        }
        switch(cnt) {
        case(1):    
            if(sscanf(argv[cnt],"%d",&dz->process)!=1) {
                sprintf(errstr,"Cannot read process no. sent from TK\n");
                return(DATA_ERROR);
            }
            break;

        case(2):    
            if(sscanf(argv[cnt],"%d",&dz->mode)!=1) {
                sprintf(errstr,"Cannot read mode no. sent from TK\n");
                return(DATA_ERROR);
            }
            if(dz->mode > 0)
                dz->mode--;
            //setup_particular_application() =
            if((exit_status = setup_fractal_application(dz))<0)
                return(exit_status);
//            ap = dz->application;
            break;

        case(3):    
            if(sscanf(argv[cnt],"%d",&infilecnt)!=1) {
                sprintf(errstr,"Cannot read infilecnt sent from TK\n");
                return(DATA_ERROR);
            }
            if(infilecnt < 1) {
                true_cnt = cnt + 1;
                cnt = PRE_CMDLINE_DATACNT;  /* force exit from loop after assign_file_data_storage */
            }
            if((exit_status = assign_file_data_storage(infilecnt,dz))<0)
                return(exit_status);
            break;
        case(INPUT_FILETYPE+4): 
            if(sscanf(argv[cnt],"%d",&dz->infile->filetype)!=1) {
                sprintf(errstr,"Cannot read filetype sent from TK (%s)\n",argv[cnt]);
                return(DATA_ERROR);
            }
            break;
        case(INPUT_FILESIZE+4): 
            if(sscanf(argv[cnt],"%d",&filesize)!=1) {
                sprintf(errstr,"Cannot read infilesize sent from TK\n");
                return(DATA_ERROR);
            }
            dz->insams[0] = filesize;   
            break;
        case(INPUT_INSAMS+4):   
            if(sscanf(argv[cnt],"%d",&insams)!=1) {
                sprintf(errstr,"Cannot read insams sent from TK\n");
                return(DATA_ERROR);
            }
            dz->insams[0] = insams; 
            break;
        case(INPUT_SRATE+4):    
            if(sscanf(argv[cnt],"%d",&dz->infile->srate)!=1) {
                sprintf(errstr,"Cannot read srate sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_CHANNELS+4): 
            if(sscanf(argv[cnt],"%d",&dz->infile->channels)!=1) {
                sprintf(errstr,"Cannot read channels sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_STYPE+4):    
            if(sscanf(argv[cnt],"%d",&dz->infile->stype)!=1) {
                sprintf(errstr,"Cannot read stype sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_ORIGSTYPE+4):    
            if(sscanf(argv[cnt],"%d",&dz->infile->origstype)!=1) {
                sprintf(errstr,"Cannot read origstype sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_ORIGRATE+4): 
            if(sscanf(argv[cnt],"%d",&dz->infile->origrate)!=1) {
                sprintf(errstr,"Cannot read origrate sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_MLEN+4): 
            if(sscanf(argv[cnt],"%d",&dz->infile->Mlen)!=1) {
                sprintf(errstr,"Cannot read Mlen sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_DFAC+4): 
            if(sscanf(argv[cnt],"%d",&dz->infile->Dfac)!=1) {
                sprintf(errstr,"Cannot read Dfac sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_ORIGCHANS+4):    
            if(sscanf(argv[cnt],"%d",&dz->infile->origchans)!=1) {
                sprintf(errstr,"Cannot read origchans sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_SPECENVCNT+4):   
            if(sscanf(argv[cnt],"%d",&dz->infile->specenvcnt)!=1) {
                sprintf(errstr,"Cannot read specenvcnt sent from TK\n");
                return(DATA_ERROR);
            }
            dz->specenvcnt = dz->infile->specenvcnt;
            break;
        case(INPUT_WANTED+4):   
            if(sscanf(argv[cnt],"%d",&dz->wanted)!=1) {
                sprintf(errstr,"Cannot read wanted sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_WLENGTH+4):  
            if(sscanf(argv[cnt],"%d",&dz->wlength)!=1) {
                sprintf(errstr,"Cannot read wlength sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_OUT_CHANS+4):    
            if(sscanf(argv[cnt],"%d",&dz->out_chans)!=1) {
                sprintf(errstr,"Cannot read out_chans sent from TK\n");
                return(DATA_ERROR);
            }
            break;
            /* RWD these chanegs to samps - tk will have to deal with that! */
        case(INPUT_DESCRIPTOR_BYTES+4): 
            if(sscanf(argv[cnt],"%d",&dz->descriptor_samps)!=1) {
                sprintf(errstr,"Cannot read descriptor_samps sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_IS_TRANSPOS+4):  
            if(sscanf(argv[cnt],"%d",&dz->is_transpos)!=1) {
                sprintf(errstr,"Cannot read is_transpos sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_COULD_BE_TRANSPOS+4):    
            if(sscanf(argv[cnt],"%d",&dz->could_be_transpos)!=1) {
                sprintf(errstr,"Cannot read could_be_transpos sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_COULD_BE_PITCH+4):   
            if(sscanf(argv[cnt],"%d",&dz->could_be_pitch)!=1) {
                sprintf(errstr,"Cannot read could_be_pitch sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_DIFFERENT_SRATES+4): 
            if(sscanf(argv[cnt],"%d",&dz->different_srates)!=1) {
                sprintf(errstr,"Cannot read different_srates sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_DUPLICATE_SNDS+4):   
            if(sscanf(argv[cnt],"%d",&dz->duplicate_snds)!=1) {
                sprintf(errstr,"Cannot read duplicate_snds sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_BRKSIZE+4):  
            if(sscanf(argv[cnt],"%d",&inbrksize)!=1) {
                sprintf(errstr,"Cannot read brksize sent from TK\n");
                return(DATA_ERROR);
            }
            if(inbrksize > 0) {
                switch(dz->input_data_type) {
                case(WORDLIST_ONLY):
                    break;
                case(PITCH_AND_PITCH):
                case(PITCH_AND_TRANSPOS):
                case(TRANSPOS_AND_TRANSPOS):
                    dz->tempsize = inbrksize;
                    break;
                case(BRKFILES_ONLY):
                case(UNRANGED_BRKFILE_ONLY):
                case(DB_BRKFILES_ONLY):
                case(ALL_FILES):
                case(ANY_NUMBER_OF_ANY_FILES):
                    if(dz->extrabrkno < 0) {
                        sprintf(errstr,"Storage location number for brktable not established by CDP.\n");
                        return(DATA_ERROR);
                    }
                    if(dz->brksize == NULL) {
                        sprintf(errstr,"CDP has not established storage space for input brktable.\n");
                        return(PROGRAM_ERROR);
                    }
                    dz->brksize[dz->extrabrkno] = inbrksize;
                    break;
                default:
                    sprintf(errstr,"TK sent brktablesize > 0 for input_data_type [%d] not using brktables.\n",
                    dz->input_data_type);
                    return(PROGRAM_ERROR);
                }
                break;
            }
            break;
        case(INPUT_NUMSIZE+4):  
            if(sscanf(argv[cnt],"%d",&dz->numsize)!=1) {
                sprintf(errstr,"Cannot read numsize sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_LINECNT+4):  
            if(sscanf(argv[cnt],"%d",&dz->linecnt)!=1) {
                sprintf(errstr,"Cannot read linecnt sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_ALL_WORDS+4):    
            if(sscanf(argv[cnt],"%d",&dz->all_words)!=1) {
                sprintf(errstr,"Cannot read all_words sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_ARATE+4):    
            if(sscanf(argv[cnt],"%f",&dz->infile->arate)!=1) {
                sprintf(errstr,"Cannot read arate sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_FRAMETIME+4):    
            if(sscanf(argv[cnt],"%lf",&dummy)!=1) {
                sprintf(errstr,"Cannot read frametime sent from TK\n");
                return(DATA_ERROR);
            }
            dz->frametime = (float)dummy;
            break;
        case(INPUT_WINDOW_SIZE+4):  
            if(sscanf(argv[cnt],"%f",&dz->infile->window_size)!=1) {
                sprintf(errstr,"Cannot read window_size sent from TK\n");
                    return(DATA_ERROR);
            }
            break;
        case(INPUT_NYQUIST+4):  
            if(sscanf(argv[cnt],"%lf",&dz->nyquist)!=1) {
                sprintf(errstr,"Cannot read nyquist sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_DURATION+4): 
            if(sscanf(argv[cnt],"%lf",&dz->duration)!=1) {
                sprintf(errstr,"Cannot read duration sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_MINBRK+4):   
            if(sscanf(argv[cnt],"%lf",&dz->minbrk)!=1) {
                sprintf(errstr,"Cannot read minbrk sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_MAXBRK+4):   
            if(sscanf(argv[cnt],"%lf",&dz->maxbrk)!=1) {
                sprintf(errstr,"Cannot read maxbrk sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_MINNUM+4):   
            if(sscanf(argv[cnt],"%lf",&dz->minnum)!=1) {
                sprintf(errstr,"Cannot read minnum sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        case(INPUT_MAXNUM+4):   
            if(sscanf(argv[cnt],"%lf",&dz->maxnum)!=1) {
                sprintf(errstr,"Cannot read maxnum sent from TK\n");
                return(DATA_ERROR);
            }
            break;
        default:
            sprintf(errstr,"case switch item missing: parse_sloom_data()\n");
            return(PROGRAM_ERROR);
        }
        cnt++;
    }
    if(cnt!=PRE_CMDLINE_DATACNT+1) {
        sprintf(errstr,"Insufficient pre-cmdline params sent from TK\n");
        return(DATA_ERROR);
    }

    if(true_cnt)
        cnt = true_cnt;
    *cmdlinecnt = 0;        

    while(cnt < argc) {
        if((exit_status = get_tk_cmdline_word(cmdlinecnt,cmdline,argv[cnt]))<0)
            return(exit_status);
        cnt++;
    }
    return(FINISHED);
}

/********************************* GET_TK_CMDLINE_WORD *********************************/

int get_tk_cmdline_word(int *cmdlinecnt,char ***cmdline,char *q)
{
    if(*cmdlinecnt==0) {
        if((*cmdline = (char **)malloc(sizeof(char *)))==NULL)  {
            sprintf(errstr,"INSUFFICIENT MEMORY for TK cmdline array.\n");
            return(MEMORY_ERROR);
        }
    } else {
        if((*cmdline = (char **)realloc(*cmdline,((*cmdlinecnt)+1) * sizeof(char *)))==NULL)    {
            sprintf(errstr,"INSUFFICIENT MEMORY for TK cmdline array.\n");
            return(MEMORY_ERROR);
        }
    }
    if(((*cmdline)[*cmdlinecnt] = (char *)malloc((strlen(q) + 1) * sizeof(char)))==NULL)    {
        sprintf(errstr,"INSUFFICIENT MEMORY for TK cmdline item %d.\n",(*cmdlinecnt)+1);
        return(MEMORY_ERROR);
    }
    strcpy((*cmdline)[*cmdlinecnt],q);
    (*cmdlinecnt)++;
    return(FINISHED);
}


/****************************** ASSIGN_FILE_DATA_STORAGE *********************************/

int assign_file_data_storage(int infilecnt,dataptr dz)
{
    int exit_status;
    int no_sndfile_system_files = FALSE;
    dz->infilecnt = infilecnt;
    if((exit_status = allocate_filespace(dz))<0)
        return(exit_status);
    if(no_sndfile_system_files)
        dz->infilecnt = 0;
    return(FINISHED);
}



/************************* redundant functions: to ensure libs compile OK *******************/

int assign_process_logic(dataptr dz)
{
    return(FINISHED);
}

void set_legal_infile_structure(dataptr dz)
{}

int set_legal_internalparam_structure(int process,int mode,aplptr ap)
{
    return(FINISHED);
}

int setup_internal_arrays_and_array_pointers(dataptr dz)
{
    return(FINISHED);
}

int establish_bufptrs_and_extra_buffers(dataptr dz)
{
    return(FINISHED);
}

int read_special_data(char *str,dataptr dz) 
{
    return(FINISHED);
}

int inner_loop
(int *peakscore,int *descnt,int *in_start_portion,int *least,int *pitchcnt,int windows_in_buf,dataptr dz)
{
    return(FINISHED);
}

int get_process_no(char *prog_identifier_from_cmdline,dataptr dz)
{
    return(FINISHED);
}


/******************************** USAGE1 ********************************/

int usage1(void)
{
    fprintf(stderr,
    "USAGE: fractal NAME (mode) infile outfile parameters\n"
    "\n"
    "where NAME can be any one of\n"
    "\n"
    "wave  spectrum\n"
    "\n"
    "Type 'fractal wave'  for more info on fractal wave option... ETC.\n");
    return(USAGE_ONLY);
}


/********************************************************************************************/

int get_the_process_no(char *prog_identifier_from_cmdline,dataptr dz)
{
    if(!strcmp(prog_identifier_from_cmdline,"wave"))                
        dz->process = FRACTAL;
    else if(!strcmp(prog_identifier_from_cmdline,"spectrum"))
        dz->process = FRACSPEC;
    else {
        sprintf(errstr,"Unknown program identification string '%s'\n",prog_identifier_from_cmdline);
        return(USAGE_ONLY);
    }
    return(FINISHED);
}

/******************************** SETUP_AND_INIT_INPUT_BRKTABLE_CONSTANTS ********************************/

int setup_and_init_input_brktable_constants(dataptr dz,int brkcnt)
{   
    int n;
    if((dz->brk      = (double **)malloc(brkcnt * sizeof(double *)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 1\n");
        return(MEMORY_ERROR);
    }
    if((dz->brkptr   = (double **)malloc(brkcnt * sizeof(double *)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 6\n");
        return(MEMORY_ERROR);
    }
    if((dz->brksize  = (int    *)malloc(brkcnt * sizeof(int)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 2\n");
        return(MEMORY_ERROR);
    }
    if((dz->firstval = (double  *)malloc(brkcnt * sizeof(double)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 3\n");
        return(MEMORY_ERROR);                                                 
    }
    if((dz->lastind  = (double  *)malloc(brkcnt * sizeof(double)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 4\n");
        return(MEMORY_ERROR);
    }
    if((dz->lastval  = (double  *)malloc(brkcnt * sizeof(double)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 5\n");
        return(MEMORY_ERROR);
    }
    if((dz->brkinit  = (int     *)malloc(brkcnt * sizeof(int)))==NULL) {
        sprintf(errstr,"setup_and_init_input_brktable_constants(): 7\n");
        return(MEMORY_ERROR);
    }
    for(n=0;n<brkcnt;n++) {
        dz->brk[n]     = NULL;
        dz->brkptr[n]  = NULL;
        dz->brkinit[n] = 0;
        dz->brksize[n] = 0;
    }
    return(FINISHED);
}

/******************************** USAGE2 ********************************/

int usage2(char *str)
{
    if(!strcmp(str,"wave")) {
        fprintf(stderr,
        "USAGE:\n"
        "fractal wave 1 inf outf shape     [-mmaxfrac] [-tstr] [-iwarp] [-s] [-o]\n"
        "fractal wave 2 inf outf shape dur [-mmaxfrac] [-tstr] [-iwarp] [-s]\n"
        "\n"
        "Fractally distort (1 or more channel) input sound (Mode 1).\n"
        "OR generate fractal wave from (mono) input wavecycle (Mode 2)\n"
        "Fractal is time-pattern of transpositions (and, in Mode 1\n"
        "causes corresponding time contractions and expansions).\n"
        "Transposition happens over total duration specified in \"SHAPE\"\n"
        "and is then repeated over every resulting sub-unit of pattern,\n"
        "over every sub-sub-unit, etc. until smallest time-unit reached.\n"
        "\n"
        "SHAPE   Breakpoint textfile of\n"
        "        (Mode 1) time-(semitone)transposition pairs, (Range -12 to 12)\n"
        "        (Mode 2) time-MIDIpitch pairs, (Range 0 to 127)\n"
        "        defining pitch-time contour of the (largest) fractal shape.\n"
        "        Times must start at zero and increase,\n"
        "        with final time indicating duration of pattern.\n"
        "        (Value at final time will be ignored).\n"
        "\n"
        "DUR     (Mode 2) Output duration (secs) (max 2 hours).\n"
        "MAXFRAC Max degree of fractalisation.  (Time-variable). If not set (or zero),\n"
        "        fractalisation proceeds until min possible wavelength reached.\n"
        "STR     Time stretch of fractal pattern (Time-variable : values >= 1).\n"
        "        If set to zero, no timestretching is done.\n"
        "WARP    Interval warping of fractal pattern (Time-variable).\n"
        "        If set to zero, no warping is done.\n"
        "\n"
        "-s      Shrink pitch-intervals as fractal time-scales shrink.\n"
        "-o      Brkpnt data read using time in outfile (default: Use time in infile).\n"
        "\n");
    } else if(!strcmp(str,"spectrum")) {
        fprintf(stderr,
        "USAGE:\n"
        "fractal spectrum inf outf shape [-mmaxfrac] [-tstr] [-iwarp] [-s] [-n]\n"
        "\n"
        "Fractally distort input spectrum by transposition.\n"
        "Transposition happens over total duration specified in \"SHAPE\"\n"
        "and is then repeated over every resulting sub-unit of pattern,\n"
        "over every sub-sub-unit, etc. until smallest time-unit reached.\n"
        "\n"
        "SHAPE   Breakpoint textfile of\n"
        "        Time-(semitone)transposition pairs, (Range -12 to 12)\n"
        "        defining pitch-time contour of the (largest) fractal shape.\n"
        "        Times must start at zero and increase,\n"
        "        with final time indicating duration of pattern.\n"
        "        (Value at final time will be ignored).\n"
        "\n"
        "MAXFRAC Max degree of fractalisation.  (Time-variable). If not set (or zero),\n"
        "        fractalisation proceeds until min possible wavelength reached.\n"
        "STR     Time stretch of fractal pattern (Time-variable : values >= 1).\n"
        "        If set to zero, no timestretching is done.\n"
        "WARP    Interval warping of fractal pattern (Time-variable).\n"
        "        If set to zero, no warping is done.\n"
        "\n"
        "-s      Shrink pitch-intervals as fractal time-scales shrink.\n"
        "-n      Transposition only (default, retain formant envelope).\n"
        "\n");
    } else
        fprintf(stdout,"Unknown option '%s'\n",str);
    return(USAGE_ONLY);
}

int usage3(char *str1,char *str2)
{
    fprintf(stderr,"Insufficient parameters on command line.\n");
    return(USAGE_ONLY);
}

/****************************** GET_MODE *********************************/

int get_the_mode_from_cmdline(char *str,dataptr dz)
{
    char temp[200], *p;
    if(sscanf(str,"%s",temp)!=1) {
        sprintf(errstr,"Cannot read mode of program.\n");
        return(USAGE_ONLY);
    }
    p = temp + strlen(temp) - 1;
    while(p >= temp) {
        if(!isdigit(*p)) {
            fprintf(stderr,"Invalid mode of program entered.\n");
            return(USAGE_ONLY);
        }
        p--;
    }
    if(sscanf(str,"%d",&dz->mode)!=1) {
        fprintf(stderr,"Cannot read mode of program.\n");
        return(USAGE_ONLY);
    }
    if(dz->mode <= 0 || dz->mode > dz->maxmode) {
        fprintf(stderr,"Program mode value [%d] is out of range [1 - %d].\n",dz->mode,dz->maxmode);
        return(USAGE_ONLY);
    }
    dz->mode--;     /* CHANGE TO INTERNAL REPRESENTATION OF MODE NO */
    return(FINISHED);
}

/**************************** HANDLE_THE_SPECIAL_DATA ****************************/

int handle_the_special_data(char *str,dataptr dz)
{
    int exit_status, n, m, cnt;
    FILE *fp;
    char temp[200], *p;
    double dummy = 0, lasttime = 0.0, lastmintrans = 0, lastmaxtrans = 0, mintrans = 0, maxtrans = 0, fracmax = 0.0;
    double firstmidi = 0, lastmaxpitch = 0, lastminpitch = 0, maxpitch = 0, minpitch = 0, max_step, min_step, srate = (double)dz->infile->srate;
    double *fractemplate, *fracintvl, *fractimes;
    double mindur_maxtrans, mindur_mintrans, maxelement, minelement, thisdur, min_step_now, max_step_now;

    if(dz->process == FRACTAL)
        dz->mintime = (float)(4.0/srate);                   //  Minimum duration of fractal pattern (> 4 samples)
    else {
        dz->frametime  = (float)(1.0/dz->infile->arate);
        dz->mintime = dz->frametime;                        //  Minimum duration of fractal pattern (> 1 analysis window)
    }
    dz->maxtrnsp =  256.0;                                  //  8 octaves
    dz->maxfractalise = 0;
    dz->minstep = HUGE;
    if((fp = fopen(str,"r"))==NULL) {
        sprintf(errstr,"Cannot open file %s to read clip lengths.\n",str);
        return(DATA_ERROR);
    }
    cnt = 0;
    lasttime = 0;
    while(fgets(temp,200,fp)!=NULL) {
        p = temp;
        while(isspace(*p))
            p++;
        if(*p == ';' || *p == ENDOFSTR) //  Allow comments in file
            continue;
        while(get_float_from_within_string(&p,&dummy)) {

            if (EVEN(cnt)) {                                //  TIMES MUST START AT ZERO AND INCREASE
                if(cnt == 0) {
                    if(dummy != 0.0) {
                        sprintf(errstr,"Invalid initial time (%lf) in file %s. (Should be zero).\n",dummy,str);
                        return DATA_ERROR;
                    }
                } else {
                    if(dummy <= lasttime) {
                        sprintf(errstr,"Times do not increase at (%lf %lf) in file %s.\n",lasttime,dummy,str);
                        return DATA_ERROR;
                    }
                    dz->minstep = min(dz->minstep,dummy - lasttime);//  Find smallest time-step in fractal-pattern
                }
                lasttime = dummy;
            } else {                                        //  VALUES MUSY LIE WITHIN RANGE
                if(dz->process == FRACTAL && dz->mode == 1) {       //  as pitch-pattern
                    if(dummy < FRAC_MINMIDI || dummy > FRAC_MAXMIDI) {
                        sprintf(errstr,"MIDIpitch (%lf) out of range (%lf to %lf) in file %s.\n",dummy,FRAC_MINMIDI,FRAC_MAXMIDI,str);
                        return DATA_ERROR;
                    }   
                    if(cnt == 1) {      
                        firstmidi = dummy;                  //  Note initial MIDI pitch
                        lastmaxpitch = dummy;               //  And search for max and min pitches
                        lastminpitch = dummy;               //  NB maximum and minimum search IGNORES last value in table
                    } else {
                        maxpitch = lastmaxpitch;
                        minpitch = lastminpitch;            
                        lastmaxpitch = max(lastmaxpitch,dummy);
                        lastminpitch = min(lastminpitch,dummy);
                    }
                } else {                                    //  as semitone-transposition-pattern   
                    if(dummy < FRAC_MINTRNS || dummy > FRAC_MAXTRNS) {
                        sprintf(errstr,"Transposition (%lf semitones) out of range (%lf to %lf) in file %s.\n",dummy,FRAC_MINTRNS,FRAC_MAXTRNS,str);
                        return DATA_ERROR;
                    }
                    if(cnt == 1) {
                        lastmintrans = dummy;               //  Search for max and min transpositions
                        lastmaxtrans = dummy;               //  NB maximum and minimum search IGNORES last value in table
                    } else {
                        mintrans = lastmintrans;
                        maxtrans = lastmaxtrans;
                        lastmintrans = min(lastmintrans,dummy);
                        lastmaxtrans = max(lastmaxtrans,dummy);
                    }
                }
            }
            cnt++;
        }
    }
    if(cnt == 0) {                                          //  Check data count
        sprintf(errstr,"No data found in file %s.\n",str);
        return DATA_ERROR;
    }
    if(ODD(cnt)) {
        sprintf(errstr,"Values not correctly paired in file %s.\n",str);
        return DATA_ERROR;
    }
    if(cnt < 4) {
        sprintf(errstr,"Insufficient values for a fractal shape (needs 2 times and 2 vals = 4 total) in file %s.\n",str);
        return DATA_ERROR;
    }
    dz->fracdur = lasttime;                                 //  Last time in data indicates total duration of fractal-shape
    if(dz->process == FRACTAL && dz->mode == 1)
        dz->startfrq = (float)miditohz(firstmidi);          //  In mode 1 (fractal-template of pitches), find initial frq of pattern

    dz->itemcnt = cnt/2;

    if((dz->parray = (double **)malloc(6 * sizeof(double *)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to create fractalisation calculation arrays.\n");
        return(MEMORY_ERROR);
    }
    if((dz->parray[3] = (double *)malloc((dz->itemcnt * 2) * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to store fractalisation data.\n");      //  fractemplate : original (input) fractal template data       
        return(MEMORY_ERROR);                                                 
    }
    fractemplate = dz->parray[3];   //  Original fractal template time-val pairs

    cnt = 0;
    fseek(fp,0,0);
    while(fgets(temp,200,fp)!=NULL) {
        p = temp;
        while(isspace(*p))
            p++;
        if(*p == ';' || *p == ENDOFSTR) //  Allow comments in file
            continue;
        while(get_float_from_within_string(&p,&dummy))
            fractemplate[cnt++] = dummy;
    }
    if(dz->process == FRACTAL && dz->mode == 1) {
        for(n=1;n<dz->itemcnt*2;n+=2)       //  Convert pitch input to transpositions of initial pitch
            fractemplate[n] -= firstmidi;
    }

    //  CHECK TIME LIMITS

    if(dz->process == FRACTAL && dz->mode == 1) {
        if(dz->fracdur > FRAC_MAXDUR) {                                             
            fprintf(stdout,"WARNING: Pattern total duration (%lf) greater than %.2lf hours, in file %s.\n",dz->fracdur,FRAC_MAXDUR/3600.0,str);
            fflush(stdout);
        }
    }
    if(dz->brksize[FRACTSTR]) {                             //  If fractal-shape time-stretched anywhere, get maximal tstretch,
        if((exit_status = get_maxvalue_in_brktable(&fracmax,FRACTSTR,dz))<0)
            return exit_status;
        dz->param[FRACTSTR] = (int)round(fracmax);
    }

    //  CHECK MAXIMUM FRACTALISATION

    dz->minfracratio = dz->minstep/dz->fracdur;
    get_max_fractalisation(dz);

    if(dz->maxfractalise < 1) {
        sprintf(errstr,"Smallest time-unit in pattern (%lf) too short to allow fractalisation.\n",dz->minstep);
        return DATA_ERROR;
    }
    if(dz->brksize[FRACMAX]) {                              //  If maximum fractalisation is preset by user
        if((exit_status = get_maxvalue_in_brktable(&fracmax,FRACMAX,dz))<0)
            return exit_status;
        dz->iparam[FRACMAX] = (int)round(fracmax);
    }                                                       //  compare it with the max possible fractalisation
    if(dz->iparam[FRACMAX] >  dz->maxfractalise) {
        fprintf(stdout,"WARNING: Max fractalisation will be restricted to %d because of time proportions in given shape data.\n",dz->maxfractalise);
        fflush(stdout);
    } else if (dz->iparam[FRACMAX] > 0 && dz->iparam[FRACMAX] < dz->maxfractalise)
        dz->maxfractalise = dz->iparam[FRACMAX];

    if(dz->brksize[FRACISTR]) {
        if((exit_status = get_maxvalue_in_brktable(&fracmax,FRACISTR,dz))<0)
            return exit_status;
        dz->param[FRACISTR] = fracmax;
    }

    //  CHECK RESTRICTIONS ON FRACTALISATION TRANSPOSITION-DEPTH CAUSED BY CHAINED-TRANSPOSITIONS
    
    //  FinD time-shrinkage at maximum amd minimum pitch (transposition) elements of fractal shape

    if(dz->vflag[FRAC_SHRINK]) {
        mindur_maxtrans = HUGE;
        mindur_mintrans = HUGE;
        if(dz->process == FRACTAL && dz->mode == 1) {
            maxelement = maxpitch - firstmidi;
            minelement = minpitch - firstmidi;
        } else {
            maxelement = maxtrans;
            minelement = mintrans;
        }
        for(n = 1; n < (dz->itemcnt -1) * 2; n+= 2) {
            if(fractemplate[n] == maxelement) {
                thisdur = fractemplate[n+1] - fractemplate[n-1];
                mindur_maxtrans = min(mindur_maxtrans,thisdur);
            }
            if(fractemplate[n] == minelement) {
                thisdur = fractemplate[n+1] - fractemplate[n-1];
                mindur_mintrans = min(mindur_mintrans,thisdur);
            }
        }
        if(mindur_maxtrans == HUGE || mindur_mintrans == HUGE) {
            sprintf(errstr,"Problem determining duration of max:min elements in fractal.\n");
            return PROGRAM_ERROR;
        }
        dz->maxtransshrink = mindur_maxtrans/dz->fracdur;
        dz->mintransshrink = mindur_mintrans/dz->fracdur;
    }

    //  Check what happens to maximum and minimum transpositions, after maximium fractalisation.

    if(dz->process == FRACTAL && dz->mode == 1)
        max_step = maxpitch - firstmidi;                //  Base-pitch assumed to be first pitch of pattern
    else
        max_step = maxtrans;
    if(dz->param[FRACISTR] > 1.0)
        max_step *= dz->param[FRACISTR];
    if(max_step > 0.0) {                                //  If highest pitch in fractal-shape is above initial pitch
        if(dz->vflag[FRAC_SHRINK]) {
            max_step_now = max_step;
            max_step = 0;
            for(n = 0;n < dz->maxfractalise;n++) {
                max_step += max_step_now;
                max_step_now *= dz->maxtransshrink;
            }
        } else
            max_step *= dz->maxfractalise;              //  calculate how mich this will step upwards in successive fractalisations
        if(dz->process == FRACTAL && dz->mode == 1) {
            maxpitch += max_step ;                          
            if(maxpitch > MIDIMAX) {
                sprintf(errstr,"Max pitch after max fractalisation (%d times) (MIDI %.2lf) exceeds limit (127).\n",dz->maxfractalise,maxpitch);
                return DATA_ERROR;
            }
        } else {                                        //  Convert to frq ratio
            maxtrans = pow(2.0,(max_step/SEMITONES_PER_OCTAVE));
            if(maxtrans > dz->maxtrnsp) {
                sprintf(errstr,"Max transpos after max fractalisation (%d times) (%lf octaves) exceeds limit (8).\n",dz->maxfractalise,LOG2(maxtrans));
                return DATA_ERROR;
            }
        }
    }
    if(dz->process == FRACTAL && dz->mode == 1)
        min_step = minpitch - firstmidi;
    else
        min_step = mintrans;
    if(dz->param[FRACISTR] > 1.0)
        min_step *= dz->param[FRACISTR];
    if(min_step < 0.0) {                                //  If lowest pitch in fractal-shape is below initial pitch
        if(dz->vflag[FRAC_SHRINK]) {
            min_step_now = min_step;
            min_step = 0;
            for(n = 0;n < dz->maxfractalise;n++) {
                min_step += min_step_now;
                min_step_now *= dz->mintransshrink;
            }
        } else
            min_step *= dz->maxfractalise;              //  calculate how mich this will step downwardsupwards in successive fractalisations
        if(dz->process == FRACTAL && dz->mode == 1) {
            minpitch += min_step;
            if(minpitch < 0) {
                sprintf(errstr,"Min pitch after max fractalisation (%d times) (MIDI %lf) falls below low limit (0).\n",dz->maxfractalise,minpitch);
                return DATA_ERROR;
            }
        } else {
            mintrans = pow(2.0,(mintrans/SEMITONES_PER_OCTAVE));
            mintrans = pow(mintrans,dz->maxfractalise);
            if(mintrans < 1.0/dz->maxtrnsp) {
                sprintf(errstr,"Max transpos down after max fractalisation (%d times) (%lf octaves) exceeds limit (-8).\n",dz->maxfractalise,LOG2(mintrans));
                return DATA_ERROR;
            }
        }
    }

    //  CREATE WORKING ARRAYS, now we know maximum depth of fractalisation (dz->maxfractalise)

    dz->arraysize = dz->itemcnt - 1;                                        //  Number of fractal elements
    dz->arraysize = (int)round(pow(dz->arraysize,dz->maxfractalise));       //  Number of entries needed for (largest) fractalisation
    dz->arraysize *= 2;                                                     //  .. then include space for timing entries ....
    dz->arraysize += 64;                                                    //  SAFETY

    if((dz->parray[0] = (double *)malloc(dz->arraysize * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to create fractalisation array.\n");
        return(MEMORY_ERROR);                                               //  fracpattern : Stores final conmplete fractalisation of data
    }
    if((dz->parray[1] = (double *)malloc(dz->arraysize * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to create swap buffer 1.\n");
        return(MEMORY_ERROR);                                               //  swapbuffer1 : 1st itermediate buffers to calc fractalisation, stage by stage
    }
    if((dz->parray[2] = (double *)malloc(dz->arraysize * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to create swap buffer 2.\n");
        return(MEMORY_ERROR);                                               //  swapbuffer2 : 2nd itermediate buffers to calc fractalisation, stage by stage
    }
    if((dz->parray[4] = (double *)malloc(dz->itemcnt * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to store transposing data.\n"); //  fracintvl : Mode 0 : Intvls in fractal template
        return(MEMORY_ERROR);                                               //              Mode 1 : Intvls btwn pitches in orig fractal pitch-template
    }
    if((dz->parray[5] = (double *)malloc(dz->itemcnt * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to store element duations.\n");
        return(MEMORY_ERROR);                                               //  fractimes : Onset times of each element in fractal template
    }

    fracintvl    = dz->parray[4];   //  Intervals between pitches in original fractal pitch-template
    fractimes    = dz->parray[5];   //  Fractal template element-start-times

    for(n=0, m=0; n < (dz->itemcnt-1) * 2; n +=2, m++) {        //  Stores dz->itemcnt-1 items
        fractimes[m] = fractemplate[n];
        fracintvl[m] = fractemplate[n+1];
    }
    dz->itemcnt--;                                              //  Last element of fractal template was needed only to specify total pattern's duration. So now ignore
                                                                //  dz->itemcnt is number of elements in fractal-template

    return FINISHED;
}

/************************************* CREATE_FRACTAL_PATTERN ***************************/

int create_fractal_pattern(dataptr dz)
{
    int fractalcnt = dz->itemcnt, total_fractalcnt, k, n, nn, t, v, ocnt = 0;
    double *fracpattern = dz->parray[0];    //  Stores final conmplete fractalisation of data
    double *swapbuffer1 = dz->parray[1];    //  Intermediate buffers to calc fractalisation, stage by stage
    double *swapbuffer2 = dz->parray[2];
    double *thisbuf = NULL, *thatbuf = NULL; 
    double *fractemplate = dz->parray[3];   //  Original fractal template time-val pairs
    double *fracintvl    = dz->parray[4];   //  Intervals between pitches in original fractal pitch-template
    double *fractimes    = dz->parray[5];   //  Fractal template element-start-times
    double starttime, startval, duration, shrinkage;

    memset((char *)fracpattern,0,dz->arraysize * sizeof(double));   
    memset((char *)swapbuffer1,0,dz->arraysize * sizeof(double));   
    memset((char *)swapbuffer2,0,dz->arraysize * sizeof(double));
    memcpy((char *)swapbuffer1,(char *)fractemplate,(dz->itemcnt+1) * 2 * sizeof(double));  //  Get original fractal-shape, with wraparound time
                                                                                            //  mode 0 = semitone transpos : mode1 = MIDIpitch 
    total_fractalcnt = fractalcnt;                                                          //  If fractalise only once, this is enough
    if(dz->maxfractalise == 1)
        thatbuf = swapbuffer1;
    else {
        for(k = 1; k < dz->maxfractalise;k++) {
            ocnt = 0;
            if(ODD(k))  {
                thisbuf = swapbuffer1;
                thatbuf = swapbuffer2;
            } else {        
                thisbuf = swapbuffer2;
                thatbuf = swapbuffer1;
            }
            memset((char *)thatbuf,0,dz->arraysize * sizeof(double));   
            for(n = 0, t = 0, v = 1; n < total_fractalcnt; n++,t+=2,v+=2) {     //  Fractalise every element of the "total_fractalcnt" elements existing at this stage.
                starttime  = thisbuf[t];
                startval   = thisbuf[v];
                duration   = thisbuf[t+2] - thisbuf[t];                         //  There is a wrap-around time-point in orig fractal-template
                shrinkage  = duration/dz->fracdur;
                for(nn = 0; nn < fractalcnt; nn++) {
                    if(ocnt + 2 >= dz->arraysize) {
                        sprintf(errstr,"Array overrun in generating fractal.\n");
                        return PROGRAM_ERROR;
                    }
                    thatbuf[ocnt++] = starttime + (fractimes[nn] * shrinkage);
                    if(dz->vflag[FRAC_SHRINK])
                        thatbuf[ocnt++] = startval + (fracintvl[nn] * shrinkage);
                    else
                        thatbuf[ocnt++] = startval + fracintvl[nn];
                }
            }
            total_fractalcnt = ocnt/2;                                          //  No of fractal elements after this fractalisation now increaaed to new "total_fractalcnt"
            if(ocnt >= dz->arraysize - 1) {
                sprintf(errstr,"Array overrun in generating last timepoint of fractal.\n");
                return PROGRAM_ERROR;
            }
            thatbuf[ocnt++] = fractemplate[dz->itemcnt*2];                      //  Retain wraparound time-point
        }
    }
    for(n = 0, t = 0, v = 1; n < total_fractalcnt; n++,t+=2,v+=2) {
        fracpattern[t] = thatbuf[t];
        if((dz->brksize[FRACISTR] > 0) || (dz->param[FRACISTR] > 0.0))          //  If fractal is interval warped, do it here
            thatbuf[v] *= dz->param[FRACISTR];
        fracpattern[v] = pow(2.0,(thatbuf[v]/SEMITONES_PER_OCTAVE));            //  Convert to 8va-transpos
    }
    fracpattern[t] = thatbuf[t];                                                //  Store wraparound time-point     

    if(dz->param[FRACTSTR] > 0.0) {
        for(t=0;t <= total_fractalcnt * 2; t+=2)                                //  If fractal is time-warped, do the timewarp
            fracpattern[t] *= dz->param[FRACTSTR];
    }
    dz->fracsize = total_fractalcnt;                                            //  Remember length of fractal pattern
    return FINISHED;
}

/************************************* CHECK_FRACTAL_PARAM_VALIDITY_AND_CONSISTENCY ***************************/

int check_fractal_param_validity_and_consistency(dataptr dz)
{
    int exit_status;
    double minwarp = 0.0;
    dz->timevary = 0;
    if(dz->brksize[FRACMAX] || dz->brksize[FRACTSTR] || dz->brksize[FRACISTR])
        dz->timevary = 1;
    if(dz->brksize[FRACTSTR]) {
        if((exit_status = get_minvalue_in_brktable(&minwarp,FRACTSTR,dz))<0)
            return exit_status;
        if(minwarp < 1.0) {
            sprintf(errstr,"Values in timewarp table must be >= 1.0\n");
            return DATA_ERROR;
        }
    } else if(dz->param[FRACTSTR] > 0.0 && dz->param[FRACTSTR] < 1.0) {
        sprintf(errstr,"Non-zero timewarp value must be >= 1.\n");
        return DATA_ERROR;
    }
    if(dz->process == FRACTAL) {
        dz->splicesmps = (int)ceil(FRAC_SPLICELEN * MS_TO_SECS * (double)dz->infile->srate);
        dz->total_splice = dz->splicesmps * dz->infile->channels;
        if(dz->mode == 1) {
            if(dz->insams[0] < dz->total_splice) {
                fprintf(stdout,"WARNING: Infile too short to enable endsplice to be made.\n");
                fflush(stdout);
                dz->total_splice = 0;   //  Don't attempt endsplice
            }
        } else
            dz->total_splice = 0;       //  No endsplice needed in mode 0
    } else {
        dz->splicesmps = 0;             //  Probably redundant
        dz->total_splice = 0;
    }
    return FINISHED;
}

/************************************* FRACTALISE ***************************/

int fractalise(dataptr dz)
{
    int exit_status, chans = dz->infile->channels, done = 0, ch, nxt, n, m;
    double intime = 0.0, outtime = 0.0, ztime, localtime, srate = (double)dz->infile->srate;
    int ibufpos = 0, gpibufpos = 0, obufpos = 0, fracindex = 0, bufcnt = 0, abs_input_start_samp = 0, nextfracsampcnt, zsamps;
    int   gpbuflen = dz->buflen/chans, abs_window_cnt = 0, next_abs_window_cnt = 0;
    double dibufpos = 0.0, localsampcnt, incr, frac, diff, spliceval, abs_time = 0, nexttime = 0.0, transpose = 1.0;
    double *fracpattern = dz->parray[0];
    float *ibuf, *obuf, *ovflwbuf = NULL;
    double *val;
    double *fractemplate = dz->parray[3];
    if(dz->process == FRACTAL) {
        ibuf = dz->sampbuf[0];
        /* input overflow in = dz->sampbuf[1] */ 
        obuf = dz->sampbuf[2];
        ovflwbuf = dz->sampbuf[3];
    } else {
        ibuf = dz->sampbuf[0];
        obuf = dz->sampbuf[1];
    }
    if((val = (double *)malloc(chans * sizeof(double))) == NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to create intermediate value storage.\n");
        return(MEMORY_ERROR);
    }
    if(!dz->timevary) {                                     //  If fractal does not vary
        if((exit_status = create_fractal_pattern(dz)) < 0)
            return exit_status;                             //  Create fixed fractal pattern
    }
    if(dz->process == FRACTAL) {
                                //  FRACTAL reads a double buffer, so that we have wraparound points to use
        if(dz->mode == 0) {                             //  (If mode 1, source used as "table", and is already in buffer)   
            dz->buflen *= 2;
            if((exit_status = read_samps(ibuf,dz))<0)
                return(exit_status);                        
            abs_input_start_samp = 0;
            dz->buflen /= 2;
        }
        for(ch = 0;ch < chans; ch++)                        //  Read initial src/table values to output value store
            val[ch] = ibuf[ch];
    } else {                                                //  FRACSPEC reads a single buffer of analysis samples  
        dz->flbufptr[0] = ibuf;
        dz->flbufptr[1] = obuf;
        if((exit_status = read_samps(ibuf,dz))<0)
            return(exit_status);
        memcpy((char *)obuf,(char *)ibuf,dz->wanted * sizeof(float));
        abs_time = dz->frametime;                           //  First window is copied (below)
        abs_window_cnt = 1;
        dz->flbufptr[0] += dz->wanted;                      //  flbufptrs advance
        dz->flbufptr[1] += dz->wanted;
    }
    while(!done) {
        if(dz->timevary) {                                  //  If fractal varies in time
            if(dz->mode == 1 || (dz->process == FRACTAL && dz->vflag[FRAC_OUTIMES])) {  //  Read brkpoint data using either time in infile or time in outfile
                if((exit_status = read_values_from_all_existing_brktables(outtime,dz))<0)
                    return exit_status;
            } else {
                if((exit_status = read_values_from_all_existing_brktables(intime,dz))<0)
                    return exit_status;
            }
            if(dz->iparam[FRACMAX] > 0)                     //  Find maximum fractalisation     
                dz->maxfractalise = dz->iparam[FRACMAX];
            else
                get_max_fractalisation(dz);
            if(dz->maxfractalise > 0)                       //  Create the fractal pattern, and remember length of fractal-pattern (dz->fracsize)
                create_fractal_pattern(dz);
        }
        ztime = fractemplate[dz->itemcnt * 2];
        if(dz->maxfractalise == 0) {
            if(dz->process == FRACTAL) {
                zsamps  = (int)round(ztime * srate);
                gpibufpos = (int)round(dibufpos);               //  Approximation of interpolating pointer involved here
                ibufpos = gpibufpos * chans;
                for(n = 0; n <zsamps; n++) {
                    if(ibufpos >= dz->buflen) {
                        if(dz->mode == 0) {                 //  If reading countinuous input, advance by buflen
                            memset((char *)ibuf,0,dz->buflen * 2 * sizeof(float));
                            bufcnt++;
                            if(dz->buflen * bufcnt >= dz->insams[0]) {
                                done = 1;                           //  Exit if attempted samps_read looks beyound input file end
                                break;
                            }
                            sndseekEx(dz->ifd[0],dz->buflen * bufcnt,0);
                            dz->buflen *= 2;                        //   and read 2 * buflen (so we have wraparound)
                            abs_input_start_samp += dz->ssampsread/2;
                            if((exit_status = read_samps(ibuf,dz))<0)
                                return(exit_status);
                            dz->buflen /= 2;
                            if(dz->ssampsread == 0) {               //  Exit if no more samples to read (should be redundant as trap at snd seek above)
                                done = 1;
                                break;
                            }
                        }
                        ibufpos -= dz->buflen;
                    }
                    if(obufpos >= dz->buflen + dz->total_splice) {  //  Allow enough samples on end of output to perform splice. (ALPHA)
                        if((exit_status = write_samps(obuf,dz->buflen,dz))<0)
                            return(exit_status);                    //  Write to outfile, then copy back ovflow into obuf
                        memset((char *)obuf,0,dz->buflen * sizeof(float));
                        memcpy((char *)obuf,(char *)ovflwbuf,dz->buflen * sizeof(float));
                        memset((char *)ovflwbuf,0,dz->buflen * sizeof(float));
                        obufpos -= dz->buflen;                      //  and reset obufptr
                    }
                    for(ch = 0;ch<chans;ch++)
                        obuf[obufpos++] = ibuf[ibufpos++];
                }
                gpibufpos  = ibufpos/chans;
                dibufpos = (double)gpibufpos;
                intime  += ztime;                                   //  overflow point in fractal template contains its duration, so advance time in input file
                outtime += ztime;                                   //  time in output file
            } else {    //   FRACSPEC
                next_abs_window_cnt = (int)round(ztime/dz->frametime);
                while(abs_window_cnt < next_abs_window_cnt) {
                    memcpy((char *)dz->flbufptr[1],(char *)dz->flbufptr[0],dz->wanted * sizeof(float));
                    dz->flbufptr[0] += dz->wanted;
                    dz->flbufptr[1] += dz->wanted;
                    if(dz->flbufptr[0] >= obuf) {
                        if((exit_status = write_samps(obuf,dz->buflen,dz))<0)
                            return(exit_status);
                        memset((char *)ibuf,0,dz->buflen * sizeof(float));
                        memset((char *)obuf,0,dz->buflen * sizeof(float));
                        if((exit_status = read_samps(ibuf,dz))<0)
                            return(exit_status);
                        if(dz->ssampsread == 0) {
                            done = 1;
                            break;
                        }
                        dz->flbufptr[0] = ibuf;
                        dz->flbufptr[1] = obuf;
                    }
                    abs_window_cnt++;
                    abs_time += dz->frametime;
                    if(abs_window_cnt >= dz->wlength) {
                        done = 1;
                        break;
                    }
                }
            }
        } else {
            if(dz->process == FRACTAL) {
                localsampcnt = 0;                                   //  This is a count in gp-samples
                fracindex = 0;
                while(fracindex < dz->fracsize * 2) {               //  For each unit of the fractal (2 entries - time:val - per fractal element)
                    nextfracsampcnt = (int)round(fracpattern[fracindex + 2] * srate);
                    while(localsampcnt > nextfracsampcnt) {
                        fracindex += 2;
                        if(fracindex >= dz->fracsize)
                            break;
                        nextfracsampcnt = (int)round(fracpattern[fracindex + 2] * srate);
                    }
                    incr = fracpattern[fracindex + 1];              //  Get current input-read increment
                    while(localsampcnt < nextfracsampcnt) {         //  While we're still using the current increment
                        for(ch = 0;ch < chans; ch++)
                            obuf[obufpos++] = (float)val[ch];       //  Copy current value from input to output
                        if(obufpos >= dz->buflen + dz->total_splice) {//    Allow enough samples on end of output to perform splice. (ALPHA)
                            if((exit_status = write_samps(obuf,dz->buflen,dz))<0)
                                return(exit_status);                //  Write to outfile, then copy back ovflow into obuf
                            memset((char *)obuf,0,dz->buflen * sizeof(float));
                            memcpy((char *)obuf,(char *)ovflwbuf,dz->buflen * sizeof(float));
                            memset((char *)ovflwbuf,0,dz->buflen * sizeof(float));
                            obufpos -= dz->buflen;                  //  and reset obufptr
                        }
                        if(dz->mode == 1) {
                            dibufpos += incr * dz->convertor;       //  Advance in table-read
                            gpibufpos = (int)floor(dibufpos);
                            ibufpos = gpibufpos;                    //  Mono
                        }else {
                            dibufpos += incr;                       //  Advance pointer in infile src
                            gpibufpos = (int)floor(dibufpos);
                            ibufpos = gpibufpos * chans;            //  In mode 1, if run off end of input file, quit
                            if(abs_input_start_samp + ibufpos >= dz->insams[0]) {               
                                done = 1;
                                break;
                            }
                        }
                        frac = dibufpos - (double)gpibufpos;            
                        if(gpibufpos >= gpbuflen) {             
                            if(dz->mode == 0) {                     //  If reading countinuous input, advance by buflen
                                memset((char *)ibuf,0,dz->buflen * 2 * sizeof(float));
                                bufcnt++;
                                if(dz->buflen * bufcnt >= dz->insams[0]) {
                                    done = 1;                       //  Exit if attempted samps_read looks beyound input file end
                                    break;
                                }
                                sndseekEx(dz->ifd[0],dz->buflen * bufcnt,0);
                                dz->buflen *= 2;                    //   and read 2 * buflen (so we have wraparound)
                                abs_input_start_samp += dz->ssampsread/2;
                                if((exit_status = read_samps(ibuf,dz))<0)
                                    return(exit_status);
                                dz->buflen /= 2;
                                if(dz->ssampsread == 0) {           //  Exit if no more samples to read (should be redundant as trap at snd seek above)
                                    done = 1;
                                    break;
                                }
                            }
                            gpibufpos -= gpbuflen;
                            dibufpos  -= (double)gpbuflen;
                            ibufpos = gpibufpos * chans;
                        }                                           //  Working in absolute sample-frame get interpolated value(s) from src/table
                        for(ch = 0,nxt = chans;ch < chans;ch++,nxt++) {
                            val[ch]  = ibuf[ibufpos + ch];
                            diff     = ibuf[ibufpos + nxt] - val[ch];
                            val[ch] += diff * frac;
                        }
                        localsampcnt += incr;                       //  Advance by given samp-time incr
                        if(localsampcnt >= nextfracsampcnt)         //  If we reach time of next fractal (we will therefore exit inner loop)
                            fracindex += 2;                         //  incr fracindex-value, hence advance in fractal pattern in outer loop
                    }
                    if(done)
                        break;
                }
                intime += fracpattern[dz->fracsize];                //  overflow point in fractal table contains its duration, so advance time in input file
                outtime = (double)((dz->total_samps_written + obufpos)/chans)/srate;    //  time in output file
                if(dz->mode == 1) {
                    if(outtime >= dz->param[FRACDUR])
                        done = 1;
                } else {
                    if(intime >= dz->duration)
                        done = 1;
                }
            } else {    //   FRACSPEC
                localtime = 0.0;
                fracindex = 0;
                while(fracindex < dz->fracsize * 2) {               //  For each unit of the fractal (2 entries - time:val - per fractal element)
                    nexttime  = fracpattern[fracindex + 2];
                    transpose = fracpattern[fracindex + 1];
                    while(localtime < nexttime) {
                        if((exit_status = fractal_spectrnsf(transpose,dz))<0)
                            return(exit_status);
                        memcpy((char *)dz->flbufptr[1],(char *)dz->flbufptr[0],dz->wanted * sizeof(float));
                        dz->flbufptr[0] += dz->wanted;
                        dz->flbufptr[1] += dz->wanted;
                        if(dz->flbufptr[0] >= obuf) {   //  obuf abutts to end of ibuf
                            if((exit_status = write_samps(obuf,dz->buflen,dz))<0)
                                return(exit_status);
                            memset((char *)ibuf,0,dz->buflen * sizeof(float));
                            memset((char *)obuf,0,dz->buflen * sizeof(float));
                            if((exit_status = read_samps(ibuf,dz))<0)
                                return(exit_status);
                            if(dz->ssampsread == 0) {
                                done = 1;
                                break;
                            }
                            dz->flbufptr[0] = ibuf;
                            dz->flbufptr[1] = obuf;
                        }
                        abs_window_cnt++;
                        abs_time  += dz->frametime;
                        localtime += dz->frametime;
                        if(abs_time >= dz->duration) {
                            done = 1;
                            break;
                        }
                    }
                    fracindex += 2;
                if(done)
                    break;
                }

            }
        }
    }
    if(obufpos > 0) {
        if(dz->process == FRACTAL) {
            if(dz->mode == 1 && dz->total_splice > 0) {
                for(n=0,m = obufpos - chans;n < dz->splicesmps;n++,m -= chans) {
                    spliceval = (double)n/(double)dz->splicesmps;   
                    for(ch = 0;ch < chans;ch++)                 //  Splice end of output
                        obuf[m+ch] = (float)(obuf[m+ch] * spliceval);
                }
            }
        }
        if((exit_status = write_samps(obuf,obufpos,dz))<0)
            return(exit_status);                            //  Write last samples to outfile
    }
    return FINISHED;
}

/**************************** GET_MAX_FRACTALISATION ****************************/

void get_max_fractalisation(dataptr dz)
{
    double minlen = dz->minstep;                            //  minimum duration in fractal-shape   
    dz->maxfractalise = 0;
    if(dz->param[FRACTSTR] > 1.0)                           //  If fractal-shape gets stretched anywhere, expand minlen appropriately
        minlen *= dz->param[FRACTSTR];
    while(minlen > dz->mintime) {                           //  Calculate the max possible fractalisation
        minlen *= dz->minfracratio;
        dz->maxfractalise++;
    }
}

/**************************** CREATE_FRACTAL_SNDBUFS ****************************/

int create_fractal_sndbufs(dataptr dz)
{
    int exit_status, n;
    int bigbufsize, secsize, m;
    int framesize = F_SECSIZE * dz->infile->channels;
    double srate = (double)dz->infile->srate;

    if(dz->process == FRACTAL) {
        if (dz->mode == 1)  //  Mode 1, source file is used as a table to read cyclically
            bigbufsize = dz->insams[0] * sizeof(float);
        else
            bigbufsize = (int)(size_t) Malloc(-1);
     secsize = bigbufsize/framesize;
        if(secsize * framesize < bigbufsize) {
            secsize++;
            bigbufsize = secsize * framesize;
        }
    } else
        bigbufsize = dz->wanted * BUF_MULTIPLIER * sizeof(float);
    dz->buflen = bigbufsize/sizeof(float);
    if(bigbufsize * dz->bufcnt <= 0) {
        if(dz->process == FRACTAL && dz->mode == 1)
            sprintf(errstr,"Infile too large to create sound buffers.\n");
        else
            sprintf(errstr,"Insufficent memory to create sound buffers.\n");
        return(PROGRAM_ERROR);
    }
    if((dz->bigbuf = (float *)malloc(bigbufsize * dz->bufcnt)) == NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY to create sound buffers.\n");
        return(PROGRAM_ERROR);
    }
    if((dz->sampbuf = (float **)malloc(sizeof(float *) * (dz->bufcnt+1)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY establishing sample buffers.\n");
        return(MEMORY_ERROR);
    }
    if((dz->sbufptr = (float **)malloc(sizeof(float *) * dz->bufcnt))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY establishing sample buffer pointers.\n");
        return(MEMORY_ERROR);
    }
    if(dz->process == FRACSPEC) {
        if((dz->flbufptr = (float **)malloc(sizeof(float *) * dz->bufcnt))==NULL) {
            sprintf(errstr,"INSUFFICIENT MEMORY for float sample buffers.\n");
            return(MEMORY_ERROR);
        }
        for(n = 0;n <dz->bufcnt; n++)
            dz->flbufptr[n] = NULL;
    }

    for(n=0;n<dz->bufcnt;n++)
        dz->sbufptr[n] = dz->sampbuf[n] = dz->bigbuf + (dz->buflen * n);
    dz->sampbuf[n] = dz->bigbuf + (dz->buflen * n);
    // FRACTAL
    // dz->sampbuf[0] ibuf
    // dz->sampbuf[1] iovflwbuf
    // dz->sampbuf[2] obuf
    // dz->sampbuf[3] ovflwbuf      dz->sampbuf[4] end of ovflwbuf
    // FRACSPEC
    // dz->sampbuf[0] ibuf
    // dz->sampbuf[1] obuf

    if(dz->process == FRACTAL && dz->mode == 1) {
        if((exit_status = read_samps(dz->sampbuf[0],dz))<0) //  Read source into buffer
            return(exit_status);
        for(n=0, m = dz->insams[0];n < dz->infile->channels;n++,m++)
            dz->sampbuf[0][m] = 0;                          //  wraparound points go into iovflwbuf
        dz->convertor = (double)dz->insams[0]/srate;        //  Table-read convertor for a 1Hz read
        dz->convertor *= dz->startfrq;                      //  Table-read convertor for a fractal-startfrq read
    }
    return FINISHED;
}

/********************************** SPECTRNSF **********************************
 *
 * transpose spectrum, but retain original spectral envelope.
 */

int fractal_spectrnsf(double transpose,dataptr dz)
{
    int exit_status;
    double pre_totalamp, post_totalamp;
    int cc, vc;
    rectify_window(dz->flbufptr[0],dz);
    if((exit_status = fractal_extract_specenv(dz))<0)
        return(exit_status);
    if((exit_status = get_totalamp(&pre_totalamp,dz->flbufptr[0],dz->wanted))<0)
        return(exit_status);
    if(dz->vflag[1]) {
        for(cc = 0, vc = 0; cc < dz->clength; cc++, vc += 2)
            dz->flbufptr[0][FREQ] = (float)(fabs(dz->flbufptr[0][FREQ])*transpose);
    } else {
        for(cc = 0, vc = 0; cc < dz->clength; cc++, vc += 2) {
            if((exit_status = fractal_tranpose_within_formant_envelope(vc,transpose,dz))<0)
                return(exit_status);
        }
    }
    if((exit_status = fractal_reposition_partials_in_appropriate_channels(transpose,dz))<0)
        return(exit_status);
    if((exit_status = get_totalamp(&post_totalamp,dz->flbufptr[0],dz->wanted))<0)
        return(exit_status);
    return normalise(pre_totalamp,post_totalamp,dz);
}

    /************************** TRANPOSE_WITHIN_FORMANT_ENVELOPE *****************************/

int fractal_tranpose_within_formant_envelope(int vc,double transpose,dataptr dz)
{
    int exit_status;
    double thisspecamp, newspecamp, thisamp, formantamp_ratio; 
    if((exit_status = fractal_getspecenvamp(&thisspecamp,(double)dz->flbufptr[0][FREQ],dz))<0)
        return(exit_status);
    dz->flbufptr[0][FREQ] = (float)(fabs(dz->flbufptr[0][FREQ])*transpose);
    if(dz->flbufptr[0][FREQ] < dz->nyquist) {
        if(thisspecamp < VERY_TINY_VAL)
            dz->flbufptr[0][AMPP] = 0.0f;
        else {
            if((exit_status = fractal_getspecenvamp(&newspecamp,(double)dz->flbufptr[0][FREQ],dz))<0)
                return(exit_status);
            if(newspecamp < VERY_TINY_VAL)
                dz->flbufptr[0][AMPP] = 0.0f;
            else {
                formantamp_ratio = newspecamp/thisspecamp;
                if((thisamp = dz->flbufptr[0][AMPP] * formantamp_ratio) < VERY_TINY_VAL)
                    dz->flbufptr[0][AMPP] = 0.0f;
                else
                    dz->flbufptr[0][AMPP] = (float)thisamp;
            }
        }
    }
    return(FINISHED);
}

/************************ REPOSITION_PARTIALS_IN_APPROPRIATE_CHANNELS *************************
 *
 * (1)  At each pass, preset store-buffer channel amps to zero.
 * (2)  Move frq data into appropriate channels, carrying the
 *      amplitude information along with them.
 *      Work down spectrum  for upward transposition, and
 * (3)  up spectrum for downward transposition,
 *      so that we do not overwrite transposed data before we move it.
 * (4)  Put new frqs back into src buff.
 */

int fractal_reposition_partials_in_appropriate_channels(double transpose,dataptr dz)
{
    int exit_status;
    int truecc,truevc;
    int cc, vc;
    for(vc = 0, cc= 0; vc < dz->wanted; vc+=2, cc++) {                      /* 1 */
        dz->windowbuf[0][AMPP] = 0.0f;
        dz->windowbuf[0][FREQ] = (float)(cc * dz->chwidth);
    }
    if(transpose > 1.0f) {          /* 2 */
        for(cc=dz->clength-1,vc = dz->wanted-2; cc>=0; cc--, vc-=2) {
            if(dz->flbufptr[0][FREQ] < dz->nyquist && dz->flbufptr[0][AMPP] > 0.0f) {
                if((exit_status = fractal_get_channel_corresponding_to_frq(&truecc,(double)dz->flbufptr[0][FREQ],dz))<0)
                    return(exit_status);
                truevc = truecc * 2;
                if((exit_status = move_data_into_appropriate_channel(vc,truevc,dz->flbufptr[0][AMPP],dz->flbufptr[0][FREQ],dz))<0)
                    return(exit_status);
            }
        }
        for(vc = 0; vc < dz->wanted; vc++)
            dz->flbufptr[0][vc] = dz->windowbuf[0][vc]; 
    } else if(transpose < 1.0f){        /* 3 */
        for(cc=0,vc = 0; cc < dz->clength; cc++, vc+=2) {
            if(dz->flbufptr[0][FREQ] < dz->nyquist && dz->flbufptr[0][FREQ]>0.0) {
                if((exit_status = fractal_get_channel_corresponding_to_frq(&truecc,(double)dz->flbufptr[0][FREQ],dz))<0)
                    return(exit_status);
                truevc = truecc * 2;
                if((exit_status = move_data_into_appropriate_channel(vc,truevc,dz->flbufptr[0][AMPP],dz->flbufptr[0][FREQ],dz))<0)
                    return(exit_status);
            }
        }
        for(vc = 0; vc < dz->wanted; vc++)
            dz->flbufptr[0][vc] = dz->windowbuf[0][vc];     /* 4 */
    }
    return(FINISHED);
}

/******************* ZERO_OUTOFRANGE_CHANNELS *****************/

int fractal_zero_outofrange_channels(double *totalamp,double lofrq_limit,double hifrq_limit,dataptr dz)
{
    int cc, vc;
    *totalamp = 0.0;
    for(cc = 0,vc = 0; cc < dz->clength; cc++, vc += 2) {
        if(dz->flbufptr[0][FREQ] < lofrq_limit || dz->flbufptr[0][FREQ] > hifrq_limit)
            dz->flbufptr[0][AMPP] = 0.0f;
        else
            *totalamp += dz->flbufptr[0][AMPP];
    }
    return(FINISHED);
}

/**************************** GETSPECENVAMP *************************/

int fractal_getspecenvamp(double *thisamp,double thisfrq,dataptr dz)
{
    double pp, ratio, ampdiff;
    int z = 1;
    if(thisfrq<0.0) {   /* NOT SURE THIS IS CORRECT */
        *thisamp = 0.0; /* SHOULD WE PHASE INVERT & RETURN A -ve AMP ?? */
        return(FINISHED);   
    }
    if(thisfrq<=1.0)
        pp = 0.0;
    else
        pp = log10(thisfrq); 
    while( dz->specenvpch[z] < pp){
        z++;
        /*RWD may need to trap on size of array? */
        if(z == dz->infile->specenvcnt -1)
            break;
    }
    ratio    = (pp - dz->specenvpch[z-1])/(dz->specenvpch[z] - dz->specenvpch[z-1]);
    ampdiff  = dz->specenvamp[z] - dz->specenvamp[z-1];
    *thisamp = dz->specenvamp[z-1] + (ampdiff * ratio);
    *thisamp = max(0.0,*thisamp);
    return(FINISHED);
}

/********************** EXTRACT_SPECENV *******************/

int fractal_extract_specenv(dataptr dz)
{
    int    n, cc, vc, specenvcnt_less_one;
    int    botchan, topchan;
    double botfreq, topfreq;
    double bwidth_in_chans;
    specenvcnt_less_one = dz->infile->specenvcnt - 1;
    vc = 0;
    //  RECTIFY_CHANNEL_FRQ_ORDER
    for(n=0;n<dz->infile->specenvcnt;n++)
        dz->specenvamp[n] = (float)0.0;
    topfreq = 0.0f;
    n = 0;
    while(n < specenvcnt_less_one) {
        botfreq  = topfreq;
        botchan  = (int)((botfreq + dz->halfchwidth)/dz->chwidth); /* TRUNCATE */
        botchan -= 4;   //  CHAN_SRCHRANGE_F
        botchan  =  max(botchan,0);
        topfreq  = dz->specenvtop[n];
        topchan  = (int)((topfreq + dz->halfchwidth)/dz->chwidth); /* TRUNCATE */
        topchan += 4;   //  CHAN_SRCHRANGE_F;
        topchan  =  min(topchan,dz->clength);
        for(cc = botchan,vc = botchan * 2; cc < topchan; cc++,vc += 2) {
            if(dz->flbufptr[0][FREQ] >= botfreq && dz->flbufptr[0][FREQ] < topfreq)
                dz->specenvamp[n] = (float)(dz->specenvamp[n] + dz->flbufptr[0][AMPP]);
        }
        bwidth_in_chans   = (double)(topfreq - botfreq)/dz->chwidth;
        dz->specenvamp[n] = (float)(dz->specenvamp[n]/bwidth_in_chans);
        n++;
    }
    return(FINISHED);
}

/************************** INITIALISE_SPECENV *********************
 *
 *  MAR 1998: not sure if the follwoing comment is relevant any more
 *  but I wont risk changing it at this stage.
 *
 *  WANTED and CLENGTH are calculated from scratch here, as dz->wanted
 *  gets set equal to dz->specenvcnt for calculations on formant data,
 *  while dz->clength may not yet be set!!      
 */

int fractal_initialise_specenv(int *arraycnt,dataptr dz)
{
    *arraycnt   = (dz->infile->channels/2) + 1;
    if((dz->specenvfrq = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for formant frq array.\n");
        return(MEMORY_ERROR);
    }
    if((dz->specenvpch = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for formant pitch array.\n");
        return(MEMORY_ERROR);
    }
    /*RWD  zero the data */
    memset(dz->specenvpch,0,*arraycnt * sizeof(float));

    if((dz->specenvamp = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for formant aplitude array.\n");
        return(MEMORY_ERROR);
    }
    if((dz->specenvtop = (float *)malloc((*arraycnt) * sizeof(float)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for formant frq limit array.\n");
        return(MEMORY_ERROR);
    }
    if((dz->windowbuf = (float **)malloc(sizeof(float *)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for extra float sample buffers.\n");
        return(MEMORY_ERROR);
    }
    if((dz->windowbuf[0] = (float *)malloc(dz->wanted * sizeof(float)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY for extra float sample buffer 0.\n");
        return(MEMORY_ERROR);
    }
    return(FINISHED);
}

/************************************ FRACTAL_SET_SPECENV_FRQS ****************************/

int fractal_set_specenv_frqs(int arraycnt,dataptr dz)
{
    int exit_status;
    double bandbot;
    double *interval;
    int m, n, k = 0, cc;
    //  PICHWISE_FORMANTS
    if((exit_status = fractal_setup_octaveband_steps(&interval,dz))<0)
        return(exit_status);
    if((exit_status = fractal_setup_low_octave_bands(arraycnt,dz))<0)
        return(exit_status);
    k  = 4; //  TOP_OF_LOW_OCTAVE_BANDS
    cc = 8; //  CHAN_ABOVE_LOW_OCTAVES
    while(cc <= dz->clength) {
        m = 0;
        if((bandbot = dz->chwidth * (double)cc) >= dz->nyquist)
            break;
        for(n=0;n<dz->formant_bands;n++) {
            if(k >= arraycnt) {
                sprintf(errstr,"Formant array too small: fractal_set_specenv_frqs()\n");
                return(PROGRAM_ERROR);
            }
            dz->specenvfrq[k]   = (float)(bandbot * interval[m++]);
            dz->specenvpch[k]   = (float)log10(dz->specenvfrq[k]);
            dz->specenvtop[k++] = (float)(bandbot * interval[m++]);
        }   
        cc *= 2;        /* 8-16: 16-32: 32-64 etc as 8vas, then split into bands */
    }
    dz->specenvfrq[k] = (float)dz->nyquist;
    dz->specenvpch[k] = (float)log10(dz->nyquist);
    dz->specenvtop[k] = (float)dz->nyquist;
    dz->specenvamp[k] = (float)0.0;
    k++;
    dz->infile->specenvcnt = k;
    return(FINISHED);
}

/************************* SETUP_OCTAVEBAND_STEPS ************************/

int fractal_setup_octaveband_steps(double **interval,dataptr dz)
{
    double octave_step;
    int n = 1, m = 0, halfbands_per_octave = dz->formant_bands * 2;
    if((*interval = (double *)malloc(halfbands_per_octave * sizeof(double)))==NULL) {
        sprintf(errstr,"INSUFFICIENT MEMORY establishing interval array for formants.\n");
        return(MEMORY_ERROR);
    }
    while(n < halfbands_per_octave) {
        octave_step   = (double)n++/(double)halfbands_per_octave;
        (*interval)[m++] = pow(2.0,octave_step);
    }
    (*interval)[m] = 2.0;
    return(FINISHED);
}

/************************ SETUP_LOW_OCTAVE_BANDS ***********************
 *
 * Lowest PVOC channels span larger freq steps and therefore we must
 * group them in octave bands, rather than in anything smaller.
 */

int fractal_setup_low_octave_bands(int arraycnt,dataptr dz)
{
    int n;
    if(arraycnt < LOW_OCTAVE_BANDS) {
        sprintf(errstr,"Insufficient array space for low_octave_bands\n");
        return(PROGRAM_ERROR);
    }
    for(n=0;n<LOW_OCTAVE_BANDS;n++) {
        switch(n) {
        case(0):
            dz->specenvfrq[0] = (float)1.0;                 /* frq whose log is 0 */
            dz->specenvpch[0] = (float)0.0;
            dz->specenvtop[0] = (float)dz->chwidth;         /* 8VA wide bands */
            break;
        case(1):
            dz->specenvfrq[1] = (float)(dz->chwidth * 1.5); /* Centre Chs 1-2 */    
            dz->specenvpch[1] = (float)log10(dz->specenvfrq[1]);
            dz->specenvtop[1] = (float)(dz->chwidth * 2.0);
            break;
        case(2):
            dz->specenvfrq[2] = (float)(dz->chwidth * 3.0); /* Centre Chs 2-4 */
            dz->specenvpch[2] = (float)log10(dz->specenvfrq[2]);
            dz->specenvtop[2] = (float)(dz->chwidth * 4.0);
            break;
        case(3):
            dz->specenvfrq[3] = (float)(dz->chwidth * 6.0); /* Centre Chs 4-8 */    
            dz->specenvpch[3] = (float)log10(dz->specenvfrq[3]);
            dz->specenvtop[3] = (float)(dz->chwidth * 8.0);
            break;
        default:
            sprintf(errstr,"Insufficient low octave band setups in fractal_setup_low_octave_bands()\n");
            return(PROGRAM_ERROR);
        }
    }
    return(FINISHED);
}

/**************************** GET_CHANNEL_CORRESPONDING_TO_FRQ ***************************/

int fractal_get_channel_corresponding_to_frq(int *chan,double thisfrq,dataptr dz)
{   
    if(dz->chwidth <= 0.0) {
        sprintf(errstr,"chwidth not set in fractal_get_channel_corresponding_to_frq()\n");
        return(PROGRAM_ERROR);
    }
    if(thisfrq < 0.0) {
        sprintf(errstr,"-ve frequency in fractal_get_channel_corresponding_to_frq()\n");
        return(PROGRAM_ERROR);
    }
    if(thisfrq > dz->nyquist) {
        sprintf(errstr,"frequency beyond nyquist in fractal_get_channel_corresponding_to_frq()\n");
        return(PROGRAM_ERROR);
    }
    *chan = (int)((fabs(thisfrq) + dz->halfchwidth)/dz->chwidth);  /* TRUNCATE */
    if(*chan >= dz->clength) {
        sprintf(errstr,"chan (%d) beyond clength-1 (%d) returned: fractal_get_channel_corresponding_to_frq()\n",
        *chan,(dz->clength)-1);
        return(PROGRAM_ERROR);
    }
    return(FINISHED);
}