ComposerDesktopProject/dev/science/spin.c

#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

char errstr[2400];

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

#define ROOT2		(1.4142136)
#define is_wide	is_mapping
#define is_bare_centre is_rectified 
#define pshift_factor is_sharp

const char* cdp_version = "6.1.0";

//CDP LIB REPLACEMENTS
static int setup_spin_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_spin_param_ranges_and_defaults(dataptr dz);
static int handle_the_extra_infile(char ***cmdline,int *cmdlinecnt,dataptr dz);
static int handle_the_outfile(int *cmdlinecnt,char ***cmdline,dataptr dz);
static int open_the_outfile(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 check_spin_param_validity_and_consistency(dataptr dz);
static void pancalc(double position,double *leftgain,double *rightgain);
static void time_display(int samps_sent,dataptr dz);
static int create_spin_sndbufs(dataptr dz);
static void calcgains(double *ch1pos,double *pos,double *lastspin,int *flipped,int *movingforward,double *leftgain,double *rightgain,double srate,dataptr dz);
static void calcgains2(double *ch1pos,double *pos,double *lastspin,int *flipped,int *movingforward,double *leftgain,double *centregain,double *rightgain,double srate,dataptr dz);
static void calcgains3(double *ch1pos,double *pos,double *lastspin,int *flipped,int *movingforward,double *leftgain,double *centregain,double *rightgain,
				double *ooleftgain, double *oileftgain, double *ocentregain, double *oirightgain, double *oorightgain, double srate,dataptr dz);
static int spindopl(dataptr dz);
static int spinwdopl(dataptr dz);
static int spinwdopl2(dataptr dz);
static int spinqdopl(dataptr dz);
static int spinqdopl2(dataptr dz);

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

int main(int argc,char *argv[])
{
	int exit_status;
	dataptr dz = NULL;
	char **cmdline;
	int  cmdlinecnt;
	int n;
	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 == SPIN)
			dz->maxmode = 3;
		else
			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--;
		dz->is_wide = 0;
		if(dz->process == SPINQ || dz->mode > 0)
			dz->is_wide = 1;
		dz->is_bare_centre = 0;
		if((dz->process == SPIN && dz->mode == 2) || (dz->process == SPINQ && dz->mode == 1))
			dz->is_bare_centre = 1;

		// setup_particular_application =
		if((exit_status = setup_spin_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_spin_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++;
//	handle_extra_infiles 
	if(dz->process == SPINQ) { 
		if((exit_status = handle_the_extra_infile(&cmdline,&cmdlinecnt,dz))<0) {
			print_messages_and_close_sndfiles(exit_status,is_launched,dz);	
			return(FAILED);
		}
	}
	// 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
 
	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);
	}
//	check_param_validity_and_consistency()
	if((exit_status = check_spin_param_validity_and_consistency(dz))<0) {
		print_messages_and_close_sndfiles(exit_status,is_launched,dz);
		return(FAILED);
	}
	if((exit_status = open_the_outfile(dz))<0) {
		print_messages_and_close_sndfiles(exit_status,is_launched,dz);
		return(FAILED);
	}
	is_launched = TRUE;
	if(dz->process == SPINQ)
		dz->bufcnt = 5;
	else
		dz->bufcnt = 3;
	if((dz->sampbuf = (float **)malloc(sizeof(float *) * (dz->bufcnt+1)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY establishing sample buffers.\n");
		return(MEMORY_ERROR);
	}
	if((dz->sbufptr = (float **)malloc(sizeof(float *) * dz->bufcnt))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY establishing sample buffer pointers.\n");
		return(MEMORY_ERROR);
	}
	for(n = 0;n <dz->bufcnt; n++)
		dz->sampbuf[n] = dz->sbufptr[n] = (float *)0;
	dz->sampbuf[n] = (float *)0;

	if((exit_status = create_spin_sndbufs(dz))<0) {
		print_messages_and_close_sndfiles(exit_status,is_launched,dz);
		return(FAILED);
	}
	//param_preprocess()						redundant
	//spec_process_file =
	if(dz->process == SPIN) {
		switch(dz->mode) {
		case(0): exit_status = spindopl(dz);	break;
		case(1): exit_status = spinwdopl(dz);	break;
		case(2): exit_status = spinwdopl2(dz);	break;
		}
	} else {
		switch(dz->mode) {
		case(0): exit_status = spinqdopl(dz);	break;
		case(1): exit_status = spinqdopl2(dz);	break;
		}
	}
	if(exit_status < 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)
{
	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);
	(*cmdline)++;
	(*cmdlinecnt)--;
	return(FINISHED);
}

/************************ OPEN_THE_OUTFILE *********************/

int open_the_outfile(dataptr dz)
{
	int exit_status, orig_chans = dz->infile->channels;
	if(dz->is_wide)
		dz->infile->channels = dz->iparam[SPNOCHNS];
	if((exit_status = create_sized_outfile(dz->outfilename,dz))<0)
		return(exit_status);
	dz->infile->channels = orig_chans;
	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_SPIN_APPLICATION *******************/

int setup_spin_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->is_wide)
		exit_status = set_param_data(ap,0   ,5,5,"Diidi");
	else
		exit_status = set_param_data(ap,0   ,5,2,"D00di");
	if(exit_status<0)
		return(FAILED);
	if(dz->is_wide) {
		if(dz->is_bare_centre)
			exit_status = set_vflgs(ap,"",0,"","bak",3,3,"ddd");
		else
			exit_status = set_vflgs(ap,"",0,"","bakc",4,4,"dddd");
	} else
		exit_status = set_vflgs(ap,"",0,"","ba",2,2,"dd");
	if(exit_status<0)
		return(FAILED);
	// set_legal_infile_structure -->
	dz->has_otherfile = FALSE;
	// assign_process_logic -->
	dz->input_data_type = SNDFILES_ONLY;
	dz->process_type	= UNEQUAL_SNDFILE;	
	dz->outfiletype		= SNDFILE_OUT;
	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);
		} else if((exit_status = cdparse(cmdline[0],infile_info))<0) {
			sprintf(errstr,"Failed to parse input file %s\n",cmdline[0]);
			return(PROGRAM_ERROR);
		} else if(infile_info->filetype != SNDFILE)  {
			sprintf(errstr,"File %s is not of correct type\n",cmdline[0]);
			return(DATA_ERROR);
		} else if(infile_info->channels != 2)  {
			sprintf(errstr,"File %s is not of correct type (must be stereo)\n",cmdline[0]);
			return(DATA_ERROR);
		} else 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);
}

/************************ HANDLE_THE_EXTRA_INFILE *********************/

int handle_the_extra_infile(char ***cmdline,int *cmdlinecnt,dataptr dz)
{
					/* OPEN ONE EXTRA ANALFILE, CHECK COMPATIBILITY */
	int  exit_status;
	char *filename;
	fileptr fp2;
	double maxamp, maxloc;
	int maxrep;
	int getmax = 0, getmaxinfo = 0;
	infileptr ifp;
	filename = (*cmdline)[0];
	if((dz->ifd[1] = sndopenEx(filename,0,CDP_OPEN_RDONLY)) < 0) {
		sprintf(errstr,"cannot open input file %s to read data.\n",filename);
		return(DATA_ERROR);
	}	
	if((ifp = (infileptr)malloc(sizeof(struct filedata)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to store data on later infile. (1)\n");
		return(MEMORY_ERROR);
	}
	if((fp2 = (fileptr)malloc(sizeof(struct fileprops)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to store data on later infile. (2)\n");
		return(MEMORY_ERROR);
	}
	if((exit_status = readhead(ifp,dz->ifd[1],filename,&maxamp,&maxloc,&maxrep,getmax,getmaxinfo))<0)
		return(exit_status);
	copy_to_fileptr(ifp,fp2);
	if(fp2->filetype != SNDFILE) {
		sprintf(errstr,"%s is not a soundfile.\n",filename);
		return(DATA_ERROR);
	}
	if(fp2->channels != 2) {
		sprintf(errstr,"File %s is not of correct type (must be stereo)\n",filename);
		return(DATA_ERROR);
	}
	if((dz->insams[1] = sndsizeEx(dz->ifd[1]))<0) {	    /* FIND SIZE OF FILE */
		sprintf(errstr, "Can't read size of input file %s.\n", filename);   //RWD added filename
		return(PROGRAM_ERROR);
	}
	if(dz->insams[1]==0) {
		sprintf(errstr, "File %s contains no data.\n",filename);
		return(DATA_ERROR);
	}
	(*cmdline)++;
	(*cmdlinecnt)--;
	return(FINISHED);
}

/************************* SETUP_SPIN_PARAM_RANGES_AND_DEFAULTS *******************/

int setup_spin_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()
	ap->lo[SPNRATE]	= -100;
	ap->hi[SPNRATE]	= 100.0;
	ap->default_val[SPNRATE] = 1;
	ap->lo[SPNBOOST]	= 0;
	ap->hi[SPNBOOST]	= 16;
	ap->default_val[SPNBOOST] = 2;
	ap->lo[SPNATTEN]	= 0;
	ap->hi[SPNATTEN]	= 1;
	ap->default_val[SPNATTEN] = 0;
	if(dz->is_wide) {
		if(dz->process == SPINQ)
			ap->lo[SPNOCHNS] = 5;
		else
			ap->lo[SPNOCHNS] = 4;
		ap->hi[SPNOCHNS] = 16;
		ap->default_val[SPNOCHNS] = 8;
		ap->lo[SPNOCNTR] = 1;
		ap->hi[SPNOCNTR] = 16;
		ap->default_val[SPNOCNTR] = 1;
		ap->lo[SPNCMIN]	= 0;
		ap->hi[SPNCMIN]	= 1;
		ap->default_val[SPNCMIN] = 0.0;
		if(!dz->is_bare_centre) {
			ap->lo[SPNCMAX]	= 0;
			ap->hi[SPNCMAX]	= 1;
			ap->default_val[SPNCMAX] = 0.5;
		}
	}
	ap->lo[SPNDOPL]	= 0;
	ap->hi[SPNDOPL]	= 12;
	ap->default_val[SPNDOPL] = 0.0;
	ap->lo[SPNXBUF]	= 1;
	ap->hi[SPNXBUF]	= 64;
	ap->default_val[SPNXBUF] = 1.0;

	if(dz->process == SPINQ)
		dz->maxmode = 2;
	else
		dz->maxmode = 3;
	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() =
			dz->is_wide = 0;
			if(dz->process == SPINQ || dz->mode > 0)
				dz->is_wide = 1;
			dz->is_bare_centre = 0;
			if((dz->process == SPIN && dz->mode == 2) || (dz->process == SPINQ && dz->mode == 1))
				dz->is_bare_centre = 1;
			if((exit_status = setup_spin_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: spin NAME mode infile outfile (parameters)\n"
	"\n"
	"where NAME can be any one of\n"
	"\n"
	"stereo  quad\n"
	"\n"
	"Type 'spin stereo'  for more info on spin stereo option... ETC.\n");
	return(USAGE_ONLY);
}

/******************************** DBTOLEVEL ***********************/

double dbtolevel(double val)
{
	int isneg = 0;
	if(flteq(val,0.0))
		return(1.0);
	if(val < 0.0) {
		val = -val;
		isneg = 1;
	}
	val /= 20.0;
	val = pow(10.0,val);
	if(isneg)
		val = 1.0/val;
	return(val);
}	

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

int get_the_process_no(char *prog_identifier_from_cmdline,dataptr dz)
{
	if(!strcmp(prog_identifier_from_cmdline,"stereo"))				dz->process = SPIN;
	else if(!strcmp(prog_identifier_from_cmdline,"quad"))			dz->process = SPINQ;
	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,"stereo")) {
		fprintf(stderr,
	    "USAGE:  spin stereo\n"
	    "1 inf outf rate dopl xbuf [-bboost] [-aatten] [-eexpbuf]\n"
	    "2 inf outf rate chns cntr dopl xbuf [-bboost] [-aatt] [-kcmn] [-ccmx]\n"
	    "3 inf outf rate chns cntr dopl xbuf [-bboost] [-aatt] [-kcmn]\n"
		"\n"
		"Spin a wide stereo-image across the stereo space.\n"
		"(with possible doppler-shift on the moving edges).\n"
		"\n"
		"MODES 2 & 3 create 3-chan-wide output, centred on channel \"centre\",\n"
		"       in an \"ochans\"-channel outfile.\n"
		"\n"
		"When the spinning image crosses the centre ....\n"
		"MODE 2 uses outer channels to project stereo-at-centre image.\n"
		"MODE 3 uses ONLY central channel to project stereo-at-centre image.\n"
		"\n"
		"RATE  spin speed in cycles per second (can vary over time).\n"
		"      Positive values spin clockwise (as viewed from above).\n"
		"      Negative values spin anticlockwise (as viewed from above).\n"
		"BOOST Multiplicative level changes, as edges pass through centre.\n"
		"      gradually increase (*boost) as edge passes \"FRONT\" centre\n"
		"      and decreases (*1/boost) as edge passes \"REAR\" centre.\n"
		"      The two edges pass through centre simultaneously\n"
		"      so one edge gets louder and the other quieter.\n"
		"ATT   overall level attenuation (*att) as BOTH edges pass thro centre.\n"		
		"DOPL  Max doppler pitchshift, in semitones (Range 0-12).\n"
		"XBUF  Expand buffers by this factor (may be ness for large doppler shift)\n"
		"\n"
		"Mode 2 & 3 only...\n"
		"CHNS  Number of channels in output file.\n"		
		"CNTR  Output channel which carries the central channel of the output.\n"		
		"CMN   Min level on centre lspkr (0-1).\n"
		"Mode 2 only...\n"
		"CMX   Max level on centre lspkr (0-1).\n"
		"\n"
		"\n");
	} else if(!strcmp(str,"quad")) {
		fprintf(stderr,
	    "USAGE: spin quad 1 inf1 inf2 outf\n"
	    "rate ochns cntr dopl xbuf [-bboost] [-aatt] [-kcmn] [-ccmx]\n"
	    "OR:    spin quad 2 inf1 inf2 outf\n"
	    "rate ochns cntr dopl xbuf [-bboost] [-aatt] [-kcmn]\n"
		"\n"
		"Spin two wide stereo-image across a 5-channel-wide sound image\n"
		"(with possible doppler pitch-shift of the moving edges).\n"
		"\n"
		"When the spinning image crosses the centre ....\n"
		"MODE 1 uses outer channels to project stereo-at-centre image.\n"
		"MODE 2 uses ONLY central channel to project stereo-at-centre image.\n"
		"\n"
		"RATE  spin speed in cycles per second (can vary over time).\n"
		"      Positive values spin clockwise (as viewed from above).\n"
		"      Negative values spin anticlockwise (as viewed from above).\n"
		"OCHNS Number of channels in output file.\n"		
		"CNTR  Output channel which carries the central channel of the 5 outputs.\n"		
		"DOPL  Max doppler pitchshift, in semitones (Range 0-12).\n"
		"XBUF  Expand buffers used by process (may be nesss for large doppler shift)\n"
		"BOOST Multiplicative level changes, as edges pass through centre.\n"
		"      gradually increase (*boost) as edge passes \"FRONT\" centre\n"
		"      and decreases (*1/boost) as edge passes \"REAR\" centre.\n"
		"      The two edges pass through centre simultaneously\n"
		"      so one edge gets louder and the other quieter.\n"
		"ATT   overall level decrease (*atten) as BOTH edges pass thro centre.\n"		
		"CMN   Min level on centre lspkr (0-1).\n"
		"Mode 2 only...\n"
		"CMX   Max level on centre lspkr (0-1).\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);
}

/************************************ PANCALC *******************************/

#define SIGNAL_TO_LEFT  (0)
#define SIGNAL_TO_RIGHT (1)

void pancalc(double position,double *leftgain,double *rightgain)
{
	int dirflag;
	double temp;
	double relpos;
	double reldist, invsquare;

	if(position < 0.0)
		dirflag = SIGNAL_TO_LEFT;		/* signal on left */
	else
		dirflag = SIGNAL_TO_RIGHT;

	if(position < 0) 
		relpos = -position;
	else 
		relpos = position;
	if(relpos <= 1.0){		/* between the speakers */
		temp = 1.0 + (relpos * relpos);
		reldist = ROOT2 / sqrt(temp);
		temp = (position + 1.0) / 2.0;
		*rightgain = temp * reldist;
		*leftgain = (1.0 - temp ) * reldist;
	} else {				/* outside the speakers */
		temp = (relpos * relpos) + 1.0;
		reldist  = sqrt(temp) / ROOT2;   /* relative distance to source */
		invsquare = 1.0 / (reldist * reldist);
		if(dirflag == SIGNAL_TO_LEFT) {
			*leftgain = invsquare;
			*rightgain = 0.0;
		} else {   /* SIGNAL_TO_RIGHT */
			*rightgain = invsquare;
			*leftgain = 0;
		}
	}
}

/******************************* TIME_DISPLAY **************************/

void time_display(int samps_sent,dataptr dz)
{
	if(sloom)
		dz->process = MTOS;
	display_virtual_time(samps_sent,dz);
	if(sloom)
		dz->process = BROWNIAN;
}

/****************************** 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);
}

/******************************** CHECK_SPIN_PARAM_VALIDITY_AND_CONSISTENCY *****************/

int check_spin_param_validity_and_consistency(dataptr dz)
{
	int exit_status;
	if(dz->is_wide) {
		if(dz->iparam[SPNOCNTR] > dz->iparam[SPNOCHNS]) {
			sprintf(errstr,"Centre channel (%d) is not within the range of output channels available (%d).\n",dz->iparam[SPNOCNTR],dz->iparam[SPNOCHNS]);
			return DATA_ERROR;
		}
		if(!dz->is_bare_centre) {
			if(dz->param[SPNCMIN] > dz->param[SPNCMAX]) {
				sprintf(errstr,"Minimum level at centre (%lf) cannot be greater than maximum (%lf).\n",dz->param[SPNCMIN],dz->param[SPNCMAX]);
				return DATA_ERROR;
			}
		}
	}
	if(dz->brksize[SPNRATE]) {
		if((exit_status = get_maxvalue_in_brktable(&(dz->param[SPNRATE]),SPNRATE,dz))<0)
			return exit_status;
	}															//	Convert semitones to octaves
	dz->param[SPNDOPL] /= SEMITONES_PER_OCTAVE;					//	NB at max speed, doplshift = speed*pshift_factor = dopl * maxspeed/maxspeed 
	dz->pshift_factor = dz->param[SPNDOPL]/dz->param[SPNRATE];	//	at halfspeed,  doplshift = halfspeed*pshift_factor = dopl * halfspeed/maxspeed = halfshift
	return FINISHED;											//	at zerospeed,  doplshift = 0*pshift_factor = 0
}

/******************************** CREATE_SPIN_SNDBUFS *****************/

int create_spin_sndbufs(dataptr dz)
{
	int bigbufsize;
	int frameunit, framesize, outbufsize;
	int outchans;
	if(dz->is_wide)
		outchans = dz->iparam[SPNOCHNS];
	else
		outchans = STEREO;
	frameunit = outchans + STEREO + STEREO;			//	frame must be a multiple of (changroupsize of input*2 (2 input bufs) + changroupsize of output)
	if(dz->process == SPINQ)
		frameunit += STEREO + STEREO;				//	Two extra stereo inputs
	framesize = F_SECSIZE * frameunit;				//	frame must also be a multiple of sectorsize
	if(dz->sbufptr == 0 || dz->sampbuf==0) {
		sprintf(errstr,"buffer pointers not allocated: create_sndbufs()\n");
		return(PROGRAM_ERROR);
	}
	bigbufsize = (int)Malloc(-1);
	dz->buflen = bigbufsize / sizeof(float);		//	Ensure buffer contains an integer number of frames
	dz->buflen = (dz->buflen / framesize)  * framesize;
	bigbufsize = dz->buflen * sizeof(float);
	if(dz->iparam[SPNXBUF] > 1) {
		bigbufsize *= dz->iparam[SPNXBUF];
		dz->buflen *= dz->iparam[SPNXBUF];
	}
	if(bigbufsize <= 0) {
		sprintf(errstr,"Not enough memory available for expanded buffers\n");
		return MEMORY_ERROR;
	}
	outbufsize = (dz->buflen/frameunit) * outchans;	//	Get output buffer size
	dz->buflen = (dz->buflen/frameunit) * STEREO;	//	Get TRUE (input) buffer size
	bigbufsize += STEREO * 2 * sizeof(float);		//  create extra space for wraparound points of 2-input-bufs for interp of vals at buffer end
	if(dz->process == SPINQ)						// ..and in this case, also accomodate wraparound points of 2-bufs of 2nd-infile.
		bigbufsize += STEREO * 2 * sizeof(float);

	if((dz->bigbuf = (float *)malloc(bigbufsize)) == NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to create sound buffers.\n");
		return(PROGRAM_ERROR);
	}
	dz->buflen += STEREO;							// accomodate wraparound points in calculating buffer boundaries
	if(dz->process == SPINQ) {
		dz->sbufptr[0] = dz->sampbuf[0] = dz->bigbuf;
		dz->sbufptr[1] = dz->sampbuf[1] = dz->sampbuf[0] + dz->buflen;
		dz->sbufptr[2] = dz->sampbuf[2] = dz->sampbuf[1] + dz->buflen;
		dz->sbufptr[3] = dz->sampbuf[3] = dz->sampbuf[2] + dz->buflen;	//	Each input file has 2 buffers, 1 to read left chan, other to read right
		dz->sbufptr[4] = dz->sampbuf[4] = dz->sampbuf[3] + dz->buflen;	//	Reads may be out of sync, 
		dz->sampbuf[5] = dz->sampbuf[4] + outbufsize;					//	and left-read may exhaust buffer before right-read (or v.v.)
	} else {
		dz->sbufptr[0] = dz->sampbuf[0] = dz->bigbuf;
		dz->sbufptr[1] = dz->sampbuf[1] = dz->sampbuf[0] + dz->buflen;
		dz->sbufptr[2] = dz->sampbuf[2] = dz->sampbuf[1] + dz->buflen;
		dz->sampbuf[3] = dz->sampbuf[2] + outbufsize;
	}
	dz->buflen -= STEREO;
	return(FINISHED);
}

/******************************** CALCGAINS *****************/

void calcgains(double *ch1pos,double *pos,double *lastspin,int *flipped,int *movingforward,double *leftgain,double *rightgain,double srate,dataptr dz)
{
	double cycleincr, lgain, rgain;

	cycleincr = dz->param[SPNRATE]/srate;		//	How far into the rotation cycle, per sample-group		
	*ch1pos += cycleincr;
												//	Moving up, from 0 towards 1
	if(cycleincr > 0.0) {
												//	If rotate changes direction, 
		if(*lastspin < 0.0)						//	if leaving centre after passing it (flipped), we're now approaching it (!flipped)
			*flipped = !(*flipped);				//	whereas if approaching centre before passing it (!flipped), we're now leaving it (flipped)

		if(!(*flipped)) {						//	If we've not previously reached 1/2 way through cycle (travelling up cycle)
			if(*ch1pos > 0.5) {					//	If we've now reached 1/2 cycle end  (Left-channel moved fully from L(-1) to R(1), 1/2 way up (-cos)-table)
				*movingforward = -(*movingforward);//	This edge starts to move backwards(if previously moving forwards) (or vice versa), 
				*flipped = 1;					//	and FLAG the fact we've passed the flip-point
			}
		}
		if(*ch1pos  > 1.0) {					//	If we've now reached full cycle end (the end of the (-cos) table, so we're back to start from -1 0 1 0 to -1)
			*flipped = 0;						//	reset the flip-flag
			*movingforward = -(*movingforward);	//	This edge starts to move forwards again (if previously backwards) (or vice versa)
			*ch1pos -= 1.0;						//	reset ch1pos within 0-1 range (0-2PI range of (-cos) table)
		}
		*lastspin = dz->param[SPNRATE];			//	Only set "lastspin" when spin is NON-zero, so system remembers last (non-zero) motion direction

	} else if(cycleincr < 0.0) {				//	Opposite logic, moving down from 1 to 0

		if(*lastspin > 0.0)
			*flipped = !(*flipped);

		if(!(*flipped)) {						//	If we've not previously reached 1/2 way through cycle (travelling down cycle)
			if(*ch1pos < 0.5) {					//	If we've now reached 1/2 cycle end  (Left-channel moved fully from L(-1) to R(1), 1/2 way down (-cos)-table)
				*movingforward = -(*movingforward);	//	This edge starts to move backwards(if previously moving forwards) (or vice versa), 
				*flipped = 1;					//	and FLAG the fact we've passed the flip-point
			}
		}
		if(*ch1pos  < 0.0) {					//	If we've now reached full cycle end (the start of the (-cos) table, so we're back to start from -1 0 1 0 to -1)
			*flipped = 0;						//	reset the flip-flag
			*movingforward = -(*movingforward);	//	This edge starts to move forwards again (if previously backwards) (or vice versa)
			*ch1pos += 1.0;						//	reset ch1pos within 0-1 range (0-2PI range of (-cos) table)
		}
		*lastspin = dz->param[SPNRATE];
	}
	*pos = -cos(*ch1pos * TWOPI);				//	ch1pos ranges from 0 to 1 and recycles, change range to 0 to 2PI
												//  -cos goes then ranges (-1 0 1 0 -1 = Left Right Left)
	pancalc(*pos,&lgain,&rgain);
	*leftgain  = lgain;
	*rightgain = rgain;
}

/******************************** SPINDOPL ********************************
 *
 *	Everything is controlled by the parameter ch1pos.
 *	which cycles 0 -> 1, then flips back to 0, at a speed controlled by ROTATION RATE.
 *
 *	Using this cycling function, "calcgains"  calculates
 *
 *	(1)	"pos" ... the current position of the (original) left edge of the image, in the stereo-rotation space.
 *	(2) "leftgain" and "rightgain", the required weightings on left and right channel of output to place this at position "pos" in output.
 *	(3)	"rleftgain" and "rrightgain", the weightings of the (orig) right channel-src (BY ANTI-SYMMETRY) in output image.
 *
 * The doppler logic is as follows
 *
 * If the rotation is +ve, if pos (spatial position) -ve (to left) , motion is away from listener, pitch falls, sampleread-incr +ve
 *						   if pos +ve (to right), motion is towards listener, pitch rises, sampleread-incr -ve
 *
 * Speed varies sinusoidally from max at position -1(left) and +1(right) to min at 0(centre)
 * so pitch-incr depends on position (which is varying sinusoidally) but inversely (pos to left (-ve) gives +ve sampread-incr).
 * the step thro the pitch-table for +ve rotation is thus multipled by a factor X*(-pos)
 *
 * If the rotation is -ve, if pos -ve (to left) , motion is towards listener, pitch rises, sampread-incr -ve
 *						   if pos +ve (to right), motion is away from listener, pitch falls, sampread-incr +ve
 * the step thro the pitch-table for -ve rotation is thus multipled by a factor X*(pos)
 *
 * in general pitch-incr = (X*-rotsign*pos) ... pos varying between -1 and + 1
 *
 * We want pitch-incr to increase, as rotation-speed increases
 *
 * so pitch-incr = (Y*-rotrate*pos)
 *
 * User enters the MAXIMUM pitchshift required ... using the maximum rotation-rate, we calculate the "pshift_factor"
 * The "pshift_factor" is the pshift per cycles-per-sec
 *
 * so pitch-incr = (pshift_factor*-rotrate*pos)
 *
 * !!!!!!!!!!!!!
 *
 * pos   = spatial position of(originally) left channel of rotating source
 *
 *	Data is read from two parallel buffers, which are topped up once either pointer reaches its buffer end
 *	either by a file-read, or by copying from the other (already read-into) buffer.
 *	Only when both read-processes reach their data-ends does process terminate.
 *
 * iposl = pointer to possibly-fractional read-position in input-buffer for read of (orig) left chan, counted in stereo-samples
 * iposr = simil for (orig) right channel: Due to inverse doppler shifting, these read points are generally out of step, hence the 2 read buffers.
 */

int spindopl(dataptr dz)
{
	int exit_status, passno = 0, flipped = 0, movingforward, buf_advanced_l, buf_advanced_r;
	float *ibufl = dz->sampbuf[0], *ibufr = dz->sampbuf[1], *obuf = dz->sampbuf[2];
	double srate = (double)dz->infile->srate, iposl, iposr;
	double ch1pos, normaliser = 1.0, maxsamp = 0.0, time = 0.0, firstspin, lastspin;
	double pos, leftgain, lleftgain, rleftgain, rightgain, lrightgain, rrightgain, boost, atten, frac, diff, lval, rval, incrl, incrr;
	int c1, c2, n, stereo_pairs_read, stereo_pairs_read_l, stereo_pairs_read_r, lo, hi;
	int sampsread_l, sampsread_r, stereo_pairs_buflen = dz->buflen/STEREO;
	if(dz->brksize[SPNRATE]) {
		if((exit_status= read_value_from_brktable(time,SPNRATE,dz))< 0)
			return exit_status;
	}
	firstspin = dz->param[SPNRATE];
	for(passno = 0;passno < 2; passno++) {
		dz->total_samps_written = 0;
		iposl = 0;
		iposr = 0;
		display_virtual_time(dz->total_samps_written,dz);
		ch1pos = 0;					//	ch1pos starts at beginning of motion-cycle range (0 of 0to1)
		if(firstspin >= 0.0)
			movingforward = 1;		//	Left image moves backwards (right image moves forwards) - clockwise, viewed from above
		else
			movingforward = -1;		//	Left image moves forward (right image moves backwards) - anticlockwise, viewed from above
		lastspin = firstspin;
		memset((char *)obuf,0,dz->buflen * sizeof(float));
		dz->total_samps_read = 0;
		dz->samps_left = dz->insams[0];
		if((sndseekEx(dz->ifd[0],0,0) < 0)){
			sprintf(errstr,"sndseek failed\n");
			return SYSTEM_ERROR;
		}
		c1 = 0;	//	current left sample of output buffer
		c2 = 1;	//	current right sample of output buffer

		memset((char *)obuf,0,dz->buflen * sizeof(float));
		memset((char *)ibufl,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibufr,0,(dz->buflen + STEREO) * sizeof(float));

		dz->buflen += STEREO;							//	accomodate wrap-around points
		if((exit_status = read_samps(ibufl,dz))<0)
			return(exit_status);
		memcpy((char *)ibufr,(char *)ibufl,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			dz->total_samps_read -= STEREO;
			dz->samps_left += STEREO;
			sndseekEx(dz->ifd[0],dz->total_samps_read,0);	//	and Reset position in file
		}
		sampsread_l = dz->ssampsread;
		sampsread_r = dz->ssampsread;
		stereo_pairs_read_l = dz->ssampsread/STEREO;
		stereo_pairs_read_r = stereo_pairs_read_l;
		stereo_pairs_read = stereo_pairs_read_l;		//	Initially, same samples on both input buffers
		buf_advanced_l = 0;
		buf_advanced_r = 0;

		//	NB only one channel of stereo needs to be calcd - other follows BY SYMMETRY
	
		while(stereo_pairs_read > 0) {					//	Process continues until BOTH input reads are exhausted

			time = (double)((dz->total_samps_written + c1)/STEREO)/srate;
			if((exit_status = read_values_from_all_existing_brktables(time,dz))< 0)
				return exit_status;

			calcgains(&ch1pos,&pos,&lastspin,&flipped,&movingforward,&leftgain,&rightgain,srate,dz);

			//	If either of the input pointers runs out of samples, attempt to read more ....

			//	If all left samps read before all right, stereo_pairs_read_l can now be ZERO.
			//	In this case, continue to read from (ZEROED) buffer, until right-chan read also reads zero samples .. signalling both reads exhausted

			if((stereo_pairs_read_l == 0 && iposl >= stereo_pairs_buflen) || (stereo_pairs_read_l > 0 && iposl >= stereo_pairs_read_l)) {
				if(buf_advanced_l && (stereo_pairs_read_l != 0)) {		//	IF left read ALREADY ahead of right-read, and left NOT exhaused, problem
					sprintf(errstr,"Reading samples for 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced_r) {									//	If already read into other (right) buffer,
					memcpy((char *)ibufl,(char *)ibufr,(sampsread_r + STEREO) * sizeof(float));
					sampsread_l = sampsread_r;							//	simply copy input data from one buff to other
					stereo_pairs_read_l = stereo_pairs_read_r;			//	Reset counters
					buf_advanced_r = 0;									//	and indicate buffer-R is not read-ahead of buffer-L

				} else {												//	IF NOT, //	Read into l-buffer etc.
					dz->buflen += STEREO;								//	accomodating possible wrap-around points
					memset((char *)ibufl,0,dz->buflen * sizeof(float));	
					if((exit_status = read_samps(ibufl,dz))<0)			
						return(exit_status);
					dz->buflen -= STEREO;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						dz->total_samps_read -= STEREO;
						dz->samps_left += STEREO;
						sndseekEx(dz->ifd[0],dz->total_samps_read,0);
					}
					sampsread_l = dz->ssampsread;
					stereo_pairs_read_l = sampsread_l/STEREO;
					buf_advanced_l = 1;									//	and indicate that L-buffer is read-ahead of right buffer
				}
																		//	stereo_pairs_read set to MAX of reads from left & from right chans (as 1 buffer may be exhausted)
				stereo_pairs_read = max(stereo_pairs_read_l,stereo_pairs_read_r);
				iposl -= stereo_pairs_buflen;							//	If previous buffer was full, backtrack by buflen lands inside buffer.
				iposl = max(0.0,iposl);									//	BUT, if previous read reached endoffile, (hence buffer here zeroed & nothing written to it).
																		//	the baktrak jumps past zerobuf to a -ve val, so just reset to buf start (to read zeros) 
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read_r == 0 && iposr >= stereo_pairs_buflen) || (stereo_pairs_read_r > 0 && iposr >= stereo_pairs_read_r)) {
				if(buf_advanced_r && (stereo_pairs_read_r != 0)) {
					sprintf(errstr,"Reading samples for 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced_l) {
					memcpy((char *)ibufr,(char *)ibufl,(sampsread_l + STEREO) * sizeof(float));
					sampsread_r = sampsread_l;
					stereo_pairs_read_r = stereo_pairs_read_l;
					buf_advanced_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibufr,0,dz->buflen * sizeof(float));
					if((exit_status = read_samps(ibufr,dz))<0)
						return(exit_status);
					dz->buflen -= STEREO;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						dz->total_samps_read -= STEREO;
						dz->samps_left += STEREO;
						sndseekEx(dz->ifd[0],dz->total_samps_read,0);
					}
					sampsread_r = dz->ssampsread;
					stereo_pairs_read_r = sampsread_r/STEREO;
					buf_advanced_r = 1;
				}
				stereo_pairs_read = max(stereo_pairs_read_l,stereo_pairs_read_r);
				iposr -= stereo_pairs_buflen;
				iposr = max(0.0,iposr);
			}
			if(stereo_pairs_read == 0)			//	Once BOTH reads get zero samples, we've reached end of both read processes, so quit
				break;

			lo = (int)floor(iposl);			//	Using doppler pointer on left-chan
			frac = iposl - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff = ibufl[hi] - ibufl[lo];
			lval = ibufl[lo] + (diff * frac);
			
			lo = (int)floor(iposr);			//	Using doppler pointer on right-chan
			frac = iposr - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff = ibufr[hi] - ibufr[lo];
			rval = ibufr[lo] + (diff * frac);

			if(dz->param[SPNATTEN] > 0.0) {			//	Atten goes linearly 0->ATTEN->0 as output moves L->C->R
				atten = (1.0 - fabs(pos)) * dz->param[SPNATTEN];
				atten = 1.0 - atten;				//	So level is multiplied by (1-atten), going from 1->(1-atten)->1 from L->C->R
				leftgain  *= atten;
				rightgain *= atten;
			}
			lleftgain  = leftgain;					//	To position left channel in stereo of output , calculate appropriate left and right gain
			lrightgain = rightgain;
			rleftgain  = rightgain;					//	By symmetry, right channel inverts the level of left and right
			rrightgain = leftgain;
													//	Differential boost between front and rear
			if(dz->param[SPNBOOST] > 0.0) {			//	Booster goes linearly 0->BOOST->0 as output moves L->C->R
				boost = (1.0 - fabs(pos)) * dz->param[SPNBOOST];
				boost += 1.0;						//	Booster becomes a multiplier(divider)
				if(movingforward < 0) {				//	moving forwards (other channel moving backwards)
					lleftgain  *= boost;			//	Original chan1(left) is moving across front, positioning levels are increased
					lrightgain *= boost;
					rleftgain  /= boost;			//	Original chan2(right) is moving across rear, positioning levels are decreased
					rrightgain /= boost;
				} else {
					lleftgain  /= boost;			//	Original chan1(left) is moving across rear, positioning levels are decrease
					lrightgain /= boost;
					rleftgain  *= boost;			//	Original chan2(right) is moving across front, positioning levels are increased
					rrightgain *= boost;
				}
			}
			obuf[c1] = (float)(obuf[c1] + (lval * lleftgain));		//	Orig ch1 signal positioned at new pos, to left and right
			obuf[c2] = (float)(obuf[c2] + (lval * lrightgain));
			obuf[c1] = (float)(obuf[c1] + (rval * rleftgain));		//	Orig ch2 signal positioned at new pos, to left and right
			obuf[c2] = (float)(obuf[c2] + (rval * rrightgain));

			c1 += 2;
			c2 += 2;								//	Advance in output buffer
													//	and if it fills up, write to output
			if(c1 >= dz->buflen) {
				if(passno == 0) {
					for(n=0;n<dz->buflen;n++)
						maxsamp = max(maxsamp,fabs(obuf[n]));
					dz->total_samps_written += dz->buflen;	//	Update to ensure "sampletime" is calculated correctly for sloom display
					dz->process = DISTORT_PULSED;			//	Forces correct progress-bar display on Loom
					display_virtual_time(dz->total_samps_written,dz);
					dz->process = SPIN;
				} else {
					if(normaliser < 1.0) {
						for(n=0;n<dz->buflen;n++)
							obuf[n] = (float)(obuf[n] * normaliser);
					}
					dz->process = DISTORT_PULSED;	//	Forces correct progress-bar display on Loom
					if((exit_status = write_samps(obuf,dz->buflen,dz))<0)
						return(exit_status);
					dz->process = SPIN;
				}
				memset((char *)obuf,0,dz->buflen * sizeof(float));
				c1 = 0;
				c2 = 1;
			}										//	Calculate read-insound increment to accomodate doppler pshift
			incrl = dz->pshift_factor * (-dz->param[SPNRATE]) * pos;
			incrl = pow(2.0,incrl);					//	Convert octaves to frq ratio
			incrr = 2.0 - incrl;					//	For incrs and decrs to cancel each other in long term, we must have incr2 = 2 - incrl;

			iposl += incrl;							//	Advance in input sound according to doppler pitchshift on (originally) left edge
			iposr += incrr;							//	Advance in input sound according to doppler pitchshift on (originally) right edge
		}
		if(c1 > 0) {								//	Write any residual output
			if(passno == 0) {
				for(n=0;n<c1;n++)
					maxsamp = max(maxsamp,fabs(obuf[n]));
				dz->total_samps_written += c1;
				display_virtual_time(dz->total_samps_written,dz);
			} else {
				if(normaliser < 1.0) {
					for(n=0;n<c1;n++)
						obuf[n] = (float)(obuf[n] * normaliser);
				}
				dz->process = DISTORT_PULSED;	//	Forces correct progress-bar display on Loom
				if((exit_status = write_samps(obuf,c1,dz))<0)
					return(exit_status);
				dz->process = SPIN;
			}
		}
		if(passno == 0) {
			if(maxsamp > 0.95)
				normaliser = 0.95/maxsamp;
			else if(maxsamp <= FLTERR) {
				sprintf(errstr,"No significant signal found in source file.\n");
				return DATA_ERROR;
			}
		}
	}
	return FINISHED;
}

/******************************** SPINWDOPL ********************************
 *
 * same logic as spindopl, but now output goes to multichan file, and signal goes to a central channel between two orig chans.
 */

int spinwdopl(dataptr dz)
{
	int exit_status, passno = 0, flipped = 0, movingforward, buf_advanced_l, buf_advanced_r, ochans = dz->iparam[SPNOCHNS];
	float *ibufl = dz->sampbuf[0], *ibufr = dz->sampbuf[1], *obuf = dz->sampbuf[2];
	double srate = (double)dz->infile->srate, iposl, iposr;
	double ch1pos, normaliser = 1.0, maxsamp = 0.0, time = 0.0, firstspin, lastspin;
	double pos = 0.0, leftgain, lleftgain, rleftgain, rightgain, lrightgain, rrightgain, boost, atten, frac, diff, lval, rval, incrl, incrr;
	int c1, c2, cc, opos, n, obuflen, stereo_pairs_read, stereo_pairs_read_l, stereo_pairs_read_r, lo, hi;
	int sampsread_l, sampsread_r, stereo_pairs_buflen = dz->buflen/STEREO;
	int lchan, rchan, cchan = dz->iparam[SPNOCNTR];
	double boostrange = dz->param[SPNCMAX] - dz->param[SPNCMIN];

	lchan = cchan - 1;
	if(lchan < 1)
		lchan += ochans;
	rchan = cchan + 1;
	if(rchan > ochans)
		rchan -= ochans;
	lchan--;		//	Convert from 1-N frame to 0to-1 frame for countingt channels
	rchan--;
	cchan--;
	obuflen = (dz->buflen/STEREO) * ochans;		//	Calc size of output buffer

	if(dz->brksize[SPNRATE]) {
		if((exit_status= read_value_from_brktable(time,SPNRATE,dz))< 0)
			return exit_status;
	}
	firstspin = dz->param[SPNRATE];
	dz->tempsize = (dz->insams[0]/STEREO) * ochans;	//	For Loom progress-bar: total size of output
	for(passno = 0;passno < 2; passno++) {
		if(passno == 0) {
			fprintf(stdout,"INFO: Assessing output level\n");
			fflush(stdout);
		} else {
			fprintf(stdout,"INFO: Creating output sound\n");
			fflush(stdout);
		}
		dz->total_samps_written = 0;
		display_virtual_time(dz->total_samps_written,dz);
		ch1pos = 0;					//	Channel 1 starts at beginning of motion-cycle range (0 of 0to1)
		if(firstspin >= 0.0)
			movingforward = 1;		//	Left image moves backwards (right image moves forwards) - clockwise, viewed from above
		else
			movingforward = -1;		//	Left image moves forward (right image moves backwards) - anticlockwise, viewed from above
		lastspin = firstspin;
		flipped = 0;
		dz->total_samps_read = 0;
		if((sndseekEx(dz->ifd[0],0,0) < 0)){
			sprintf(errstr,"sndseek failed\n");
			return SYSTEM_ERROR;
		}
		iposl = 0;
		iposr = 0;
		opos = 0;
		c1 = lchan;
		c2 = rchan;
		cc = cchan;

		memset((char *)obuf,0,obuflen * sizeof(float));
		memset((char *)ibufl,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibufr,0,(dz->buflen + STEREO) * sizeof(float));

		dz->buflen += STEREO;							//	accomodate wrap-around points
		if((exit_status = read_samps(ibufl,dz))<0)
			return(exit_status);
		memcpy((char *)ibufr,(char *)ibufl,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			dz->total_samps_read -= STEREO;
			sndseekEx(dz->ifd[0],dz->total_samps_read,0);	//	and Reset position in file
		}

		sampsread_l = dz->ssampsread;
		sampsread_r = dz->ssampsread;
		stereo_pairs_read_l = dz->ssampsread/STEREO;
		stereo_pairs_read_r = stereo_pairs_read_l;
		stereo_pairs_read = stereo_pairs_read_l;		//	Initially, same samples on both input buffers
		buf_advanced_l = 0;
		buf_advanced_r = 0;

		//	NB only one channel of stereo needs to be calcd - other follows BY SYMMETRY

		while(stereo_pairs_read > 0) {
	
			time = (double)((dz->total_samps_written + c1)/STEREO)/srate;
			if((exit_status = read_values_from_all_existing_brktables(time,dz))< 0)
				return exit_status;

			calcgains(&ch1pos,&pos,&lastspin,&flipped,&movingforward,&leftgain,&rightgain,srate,dz);

			if((stereo_pairs_read_l == 0 && iposl >= stereo_pairs_buflen) || (stereo_pairs_read_l > 0 && iposl >= stereo_pairs_read_l)) {
				if(buf_advanced_l && (stereo_pairs_read_l != 0)) {
					sprintf(errstr,"Reading samples for 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced_r) {
					memcpy((char *)ibufl,(char *)ibufr,(sampsread_r + STEREO) * sizeof(float));
					sampsread_l = sampsread_r;
					stereo_pairs_read_l = stereo_pairs_read_r;
					buf_advanced_r = 0;

				} else {
					dz->buflen += STEREO;
					memset((char *)ibufl,0,dz->buflen * sizeof(float));	
					if((exit_status = read_samps(ibufl,dz))<0)			
						return(exit_status);
					dz->buflen -= STEREO;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						dz->total_samps_read -= STEREO;
						sndseekEx(dz->ifd[0],dz->total_samps_read,0);
					}
					sampsread_l = dz->ssampsread;
					stereo_pairs_read_l = sampsread_l/STEREO;
					buf_advanced_l = 1;
				}
				stereo_pairs_read = max(stereo_pairs_read_l,stereo_pairs_read_r);
				iposl -= stereo_pairs_buflen;
				iposl = max(0.0,iposl);
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read_r == 0 && iposr >= stereo_pairs_buflen) || (stereo_pairs_read_r > 0 && iposr >= stereo_pairs_read_r)) {
				if(buf_advanced_r && (stereo_pairs_read_r != 0)) {
					sprintf(errstr,"Reading samples for 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced_l) {
					memcpy((char *)ibufr,(char *)ibufl,(sampsread_l + STEREO) * sizeof(float));
					sampsread_r = sampsread_l;
					stereo_pairs_read_r = stereo_pairs_read_l;
					buf_advanced_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibufr,0,dz->buflen * sizeof(float));
					if((exit_status = read_samps(ibufr,dz))<0)
						return(exit_status);
					dz->buflen -= STEREO;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						dz->total_samps_read -= STEREO;
//						dz->samps_left += STEREO;
						sndseekEx(dz->ifd[0],dz->total_samps_read,0);
					}
					sampsread_r = dz->ssampsread;
					stereo_pairs_read_r = sampsread_r/STEREO;
					buf_advanced_r = 1;
				}
				stereo_pairs_read = max(stereo_pairs_read_l,stereo_pairs_read_r);
				iposr -= stereo_pairs_buflen;
				iposr = max(0.0,iposr);
			}
			if(stereo_pairs_read == 0)
				break;

			lo = (int)floor(iposl);			//	Using doppler pointer on left-chan
			frac = iposl - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff = ibufl[hi] - ibufl[lo];
			lval = ibufl[lo] + (diff * frac);
			
			lo = (int)floor(iposr);			//	Using doppler pointer on right-chan
			frac = iposr - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff = ibufr[hi] - ibufr[lo];
			rval = ibufr[lo] + (diff * frac);

			if(dz->param[SPNATTEN] > 0.0) {			//	Atten goes linearly 0->ATTEN->0 as output moves L->C->R
				atten = (1.0 - fabs(pos)) * dz->param[SPNATTEN];
				atten = 1.0 - atten;				//	So level is multiplied by (1-atten), going from 1->(1-atten)->1 from L->C->R
				leftgain  *= atten;
				rightgain *= atten;
			}
			lleftgain  = leftgain;					//	To position left channel in stereo of output , calculate appropriate left and right gain
			lrightgain = rightgain;
			rleftgain  = rightgain;					//	By symmetry, right channel inverts the level of left and right
			rrightgain = leftgain;
													//	Differential boost between front and rear
			if(dz->param[SPNBOOST] > 0.0) {			//	Booster goes linearly 0->BOOST->0 as output moves L->C->R
				boost = (1.0 - fabs(pos)) * dz->param[SPNBOOST];
				boost += 1.0;						//	Booster becomes a multiplier(divider)
				if(movingforward < 0) {				//	moving forwards (other channel moving backwards)
					lleftgain  *= boost;			//	Original chan1(left) is moving across front, positioning levels are increased
					lrightgain *= boost;
					rleftgain  /= boost;			//	Original chan2(right) is moving across rear, positioning levels are decreased
					rrightgain /= boost;
				} else {
					lleftgain  /= boost;			//	Original chan1(left) is moving across rear, positioning levels are decrease
					lrightgain /= boost;
					rleftgain  *= boost;			//	Original chan2(right) is moving across front, positioning levels are increased
					rrightgain *= boost;
				}
			}
			obuf[c1] = (float)(obuf[c1] + (lval * lleftgain));	//	Orig ch1 signal positioned at new pos, to left and right
			obuf[c2] = (float)(obuf[c2] + (lval * lrightgain));
			obuf[c1] = (float)(obuf[c1] + (rval * rleftgain));	//	Orig ch2 signal positioned at new pos, to left and right
			obuf[c2] = (float)(obuf[c2] + (rval * rrightgain));

			boost = (1.0 - fabs(pos)) * boostrange;				//	Central channel
			boost += dz->param[SPNCMIN];
			obuf[cc] = (float)((lval + rval) * boost);			//	Gets scaled mono mix of stereo input

			opos += ochans;
			c1 += ochans;
			c2 += ochans;
			cc += ochans;
			if(opos >= obuflen) {
				if(passno == 0) {
					for(n=0;n<obuflen;n++)
						maxsamp = max(maxsamp,fabs(obuf[n]));
					dz->total_samps_written += obuflen;			//	Update to ensure "time" is calculated correctly
					dz->process = DISTORT_PULSED;				//	Forces correct progress-bar display on Loom
					time_display(dz->total_samps_written,dz);
					dz->process = SPIN;
				} else {
					if(normaliser < 1.0) {
						for(n=0;n<obuflen;n++)
							obuf[n] = (float)(obuf[n] * normaliser);
					}
					dz->process = DISTORT_PULSED;
					if((exit_status = write_samps(obuf,obuflen,dz))<0)
						return(exit_status);
					dz->process = SPIN;
				}
				memset((char *)obuf,0,obuflen * sizeof(float));
				opos = 0;
				c1 = lchan;
				c2 = rchan;
				cc = cchan;
			}										//	Calculate read-insound increment to accomodate doppler pshift
			incrl = dz->pshift_factor * (-dz->param[SPNRATE]) * pos;
			incrl = pow(2.0,incrl);					//	Convert octaves to frq ratio
			incrr = 2.0 - incrl;					//	For incrs and decrs to cancel each other in long term, we must have incr2 = 2 - incrl;

			iposl += incrl;							//	Advance in input sound according to doppler pitchshift on (originally) left edge
			iposr += incrr;							//	Advance in input sound according to doppler pitchshift on (originally) right edge
		}
		if(opos > 0) {
			if(passno == 0) {
				for(n=0;n<opos;n++)
					maxsamp = max(maxsamp,fabs(obuf[n]));
				dz->process = DISTORT_PULSED;
				display_virtual_time(dz->tempsize,dz);
				dz->process = SPIN;
			} else {
				if(normaliser < 1.0) {
					for(n=0;n<opos;n++)
						obuf[n] = (float)(obuf[n] * normaliser);
				}
				dz->process = DISTORT_PULSED;
				if((exit_status = write_samps(obuf,opos,dz))<0)
					return(exit_status);
				dz->process = SPIN;
			}
		}
		if(passno == 0) {
			if(maxsamp > 0.95)
				normaliser = 0.95/maxsamp;
			else if(maxsamp <= FLTERR) {
				sprintf(errstr,"No significant signal found in source file.\n");
				return DATA_ERROR;
			}
		}
	}
	return FINISHED;
}

/******************************** SPINQDOPL ********************************
 *
 * The same logic, with 1 stereo input on chans -1 and +1,and other on -2 and +2, around a cnetre channel.
 */

int spinqdopl(dataptr dz)
{
	int exit_status, budge, passno = 0, flipped = 0, movingforward, buf_advanced1_l, buf_advanced1_r, buf_advanced2_l, buf_advanced2_r, ochans = dz->iparam[SPNOCHNS];
	float *ibuf1l = dz->sampbuf[0], *ibuf1r = dz->sampbuf[1], *ibuf2l = dz->sampbuf[2], *ibuf2r = dz->sampbuf[3], *obuf = dz->sampbuf[4];
	double srate = (double)dz->infile->srate, ipos1l, ipos1r, ipos2l, ipos2r;
	double ch1pos, normaliser = 1.0, maxsamp = 0.0, time = 0.0, firstspin, lastspin;
	double pos = 0.0, leftgain, lleftgain, rleftgain, rightgain, lrightgain, rrightgain, boost, atten, frac, diff, lval1, rval1, lval2, rval2, incrl, incrr;
	int c1, c2, cc, c3, c4, opos, n, obuflen;
	int stereo_pairs_read, stereo_pairs_read1, stereo_pairs_read2, stereo_pairs_read1_l, stereo_pairs_read1_r, stereo_pairs_read2_l, stereo_pairs_read2_r;
	int lo, hi, total_samps_read1, total_samps_read2, sampsread1_l, sampsread1_r, sampsread2_l, sampsread2_r, stereo_pairs_buflen = dz->buflen/STEREO;
	int lchan1, rchan1, lchan2, rchan2, cchan = dz->iparam[SPNOCNTR];
	double boostrange = dz->param[SPNCMAX] - dz->param[SPNCMIN];
	lchan1 = cchan - 1;
	if(lchan1 < 1)
		lchan1 += ochans;
	rchan1 = cchan + 1;
	if(rchan1 > ochans)
		rchan1 -= ochans;
	lchan2 = cchan - 2;
	if(lchan2 < 1)
		lchan2 += ochans;
	rchan2 = cchan + 2;
	if(rchan2 > ochans)
		rchan2 -= ochans;
	lchan1--;		//	Convert from 1-N frame to 0to-1 frame for countingt channels
	rchan1--;
	lchan2--;
	rchan2--;
	cchan--;
	obuflen = (dz->buflen/STEREO) * ochans;		//	Calc size of output buffer

	if(dz->brksize[SPNRATE]) {
		if((exit_status= read_value_from_brktable(time,SPNRATE,dz))< 0)
			return exit_status;
	}
	firstspin = dz->param[SPNRATE];
	dz->total_samps_written = 0;
	dz->tempsize = (dz->insams[0]/STEREO) * ochans;	//	For Loom progress-bar: total size of output
	for(passno = 0;passno < 2; passno++) {
		if(passno == 0) {
			fprintf(stdout,"INFO: Assessing output level\n");
			fflush(stdout);
		} else {
			fprintf(stdout,"INFO: Creating output sound\n");
			fflush(stdout);
		}
		dz->total_samps_written = 0;
		display_virtual_time(dz->total_samps_written,dz);
		ch1pos = 0;					//	Channel 1 starts at beginning of motion-cycle range (0 of 0to1)
		if(firstspin >= 0.0)
			movingforward = 1;		//	Left image moves backwards (right image moves forwards) - clockwise, viewed from above
		else
			movingforward = -1;		//	Left image moves forward (right image moves backwards) - anticlockwise, viewed from above
		lastspin = firstspin;
		flipped = 0;
		dz->total_samps_read = 0;
		if((sndseekEx(dz->ifd[0],0,0) < 0)){
			sprintf(errstr,"sndseek failed in input file 1\n");
			return SYSTEM_ERROR;
		}
		if((sndseekEx(dz->ifd[1],0,0) < 0)){
			sprintf(errstr,"sndseek failed in input file 2\n");
			return SYSTEM_ERROR;
		}
		ipos1l = 0;					//	initialise all buffer pointers
		ipos1r = 0;
		ipos2l = 0;
		ipos2r = 0;
		opos = 0;
		c1 = lchan1;
		c2 = rchan1;
		c3 = lchan2;
		c4 = rchan2;
		cc = cchan;					//	zero all buffers, including wraparound points

		memset((char *)obuf,0,dz->buflen * sizeof(float));
		memset((char *)ibuf1l,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibuf1r,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibuf2l,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibuf2r,0,(dz->buflen + STEREO) * sizeof(float));

		dz->buflen += STEREO;							//	accomodate wrap-around points
		memset((char *)ibuf1l,0,dz->buflen * sizeof(float));
		if((dz->ssampsread = fgetfbufEx(ibuf1l, dz->buflen,dz->ifd[0],0)) < 0) {
			sprintf(errstr,"Can't read samples from input soundfile 1.\n");
			return(SYSTEM_ERROR);
		}
		memcpy((char *)ibuf1r,(char *)ibuf1l,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			sndseekEx(dz->ifd[0],dz->ssampsread,0);		//	and Reset position in file
		}

		total_samps_read1 = dz->ssampsread;
		sampsread1_l = dz->ssampsread;
		sampsread1_r = dz->ssampsread;
		stereo_pairs_read1_l = dz->ssampsread/STEREO;
		stereo_pairs_read1_r = stereo_pairs_read1_l;
		stereo_pairs_read1 = stereo_pairs_read1_l;		//	Initially, same samples on both input buffers
		buf_advanced1_l = 0;
		buf_advanced1_r = 0;

		dz->buflen += STEREO;							//	accomodate wrap-around points
		memset((char *)ibuf2l,0,dz->buflen * sizeof(float));
		if((dz->ssampsread = fgetfbufEx(ibuf2l, dz->buflen,dz->ifd[1],0)) < 0) {
			sprintf(errstr,"Can't read samples from input soundfile 2.\n");
			return(SYSTEM_ERROR);
		}
		memcpy((char *)ibuf2r,(char *)ibuf2l,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			sndseekEx(dz->ifd[1],dz->ssampsread,0);		//	and Reset position in file
		}

		total_samps_read2 = dz->ssampsread;
		sampsread2_l = dz->ssampsread;
		sampsread2_r = dz->ssampsread;
		stereo_pairs_read2_l = dz->ssampsread/STEREO;
		stereo_pairs_read2_r = stereo_pairs_read2_l;
		stereo_pairs_read2 = stereo_pairs_read2_l;		//	Initially, same samples on both input buffers
		buf_advanced2_l = 0;
		buf_advanced2_r = 0;

		stereo_pairs_read = max(stereo_pairs_read1,stereo_pairs_read2);

		//	NB only one channel of stereo needs to be calcd - other follows BY SYMMETRY
	
		while(stereo_pairs_read > 0) {

			time = (double)((dz->total_samps_written + opos)/ochans)/srate;	//	Time calculated from count of output
			if((exit_status= read_values_from_all_existing_brktables(time,dz))< 0)
				return exit_status;

			calcgains(&ch1pos,&pos,&lastspin,&flipped,&movingforward,&leftgain,&rightgain,srate,dz);

			if((stereo_pairs_read1_l == 0 && ipos1l >= stereo_pairs_buflen) || (stereo_pairs_read1_l > 0 && ipos1l >= stereo_pairs_read1_l)) {
				if(buf_advanced1_l && (stereo_pairs_read1_l != 0)) {
					sprintf(errstr,"Reading samples for 1st sound, 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced1_r) {
					memcpy((char *)ibuf1l,(char *)ibuf1r,(sampsread1_r + STEREO) * sizeof(float));
					sampsread1_l = sampsread1_r;
					stereo_pairs_read1_l = stereo_pairs_read1_r;
					buf_advanced1_r = 0;

				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf1l,0,dz->buflen * sizeof(float));	
					if((dz->ssampsread = fgetfbufEx(ibuf1l, dz->buflen,dz->ifd[0],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 1.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						budge = 1;
						dz->ssampsread -= STEREO;
					}
					total_samps_read1 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[0],total_samps_read1,0);
					sampsread1_l = dz->ssampsread;
					stereo_pairs_read1_l = sampsread1_l/STEREO;
					buf_advanced1_l = 1;
				}
				stereo_pairs_read1 = max(stereo_pairs_read1_l,stereo_pairs_read1_r);
				ipos1l -= stereo_pairs_buflen;
				ipos1l = max(0.0,ipos1l);
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read1_r == 0 && ipos1r >= stereo_pairs_buflen) || (stereo_pairs_read1_r > 0 && ipos1r >= stereo_pairs_read1_r)) {
				if(buf_advanced1_r && (stereo_pairs_read1_r != 0)) {
					sprintf(errstr,"Reading samples for 1st file, 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced1_l) {
					memcpy((char *)ibuf1r,(char *)ibuf1l,(sampsread1_l + STEREO) * sizeof(float));
					sampsread1_r = sampsread1_l;
					stereo_pairs_read1_r = stereo_pairs_read1_l;
					buf_advanced1_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf1r,0,dz->buflen * sizeof(float));
					if((dz->ssampsread = fgetfbufEx(ibuf1r, dz->buflen,dz->ifd[0],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 1.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						budge = 1;
					}
					total_samps_read1 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[0],total_samps_read1,0);
					sampsread1_r = dz->ssampsread;
					stereo_pairs_read1_r = sampsread1_r/STEREO;
					buf_advanced1_r = 1;
				}
				stereo_pairs_read1 = max(stereo_pairs_read1_l,stereo_pairs_read1_r);
				ipos1r -= stereo_pairs_buflen;
				ipos1r = max(0.0,ipos1r);
			}

			//	SAME THING FOR 2ND INFILE

			if((stereo_pairs_read2_l == 0 && ipos2l >= stereo_pairs_buflen) || (stereo_pairs_read2_l > 0 && ipos2l >= stereo_pairs_read2_l)) {
				if(buf_advanced2_l && (stereo_pairs_read2_l != 0)) {
					sprintf(errstr,"Reading samples for 2nd sound, 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced2_r) {
					memcpy((char *)ibuf2l,(char *)ibuf2r,(sampsread2_r + STEREO) * sizeof(float));
					sampsread2_l = sampsread2_r;
					stereo_pairs_read2_l = stereo_pairs_read2_r;
					buf_advanced2_r = 0;

				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf2l,0,dz->buflen * sizeof(float));	
					if((dz->ssampsread = fgetfbufEx(ibuf2l, dz->buflen,dz->ifd[1],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 2.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						budge = 1;
					}
					total_samps_read2 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[1],total_samps_read2,0);
					sampsread2_l = dz->ssampsread;
					stereo_pairs_read2_l = sampsread2_l/STEREO;
					buf_advanced2_l = 1;
				}
				stereo_pairs_read2 = max(stereo_pairs_read2_l,stereo_pairs_read2_r);
				ipos2l -= stereo_pairs_buflen;
				ipos2l = max(0.0,ipos2l);
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read2_r == 0 && ipos2r >= stereo_pairs_buflen) || (stereo_pairs_read2_r > 0 && ipos2r >= stereo_pairs_read2_r)) {
				if(buf_advanced2_r && (stereo_pairs_read2_r != 0)) {
					sprintf(errstr,"Reading samples for 2nd file, 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced2_l) {
					memcpy((char *)ibuf2r,(char *)ibuf2l,(sampsread2_l + STEREO) * sizeof(float));
					sampsread2_r = sampsread2_l;
					stereo_pairs_read2_r = stereo_pairs_read2_l;
					buf_advanced2_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf2r,0,dz->buflen * sizeof(float));
					if((dz->ssampsread = fgetfbufEx(ibuf2r, dz->buflen,dz->ifd[1],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 2.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						budge = 1;
					}
					if(budge)
						total_samps_read2 += dz->ssampsread;
					sndseekEx(dz->ifd[1],total_samps_read2,0);
					total_samps_read2 += dz->ssampsread;
					sampsread2_r = dz->ssampsread;
					stereo_pairs_read2_r = sampsread2_r/STEREO;
					buf_advanced2_r = 1;
				}
				stereo_pairs_read2 = max(stereo_pairs_read2_l,stereo_pairs_read2_r);
				ipos2r -= stereo_pairs_buflen;
				ipos2r = max(0.0,ipos2r);
			}

			stereo_pairs_read = max(stereo_pairs_read1,stereo_pairs_read2);
			if(stereo_pairs_read == 0)
				break;

			lo = (int)floor(ipos1l);			//	Using doppler pointer on left-chan
			frac = ipos1l - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff  = ibuf1l[hi] - ibuf1l[lo];
			lval1 = ibuf1l[lo] + (diff * frac);
			
			lo = (int)floor(ipos1r);			//	Using doppler pointer on right-chan
			frac = ipos1r - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff  = ibuf1r[hi] - ibuf1r[lo];
			rval1 = ibuf1r[lo] + (diff * frac);

			//	and for file 2			

			lo = (int)floor(ipos2l);			//	Using doppler pointer on left-chan
			frac = ipos2l - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff  = ibuf2l[hi] - ibuf2l[lo];
			lval2 = ibuf2l[lo] + (diff * frac);
			
			lo = (int)floor(ipos2r);			//	Using doppler pointer on right-chan
			frac = ipos2r - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff  = ibuf2r[hi] - ibuf2r[lo];
			rval2 = ibuf2r[lo] + (diff * frac);


			if(dz->param[SPNATTEN] > 0.0) {			//	Atten goes linearly 0->ATTEN->0 as output moves L->C->R
				atten = (1.0 - fabs(pos)) * dz->param[SPNATTEN];
				atten = 1.0 - atten;				//	So level is multiplied by (1-atten), going from 1->(1-atten)->1 from L->C->R
				leftgain  *= atten;
				rightgain *= atten;
			}
			lleftgain  = leftgain;					//	To position left channel in stereo of output , calculate appropriate left and right gain
			lrightgain = rightgain;
			rleftgain  = rightgain;					//	By symmetry, right channel inverts the level of left and right
			rrightgain = leftgain;
													//	Differential boost between front and rear
			if(dz->param[SPNBOOST] > 0.0) {			//	Booster goes linearly 0->BOOST->0 as output moves L->C->R
				boost = (1.0 - fabs(pos)) * dz->param[SPNBOOST];
				boost += 1.0;						//	Booster becomes a multiplier(divider)
				if(movingforward < 0) {				//	moving forwards (other channel moving backwards)
					lleftgain  *= boost;			//	Original chan1(left) is moving across front, positioning levels are increased
					lrightgain *= boost;
					rleftgain  /= boost;			//	Original chan2(right) is moving across rear, positioning levels are decreased
					rrightgain /= boost;
				} else {
					lleftgain  /= boost;			//	Original chan1(left) is moving across rear, positioning levels are decrease
					lrightgain /= boost;
					rleftgain  *= boost;			//	Original chan2(right) is moving across front, positioning levels are increased
					rrightgain *= boost;
				}
			}
			obuf[c1] = (float)(obuf[c1] + (lval1 * lleftgain));	//	Orig file1 left signal positioned at new pos, to left and right
			obuf[c2] = (float)(obuf[c2] + (lval1 * lrightgain));
			obuf[c3] = (float)(obuf[c3] + (lval2 * lleftgain));	//	Orig file2 left signal positioned at new pos, to left and right
			obuf[c4] = (float)(obuf[c4] + (lval2 * lrightgain));

			obuf[c1] = (float)(obuf[c1] + (rval1 * rleftgain));	//	Orig file1 right signal positioned at new pos, to left and right
			obuf[c2] = (float)(obuf[c2] + (rval1 * rrightgain));
			obuf[c3] = (float)(obuf[c3] + (rval2 * rleftgain));	//	Orig file2 right signal positioned at new pos, to left and right
			obuf[c4] = (float)(obuf[c4] + (rval2 * rrightgain));

			boost = (1.0 - fabs(pos)) * boostrange;				//	Central channel
			boost += dz->param[SPNCMIN];
			obuf[cc] = (float)((lval1 + rval1 + lval2 + rval2) * boost);			//	Gets scaled mono mix of stereo input

			opos += ochans;
			c1 += ochans;
			c2 += ochans;
			c3 += ochans;
			c4 += ochans;
			cc += ochans;
			if(opos >= obuflen) {
				if(passno == 0) {
					for(n=0;n<obuflen;n++)
						maxsamp = max(maxsamp,fabs(obuf[n]));
					dz->total_samps_written += obuflen;			//	Update to ensure "time" is calculated correctly
					dz->process = DISTORT_PULSED;				//	Forces correct progress-bar display on Loom
					time_display(dz->total_samps_written,dz);
					dz->process = SPIN;
				} else {
					if(normaliser < 1.0) {
						for(n=0;n<obuflen;n++)
							obuf[n] = (float)(obuf[n] * normaliser);
					}
					dz->process = DISTORT_PULSED;
					if((exit_status = write_samps(obuf,obuflen,dz))<0)
						return(exit_status);
					dz->process = SPIN;
				}
				memset((char *)obuf,0,obuflen * sizeof(float));
				opos = 0;
				c1 = lchan1;
				c2 = rchan1;
				c3 = lchan2;
				c4 = rchan2;
				cc = cchan;
			}										//	Calculate read-insound increment to accomodate doppler pshift

			incrl = dz->pshift_factor * (-dz->param[SPNRATE]) * pos;
			incrl = pow(2.0,incrl);					//	Convert octaves to frq ratio
			incrr = 2.0 - incrl;					//	For incrs and decrs to cancel each other in long term, we must have incr2 = 2 - incrl;

			ipos1l += incrl;						//	Advance in input sound according to doppler pitchshift on (originally) left edge
			ipos1r += incrr;						//	Advance in input sound according to doppler pitchshift on (originally) right edge
			ipos2l += incrl;						//	and same for other file
			ipos2r += incrr;
		}
		if(opos > 0) {
			if(passno == 0) {
				for(n=0;n<opos;n++)
					maxsamp = max(maxsamp,fabs(obuf[n]));
				dz->process = DISTORT_PULSED;
				display_virtual_time(dz->tempsize,dz);
				dz->process = SPIN;
			} else {
				if(normaliser < 1.0) {
					for(n=0;n<opos;n++)
						obuf[n] = (float)(obuf[n] * normaliser);
				}
				dz->process = DISTORT_PULSED;
				if((exit_status = write_samps(obuf,opos,dz))<0)
					return(exit_status);
				dz->process = SPIN;
			}
		}
		if(passno == 0) {
			if(maxsamp > 0.95)
				normaliser = 0.95/maxsamp;
			else if(maxsamp <= FLTERR) {
				sprintf(errstr,"No significant signal found in source file.\n");
				return DATA_ERROR;
			}
		}
	}
	return FINISHED;
}

/******************************** SPINWDOPL2 ********************************
 *
 *	SPINWDOPL retains pans L and R edges of sound image  between channels C-1 and C+1 (where C is centre channel)
 *		complementing it with (variable) extra signal in C.
 * SPINWDOPL2 pans L-edge from chan C-1 to C, then from C to C+1, (and R-edge C+1 ->C then C->C-1)
 *		so that signal in centre channel is generated by the Ledge->C or Redge->C pans, directly.
 */

int spinwdopl2(dataptr dz)
{
	int exit_status, passno = 0, flipped = 0, movingforward, buf_advanced_l, buf_advanced_r, ochans = dz->iparam[SPNOCHNS];
	float *ibufl = dz->sampbuf[0], *ibufr = dz->sampbuf[1], *obuf = dz->sampbuf[2];
	double srate = (double)dz->infile->srate, iposl, iposr;
	double ch1pos, normaliser = 1.0, maxsamp = 0.0, time = 0.0, firstspin, lastspin;
	double pos = 0.0, leftgain, lleftgain, rleftgain, rightgain, lrightgain, rrightgain, centregain, lcentregain, rcentregain, atten, boost, frac, diff, lval, rval, incrl, incrr;
	int c1, c2, cc, opos, n, obuflen, stereo_pairs_read, stereo_pairs_read_l, stereo_pairs_read_r, lo, hi;
	int sampsread_l, sampsread_r, stereo_pairs_buflen = dz->buflen/STEREO;
	int lchan, rchan, cchan = dz->iparam[SPNOCNTR];

	lchan = cchan - 1;
	if(lchan < 1)
		lchan += ochans;
	rchan = cchan + 1;
	if(rchan > ochans)
		rchan -= ochans;
	lchan--;		//	Convert from 1-N frame to 0to-1 frame for countingt channels
	rchan--;
	cchan--;
	obuflen = (dz->buflen/STEREO) * ochans;		//	Calc size of output buffer

	atten = 1.0 - dz->param[SPNATTEN];
	if(dz->brksize[SPNRATE]) {
		if((exit_status= read_value_from_brktable(time,SPNRATE,dz))< 0)
			return exit_status;
	}
	firstspin = dz->param[SPNRATE];
	dz->tempsize = (dz->insams[0]/STEREO) * ochans;	//	For Loom progress-bar: total size of output
	for(passno = 0;passno < 2; passno++) {
		if(passno == 0) {
			fprintf(stdout,"INFO: Assessing output level\n");
			fflush(stdout);
		} else {
			fprintf(stdout,"INFO: Creating output sound\n");
			fflush(stdout);
		}
		dz->total_samps_written = 0;
		display_virtual_time(dz->total_samps_written,dz);
		ch1pos = 0;					//	Channel 1 starts at beginning of motion-cycle range (0 of 0to1)
		if(firstspin >= 0.0)
			movingforward = 1;		//	Left image moves backwards (right image moves forwards) - clockwise, viewed from above
		else
			movingforward = -1;		//	Left image moves forward (right image moves backwards) - anticlockwise, viewed from above
		lastspin = firstspin;
		flipped = 0;
		dz->total_samps_read = 0;
//		dz->samps_left = dz->insams[0];
		if((sndseekEx(dz->ifd[0],0,0) < 0)){
			sprintf(errstr,"sndseek failed\n");
			return SYSTEM_ERROR;
		}
		iposl = 0;
		iposr = 0;
		opos = 0;
		c1 = lchan;
		c2 = rchan;
		cc = cchan;

		memset((char *)obuf,0,obuflen * sizeof(float));
		memset((char *)ibufl,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibufr,0,(dz->buflen + STEREO) * sizeof(float));

		dz->buflen += STEREO;							//	accomodate wrap-around points
		if((exit_status = read_samps(ibufl,dz))<0)
			return(exit_status);
		memcpy((char *)ibufr,(char *)ibufl,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			dz->total_samps_read -= STEREO;
//			dz->samps_left += STEREO;
			sndseekEx(dz->ifd[0],dz->total_samps_read,0);	//	and Reset position in file
		}

		sampsread_l = dz->ssampsread;
		sampsread_r = dz->ssampsread;
		stereo_pairs_read_l = dz->ssampsread/STEREO;
		stereo_pairs_read_r = stereo_pairs_read_l;
		stereo_pairs_read = stereo_pairs_read_l;		//	Initially, same samples on both input buffers
		buf_advanced_l = 0;
		buf_advanced_r = 0;

		//	NB only one channel of stereo needs to be calcd - other follows BY SYMMETRY

		while(stereo_pairs_read > 0) {
	
			time = (double)((dz->total_samps_written + c1)/STEREO)/srate;
			if((exit_status = read_values_from_all_existing_brktables(time,dz))< 0)
				return exit_status;

			calcgains2(&ch1pos,&pos,&lastspin,&flipped,&movingforward,&leftgain,&centregain,&rightgain,srate,dz);

			if((stereo_pairs_read_l == 0 && iposl >= stereo_pairs_buflen) || (stereo_pairs_read_l > 0 && iposl >= stereo_pairs_read_l)) {
				if(buf_advanced_l && (stereo_pairs_read_l != 0)) {
					sprintf(errstr,"Reading samples for 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced_r) {
					memcpy((char *)ibufl,(char *)ibufr,(sampsread_r + STEREO) * sizeof(float));
					sampsread_l = sampsread_r;
					stereo_pairs_read_l = stereo_pairs_read_r;
					buf_advanced_r = 0;

				} else {
					dz->buflen += STEREO;
					memset((char *)ibufl,0,dz->buflen * sizeof(float));	
					if((exit_status = read_samps(ibufl,dz))<0)			
						return(exit_status);
					dz->buflen -= STEREO;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						dz->total_samps_read -= STEREO;
						sndseekEx(dz->ifd[0],dz->total_samps_read,0);
					}
					sampsread_l = dz->ssampsread;
					stereo_pairs_read_l = sampsread_l/STEREO;
					buf_advanced_l = 1;
				}
				stereo_pairs_read = max(stereo_pairs_read_l,stereo_pairs_read_r);
				iposl -= stereo_pairs_buflen;
				iposl = max(0.0,iposl);
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read_r == 0 && iposr >= stereo_pairs_buflen) || (stereo_pairs_read_r > 0 && iposr >= stereo_pairs_read_r)) {
				if(buf_advanced_r && (stereo_pairs_read_r != 0)) {
					sprintf(errstr,"Reading samples for 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced_l) {
					memcpy((char *)ibufr,(char *)ibufl,(sampsread_l + STEREO) * sizeof(float));
					sampsread_r = sampsread_l;
					stereo_pairs_read_r = stereo_pairs_read_l;
					buf_advanced_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibufr,0,dz->buflen * sizeof(float));
					if((exit_status = read_samps(ibufr,dz))<0)
						return(exit_status);
					dz->buflen -= STEREO;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						dz->total_samps_read -= STEREO;
						sndseekEx(dz->ifd[0],dz->total_samps_read,0);
					}
					sampsread_r = dz->ssampsread;
					stereo_pairs_read_r = sampsread_r/STEREO;
					buf_advanced_r = 1;
				}
				stereo_pairs_read = max(stereo_pairs_read_l,stereo_pairs_read_r);
				iposr -= stereo_pairs_buflen;
				iposr = max(0.0,iposr);
			}
			if(stereo_pairs_read == 0)
				break;

			lo = (int)floor(iposl);			//	Using doppler pointer on left-chan
			frac = iposl - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff = ibufl[hi] - ibufl[lo];
			lval = ibufl[lo] + (diff * frac);
			
			lo = (int)floor(iposr);			//	Using doppler pointer on right-chan
			frac = iposr - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff = ibufr[hi] - ibufr[lo];
			rval = ibufr[lo] + (diff * frac);

			lleftgain   = leftgain;				//	Position originally-L-edge by weighting on 3 lspkrs
			lcentregain = centregain;			
			lrightgain  = rightgain;			

			rleftgain   = rightgain;			//	By antisymmetry, do opposite for other edge
			rcentregain = centregain;
			rrightgain  = leftgain;
													//	Differential boost between front and rear
			if(dz->param[SPNBOOST] > 0.0) {			//	Booster goes linearly 0->BOOST->0 as output moves L->C->R
				boost = (1.0 - fabs(pos)) * dz->param[SPNBOOST];
				boost += 1.0;						//	Booster becomes a multiplier(divider)
				if(movingforward < 0) {				//	moving forwards (other channel moving backwards)
					lcentregain *= boost;			//	Original chan1(left) is moving across front, positioning levels are increased
					rcentregain /= boost;			//	Original chan2(right) is moving across rear, positioning levels are decreased
				} else {
					lcentregain /= boost;			//	Original chan1(left) is moving across rear, positioning levels are decrease
					rcentregain *= boost;			//	Original chan2(right) is moving across front, positioning levels are increased
				}
			}
			obuf[c1] = (float)(obuf[c1] + (lval * lleftgain));	//	Orig ch1 signal contribution , on left and right chans
			obuf[c2] = (float)(obuf[c2] + (lval * lrightgain));
			obuf[c1] = (float)(obuf[c1] + (rval * rleftgain));	//	Orig ch2 signal contribution , on left and right chans
			obuf[c2] = (float)(obuf[c2] + (rval * rrightgain));

			obuf[cc] = (float)(((lval * lcentregain) + (rval * rcentregain)) * atten);	//	Contribution of orig ch1 and ch2 to centre chan level
			obuf[cc] = (float)(obuf[cc] + ((lval + rval) * dz->param[SPNCMIN]));		//	Add monoed src at min-centre-level
			opos += ochans;
			c1 += ochans;
			c2 += ochans;
			cc += ochans;
			if(opos >= obuflen) {
				if(passno == 0) {
					for(n=0;n<obuflen;n++)
						maxsamp = max(maxsamp,fabs(obuf[n]));
					dz->total_samps_written += obuflen;			//	Update to ensure "time" is calculated correctly
					dz->process = DISTORT_PULSED;				//	Forces correct progress-bar display on Loom
					time_display(dz->total_samps_written,dz);
					dz->process = SPIN;
				} else {
					if(normaliser < 1.0) {
						for(n=0;n<obuflen;n++)
							obuf[n] = (float)(obuf[n] * normaliser);
					}
					dz->process = DISTORT_PULSED;
					if((exit_status = write_samps(obuf,obuflen,dz))<0)
						return(exit_status);
					dz->process = SPIN;
				}
				memset((char *)obuf,0,obuflen * sizeof(float));
				opos = 0;
				c1 = lchan;
				c2 = rchan;
				cc = cchan;
			}										//	Calculate read-insound increment to accomodate doppler pshift
			incrl = dz->pshift_factor * (-dz->param[SPNRATE]) * pos;
			incrl = pow(2.0,incrl);					//	Convert octaves to frq ratio
			incrr = 2.0 - incrl;					//	For incrs and decrs to cancel each other in long term, we must have incr2 = 2 - incrl;

			iposl += incrl;							//	Advance in input sound according to doppler pitchshift on (originally) left edge
			iposr += incrr;							//	Advance in input sound according to doppler pitchshift on (originally) right edge
		}
		if(opos > 0) {
			if(passno == 0) {
				for(n=0;n<opos;n++)
					maxsamp = max(maxsamp,fabs(obuf[n]));
				dz->process = DISTORT_PULSED;
				display_virtual_time(dz->tempsize,dz);
				dz->process = SPIN;
			} else {
				if(normaliser < 1.0) {
					for(n=0;n<opos;n++)
						obuf[n] = (float)(obuf[n] * normaliser);
				}
				dz->process = DISTORT_PULSED;
				if((exit_status = write_samps(obuf,opos,dz))<0)
					return(exit_status);
				dz->process = SPIN;
			}
		}
		if(passno == 0) {
			if(maxsamp > 0.95)
				normaliser = 0.95/maxsamp;
			else if(maxsamp <= FLTERR) {
				sprintf(errstr,"No significant signal found in source file.\n");
				return DATA_ERROR;
			}
		}
	}
	return FINISHED;
}

/******************************** CALCGAINS2 *****************
 *
 * This function outputs the weightings between L and C channel, and C & RIGHT channels for the item plaaced at "pos" in (L->R) range  -1 to 1
 */

void calcgains2(double *ch1pos,double *pos,double *lastspin,int *flipped,int *movingforward,double *leftgain,double *centregain,double *rightgain,double srate,dataptr dz)
{
	double cycleincr, lgain, rgain, lrcpos;

	cycleincr = dz->param[SPNRATE]/srate;		//	How far into the rotation cycle, per sample-group		
	*ch1pos += cycleincr;
												//	Moving up, from 0 towards 1
	if(cycleincr > 0.0) {
												//	If rotate changes direction, 
		if(*lastspin < 0.0)						//	if leaving centre after passing it (flipped), we're now approaching it (!flipped)
			*flipped = !(*flipped);				//	whereas if approaching centre before passing it (!flipped), we're now leaving it (flipped)

		if(!(*flipped)) {						//	If we've not previously reached 1/2 way through cycle (travelling up cycle)
			if(*ch1pos > 0.5) {					//	If we've now reached 1/2 cycle end  (Left-channel moved fully from L(-1) to R(1), 1/2 way up (-cos)-table)
				*movingforward = -(*movingforward);//	This edge starts to move backwards(if previously moving forwards) (or vice versa), 
				*flipped = 1;					//	and FLAG the fact we've passed the flip-point
			}
		}
		if(*ch1pos  > 1.0) {					//	If we've now reached full cycle end (the end of the (-cos) table, so we're back to start from -1 0 1 0 to -1)
			*flipped = 0;						//	reset the flip-flag
			*movingforward = -(*movingforward);	//	This edge starts to move forwards again (if previously backwards) (or vice versa)
			*ch1pos -= 1.0;						//	reset ch1pos within 0-1 range (0-2PI range of (-cos) table)
		}
		*lastspin = dz->param[SPNRATE];			//	Only set "lastspin" when spin is NON-zero, so system remembers last (non-zero) motion direction

	} else if(cycleincr < 0.0) {				//	Opposite logic, moving down from 1 to 0

		if(*lastspin > 0.0)
			*flipped = !(*flipped);

		if(!(*flipped)) {						//	If we've not previously reached 1/2 way through cycle (travelling down cycle)
			if(*ch1pos < 0.5) {					//	If we've now reached 1/2 cycle end  (Left-channel moved fully from L(-1) to R(1), 1/2 way down (-cos)-table)
				*movingforward = -(*movingforward);	//	This edge starts to move backwards(if previously moving forwards) (or vice versa), 
				*flipped = 1;					//	and FLAG the fact we've passed the flip-point
			}
		}
		if(*ch1pos  < 0.0) {					//	If we've now reached full cycle end (the start of the (-cos) table, so we're back to start from -1 0 1 0 to -1)
			*flipped = 0;						//	reset the flip-flag
			*movingforward = -(*movingforward);	//	This edge starts to move forwards again (if previously backwards) (or vice versa)
			*ch1pos += 1.0;						//	reset ch1pos within 0-1 range (0-2PI range of (-cos) table)
		}
		*lastspin = dz->param[SPNRATE];
	}
	*pos = -cos(*ch1pos * TWOPI);				//	ch1pos ranges from 0 to 1 and recycles, change range to 0 to 2PI
												//  -cos goes then ranges (-1 0 1 0 -1 = Left Right Left)

												//	pos range   = -1 to +1
	lrcpos = *pos * 2.0;						//	lrcpos Range = -2 to 2
	if(*pos <= 0.0) {							//	i.e. pos Range = -1 to 0, lrcpos range = -2 to 0
		lrcpos += 1.0;							//	lrcpos range -1 to + 1
		pancalc(lrcpos,&lgain,&rgain);
		*leftgain   = lgain;
		*centregain = rgain;
		*rightgain  = 0.0;
	} else {									//	i.e. pos Range = 0 to 1, lcpos range = 0 to 2
		lrcpos -= 1.0;							//	lrcpos range = -1 to +1
		pancalc(lrcpos,&lgain,&rgain);
		*leftgain   = 0.0;
		*centregain = lgain;
		*rightgain  = rgain;
	}
}

/******************************** SPINQDOPL2 ********************************
 *
 * The same logic, with 1 stereo input on chans -1 and +1,and other on -2 and +2, around a centre channel.
 */

int spinqdopl2(dataptr dz)
{
	int exit_status, budge, passno = 0, flipped = 0, movingforward, buf_advanced1_l, buf_advanced1_r, buf_advanced2_l, buf_advanced2_r, ochans = dz->iparam[SPNOCHNS];
	float *ibuf1l = dz->sampbuf[0], *ibuf1r = dz->sampbuf[1], *ibuf2l = dz->sampbuf[2], *ibuf2r = dz->sampbuf[3], *obuf = dz->sampbuf[4];
	double srate = (double)dz->infile->srate, ipos1l, ipos1r, ipos2l, ipos2r;
	double ch1pos, normaliser = 1.0, maxsamp = 0.0, time = 0.0, firstspin, lastspin;
	double pos = 0.0, leftgain, lleftgain, rleftgain, rightgain, lrightgain, rrightgain, boost, halfboost, atten, frac, diff, lval1, rval1, lval2, rval2, incrl, incrr;
	double centregain,ooleftgain,oileftgain,ocentregain,oirightgain,oorightgain, oval1, oval2;
	double loleftgain, lileftgain, lcentregain, lirightgain, lorightgain, roleftgain, rileftgain, rcentregain, rirightgain, rorightgain;		
	int c1, c2, cc, c3, c4, opos, n, obuflen;
	int stereo_pairs_read, stereo_pairs_read1, stereo_pairs_read2, stereo_pairs_read1_l, stereo_pairs_read1_r, stereo_pairs_read2_l, stereo_pairs_read2_r;
	int lo, hi, total_samps_read1, total_samps_read2, sampsread1_l, sampsread1_r, sampsread2_l, sampsread2_r, stereo_pairs_buflen = dz->buflen/STEREO;
	int lchan1, rchan1, lchan2, rchan2, cchan = dz->iparam[SPNOCNTR];
	lchan1 = cchan - 1;
	if(lchan1 < 1)
		lchan1 += ochans;
	rchan1 = cchan + 1;
	if(rchan1 > ochans)
		rchan1 -= ochans;
	lchan2 = cchan - 2;
	if(lchan2 < 1)
		lchan2 += ochans;
	rchan2 = cchan + 2;
	if(rchan2 > ochans)
		rchan2 -= ochans;
	lchan1--;		//	Convert from 1-N frame to 0to-1 frame for countingt channels
	rchan1--;
	lchan2--;
	rchan2--;
	cchan--;
	obuflen = (dz->buflen/STEREO) * ochans;		//	Calc size of output buffer
	atten = 1.0 - dz->param[SPNATTEN];

	if(dz->brksize[SPNRATE]) {
		if((exit_status= read_value_from_brktable(time,SPNRATE,dz))< 0)
			return exit_status;
	}
	firstspin = dz->param[SPNRATE];
	dz->total_samps_written = 0;
	dz->tempsize = (dz->insams[0]/STEREO) * ochans;	//	For Loom progress-bar: total size of output
	for(passno = 0;passno < 2; passno++) {
		if(passno == 0) {
			fprintf(stdout,"INFO: Assessing output level\n");
			fflush(stdout);
		} else {
			fprintf(stdout,"INFO: Creating output sound\n");
			fflush(stdout);
		}
		dz->total_samps_written = 0;
		display_virtual_time(dz->total_samps_written,dz);
		ch1pos = 0;					//	Channel 1 starts at beginning of motion-cycle range (0 of 0to1)
		if(firstspin >= 0.0)
			movingforward = 1;		//	Left image moves backwards (right image moves forwards) - clockwise, viewed from above
		else
			movingforward = -1;		//	Left image moves forward (right image moves backwards) - anticlockwise, viewed from above
		lastspin = firstspin;
		flipped = 0;
		dz->total_samps_read = 0;
		if((sndseekEx(dz->ifd[0],0,0) < 0)){
			sprintf(errstr,"sndseek failed in input file 1\n");
			return SYSTEM_ERROR;
		}
		if((sndseekEx(dz->ifd[1],0,0) < 0)){
			sprintf(errstr,"sndseek failed in input file 2\n");
			return SYSTEM_ERROR;
		}
		ipos1l = 0;					//	initialise all buffer pointers
		ipos1r = 0;
		ipos2l = 0;
		ipos2r = 0;
		opos = 0;
		c1 = lchan1;
		c2 = rchan1;
		c3 = lchan2;
		c4 = rchan2;
		cc = cchan;					//	zero all buffers, including wraparound points

		memset((char *)obuf,0,dz->buflen * sizeof(float));
		memset((char *)ibuf1l,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibuf1r,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibuf2l,0,(dz->buflen + STEREO) * sizeof(float));
		memset((char *)ibuf2r,0,(dz->buflen + STEREO) * sizeof(float));

		dz->buflen += STEREO;							//	accomodate wrap-around points
		if((dz->ssampsread = fgetfbufEx(ibuf1l, dz->buflen,dz->ifd[0],0)) < 0) {
			sprintf(errstr,"Can't read samples from input soundfile 1.\n");
			return(SYSTEM_ERROR);
		}
		memcpy((char *)ibuf1r,(char *)ibuf1l,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			sndseekEx(dz->ifd[0],dz->ssampsread,0);		//	and Reset position in file
		}

		total_samps_read1 = dz->ssampsread;
		sampsread1_l = dz->ssampsread;
		sampsread1_r = dz->ssampsread;
		stereo_pairs_read1_l = dz->ssampsread/STEREO;
		stereo_pairs_read1_r = stereo_pairs_read1_l;
		stereo_pairs_read1 = stereo_pairs_read1_l;		//	Initially, same samples on both input buffers
		buf_advanced1_l = 0;
		buf_advanced1_r = 0;

		dz->buflen += STEREO;							//	accomodate wrap-around points
		if((dz->ssampsread = fgetfbufEx(ibuf2l, dz->buflen,dz->ifd[1],0)) < 0) {
			sprintf(errstr,"Can't read samples from input soundfile 2.\n");
			return(SYSTEM_ERROR);
		}
		memcpy((char *)ibuf2r,(char *)ibuf2l,dz->ssampsread * sizeof(float));
		dz->buflen -= STEREO;
		if(dz->ssampsread > dz->buflen) {				//	IF wraparound points read
			dz->ssampsread -= STEREO;					//	Reset buffer params
			sndseekEx(dz->ifd[1],dz->ssampsread,0);		//	and Reset position in file
		}

		total_samps_read2 = dz->ssampsread;
		sampsread2_l = dz->ssampsread;
		sampsread2_r = dz->ssampsread;
		stereo_pairs_read2_l = dz->ssampsread/STEREO;
		stereo_pairs_read2_r = stereo_pairs_read2_l;
		stereo_pairs_read2 = stereo_pairs_read2_l;		//	Initially, same samples on both input buffers
		buf_advanced2_l = 0;
		buf_advanced2_r = 0;

		stereo_pairs_read = max(stereo_pairs_read1,stereo_pairs_read2);

		//	NB only one channel of stereo needs to be calcd - other follows BY SYMMETRY
	
		while(stereo_pairs_read > 0) {

			time = (double)((dz->total_samps_written + opos)/ochans)/srate;	//	Time calculated from count of output
			if((exit_status= read_values_from_all_existing_brktables(time,dz))< 0)
				return exit_status;

			calcgains3(&ch1pos,&pos,&lastspin,&flipped,&movingforward,&leftgain,&centregain,&rightgain,&ooleftgain,&oileftgain,&ocentregain,&oirightgain,&oorightgain,srate,dz);

			if((stereo_pairs_read1_l == 0 && ipos1l >= stereo_pairs_buflen) || (stereo_pairs_read1_l > 0 && ipos1l >= stereo_pairs_read1_l)) {
				if(buf_advanced1_l && (stereo_pairs_read1_l != 0)) {
					sprintf(errstr,"Reading samples for 1st sound, 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced1_r) {
					memcpy((char *)ibuf1l,(char *)ibuf1r,(sampsread1_r + STEREO) * sizeof(float));
					sampsread1_l = sampsread1_r;
					stereo_pairs_read1_l = stereo_pairs_read1_r;
					buf_advanced1_r = 0;

				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf1l,0,dz->buflen * sizeof(float));	
					if((dz->ssampsread = fgetfbufEx(ibuf1l, dz->buflen,dz->ifd[0],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 1.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						budge = 1;
						dz->ssampsread -= STEREO;
					}
					total_samps_read1 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[0],total_samps_read1,0);
					sampsread1_l = dz->ssampsread;
					stereo_pairs_read1_l = sampsread1_l/STEREO;
					buf_advanced1_l = 1;
				}
				stereo_pairs_read1 = max(stereo_pairs_read1_l,stereo_pairs_read1_r);
				ipos1l -= stereo_pairs_buflen;
				ipos1l = max(0.0,ipos1l);
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read1_r == 0 && ipos1r >= stereo_pairs_buflen) || (stereo_pairs_read1_r > 0 && ipos1r >= stereo_pairs_read1_r)) {
				if(buf_advanced1_r && (stereo_pairs_read1_r != 0)) {
					sprintf(errstr,"Reading samples for 1st file, 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced1_l) {
					memcpy((char *)ibuf1r,(char *)ibuf1l,(sampsread1_l + STEREO) * sizeof(float));
					sampsread1_r = sampsread1_l;
					stereo_pairs_read1_r = stereo_pairs_read1_l;
					buf_advanced1_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf1r,0,dz->buflen * sizeof(float));
					if((dz->ssampsread = fgetfbufEx(ibuf1r, dz->buflen,dz->ifd[0],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 1.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						budge = 1;
					}
					total_samps_read1 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[0],total_samps_read1,0);
					sampsread1_r = dz->ssampsread;
					stereo_pairs_read1_r = sampsread1_r/STEREO;
					buf_advanced1_r = 1;
				}
				stereo_pairs_read1 = max(stereo_pairs_read1_l,stereo_pairs_read1_r);
				ipos1r -= stereo_pairs_buflen;
				ipos1r = max(0.0,ipos1r);
			}

			//	SAME THING FOR 2ND INFILE

			if((stereo_pairs_read2_l == 0 && ipos2l >= stereo_pairs_buflen) || (stereo_pairs_read2_l > 0 && ipos2l >= stereo_pairs_read2_l)) {
				if(buf_advanced2_l && (stereo_pairs_read2_l != 0)) {
					sprintf(errstr,"Reading samples for 2nd sound, 1st image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced2_r) {
					memcpy((char *)ibuf2l,(char *)ibuf2r,(sampsread2_r + STEREO) * sizeof(float));
					sampsread2_l = sampsread2_r;
					stereo_pairs_read2_l = stereo_pairs_read2_r;
					buf_advanced2_r = 0;

				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf2l,0,dz->buflen * sizeof(float));	
					if((dz->ssampsread = fgetfbufEx(ibuf2l, dz->buflen,dz->ifd[1],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 2.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						budge = 1;
					}
					total_samps_read2 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[1],total_samps_read2,0);
					sampsread2_l = dz->ssampsread;
					stereo_pairs_read2_l = sampsread2_l/STEREO;
					buf_advanced2_l = 1;
				}
				stereo_pairs_read2 = max(stereo_pairs_read2_l,stereo_pairs_read2_r);
				ipos2l -= stereo_pairs_buflen;
				ipos2l = max(0.0,ipos2l);
			}
									//	SIMIL FOR READING RIGHT-CHAN INFO

			if((stereo_pairs_read2_r == 0 && ipos2r >= stereo_pairs_buflen) || (stereo_pairs_read2_r > 0 && ipos2r >= stereo_pairs_read2_r)) {
				if(buf_advanced2_r && (stereo_pairs_read2_r != 0)) {
					sprintf(errstr,"Reading samples for 2nd file, 2nd image-edge exceeds other by > buffer length: CANNOT PROCEED\n");
					return MEMORY_ERROR;
				}
				if(buf_advanced2_l) {
					memcpy((char *)ibuf2r,(char *)ibuf2l,(sampsread2_l + STEREO) * sizeof(float));
					sampsread2_r = sampsread2_l;
					stereo_pairs_read2_r = stereo_pairs_read2_l;
					buf_advanced2_l = 0;
				} else {
					dz->buflen += STEREO;
					memset((char *)ibuf2r,0,dz->buflen * sizeof(float));
					if((dz->ssampsread = fgetfbufEx(ibuf2r, dz->buflen,dz->ifd[1],0)) < 0) {
						sprintf(errstr,"Can't read samples from input soundfile 2.\n");
						return(SYSTEM_ERROR);
					}
					dz->buflen -= STEREO;
					budge = 0;
					if(dz->ssampsread > dz->buflen) {
						dz->ssampsread -= STEREO;
						budge = 1;
					}
					total_samps_read2 += dz->ssampsread;
					if(budge)
						sndseekEx(dz->ifd[1],total_samps_read2,0);
					total_samps_read2 += dz->ssampsread;
					sampsread2_r = dz->ssampsread;
					stereo_pairs_read2_r = sampsread2_r/STEREO;
					buf_advanced2_r = 1;
				}
				stereo_pairs_read2 = max(stereo_pairs_read2_l,stereo_pairs_read2_r);
				ipos2r -= stereo_pairs_buflen;
				ipos2r = max(0.0,ipos2r);
			}

			stereo_pairs_read = max(stereo_pairs_read1,stereo_pairs_read2);
			if(stereo_pairs_read == 0)
				break;

			lo = (int)floor(ipos1l);			//	Using doppler pointer on left-chan
			frac = ipos1l - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff  = ibuf1l[hi] - ibuf1l[lo];
			lval1 = ibuf1l[lo] + (diff * frac);
			
			lo = (int)floor(ipos1r);			//	Using doppler pointer on right-chan
			frac = ipos1r - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff  = ibuf1r[hi] - ibuf1r[lo];
			rval1 = ibuf1r[lo] + (diff * frac);

			//	and for file 2			

			lo = (int)floor(ipos2l);			//	Using doppler pointer on left-chan
			frac = ipos2l - (double)lo;			
			lo *= STEREO;						//	Find left-chan samples adjacent to pointer
			hi = lo + 2;						//	and Interp value
			diff  = ibuf2l[hi] - ibuf2l[lo];
			lval2 = ibuf2l[lo] + (diff * frac);
			
			lo = (int)floor(ipos2r);			//	Using doppler pointer on right-chan
			frac = ipos2r - (double)lo;			
			lo *= STEREO;						
			lo++;								//	Find right-chan sample
			hi = lo + 2;						//	simil
			diff  = ibuf2r[hi] - ibuf2r[lo];
			rval2 = ibuf2r[lo] + (diff * frac);

			//	FOR THE INNER SOUND

			lleftgain   = leftgain;				//	Position originally-L-edge by weighting on 3 lspkrs
			lcentregain = centregain;			
			lrightgain  = rightgain;			

			rleftgain   = rightgain;			//	By antisymmetry, do opposite for other edge
			rcentregain = centregain;
			rrightgain  = leftgain;

			//	Differential boost between front and rear
			if(dz->param[SPNBOOST] > 0.0) {			//	Booster goes linearly 0->BOOST->0 as output moves L->C->R
				boost = (1.0 - fabs(pos)) * dz->param[SPNBOOST];
				boost += 1.0;						//	Booster becomes a multiplier(divider)
				if(movingforward < 0) {				//	moving forwards (other channel moving backwards)
					lcentregain *= boost;			//	Original chan1(left) is moving across front, positioning levels are increased
					rcentregain /= boost;			//	Original chan2(right) is moving across rear, positioning levels are decreased
				} else {
					lcentregain /= boost;			//	Original chan1(left) is moving across rear, positioning levels are decrease
					rcentregain *= boost;			//	Original chan2(right) is moving across front, positioning levels are increased
				}
			}
			obuf[c1] = (float)(obuf[c1] + (lval1 * lleftgain));	//	Orig ch1 signal contribution , on left and right chans
			obuf[c2] = (float)(obuf[c2] + (lval1 * lrightgain));
			obuf[c1] = (float)(obuf[c1] + (rval1 * rleftgain));	//	Orig ch2 signal contribution , on left and right chans
			obuf[c2] = (float)(obuf[c2] + (rval1 * rrightgain));

			oval1  = (float)(((lval1 * lcentregain) + (rval1 * rcentregain)) * atten);	//	Contribution of orig ch1 and ch2 to centre chan level
			oval1 += (lval1 + rval1) * dz->param[SPNCMIN];								//	Add monoed src at min-centre-level
			obuf[cc] = (float)(obuf[cc] + oval1);

			//	FOR THE OUTER SOUND

			loleftgain  = ooleftgain;			//	Weightings on the 5 loudspkrs, of the orig-LEFT-edge of image
			lileftgain  = oileftgain;
			lcentregain = ocentregain;			
			lirightgain = oirightgain;			
			lorightgain = oorightgain;			

			roleftgain  = oorightgain;			//	by anti-symmetry, Weightings for the orig-RIGHT-edge of image
			rileftgain  = oirightgain;
			rcentregain = ocentregain;			
			rirightgain = oileftgain;			
			rorightgain = ooleftgain;			



		//	Differential boost between front and rear
			if(dz->param[SPNBOOST] > 0.0) {			//	Booster goes linearly 0->BOOST->0 as output moves L->C->R
				boost = (1.0 - fabs(pos)) * dz->param[SPNBOOST];
				boost += 1.0;						//	Booster becomes a multiplier(divider)
				halfboost = boost/2.0;
				if(movingforward < 0) {				//	moving forwards (other channel moving backwards)
					lcentregain *= boost;			//	Original chan1(left) is moving across front, positioning levels are increased
					lileftgain  *= halfboost;
					lirightgain *= halfboost;
					rcentregain /= boost;			//	Original chan2(right) is moving across rear, positioning levels are decreased
					rileftgain  /= halfboost; 
					rirightgain /= halfboost; 
				} else {
					lcentregain /= boost;			//	Original chan1(left) is moving across rear, positioning levels are decrease
					lileftgain  /= halfboost;
					lirightgain /= halfboost;
					rcentregain *= boost;			//	Original chan2(right) is moving across front, positioning levels are increased
					rileftgain  *= halfboost; 
					rirightgain *= halfboost; 
				}
			}														//	Orig L-edge signal contribution , on all 5 chans
			obuf[c3] = (float)(obuf[c3] + (lval2 * loleftgain));	//	Left outer chan
			obuf[c1] = (float)(obuf[c1] + (lval2 * lileftgain));	//	Left inner chan
			obuf[c2] = (float)(obuf[c2] + (lval2 * lirightgain));	//	Right inner chan
			obuf[c4] = (float)(obuf[c4] + (lval2 * lorightgain));	//	Right outer chan

			obuf[c3] = (float)(obuf[c3] + (rval2 * roleftgain));	//	Orig R-edge signal contribution , on all 5 chans
			obuf[c1] = (float)(obuf[c1] + (rval2 * rileftgain));
			obuf[c2] = (float)(obuf[c2] + (rval2 * rirightgain));
			obuf[c4] = (float)(obuf[c4] + (rval2 * rorightgain));

			oval2 = ((lval2 * lcentregain) + (rval2 * rcentregain)) * atten;	//	Contribution of orig ch1 and ch2 (outer) snd to centre chan level
			oval2 += (lval2 + rval2) * dz->param[SPNCMIN];						//	Add monoed src at min-centre-level
			obuf[cc] = (float)(obuf[cc] + oval2);
			opos += ochans;
			c1 += ochans;
			c2 += ochans;
			c3 += ochans;
			c4 += ochans;
			cc += ochans;
			if(opos >= obuflen) {
				if(passno == 0) {
					for(n=0;n<obuflen;n++)
						maxsamp = max(maxsamp,fabs(obuf[n]));
					dz->total_samps_written += obuflen;			//	Update to ensure "time" is calculated correctly
					dz->process = DISTORT_PULSED;				//	Forces correct progress-bar display on Loom
					time_display(dz->total_samps_written,dz);
					dz->process = SPIN;
				} else {
					if(normaliser < 1.0) {
						for(n=0;n<obuflen;n++)
							obuf[n] = (float)(obuf[n] * normaliser);
					}
					dz->process = DISTORT_PULSED;
					if((exit_status = write_samps(obuf,obuflen,dz))<0)
						return(exit_status);
					dz->process = SPIN;
				}
				memset((char *)obuf,0,obuflen * sizeof(float));
				opos = 0;
				c1 = lchan1;
				c2 = rchan1;
				c3 = lchan2;
				c4 = rchan2;
				cc = cchan;
			}										//	Calculate read-insound increment to accomodate doppler pshift

			incrl = dz->pshift_factor * (-dz->param[SPNRATE]) * pos;
			incrl = pow(2.0,incrl);					//	Convert octaves to frq ratio
			incrr = 2.0 - incrl;					//	For incrs and decrs to cancel each other in long term, we must have incr2 = 2 - incrl;

			ipos1l += incrl;						//	Advance in input sound according to doppler pitchshift on (originally) left edge
			ipos1r += incrr;						//	Advance in input sound according to doppler pitchshift on (originally) right edge
			ipos2l += incrl;						//	and same for other file
			ipos2r += incrr;
		}
		if(opos > 0) {
			if(passno == 0) {
				for(n=0;n<opos;n++)
					maxsamp = max(maxsamp,fabs(obuf[n]));
				dz->process = DISTORT_PULSED;
				display_virtual_time(dz->tempsize,dz);
				dz->process = SPIN;
			} else {
				if(normaliser < 1.0) {
					for(n=0;n<opos;n++)
						obuf[n] = (float)(obuf[n] * normaliser);
				}
				dz->process = DISTORT_PULSED;
				if((exit_status = write_samps(obuf,opos,dz))<0)
					return(exit_status);
				dz->process = SPIN;
			}
		}
		if(passno == 0) {
			if(maxsamp > 0.95)
				normaliser = 0.95/maxsamp;
			else if(maxsamp <= FLTERR) {
				sprintf(errstr,"No significant signal found in source file.\n");
				return DATA_ERROR;
			}
		}
	}
	return FINISHED;
}

/******************************** CALCGAINS3 *******************************
 *
 * This function outputs the weightings between L and C channel, and C & RIGHT channels for the item plaaced at "pos" in (L->R) range  -1 to 1
 */

void calcgains3(double *ch1pos,double *pos,double *lastspin,int *flipped,int *movingforward,double *leftgain,double *centregain,double *rightgain,
				double *ooleftgain, double *oileftgain, double *ocentregain, double *oirightgain, double *oorightgain, double srate,dataptr dz)
{
	double cycleincr, lgain, rgain, lrcpos, olrcpos;

	cycleincr = dz->param[SPNRATE]/srate;		//	How far into the rotation cycle, per sample-group		
	*ch1pos += cycleincr;
												//	Moving up, from 0 towards 1
	if(cycleincr > 0.0) {
												//	If rotate changes direction, 
		if(*lastspin < 0.0)						//	if leaving centre after passing it (flipped), we're now approaching it (!flipped)
			*flipped = !(*flipped);				//	whereas if approaching centre before passing it (!flipped), we're now leaving it (flipped)

		if(!(*flipped)) {						//	If we've not previously reached 1/2 way through cycle (travelling up cycle)
			if(*ch1pos > 0.5) {					//	If we've now reached 1/2 cycle end  (Left-channel moved fully from L(-1) to R(1), 1/2 way up (-cos)-table)
				*movingforward = -(*movingforward);//	This edge starts to move backwards(if previously moving forwards) (or vice versa), 
				*flipped = 1;					//	and FLAG the fact we've passed the flip-point
			}
		}
		if(*ch1pos  > 1.0) {					//	If we've now reached full cycle end (the end of the (-cos) table, so we're back to start from -1 0 1 0 to -1)
			*flipped = 0;						//	reset the flip-flag
			*movingforward = -(*movingforward);	//	This edge starts to move forwards again (if previously backwards) (or vice versa)
			*ch1pos -= 1.0;						//	reset ch1pos within 0-1 range (0-2PI range of (-cos) table)
		}
		*lastspin = dz->param[SPNRATE];			//	Only set "lastspin" when spin is NON-zero, so system remembers last (non-zero) motion direction

	} else if(cycleincr < 0.0) {				//	Opposite logic, moving down from 1 to 0

		if(*lastspin > 0.0)
			*flipped = !(*flipped);

		if(!(*flipped)) {						//	If we've not previously reached 1/2 way through cycle (travelling down cycle)
			if(*ch1pos < 0.5) {					//	If we've now reached 1/2 cycle end  (Left-channel moved fully from L(-1) to R(1), 1/2 way down (-cos)-table)
				*movingforward = -(*movingforward);	//	This edge starts to move backwards(if previously moving forwards) (or vice versa), 
				*flipped = 1;					//	and FLAG the fact we've passed the flip-point
			}
		}
		if(*ch1pos  < 0.0) {					//	If we've now reached full cycle end (the start of the (-cos) table, so we're back to start from -1 0 1 0 to -1)
			*flipped = 0;						//	reset the flip-flag
			*movingforward = -(*movingforward);	//	This edge starts to move forwards again (if previously backwards) (or vice versa)
			*ch1pos += 1.0;						//	reset ch1pos within 0-1 range (0-2PI range of (-cos) table)
		}
		*lastspin = dz->param[SPNRATE];
	}
	*pos = -cos(*ch1pos * TWOPI);				//	ch1pos ranges from 0 to 1 and recycles, change range to 0 to 2PI
												//  -cos goes then ranges (-1 0 1 0 -1 = Left Right Left)

												//	pos range   = -1 to +1
	lrcpos = *pos * 2.0;						//	lrcpos Range = -2 to 2
	if(*pos <= 0.0) {							//	i.e. pos Range = -1 to 0, lrcpos range = -2 to 0
		lrcpos += 1.0;							//	lrcpos range -1 to + 1
		pancalc(lrcpos,&lgain,&rgain);
		*leftgain   = lgain;
		*centregain = rgain;
		*rightgain  = 0.0;
	} else {									//	i.e. pos Range = 0 to 1, lcpos range = 0 to 2
		lrcpos -= 1.0;							//	lrcpos range = -1 to +1
		pancalc(lrcpos,&lgain,&rgain);
		*leftgain   = 0.0;
		*centregain = lgain;
		*rightgain  = rgain;
	}

	olrcpos = *pos * 4.0;						//	olrcpos Range = -4 to 4
	if(*pos <= -0.5) {							//	i.e. pos Range = -1 to -0.5, olrcpos range = -4 to -2
		olrcpos += 3.0;							//	olrcpos range -1 to + 1
		pancalc(olrcpos,&lgain,&rgain);
		*ooleftgain   = lgain;
		*oileftgain   = rgain;
		*ocentregain  = 0.0;
		*oirightgain  = 0.0;
		*oorightgain  = 0.0;
	} else if(*pos <= 0.0) {					//	i.e. pos Range = -0.5 to 0, olcpos range = -2 to 0
		olrcpos += 1.0;							//	olrcpos range = -1 to +1
		pancalc(olrcpos,&lgain,&rgain);
		*ooleftgain   = 0.0;
		*oileftgain   = lgain;
		*ocentregain  = rgain;
		*oirightgain  = 0.0;
		*oorightgain  = 0.0;
	} else if(*pos <= 0.5) {					//	i.e. pos Range = 0 to 0.5, olcpos range = 0 to 2
		olrcpos -= 1.0;							//	olrcpos range = -1 to +1
		pancalc(olrcpos,&lgain,&rgain);
		*ooleftgain   = 0.0;
		*oileftgain   = 0.0;
		*ocentregain  = lgain;
		*oirightgain  = rgain;
		*oorightgain  = 0.0;
	} else {									//	i.e. pos Range = 0.5 to 1, olcpos range = 2 to 4
		olrcpos -= 3.0;							//	olrcpos range = -1 to +1
		pancalc(olrcpos,&lgain,&rgain);
		*ooleftgain   = 0.0;
		*oileftgain   = 0.0;
		*ocentregain  = 0.0;
		*oirightgain  = lgain;
		*oorightgain  = rgain;
	}
}