ComposerDesktopProject/dev/focus/ap_focus.c

/*
 * Copyright (c) 1983-2013 Trevor Wishart and Composers Desktop Project Ltd
 * http://www.trevorwishart.co.uk
 * http://www.composersdesktop.com
 *
 This file is part of the CDP System.

    The CDP System is free software; you can redistribute it
    and/or modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    The CDP System is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with the CDP System; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307 USA
 *
 */



#include <stdio.h>
#include <stdlib.h>
#include <structures.h>
#include <cdpmain.h>
#include <tkglobals.h>
#include <pnames.h>
#include <focus.h>
#include <processno.h>
#include <modeno.h>
#include <globcon.h>
#include <logic.h>
#include <filetype.h>
#include <mixxcon.h>
#include <flags.h>
#include <speccon.h>
#include <arrays.h>
#include <special.h>
#include <formants.h>
#include <sfsys.h>
#include <osbind.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <srates.h>

#ifndef cdp_round
extern int cdp_round(double a);
#endif

#if defined unix || defined __GNUC__
#define round(x) lround((x))
#endif

/********************************************************************************************/
/********************************** FORMERLY IN pconsistency.c ******************************/
/********************************************************************************************/

static int 	check_consistency_of_frq_limits_for_focus(dataptr dz);

/********************************************************************************************/
/********************************** FORMERLY IN preprocess.c ********************************/
/********************************************************************************************/

static int  scale_accu_parameters(dataptr dz);
static int  convert_params_for_exag(dataptr dz);
static int  setup_internal_arrays_and_params_for_focus(dataptr dz);
static int  generate_focu_filter_params(dataptr dz);
static int  establish_internal_arrays_for_focus(dataptr dz);
static int  fold_preprocess(dataptr dz);
static int  get_frztimes(dataptr dz);
static int  rationalise_frztimes(dataptr dz);
static int  convert_params_for_step(dataptr dz);

/********************************************************************************************/
/********************************** FORMERLY IN specialin.c *********************************/
/********************************************************************************************/

static int  read_specfreeze_data(char *filename,dataptr dz);
static int  read_specfreeze2_data(char *filename,dataptr dz);
static int  set_timetype(char **first_char_of_string,int strno,int *is_direction_info,dataptr dz);
static int  read_time(char **p,double *dtime,int strno,int linecnt, char *filename);
static int  insert_values_at_time_zero(int *n,dataptr dz);
static int  check_time_sequencing(int n,char *filename,dataptr dz);

/***************************************************************************************/
/****************************** FORMERLY IN aplinit.c **********************************/
/***************************************************************************************/

/***************************** ESTABLISH_BUFPTRS_AND_EXTRA_BUFFERS **************************/

int establish_bufptrs_and_extra_buffers(dataptr dz)
{
	int exit_status;
	int is_spec = FALSE;
	dz->extra_bufcnt = -1;	/* ENSURE EVERY CASE HAS A PAIR OF ENTRIES !! */
	dz->bptrcnt = 0;
	dz->bufcnt  = 0;
	switch(dz->process) {
	case(ACCU):       		dz->extra_bufcnt =  1; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(EXAG):       		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(FOCUS):      		dz->extra_bufcnt =  0; dz->bptrcnt = 4; 	is_spec = TRUE;		break;
	case(FOLD):       		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(FREEZE):     		dz->extra_bufcnt =  1; dz->bptrcnt = 4; 	is_spec = TRUE;		break;	
	case(FREEZE2):     		dz->extra_bufcnt =  0; dz->bptrcnt = 4; 	is_spec = TRUE;		break;	
	case(STEP):       		dz->extra_bufcnt =  1; dz->bptrcnt = 2; 	is_spec = TRUE;		break;
	default:
		sprintf(errstr,"Unknown program type [%d] in establish_bufptrs_and_extra_buffers()\n",dz->process);
		return(PROGRAM_ERROR);
	}

	if(dz->extra_bufcnt < 0) {
		sprintf(errstr,"bufcnts have not been set: establish_bufptrs_and_extra_buffers()\n");
		return(PROGRAM_ERROR);
	}
	if(is_spec)
		return establish_spec_bufptrs_and_extra_buffers(dz);
	else if((dz->process==HOUSE_SPEC && dz->mode==HOUSE_CONVERT) || dz->process==INFO_DIFF) {
		if((exit_status = establish_spec_bufptrs_and_extra_buffers(dz))<0)
			return(exit_status);
	}
	return establish_groucho_bufptrs_and_extra_buffers(dz);
}

/***************************** SETUP_INTERNAL_ARRAYS_AND_ARRAY_POINTERS **************************/

int setup_internal_arrays_and_array_pointers(dataptr dz)
{
	int n;		 
	dz->ptr_cnt    = -1;		/* base constructor...process */
	dz->array_cnt  = -1;
	dz->iarray_cnt = -1;
	dz->larray_cnt = -1;
	switch(dz->process) {
	case(ACCU):   	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(EXAG):   	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(FOCUS):  	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(FOLD):   	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(FREEZE): 	dz->array_cnt = 0; dz->iarray_cnt =1;  dz->larray_cnt =2;  dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(FREEZE2): 	dz->array_cnt = 0; dz->iarray_cnt =1;  dz->larray_cnt =2;  dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(STEP):   	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	}

/*** WARNING ***
ANY APPLICATION DEALING WITH A NUMLIST INPUT: MUST establish AT LEAST 1 double array: i.e. dz->array_cnt = at least 1
**** WARNING ***/


	if(dz->array_cnt < 0 || dz->iarray_cnt < 0 || dz->larray_cnt < 0 || dz->ptr_cnt < 0 || dz->fptr_cnt < 0) {
		sprintf(errstr,"array_cnt not set in setup_internal_arrays_and_array_pointers()\n");	   
		return(PROGRAM_ERROR);
	}

	if(dz->array_cnt > 0) {  
		if((dz->parray  = (double **)malloc(dz->array_cnt * sizeof(double *)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY for internal double arrays.\n");
			return(MEMORY_ERROR);
		}
		for(n=0;n<dz->array_cnt;n++)
			dz->parray[n] = NULL;
	}
	if(dz->iarray_cnt > 0) {
		if((dz->iparray = (int     **)malloc(dz->iarray_cnt * sizeof(int *)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY for internal int arrays.\n");
			return(MEMORY_ERROR);
		}
		for(n=0;n<dz->iarray_cnt;n++)
			dz->iparray[n] = NULL;
	}
	if(dz->larray_cnt > 0) {	  
		if((dz->lparray = (int    **)malloc(dz->larray_cnt * sizeof(int *)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY for internal long arrays.\n");
			return(MEMORY_ERROR);
		}
		for(n=0;n<dz->larray_cnt;n++)
			dz->lparray[n] = NULL;
	}
	if(dz->ptr_cnt > 0)   {  	  
		if((dz->ptr    	= (double  **)malloc(dz->ptr_cnt  * sizeof(double *)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY for internal pointer arrays.\n");
			return(MEMORY_ERROR);
		}
		for(n=0;n<dz->ptr_cnt;n++)
			dz->ptr[n] = NULL;
	}
	if(dz->fptr_cnt > 0)   {  	  
		if((dz->fptr = (float  **)malloc(dz->fptr_cnt * sizeof(float *)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY for internal float-pointer arrays.\n");
			return(MEMORY_ERROR);
		}
		for(n=0;n<dz->fptr_cnt;n++)
			dz->fptr[n] = NULL;
	}
	return(FINISHED);
}

/****************************** ASSIGN_PROCESS_LOGIC *********************************/

int assign_process_logic(dataptr dz)
{						 
	switch(dz->process) {
	case(ACCU):			setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(EXAG):			setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(FOCUS):		setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(FOLD):			setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(FREEZE):		setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(FREEZE2):		setup_process_logic(ANALFILE_ONLY,		  	BIG_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(STEP):			setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	default:
		sprintf(errstr,"Unknown process: assign_process_logic()\n");
		return(PROGRAM_ERROR);
		break;
	}
	if(dz->has_otherfile) {
		switch(dz->input_data_type) {
		case(ALL_FILES):
		case(TWO_SNDFILES):
		case(SNDFILE_AND_ENVFILE):
		case(SNDFILE_AND_BRKFILE):
		case(SNDFILE_AND_UNRANGED_BRKFILE):
		case(SNDFILE_AND_DB_BRKFILE):
			break;
		case(MANY_SNDFILES):
			if(dz->process==INFO_TIMELIST)
				break;
			/* fall thro */
		default:
			sprintf(errstr,"Most processes accepting files with different properties\n"
						   "can only take 2 sound infiles.\n");
			return(PROGRAM_ERROR);
		}
	}
	return(FINISHED);
}

/***************************** SET_LEGAL_INFILE_STRUCTURE **************************
 *
 * Allows 2nd infile to have different props to first infile.
 */

void set_legal_infile_structure(dataptr dz)
{
	switch(dz->process) {
	default:
		dz->has_otherfile = FALSE;
		break;
	}
}

/***************************************************************************************/
/****************************** FORMERLY IN internal.c *********************************/
/***************************************************************************************/

/****************************** SET_LEGAL_INTERNALPARAM_STRUCTURE *********************************/

int set_legal_internalparam_structure(int process,int mode,aplptr ap)
{
	int exit_status = FINISHED;
	mode = 0;
	switch(process) {
	case(ACCU):		  	return(FINISHED);
	case(EXAG):		  	return(FINISHED);
	case(FOCUS):	  	exit_status = set_internalparam_data("ddi",ap);					break;
	case(FOLD):		  	exit_status = set_internalparam_data("iidd",ap);				break;
	case(FREEZE):	  	return(FINISHED);
	case(FREEZE2):	  	return(FINISHED);
	case(STEP):		  	return(FINISHED);
	default:
		sprintf(errstr,"Unknown process in set_legal_internalparam_structure()\n");
		return(PROGRAM_ERROR);
	}
	return(exit_status);		
}

/********************************************************************************************/
/********************************** FORMERLY IN specialin.c *********************************/
/********************************************************************************************/

/********************** READ_SPECIAL_DATA ************************/

int read_special_data(char *str,dataptr dz)	   
{
//	int exit_status = FINISHED;
	aplptr ap = dz->application;

	switch(ap->special_data) {
	case(FREEZE_DATA):		  	return read_specfreeze_data(str,dz);
	case(FREEZE2_DATA):		  	return read_specfreeze2_data(str,dz);
	default:
		sprintf(errstr,"Unknown special_data type: read_special_data()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}

/************************** READ_SPECFREEZE_DATA ********************************/

int read_specfreeze_data(char *filename,dataptr dz)
{
	int exit_status;
	int n = 0, OK = 1, is_direction_info = FALSE, linecnt = 0;
	FILE *fp;
	char temp[200], *p;
	double dtime;
	int arraysize = BIGARRAY;
	if((dz->iparray[FRZ_TIMETYPE] = (int  *)malloc(arraysize * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for array of freeze-timetypes.\n");
		return(MEMORY_ERROR);
	}
	if((dz->lparray[FRZ_SEGTIME]  = (int *)malloc(arraysize * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for array of freeze sample times.\n");
		return(MEMORY_ERROR);
	}
	if((fp = fopen(filename,"r"))==NULL) {
		sprintf(errstr,"nCannot open file %s to read data.\n",filename);
		return(DATA_ERROR);
	}
	while(OK && fgets(temp,200,fp)) {
		linecnt++;
 		p = temp;
		for(;;) {
			dz->iparray[FRZ_TIMETYPE][n] = FRZ_LIMIT;
			while(isspace(*p))
				p++;
			if(*p == '\n' || *p == '\0')
				break;
			if((exit_status = set_timetype(&p,n,&is_direction_info,dz))<0)
				return(exit_status);
			if((exit_status = read_time(&p,&dtime,n,linecnt,filename))<0)
				return(exit_status);
			dz->lparray[FRZ_SEGTIME][n] = round(dtime/dz->frametime);
			if(n==0) {
				if(dz->lparray[FRZ_SEGTIME][0]!=0) {
					if((exit_status = insert_values_at_time_zero(&n,dz))<0)
						return(exit_status);
				}
			} else if((exit_status = check_time_sequencing(n,filename,dz))<0)
				return(exit_status);
			if(dz->lparray[FRZ_SEGTIME][n] > dz->wlength) {
				dz->lparray[FRZ_SEGTIME][n] = dz->wlength;	 
				n++;
				OK = 0;
				break;
			}	
			if(++n>=arraysize) {
				arraysize += BIGARRAY;
				if((dz->lparray[FRZ_SEGTIME]  = 
				(int *)realloc((char *)dz->lparray[FRZ_SEGTIME], arraysize * sizeof(int)))==NULL) {
					sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze sample times.\n");
					return(MEMORY_ERROR);
				}
				if((dz->iparray[FRZ_TIMETYPE] = 
				(int  *)realloc((char *)dz->iparray[FRZ_TIMETYPE],arraysize * sizeof(int)))==NULL) {
					sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze timetypes.\n");
					return(MEMORY_ERROR);
				}
			}
		}
	}
	if(!is_direction_info) {
		sprintf(errstr,"No flags given in freeze data\n");
		return(DATA_ERROR);
	}
	if(dz->lparray[FRZ_SEGTIME][n-1]!=dz->wlength) {
		if(++n>=arraysize) {
			if((dz->lparray[FRZ_SEGTIME]  = (int *)realloc((char *)dz->lparray[FRZ_SEGTIME], n * sizeof(int)))==NULL) {
				sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze sample times.\n");
				return(MEMORY_ERROR);
			}
			if((dz->iparray[FRZ_TIMETYPE] = (int  *)realloc((char *)dz->iparray[FRZ_TIMETYPE],n * sizeof(int)))==NULL) {
				sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze timetypes.\n");
				return(MEMORY_ERROR);
			}
		}
		dz->lparray[FRZ_SEGTIME][n-1]  = dz->wlength;
		dz->iparray[FRZ_TIMETYPE][n-1] = FRZ_LIMIT;
	} else {
		if((dz->lparray[FRZ_SEGTIME]  = (int *)realloc((char *)dz->lparray[FRZ_SEGTIME], n * sizeof(int)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze sample times.\n");
			return(MEMORY_ERROR);
		}
		if((dz->iparray[FRZ_TIMETYPE] = (int  *)realloc((char *)dz->iparray[FRZ_TIMETYPE],n * sizeof(int)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze timetypes.\n");
			return(MEMORY_ERROR);
		}
	}
	dz->itemcnt = n;
	return(FINISHED);
}

/************************** READ_SPECFREEZE2_DATA ********************************/

int read_specfreeze2_data(char *filename,dataptr dz)
{
//	int n = 0, OK = 1, is_location = TRUE;
	int is_location = TRUE;
	FILE *fp;
	char temp[200], *p;
	double dtime;
	int arraysize = BIGARRAY;
 	dz->itemcnt = 0;
	if((dz->lparray[FRZ_FRZTIME]  = (int *)malloc(arraysize * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for array of freeze times.\n");
		return(MEMORY_ERROR);
	}
	if((dz->lparray[FRZ_SEGTIME]  = (int *)malloc(arraysize * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for array of freeze lengths.\n");
		return(MEMORY_ERROR);
	}
	if((fp = fopen(filename,"r"))==NULL) {
		sprintf(errstr,"nCannot open file %s to read data.\n",filename);
		return(DATA_ERROR);
	}
	while(fgets(temp,200,fp)) {
 		p = temp;
		while(isspace(*p))
			p++;
		if(*p==ENDOFSTR)
			continue;
		dz->scalefact = dz->duration/dz->frametime;
		while(get_float_from_within_string(&p,&dtime)) {
			dtime /= dz->frametime;
			dz->scalefact += (dtime - 1);
			if(is_location) {
				dz->lparray[FRZ_FRZTIME][dz->itemcnt] = round(dtime);
				if(dz->lparray[FRZ_FRZTIME][dz->itemcnt] < 0
				|| dz->lparray[FRZ_FRZTIME][dz->itemcnt] >= dz->wlength) {
					sprintf(errstr,"Invalid freeze location : %lf\n",dtime);
					return(DATA_ERROR);
				}
			} else {
				dz->lparray[FRZ_SEGTIME][dz->itemcnt] = round(dtime);
				if(dz->lparray[FRZ_SEGTIME][dz->itemcnt] < 0) {
					sprintf(errstr,"Invalid freeze duration : %lf\n",dtime);
					return(DATA_ERROR);
				}
			}
			is_location = !is_location;
			if(is_location) {
				if(++dz->itemcnt >= arraysize) {
					arraysize += BIGARRAY;
					if((dz->lparray[FRZ_FRZTIME]  = 
					(int *)realloc((char *)dz->lparray[FRZ_FRZTIME],arraysize * sizeof(int)))==NULL) {
						sprintf(errstr,"INSUFFICIENT MEMORY to realloc array of freeze times.\n");
						return(MEMORY_ERROR);
					}
					if((dz->lparray[FRZ_SEGTIME]  = 
					(int *)realloc((char *)dz->lparray[FRZ_SEGTIME],arraysize * sizeof(int)))==NULL) {
						sprintf(errstr,"INSUFFICIENT MEMORY to realloc array of freeze lengths.\n");
						return(MEMORY_ERROR);
					}
				}
			}
		}
	}
	if(!is_location) {
		sprintf(errstr,"Freeze times not paired correctly.\n");
		return(DATA_ERROR);
	}
	if((dz->lparray[FRZ_FRZTIME]  = 
	(int *)realloc((char *)dz->lparray[FRZ_FRZTIME],dz->itemcnt * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to realloc array of freeze times.\n");
		return(MEMORY_ERROR);
	}
	if((dz->lparray[FRZ_SEGTIME]  = 
	(int *)realloc((char *)dz->lparray[FRZ_SEGTIME],dz->itemcnt * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to realloc array of freeze lengths.\n");
		return(MEMORY_ERROR);
	}
	return(FINISHED);
}

/************************** SET_TIMETYPE ********************************/

int set_timetype(char **first_char_of_string,int strno,int *is_direction_info,dataptr dz)
{
	char *p = *first_char_of_string;
	switch(*p) {
	case('b'):
		dz->iparray[FRZ_TIMETYPE][strno] = FRZ_BEFORE;
		*is_direction_info = TRUE;
		p++;
		break;
	case('a'):
		dz->iparray[FRZ_TIMETYPE][strno]  = FRZ_AFTER;
		*is_direction_info = TRUE;
		p++;
		break;
	}
	*first_char_of_string = p;
	return(FINISHED);
}

/************************** READ_TIME ********************************/

int read_time(char **p,double *dtime,int strno,int linecnt, char *filename)
{			
	if(**p!='.' && **p!='-' && !isdigit(**p)) {
		sprintf(errstr,"Unknown time flag '%c' on line %d of file %s\n",**p, linecnt,filename);
		return(DATA_ERROR);
	}
	if(sscanf(*p,"%lf",dtime)!=1) {
		sprintf(errstr,"Cannot read time value %d on line %d of file %s.\n",strno+1, linecnt,filename);
		return(DATA_ERROR);
	}
	while(!isspace(**p) && **p!='\n' && **p != '\0')
		(*p)++;
	return(FINISHED);
}

/************************** INSERT_VALUES_AT_TIME_ZERO ********************************/

int insert_values_at_time_zero(int *n,dataptr dz)
{
	if(dz->lparray[FRZ_SEGTIME][0] < 0) {
		dz->lparray[FRZ_SEGTIME][0] = 0;
		*n = 0;
	} else {
		dz->lparray[FRZ_SEGTIME][1]  = dz->lparray[FRZ_SEGTIME][0];
		dz->iparray[FRZ_TIMETYPE][1] = dz->iparray[FRZ_TIMETYPE][0];		
		dz->lparray[FRZ_SEGTIME][0]  = 0;
		dz->iparray[FRZ_TIMETYPE][0] = FRZ_LIMIT;		
		*n = 1;
	}
	return(FINISHED);
}

/************************** CHECK_TIME_SEQUENCING ********************************/

int check_time_sequencing(int n,char *filename,dataptr dz)
{
	if(dz->lparray[FRZ_SEGTIME][n] <= dz->lparray[FRZ_SEGTIME][n-1]) {
		sprintf(errstr,"Time values out of sequence in file %s.\n",filename);
		return(DATA_ERROR);
	}
	return(FINISHED);
}


/********************************************************************************************/
/********************************** FORMERLY IN preprocess.c ********************************/
/********************************************************************************************/

/****************************** PARAM_PREPROCESS *********************************/

int param_preprocess(dataptr dz)	
{
//	int exit_status = FINISHED;

	switch(dz->process) {
	case(ACCU):			return scale_accu_parameters(dz);
	case(EXAG):			return convert_params_for_exag(dz);
	case(FOCUS):		return setup_internal_arrays_and_params_for_focus(dz);
	case(FOLD):			return fold_preprocess(dz);
	case(FREEZE):		return get_frztimes(dz);
	case(FREEZE2):		return(FINISHED);
	case(STEP):			return convert_params_for_step(dz);
	default:
		sprintf(errstr,"PROGRAMMING PROBLEM: Unknown process in param_preprocess()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}

/************************************* SCALE_ACCU_PARAMETERS *******************/

int scale_accu_parameters(dataptr dz)
{
	int n;
	double *p;
		   		/* decayratio per sec -> decayratio per window */
	if(dz->brksize[ACCU_DINDEX]) {
		p = dz->brk[ACCU_DINDEX] + 1;
		for(n=0;n<dz->brksize[ACCU_DINDEX];n++) {
			*p = exp(log(*p) * dz->frametime);		
			 p += 2;
		}
	} else
		dz->param[ACCU_DINDEX] = exp(log(dz->param[ACCU_DINDEX]) * dz->frametime);

			  	/* glis in 8va per sec -> frqratio per window */
	if(dz->brksize[ACCU_GINDEX]) {
		p = dz->brk[ACCU_GINDEX] + 1;
		for(n=0;n<dz->brksize[ACCU_GINDEX];n++) {
			*p = pow(2.0,*p * dz->frametime);
			 p += 2;
		}
	} else
		dz->param[ACCU_GINDEX] = pow(2.0,dz->param[ACCU_GINDEX] * dz->frametime);
	return(FINISHED);
}

/************ CONVERT_PARAMS_FOR_EXAG *************/

int convert_params_for_exag(dataptr dz)
{
	double *p;
	int n;
	if(dz->brksize[EXAG_EXAG]) {	/* convert to reciprocal of value */
		p = dz->brk[EXAG_EXAG]+1;
		for(n=0;n<dz->brksize[EXAG_EXAG];n++) {
			*p = 1.0/(*p);
			p += 2;
		}
	} else
		dz->param[EXAG_EXAG] = 1.0/dz->param[EXAG_EXAG];
	return(FINISHED);
}

/************ SETUP_INTERNAL_ARRAYS_AND_PARAMS_FOR_FOCUS *************/

int setup_internal_arrays_and_params_for_focus(dataptr dz)
{
	int exit_status;
	dz->itemcnt = dz->iparam[FOCU_PKCNT];
	if(dz->brksize[FOCU_BW]==0)	{
		if((exit_status = generate_focu_filter_params(dz))<0)
			return(exit_status);
	}
	if((exit_status = establish_internal_arrays_for_focus(dz))<0)
		return(exit_status);
	if(dz->vflag[FOCUS_STABLE]) {
		if((exit_status = setup_stability_arrays_and_constants(FOCU_STABL,FOCU_SL1,dz))<0)
			return(exit_status);
	}
	return(FINISHED);
}

/****************************** GENERATE_FOCU_FILTER_PARAMS ***************************/

int generate_focu_filter_params(dataptr dz)
{
	double halfbwidth = dz->param[FOCU_BW]/2.0;
	dz->scalefact = PI/halfbwidth;	/* Convert 8va offset from flt centre-frq to a fraction of the bandwidth X PI */
	dz->param[FOCU_BRATIO_UP] = pow(2.0,halfbwidth);			/* upward transpratio to top of filter band  */
	dz->param[FOCU_BRATIO_DN] = 1.0/dz->param[FOCU_BRATIO_UP];	/* Downward transpratio to bottom of filter band */
	return(FINISHED);
}

/********************** ESTABLISH_INTERNAL_ARRAYS_FOR_FOCUS **********************/

int establish_internal_arrays_for_focus(dataptr dz)
{									
	if((dz->filtpeak = (double *)malloc((dz->itemcnt+1) * sizeof(double)))==NULL) 	 {
		sprintf(errstr,"INSUFFICIENT MEMORY for focus peaks array.\n");
		return(MEMORY_ERROR);		/* stores amps of filter peaks */
	}						
	if((dz->fbandtop = (double *)malloc((dz->itemcnt+1) * sizeof(double)))==NULL)	 {
		sprintf(errstr,"INSUFFICIENT MEMORY for focus band tops array.\n");
		return(MEMORY_ERROR);		/* stores top of fiter bands */
	}							
	if((dz->fbandbot = (double *)malloc((dz->itemcnt+1) * sizeof(double)))==NULL)	 {
		sprintf(errstr,"INSUFFICIENT MEMORY for focus band bottoms array.\n");
		return(MEMORY_ERROR);		/* stores bots of filtbands */
	}							
	if((dz->fsampbuf = (float  *)malloc((dz->clength+1) * sizeof(float)))==NULL)	 {
		sprintf(errstr,"INSUFFICIENT MEMORY for filter contour array.\n");
		return(MEMORY_ERROR);		/* stores filter contour */
	}							
	if((dz->peakno   = (int    *)malloc((dz->itemcnt+1) * sizeof(int)))==NULL)		 {
		sprintf(errstr,"INSUFFICIENT MEMORY for focus peak location array.\n");
		return(MEMORY_ERROR);		/* specenv chans where peaks are */
	}
	memset(dz->peakno,0,dz->itemcnt * sizeof(int));
	/* set_array_safety */
	dz->filtpeak[dz->itemcnt] = 0.0;
    dz->fbandtop[dz->itemcnt] = 0.0;		/* stores top of fiter bands */
    dz->fbandbot[dz->itemcnt] = 0.0;		/* stores bottoms of filtbands */
	dz->fsampbuf[dz->clength] = 0.0f;		/* stores filter contour */
	dz->peakno[dz->itemcnt] = 0;			/* points to specenv chans where peaks are */
	return(FINISHED);
}

/************************** FOLD_PREPROCESS ******************************/

int fold_preprocess(dataptr dz)
{
	if(dz->brksize[FOLD_HIFRQ]==0) {
		dz->iparam[FOLD_HICHAN]   = (int)((dz->param[FOLD_HIFRQ] + dz->halfchwidth)/dz->chwidth); /* TRUNCATE */
		dz->param[FOLD_HICHANTOP] = ((double)dz->iparam[FOLD_HICHAN] * dz->chwidth) + dz->halfchwidth;
		if(dz->iparam[FOLD_HICHAN]!=0)
	   		dz->iparam[FOLD_HICHAN] <<= 1;
	}
	if(dz->brksize[FOLD_LOFRQ]==0) {
		dz->iparam[FOLD_LOCHAN]   = (int)((dz->param[FOLD_LOFRQ] + dz->halfchwidth)/dz->chwidth); /* TRUNCATE */
		if(dz->iparam[FOLD_LOCHAN]>0)
			dz->param[FOLD_LOCHANBOT] = ((double)(dz->iparam[FOLD_LOCHAN]-1) * dz->chwidth) + dz->halfchwidth;
		else
		   dz->param[FOLD_LOCHANBOT] = 0.0;
		if(dz->iparam[FOLD_LOCHAN]!=0)
	    	dz->iparam[FOLD_LOCHAN] <<= 1;
	}
	return(FINISHED);
}

/************************* GET_FRZTIMES ****************************/

int get_frztimes(dataptr dz)
{
	int n;
	if((dz->lparray[FRZ_FRZTIME] = (int *)malloc((dz->itemcnt-1) * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for freezetimes array.\n");
		return(MEMORY_ERROR);
	}
	for(n=0;n<dz->itemcnt-1;n++) {
 		if(dz->iparray[FRZ_TIMETYPE][n+1]<FRZ_BEFORE 
			|| dz->iparray[FRZ_TIMETYPE][n+1]>FRZ_AFTER) {
			sprintf(errstr,"Invalid timetype flag in get_frztimes()\n");
			return(PROGRAM_ERROR);
		}
		switch(dz->iparray[FRZ_TIMETYPE][n]) {
		case(FRZ_BEFORE):
		case(FRZ_LIMIT):
			switch(dz->iparray[FRZ_TIMETYPE][n+1]) {
			case(FRZ_LIMIT):
			case(FRZ_AFTER):  dz->lparray[FRZ_FRZTIME][n] = -1;						
				break;
			case(FRZ_BEFORE): dz->lparray[FRZ_FRZTIME][n] = dz->lparray[FRZ_SEGTIME][n+1];
				break;
			}
			break;
		case(FRZ_AFTER):
			switch(dz->iparray[FRZ_TIMETYPE][n+1]) {
			case(FRZ_LIMIT):
			case(FRZ_AFTER):  dz->lparray[FRZ_FRZTIME][n] = dz->lparray[FRZ_SEGTIME][n];	
				break; 			
			case(FRZ_BEFORE):
				sprintf(errstr,"Impossible time sequence in freeze file.\n");
				return(USER_ERROR);
			}
			break;
		default:
			if(n==0) {
				sprintf(errstr,"Invalid timetype flag in get_frztimes()\n");
				return(PROGRAM_ERROR);
			}
		}
	}
	return rationalise_frztimes(dz);
}

/************************** RATIONALISE_FRZTIMES **************************
 *
 * Bear in mind that there are scnt times, icluding the time at the
 * end of the file. This means there are (scnt-1) time-segments to
 * operate on and therefore (scnt-1) frztimes.
 *
 * (1)	If two consecutive time-segments are flagged (frztime<0) to
 *	have no action on them, then we can eliminate the time (and
 *	the related frztime info) of the 2nd window.
 * (2)	Do this by shuffling existing values above this time[n] downwards,
 *	overwriting the existing value (ditto for 'frztime' vals), up as far
 *	end of frztime array,and therefore 1 below top of time array.
 * (3)	Reduce value of time_seg counter.
 * (4)	Move the uppermost time_seg value down.
 * (5)	Replace the absolute values of the time vals, to differences,
 *	which will be the successive numbers of windows to process when
 *	the processing begins.
 * (6)	Hence reduce by 1 the count of time vals stored.
 * (7)	Realloc memory space for time and frztime values.
 */

int rationalise_frztimes(dataptr dz)
{
	int n, m;
	int orig_itemcnt = dz->itemcnt;  
	for(n=1;n<dz->itemcnt-1;n++) {
		if(dz->lparray[FRZ_FRZTIME][n-1]<0 && dz->lparray[FRZ_FRZTIME][n]<0) {/* 1 */
			for(m=n;m<dz->itemcnt-1;m++) {									  
				dz->lparray[FRZ_SEGTIME][n] = dz->lparray[FRZ_SEGTIME][n+1];/* 2 */
				dz->lparray[FRZ_FRZTIME][n] = dz->lparray[FRZ_FRZTIME][n+1];
			}
			dz->itemcnt--;													/* 3 */
			dz->lparray[FRZ_SEGTIME][dz->itemcnt-1] 
				= dz->lparray[FRZ_SEGTIME][dz->itemcnt];/* 4 */
		}
	}
	if(dz->itemcnt != orig_itemcnt) {
		if((dz->lparray[FRZ_SEGTIME] = 
		(int *)realloc((char *)dz->lparray[FRZ_SEGTIME],dz->itemcnt * sizeof(int)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freeze segtime array.\n");
			return(MEMORY_ERROR);
		}
		if((dz->lparray[FRZ_FRZTIME] = 
		(int *)realloc((char *)dz->lparray[FRZ_FRZTIME],(dz->itemcnt-1) * sizeof(int)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to reallocate freezetimes array.\n");
			return(MEMORY_ERROR);
		}
	}
	return(FINISHED);
}

/************ CONVERT_PARAMS_FOR_STEP *************/

int convert_params_for_step(dataptr dz)
{
	double *p;
	int n;
	if(dz->brksize[STEP_STEP]==0)
		dz->iparam[STEP_STEP] = round(dz->param[STEP_STEP]/dz->frametime);
	else {
		p = dz->brk[STEP_STEP] + 1;
		for(n=0;n < dz->brksize[STEP_STEP];n++) {
			*p /= dz->frametime;
			p  += 2;
		}
		dz->is_int[STEP_STEP] = 1;
	}	
	return(FINISHED);
}

/********************************************************************************************/
/********************************** FORMERLY IN procspec.c **********************************/
/********************************************************************************************/

/**************************** SPEC_PROCESS_FILE ****************************/

int spec_process_file(dataptr dz)
{	
	dz->total_windows = 0;

	if(dz->process == FREEZE2)
		dz->tempsize = (int)round(dz->scalefact) * dz->wanted;

	display_virtual_time(0L,dz);

	switch(dz->process) {
	case(ACCU):		return outer_loop(dz);
	case(EXAG):		return outer_loop(dz);
	case(FOLD):		return outer_loop(dz);
	
	case(FOCUS): 	return outer_focu_loop(dz);
	case(FREEZE):	return specfreeze(dz);								
	case(FREEZE2):	return specfreeze2(dz);								
	case(STEP):  	return specstep(dz);
	default:
		sprintf(errstr,"Unknown process in spec_process_file()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}

/**************************** INNER_LOOP ****************************/

int inner_loop
(int *peakscore,int *descnt,int *in_start_portion,int *least,int *pitchcnt,int windows_in_buf,dataptr dz)
{
	int exit_status;
	int local_zero_set = FALSE;
	int wc;

   	for(wc=0; wc<windows_in_buf; wc++) {
		if(dz->total_windows==0) {
			if((exit_status = skip_or_special_operation_on_window_zero(dz))<0)
				return(exit_status);
			if(exit_status==TRUE) {
				dz->flbufptr[0] += dz->wanted;
				dz->total_windows++;
				dz->time = (float)(dz->time + dz->frametime);
				continue;
			}
		}
		if((exit_status = read_values_from_all_existing_brktables((double)dz->time,dz))<0)
			return(exit_status);

		switch(dz->process) {
		case(FOCUS):	exit_status = specfocus(peakscore,descnt,least,dz);	break;
		case(FOLD):		exit_status = specfold(dz);							break;
		case(ACCU):		exit_status = specaccu(dz);							break;
		case(EXAG):		exit_status = specexag(&local_zero_set,dz);			break;
		default:
			sprintf(errstr,"unknown process in inner_loop()\n");
			return(PROGRAM_ERROR);
		}
		if(exit_status<0)
			return(exit_status);
		dz->flbufptr[0] += dz->wanted;
		dz->total_windows++;
		dz->time = (float)(dz->time + dz->frametime);
	}
	if(!dz->zeroset && local_zero_set==TRUE) {
		fprintf(stdout,"WARNING: Zero-amp spectral window(s) encountered: orig window(s) substituted.\n"); 
		fflush(stdout);
		dz->zeroset = TRUE;
	}
	return(FINISHED);
}

/***************** SKIP_OR_SPECIAL_OPERATION_ON_WINDOW_ZERO ************/

int skip_or_special_operation_on_window_zero(dataptr dz)
{
	int exit_status = FINISHED;
	int vc;
	switch(dz->process) {
	case(EXAG):	  case(FOCUS): case(ACCU):	 
		switch(dz->process) {
		case(ACCU):
			for(vc = 0; vc < dz->wanted; vc += 2)
				dz->windowbuf[0][AMPP] = dz->flbufptr[0][AMPP];
			break;
		case(FOCUS):
		   if(!dz->vflag[FOCUS_STABLE])
		   		break;
			rectify_window(dz->flbufptr[0],dz);
			if((exit_status = extract_specenv(0,0,dz))<0)
				return(exit_status);
 /* put 1st specenv in end of stability store && copy 1st buf to end of bufstore */
			memmove((char *)dz->stable->spec[dz->iparam[FOCU_SL1]],
//TW ERROR IN ORIGINAL CODE
//				(char *)dz->specenvamp,dz->infile->specenvcnt * sizeof(int));
				(char *)dz->specenvamp,dz->infile->specenvcnt * sizeof(float));
			memmove((char *)dz->stable->sbuf[dz->iparam[FOCU_SL1]],
				(char *)dz->flbufptr[0],(size_t)dz->wanted * sizeof(float));
			dz->stable->total_pkcnt[dz->iparam[FOCU_SL1]] = 0; /* 1st window has 0 amp, hence 0 peaks */
	   		break;
		}
		return(TRUE);
	}
	return(FALSE);
}

/****************************** CONSTRUCT_FILTER_ENVELOPE ***************************
 *
 * If we reach the top of the channels, and there is another peak to work on,
 * we must be backtracking to a lower channel. If we are NOT, there is a problem
 * in my logic ... no peak can have its lowest point higher than the frq in the highest
 * channel!! That's why we have used CHECKLOGIC to check this out!!!
 */

int construct_filter_envelope(int pkcnt_here,float *fbuf,dataptr dz)
{
#define OVERSHOOT	(8)	/* No of channels to test beyond current ch, for frqs BELOW current frq */
						/* Guesstimate */
	int exit_status;
	double thisfrq, thisamp, filt_centre_frq;
	int n, m;
	int  baktrak = -1, activate_baktrak = 0, checklogic = 0;
	int  beyond_top, band_incremented;
	int cc , vc;
    for(cc=0; cc<dz->clength; cc++)	/* PRESET FILTER ENVELOPE TO ZERO */ 
   		dz->fsampbuf[cc] = 0.0f;
	n = 0;						/* COUNTER FOR CURRENT PEAK */
	m = 1;						/* COUNTER FOR NEXT PEAK */
	cc = 0;
	vc = 0;
	beyond_top = 0;
	while(cc < dz->clength) {
		switch(dz->process) {
		case(FOCUS): filt_centre_frq = dz->specenvfrq[dz->peakno[n]]; 	break;
		default:
			sprintf(errstr,"Invalid application in construct_filter_envelope()\n");
			return(PROGRAM_ERROR);

		}
		band_incremented = 0;
		thisfrq = fabs(fbuf[FREQ]);
		if(baktrak<0 && (m < pkcnt_here) && (thisfrq > dz->fbandbot[m]))
			baktrak = cc;						/* IF A FRQ IS ENCOUNTERED WHICH IS IN NEXT BAND
												   AND FOR THE FIRST TIME : mark this as channel to baktrak to */
		if(thisfrq < dz->fbandbot[n])	{  			
			if(beyond_top)						/* IF FRQ BELOW BAND: IGNORE IT */
				beyond_top++;					/* If beyond possible band_top, count channels beyond */
		}
		else if(thisfrq < filt_centre_frq) {		/* IF FRQ IN LOWER HALFBAND: generate filter envel */
			if((exit_status = gen_amplitude_in_lo_half_filterband(&thisamp,thisfrq,filt_centre_frq,dz))<0)
				return(exit_status);
			dz->fsampbuf[cc] = (float)max(dz->fsampbuf[cc],thisamp);
			if(beyond_top)
				beyond_top++;				/* If beyond possible band_top, count channels beyond */
		}
		else if(thisfrq < dz->fbandtop[n])	{		 /* IF FRQ IN HIGHER HALFBAND: generate filter envel */
			if((exit_status = gen_amplitude_in_hi_half_filterband(&thisamp,thisfrq,filt_centre_frq,dz))<0)
				return(exit_status);
			dz->fsampbuf[cc] = (float)max(dz->fsampbuf[cc],thisamp);
			if(beyond_top)
				beyond_top++;				/* If beyond possible band_top, count channels beyond */
		}
		else {							/* FREQ is ABOVE TOP OF BAND */
			if(!beyond_top) {			/* IF only just reached possible bandtop among channel frqs */
				if(baktrak < 0)			/* If channel to baktrak to has not been set, set it here */
					baktrak = cc;
			}
			if(++beyond_top>OVERSHOOT){/* IF GONE FAR ENOUGH BEYOND POSSIBLE BAND TOP */
				beyond_top = 0;			/* switch off band_top flag */
				if(++n >= pkcnt_here)	/* MOVE ON TO NEXT BAND  */			
					break;				/* IF REACHED END OF ALL BANDS: stop  */
				m++;
				band_incremented = 1;	/* Note that band has been incremented */
				activate_baktrak = 1;	/* activate the baktraking mechanism */
			}
		}
		if(cc == dz->clength-1) {			/* IF REACHED TOP OF CHANNELS ON THIS PASS */
			checklogic = 1;
			if(!band_incremented) {		/* IF BAND HAS NOT ALREADY BEEN INCREMENTED */
				beyond_top = 0;			/* Ensure band_top flag is switched off */
				if(++n >= pkcnt_here)	/* MOVE ON TO NEXT BAND  */				
					break;				/* IF REACHED END OF ALL BANDS: stop  */
				m++;
				activate_baktrak = 1;	/* activate the baktraking mechanism */
			}
		}
		if(activate_baktrak && baktrak>=0) {/* If necessary, baktrak to channel just inside bottom of next band */
			if(checklogic)
				checklogic++;
			cc = baktrak;
			vc = cc * 2;
			baktrak = -1;				 /* Cancel baktrak value */
			activate_baktrak = 0;		 /* Deactivate baktraking mechanism */
			continue;
		}
		if(checklogic==1) {
			sprintf(errstr,"Problem with peak-scanning logic. construct_filter_envelope()\n");
			return(PROGRAM_ERROR);
		}
		checklogic = 0;
		cc++;							/* Otherwise, move on to next channel */
		vc += 2;
	}
	return filter_band_test(dz);
}

/********************************************************************************************/
/********************************** FORMERLY IN pconsistency.c ******************************/
/********************************************************************************************/

/****************************** CHECK_PARAM_VALIDITY_AND_CONSISTENCY *********************************/

int check_param_validity_and_consistency(dataptr dz)
{
//	int exit_status = FINISHED;
	handle_pitch_zeros(dz);
	switch(dz->process) {
	case(FOCUS):	   return check_consistency_of_frq_limits_for_focus(dz);
	}
	return(FINISHED);
}

/********************** CHECK_CONSISTENCY_OF_FRQ_LIMITS_FOR_FOCUS **********************/

int check_consistency_of_frq_limits_for_focus(dataptr dz)
{
	if(dz->brksize[FOCU_LOFRQ]==0 && dz->brksize[FOCU_HIFRQ]==0) {
		if(flteq(dz->param[FOCU_LOFRQ],dz->param[FOCU_HIFRQ])) {
			sprintf(errstr,"Frequency limits define a zero-width band.\n");
			return(USER_ERROR);
		}
		if(dz->param[FOCU_LOFRQ] > dz->param[FOCU_HIFRQ])
			swap(&dz->param[FOCU_LOFRQ],&dz->param[FOCU_HIFRQ]);
	}
	return(FINISHED);
}

/********************************************************************************************/
/********************************** FORMERLY IN buffers.c ***********************************/
/********************************************************************************************/

/**************************** ALLOCATE_LARGE_BUFFERS ******************************/

int allocate_large_buffers(dataptr dz)
{
	switch(dz->process) {
	case(ACCU):		case(EXAG):		case(FOLD):		
	case(STEP):		
		return allocate_single_buffer(dz);
	case(FOCUS):
		if(dz->vflag[FOCUS_STABLE])
			return allocate_double_buffer(dz);
		return allocate_single_buffer(dz);

	case(FREEZE): 	
	case(FREEZE2): 	
		return allocate_double_buffer(dz);
	default:
		sprintf(errstr,"Unknown program no. in allocate_large_buffers()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}
/********************************************************************************************/
/********************************** FORMERLY IN cmdline.c ***********************************/
/********************************************************************************************/

int get_process_no(char *prog_identifier_from_cmdline,dataptr dz)
{
	if     (!strcmp(prog_identifier_from_cmdline,"accu"))  	   		dz->process = ACCU;	 
	else if(!strcmp(prog_identifier_from_cmdline,"exag"))	   		dz->process = EXAG;
	else if(!strcmp(prog_identifier_from_cmdline,"focus"))	   		dz->process = FOCUS;
	else if(!strcmp(prog_identifier_from_cmdline,"fold"))	   		dz->process = FOLD;
	else if(!strcmp(prog_identifier_from_cmdline,"freeze"))	   		dz->process = FREEZE;
	else if(!strcmp(prog_identifier_from_cmdline,"hold"))	   		dz->process = FREEZE2;
	else if(!strcmp(prog_identifier_from_cmdline,"step"))	   		dz->process = STEP;
	else {
		sprintf(errstr,"Unknown program identification string '%s'\n",prog_identifier_from_cmdline);
		return(USAGE_ONLY);
	}
//TW UPDATE
	return(FINISHED);
}

/********************************************************************************************/
/********************************** FORMERLY IN usage.c *************************************/
/********************************************************************************************/

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

int usage1(void)
{
	sprintf(errstr,
	"\nFOCUSING OPERATIONS ON A SPECTRAL FILE\n\n"
	"USAGE: focus NAME (mode) infile outfile parameters: \n"
	"\n"
	"where NAME can be any one of\n"
	"\n"
	"accu    exag    focus    fold    freeze    hold     step\n\n"
	"Type 'focus accu' for more info on focus accu..ETC.\n");
	return(USAGE_ONLY);
}

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

int usage2(char *str)
{
	if(!strcmp(str,"accu")) {
		fprintf(stdout,
		"focus accu infile outfile [-ddecay] [-gglis]\n"
		"\n"
		"SUSTAIN EACH SPECTRAL BAND, UNTIL LOUDER DATA APPEARS IN THAT BAND\n"
		"\n"
		"-d    sutained channel data decays by factor DECAY per sec.\n"
		"      (Possible Range : %lf to 1.0 : Default 1.0)\n"
		"      (Suggested Effective Range : %lf to 0.5)\n"
		"-g    sutained channel data glisses at GLIS 8vas per sec.\n"
		"      (Approx Range : -11.7 to 11.7 : Default 0)\n"
		"\n",ACCU_MIN_DECAY,ACCU_MIN_DECAY);
	} else if(!strcmp(str,"exag")) {
		fprintf(stdout,
		"focus exag infile outfile exaggeration\n"
		"\n"
		"EXAGGERATE SPECTRAL CONTOUR\n"
		"\n"
		"exaggeration >0 will widen troughs: <0 will widen peaks.\n"
		"\n"
		"exaggeration may vary over time.\n"
		"\n");
	} else if(!strcmp(str,"focus")) {
		fprintf(stdout,
		"focus focus infile outfile -fN|-pN [-i] pk bw [-bbt] [-ttp] [-sval]\n"
		"\n"
		"FOCUS SPECTRAL ENERGY ONTO PEAKS IN SPECTRUM\n"
		"\n"
		"-f     extract formant envelope linear frqwise,\n"
		"       using 1 point for every N equally-spaced frequency-channels.\n"
		"-p     extract formant envelope linear pitchwise,\n"
		"       using N equally-spaced pitch-bands per octave.\n"
		"-i   quicksearch for formants (less accurate).\n"
		"pk   (max) number of peaks to find : Range 1 - %d\n"
		"bw   bandwidth of peak-centred filters, in octaves.\n"
		"-b   BT is bottom frequency to start peak search.\n"
		"-t   TP is top frequency to end peak search.\n"
		"-s   Attempt to retain only peaks which are STABLE over time.\n"
		"       Range 2 - %d : default %d : is no. of windows over which peaks averaged.\n"
		"\n"
		"bandwidth,bottom frequency & top frequency may vary over time.\n"
		"\n",MAXPKCNT,MAXSTABIL,DEFAULT_STABILITY);
	} else if(!strcmp(str,"fold")) {
		fprintf(stdout,
		"focus fold infile outfile lofrq hifrq [-x]\n"
		"\n"
		"OCTAVE-TRANSPOSE SPECTRAL COMPONENTS INTO SPECIFIED RANGE\n"
		"\n"
		"lofrq & hifrq specify range into which spectrum is folded,\n"
		"-x            Fuller spectrum.\n"
		"\n"
		"lofrq & hifrq  may vary over time. \n");
	} else if(!strcmp(str,"freeze")) {
		fprintf(stdout,
		"focus freeze mode infile outfile datafile\n\n"
		"FREEZE SPECTRAL CHARACTERISTICS IN SOUND, AT GIVEN TIMES \n\n"
		"Datafile contains times at which spectrum is frozen.\n"
		"These times may be preceded by character MARKERS....\n\n"
		"a   use window here as freezewindow for spectrum AFTER this time.\n"
		"b   use window here as freezewindow for spectrum BEFORE this time.\n\n"
		"Otherwise, times are end\\start of freeze established at one of these markers.\n\n"
		"MODES\n"
		"1   freeze channel amplitudes\n"
		"2   freeze channel frequencies\n"
		"3   freeze channel amplitudes & frequencies\n"
		"\n");
	} else if(!strcmp(str,"hold")) {
		fprintf(stdout,
//TW UPDATE
//		"focus hold mode infile outfile datafile\n\n"
		"focus hold infile outfile datafile\n\n"
		"HOLD SOUND SPECTRUM, AT GIVEN TIMES \n\n"
		"Datafile contains times at which spectrum is held, & hold-duration.\n"
		"These data items must be paired correctly.\n"
		"The process expands each hold window to the duration given,\n"
		"before proceeding to the next window. The output file is therefore longer\n"
		"than the input file.\n"
		"\n");
	} else if(!strcmp(str,"step")) {
		fprintf(stdout,
		"focus step infile outfile timestep\n"
		"\n"
		"STEP-FRAME THROUGH SOUND BY FREEZING SPECTRUM AT REGULAR TIME INTERVALS\n"
		"\n"
		"Once a freeze window is reached, the following windows are given the spectrum\n"
		"of that window, until the freeze end is reached. The output is the same duration\n"
		"as the input.\n"
		"\n"
		"timestep   duration of steps. Must be >= duration of 2 analysis frames.\n"
		"           (Rounded internally to a multiple of analysis-frame time.)\n");
	} else
		fprintf(stdout,"Unknown option '%s'\n",str);
	return(USAGE_ONLY);
}

/******************************** USAGE3 ********************************/

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