ComposerDesktopProject/dev/pitch/ap_pitch.c

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

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

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

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



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

#ifndef HUGE
#define HUGE 3.40282347e+38F
#endif

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

static int 	check_viability_and_compatibility_of_shiftp_params(dataptr dz);
static int  sub_check_shiftp(dataptr dz);

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

#define SCALEFUDGE  (3.0)
static int  tune_preprocess(dataptr dz);
static int  convert_params_for_tune(dataptr dz);
static int  pick_preprocess(dataptr dz);
static int  adjust_parameters_for_specpick(dataptr dz);
static int  mark_chosen_channels_in_bitflags(dataptr dz);
static int  chan_containing_partial(int *botpchan,double *lastchtop,int *chan,double partial,dataptr dz);

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

static int  generate_template_frqs(char *str,int datatype,dataptr dz);
static int  get_input_frqs(char *str,int datatype,double **fundamentals, double **harmonics,int *infrqcnt,dataptr dz);
static int  generate_template(double *fundamentals, double *harmonics, int infrqcnt, dataptr dz);
static int  getnextfrq(double *minfrq,double *fundamentals,double *harmonics,int infrqcnt);
static int  chordget(char *str,dataptr dz);

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

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

int establish_bufptrs_and_extra_buffers(dataptr dz)
{
	int exit_status;
	int is_spec = FALSE;
	dz->extra_bufcnt = -1;	/* ENSURE EVERY CASE HAS A PAIR OF ENTRIES !! */
	dz->bptrcnt = 0;
	dz->bufcnt  = 0;
	switch(dz->process) {
	case(ALT):        		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(OCT):        		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(SHIFTP):     		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(TUNE):       		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(PICK):       		dz->extra_bufcnt =  0; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(MULTRANS):   		dz->extra_bufcnt =  1; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	case(CHORD):      		dz->extra_bufcnt =  1; dz->bptrcnt = 1; 	is_spec = TRUE;		break;
	default:
		sprintf(errstr,"Unknown program type [%d] in establish_bufptrs_and_extra_buffers()\n",dz->process);
		return(PROGRAM_ERROR);
	}

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

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

int setup_internal_arrays_and_array_pointers(dataptr dz)
{
	int n;		 
	dz->ptr_cnt    = -1;		/* base constructor...process */
	dz->array_cnt  = -1;
	dz->iarray_cnt = -1;
	dz->larray_cnt = -1;
	switch(dz->process) {
	case(ALT):    	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(OCT):    	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(SHIFTP): 	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(TUNE):   	dz->array_cnt = 0; dz->iarray_cnt =1;  dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(PICK):   	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt =1;  dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(MULTRANS): dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	case(CHORD):  	dz->array_cnt = 0; dz->iarray_cnt = 0; dz->larray_cnt = 0; dz->ptr_cnt = 0; dz->fptr_cnt = 0;	break;
	}

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


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

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

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

int assign_process_logic(dataptr dz)
{						 
	switch(dz->process) {
	case(ALT):			setup_process_logic(ANAL_WITH_PITCHDATA,  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(OCT):			setup_process_logic(ANAL_WITH_PITCHDATA,  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(SHIFTP):		setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(TUNE):			setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(PICK):			setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(MULTRANS):		setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	case(CHORD):		setup_process_logic(ANALFILE_ONLY,		  	EQUAL_ANALFILE,		ANALFILE_OUT,	dz);	break;
	default:
		sprintf(errstr,"Unknown process: assign_process_logic()\n");
		return(PROGRAM_ERROR);
		break;
	}
	if(dz->has_otherfile) {
		switch(dz->input_data_type) {
		case(ALL_FILES):
		case(TWO_SNDFILES):
		case(SNDFILE_AND_ENVFILE):
		case(SNDFILE_AND_BRKFILE):
		case(SNDFILE_AND_UNRANGED_BRKFILE):
		case(SNDFILE_AND_DB_BRKFILE):
			break;
		case(MANY_SNDFILES):
			if(dz->process==INFO_TIMELIST)
				break;
			/* fall thro */
		default:
			sprintf(errstr,"Most processes accepting files with different properties\n"
						   "can only take 2 sound infiles.\n");
			return(PROGRAM_ERROR);
		}
	}
	return(FINISHED);
}

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

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

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

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

int set_legal_internalparam_structure(int process,int mode,aplptr ap)
{
	int exit_status = FINISHED;

	switch(process) {
	case(ALT):		  	return(FINISHED);
	case(OCT):		  	return(FINISHED);
	case(SHIFTP):	  	exit_status = set_internalparam_data("idddddd",ap);				break;
	case(TUNE):		  	return(FINISHED);
	case(PICK):		  	exit_status = set_internalparam_data("ii",ap);					break;
	case(MULTRANS):	  	return(FINISHED);
	case(CHORD):	  	return(FINISHED);
	default:
		sprintf(errstr,"Unknown process in set_legal_internalparam_structure()\n");
		return(PROGRAM_ERROR);
	}
	return(exit_status);		
}

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

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

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

	switch(ap->special_data) {
	case(FRQ_OR_FRQSET):
	case(PITCH_OR_PITCHSET):	return generate_template_frqs(str,(int)ap->special_data,dz);

	case(SEMIT_TRANSPOS_SET): 	return chordget(str,dz);
	default:
		sprintf(errstr,"Unknown special_data type: read_special_data()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}

/**************************** GENERATE_TEMPLATE_FRQS ****************************/

int generate_template_frqs(char *str,int datatype,dataptr dz) /* 'datatype' has to be  PITCH_OR_PITCHSET or FRQ_OR_FRQSET */
{
 	double *fundamentals, *harmonics;
	int infrqcnt;
	int exit_status;
	if((exit_status = get_input_frqs(str,datatype,&fundamentals,&harmonics,&infrqcnt,dz))<0)
		return(exit_status);
	if((exit_status = generate_template(fundamentals,harmonics,infrqcnt,dz))<0)
		return(exit_status);
	free(fundamentals);
	free(harmonics);
	return(FINISHED);
}

/**************************** GET_INPUT_FRQS ****************************/

int get_input_frqs(char *str,int datatype,double **fundamentals, double **harmonics,int *infrqcnt,dataptr dz)
{		
	double dummy = 0.0, mididummy = 0.0;
	FILE *fp;
	int n, is_numeric = 0;
	int arraysize = BIGARRAY;
	char temp[200], *p;

	*infrqcnt = 0;

	if(!sloom) {
//TW NEW CONVENTION ON numeric filenames
		if(!value_is_numeric(str) && file_has_invalid_startchar(str)) {
    		sprintf(errstr,"Filename has invalid start-character [%s]\n",str);
			return(USER_ERROR);
		}
		if(value_is_numeric(str)) {
			if(sscanf(str,"%lf",&dummy)!=1) {
				sprintf(errstr,"Invalid frq or pitch data: get_input_frqs()\n");
				return(DATA_ERROR);
			}
			is_numeric = 1;
		}
	} else {
		if(str[0]==NUMERICVAL_MARKER) {
			str++;
			if(strlen(str)<=0 || sscanf(str,"%lf",&dummy)!=1) {
				sprintf(errstr,"Invalid frq or pitch data: get_input_frqs()\n");
				return(DATA_ERROR);
			}
			is_numeric = 1;
		}
	}
	if(is_numeric) {
		if(datatype == PITCH_OR_PITCHSET) {
			mididummy = dummy;
			dummy = miditohz(dummy);
		}
		if(dummy <= 0.0 || dummy >= dz->nyquist) {
			if(datatype == PITCH_OR_PITCHSET) {
				sprintf(errstr,"Input midi value %lf in file %s is outside frq range (>0 - %.0lf[nyquist])\n",
				mididummy,str,dz->nyquist);
			} else {
				sprintf(errstr,"Input frq value %lf in file %s is outside frq range (>0 - %.0lf[nyquist])\n",
				dummy,str,dz->nyquist);
			}
			return(USER_ERROR);
		}
		if((*fundamentals = (double *)malloc(sizeof(double)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to store fundamentals.\n");
			return(MEMORY_ERROR);
		}
		(*fundamentals)[(*infrqcnt)++] = (float)dummy;
	} else {
		if((fp = fopen(str,"r"))==NULL) {
			sprintf(errstr,"Cannot open file %s to read template.\n",str);
			return(DATA_ERROR);
		}
		if((*fundamentals = (double *)malloc(arraysize * sizeof(double)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to store fundamentals.\n");
			return(MEMORY_ERROR);
		}
		while(fgets(temp,200,fp)!=NULL) {
			p = temp;
			while(get_float_from_within_string(&p,&dummy)) {
				switch(datatype) {
				case(PITCH_OR_PITCHSET):
					mididummy = dummy;
					dummy = miditohz(dummy);
					/* fall thro */
				case(FRQ_OR_FRQSET):
					if(dummy <= 0.0 || dummy >= dz->nyquist) {
						if(datatype == PITCH_OR_PITCHSET) {
							sprintf(errstr,"Input midi value %lf in file %s is outside frq range (>0 - %.0lf[nyquist])\n",
							mididummy,str,dz->nyquist);
						} else {
							sprintf(errstr,"Input frq value %lf in file %s is outside frq range (>0 - %.0lf[nyquist])\n",
							dummy,str,dz->nyquist);
						}
						return(USER_ERROR);
					}
					break;
				}
				(*fundamentals)[*infrqcnt] = (float)dummy;
				if(++(*infrqcnt)>=arraysize) {
					arraysize += BIGARRAY;
					if((*fundamentals = (double *)realloc((char *)(*fundamentals),arraysize*sizeof(double)))==NULL) {
						sprintf(errstr,"INSUFFICIENT MEMORY to reallocate fundamentals store.\n");
						return(MEMORY_ERROR);
					}
				}
			}
		}
		if(*infrqcnt==0) {
			sprintf(errstr,"No data found in frq template file %s\n",str);
			return(DATA_ERROR);
		}
		if((*fundamentals = (double *)realloc((char *)(*fundamentals),(*infrqcnt) * sizeof(double)))==NULL) {
			sprintf(errstr,"INSUFFICIENT MEMORY to reallocate fundamentals store.\n");
			return(MEMORY_ERROR);
		}
		if(fclose(fp)<0) {
			fprintf(stdout,"WARNING: Failed to close input textfile %s.\n",str);
			fflush(stdout);
		}
	}
	if((*harmonics = (double *)malloc((*infrqcnt) * sizeof(double)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to store harmonics.\n");
		return(MEMORY_ERROR);
	}
	for(n=0;n<(*infrqcnt);n++)
		(*harmonics)[n] = (*fundamentals)[n];
	return(FINISHED);
}
    
/**************************** GENERATE_TEMPLATE *************************/

int generate_template(double *fundamentals, double *harmonics, int infrqcnt, dataptr dz)
{
	int exit_status;
	int n;
	double lastchtop, thischtop, thisfrq;
	for(n=0;n<infrqcnt;n++) {
		if(fundamentals[n]>=dz->nyquist) {
			sprintf(errstr,"Input frq %d = %lf >= nyquist[%.0lf].\n",n+1,fundamentals[n],dz->nyquist);
			return(DATA_ERROR);
		}
	}
	lastchtop = 0.0;
	thischtop = dz->chwidth/2.0;
	if((exit_status = getnextfrq(&thisfrq,fundamentals,harmonics,infrqcnt))<0)
		return(exit_status);
	if((exit_status = float_array(&(dz->frq_template),dz->clength))<0)
		return(exit_status);
	for(n=0;n<dz->clength;n++) {
		while(thisfrq < lastchtop) {
			if((exit_status = getnextfrq(&thisfrq,fundamentals,harmonics,infrqcnt))<0)
				return(exit_status);
		}
		if(thisfrq > thischtop)
			dz->frq_template[n] = (float)(-1.0);
		else
			dz->frq_template[n] = (float)thisfrq;
		lastchtop = thischtop;
		if((thischtop += dz->chwidth) > dz->nyquist)
			thischtop = dz->nyquist;
	}
	return(FINISHED);
}

/***************************** GETNEXTFRQ *****************************/

int getnextfrq(double *minfrq,double *fundamentals,double *harmonics,int infrqcnt)
{
	int minptr = 0, n;
	*minfrq = HUGE;
	for(n=0;n<infrqcnt;n++) {
		if(harmonics[n] < *minfrq) {		/* FIND CURRENT MIN FRQ IN ARRAY harmonics[] */
			*minfrq = harmonics[n];
			minptr   = n;
		}
	}
	harmonics[minptr] += fundamentals[minptr];	/* INCREMENT MIN VALUE TO NEXT APPROPRIATE HARMONIC */
	return(FINISHED);
}

/*************************** CHORDGET ******************************/

int chordget(char *str,dataptr dz)
{
	FILE *fp;
	double val;
	int arraysize = BIGARRAY;
	char temp[200], *q;
	if((dz->transpos = (float *)malloc(arraysize * sizeof(float)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for transposition array.\n");
		return(MEMORY_ERROR);
	}
	if(!sloom) {
//TW NEW CONVENTION on numeric filenames
		if(!value_is_numeric(str) && file_has_invalid_startchar(str)) {
    		sprintf(errstr,"Cannot read parameter value [%s]\n",str);
			return(USER_ERROR);
		}
//TW REVISED Dec 2002
		if(value_is_numeric(str)) {
			sprintf(errstr,"This process takes chord-data in a FILE only.\n");
			return(DATA_ERROR);
		}
		if((fp = fopen(str,"r"))==NULL) {
			sprintf(errstr,"Can't open text file %s to read.\n",str);
			return(DATA_ERROR);
		}
	} else {
		if(str[0] == NUMERICVAL_MARKER) {
//TW THis Check should be redundant: trapped by Sound Loom
			sprintf(errstr,"This process takes chord-data in a FILE only.\n");
			return(DATA_ERROR);
		} else if((fp = fopen(str,"r"))==NULL) {
			sprintf(errstr,"Can't open text file %s to read.\n",str);
			return(DATA_ERROR);
		}
	}
	while(fgets(temp,200,fp)==temp) {
		q = temp;
		while(get_float_from_within_string(&q,&val)) {
			val *= OCTAVES_PER_SEMITONE;	/* CONVERT SEMITONES TO OCTAVES */
			val = pow(2.0,val);				/* CONVERT OCTAVES TO FRQ RATIO */
			if(val <= MIN_TRANSPOS || val > MAX_TRANSPOS) {
				sprintf(errstr,"transposition out of range (frq ratio %lf to %lf)\n",
				LOG2(MIN_TRANSPOS) * SEMITONES_PER_OCTAVE,LOG2(MAX_TRANSPOS) * SEMITONES_PER_OCTAVE);
				return(DATA_ERROR);
			}
			dz->transpos[dz->itemcnt] = (float)val;
			if(++dz->itemcnt >= arraysize) {
				arraysize += BIGARRAY;
				if((dz->transpos = (float *)realloc((char *)dz->transpos,arraysize * sizeof(float)))==NULL) {
					sprintf(errstr,"INSUFFICIENT MEMORY to reallocate transposition array.\n");
					return(MEMORY_ERROR);
				}
			}
		}
	}	    
	if(dz->itemcnt == 0) {
		sprintf(errstr,"No data in file %s\n",str);
		return(DATA_ERROR);
	}
	if((dz->transpos = (float *)realloc((char *)dz->transpos,dz->itemcnt * sizeof(float)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY to reallocate transposition array.\n");
		return(MEMORY_ERROR);
	}
	if(fclose(fp)<0) {
		fprintf(stdout,"WARNING: Failed to close input textfile %s.\n",str);
		fflush(stdout);
	}
	return(FINISHED);
}
/********************************************************************************************/
/********************************** FORMERLY IN preprocess.c ********************************/
/********************************************************************************************/

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

int param_preprocess(dataptr dz)	
{
	int check;

	switch(dz->process) {
	case(OCT):			return initialise_specenv(&check,dz);
	case(SHIFTP):		return adjust_params_and_setup_internal_params_for_shiftp(dz);
	case(TUNE):			return tune_preprocess(dz);
	case(PICK):			return pick_preprocess(dz);

  	case(ALT):	case(MULTRANS): case(CHORD): 		
  		return(FINISHED);
	default:
		sprintf(errstr,"PROGRAMMING PROBLEM: Unknown process in param_preprocess()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}

/************ ADJUST_PARAMS_AND_SETUP_INTERNAL_PARAMS_FOR_SHIFTP *************/

int adjust_params_and_setup_internal_params_for_shiftp(dataptr dz)
{
	int exit_status;
	double frq;
	frq = dz->param[SHIFTP_FFRQ]  + dz->chwidth/2.0;
	dz->iparam[SHIFTP_FDCNO] = (int)floor(frq/dz->chwidth);
	dz->param[SHIFTP_S1L1] = dz->param[SHIFTP_SHF1] - 1.0;
 	dz->param[SHIFTP_1LS1] = 1.0 - dz->param[SHIFTP_SHF1];
	if(dz->mode == P_SHFT_UP_AND_DN) {
		dz->param[SHIFTP_S2L1] = dz->param[SHIFTP_SHF2] - 1.0;
		dz->param[SHIFTP_1LS2] = 1.0 - dz->param[SHIFTP_SHF2];
	}
	else {	   
		dz->param[SHIFTP_S2L1] = 0.0;
		dz->param[SHIFTP_1LS2] = 0.0;
	}
	dz->param[SHIFTP_NS1] = dz->param[SHIFTP_SHF1];
	if(dz->mode == P_SHFT_UP_AND_DN)
		dz->param[SHIFTP_NS2] = dz->param[SHIFTP_SHF2];
	else						 
		dz->param[SHIFTP_NS2] =  0.0;
	if(dz->vflag[SHP_IS_DEPTH] && dz->brksize[SHIFTP_DEPTH]==0) {
		if((exit_status = reset_shiftps_according_to_depth_value(dz))<0)
			return(exit_status);
	}
	return(FINISHED);
}

/************************ RESET_SHIFTPS_ACCORDING_TO_DEPTH_VALUE ****************************/

int reset_shiftps_according_to_depth_value(dataptr dz)
{
	switch(dz->mode) {
	case(6):
  		if(dz->param[SHIFTP_SHF2] > 1.0)
  			dz->param[SHIFTP_NS2] = (dz->param[SHIFTP_S2L1] * dz->param[SHIFTP_DEPTH]) + 1.0;
		else
			dz->param[SHIFTP_NS2] = 1.0 - (dz->param[SHIFTP_1LS2] * dz->param[SHIFTP_DEPTH]);
	default:
		if(dz->param[SHIFTP_SHF1] > 1.0)
			dz->param[SHIFTP_NS1]  = (dz->param[SHIFTP_S1L1] * dz->param[SHIFTP_DEPTH]) + 1.0;
		else
			dz->param[SHIFTP_NS1]  = 1.0 - (dz->param[SHIFTP_1LS1] * dz->param[SHIFTP_DEPTH]);
	}
	return(FINISHED);
}

/************************** TUNE_PREPROCESS ******************************/

int tune_preprocess(dataptr dz)
{
	int exit_status;
	if((exit_status = convert_params_for_tune(dz))<0)
		return(exit_status);
	if((dz->iparray[TUNE_LOUD] = (int *)malloc(dz->wanted * sizeof(int)))==NULL) {
		sprintf(errstr,"INSUFFICIENT MEMORY for loudness array.\n");
		return(MEMORY_ERROR);
	}
	return setup_ring(dz);
}

/************ CONVERT_PARAMS_FOR_TUNE *************/

int convert_params_for_tune(dataptr dz)
{
	double *p;
	int n;
	if(dz->brksize[TUNE_CLAR]==0)
		dz->param[TUNE_CLAR] = 1.0 - dz->param[TUNE_CLAR];
	else {
		p = dz->brk[TUNE_CLAR] + 1;
		for(n = 0;n<dz->brksize[TUNE_CLAR];n++) {
			*p = 1.0 - *p;
			p += 2;
		}
	}
	return(FINISHED);
}

/************************** PICK_PREPROCESS ******************************/

int pick_preprocess(dataptr dz)
{
	int exit_status;
	if((exit_status = adjust_parameters_for_specpick(dz))<0)
		return(exit_status);
	if((exit_status = setup_internal_bitflags(PICK_BFLG,PICK_LONGPOW2,PICK_DIVMASK,dz))<0)
		return(exit_status);
	return mark_chosen_channels_in_bitflags(dz);
}

/************ ADJUST_PARAMETERS_FOR_SPECPICK *************/

int adjust_parameters_for_specpick(dataptr dz)
{
	/* Make perceived clarity grow linearly with entered val: PICK */

	double *p;
	int n;
	if(dz->brksize[PICK_CLAR] == 0) {
		dz->param[PICK_CLAR] = 1.0 - dz->param[PICK_CLAR];
		dz->param[PICK_CLAR] = pow(dz->param[PICK_CLAR],SCALEFUDGE);
	} else {
		p = dz->brk[PICK_CLAR] + 1;
		for(n=0; n < dz->brksize[PICK_CLAR]; n++) {
			*p = 1.0 - *p;
			*p = pow(*p,SCALEFUDGE);
			p += 2;
		}
	}
	return(FINISHED);
}

/***************************** MARK_CHOSEN_CHANNELS_IN_BITFLAGS *************/

int mark_chosen_channels_in_bitflags(dataptr dz)
{
	int exit_status;
	int n=1, chan;
	int mask;
	int botpchan = 0;
	double lastchtop = dz->chwidth/2.0;
	double partial = dz->param[PICK_FUND];
	do {
		if((exit_status = chan_containing_partial(&botpchan,&lastchtop,&chan,partial,dz))<0) {
			sprintf(errstr,"Problem with partial->channel calculation: mark_chosen_channels_in_bitflags()\n");
			return(PROGRAM_ERROR);
		}
		mask = 1;		  /* set bitflag */
		dz->lparray[PICK_BFLG][(chan>>dz->iparam[PICK_LONGPOW2])] 
			|= (mask <<= (chan & dz->iparam[PICK_DIVMASK]));
		switch(dz->mode) {
		case(PIK_HARMS):  		   n++;   partial  =  dz->param[PICK_FUND] * (double)n;	    					break;
		case(PIK_OCTS):    	 	   		  partial  =  partial * 2.0;	    									break;
		case(PIK_ODD_HARMS):  	   n+=2;  partial  =  dz->param[PICK_FUND] * (double)n;	    					break;
		case(PIK_LINEAR):	       		  partial +=  dz->param[PICK_LIN];    									break;
		case(PIK_DISPLACED_HARMS): n++;   partial  = (dz->param[PICK_FUND] 
										* (double)n) + dz->param[PICK_LIN];  
			break;
		default:
			sprintf(errstr,"Programing Problem: Unknown mode in mark_chosen_channels_in_bitflags()\n");
			return(PROGRAM_ERROR);
		}
	} while(partial < dz->nyquist);
	return(FINISHED);
}

/************************** CHAN_CONTAINING_PARTIAL *************************/

int chan_containing_partial(int *botpchan,double *lastchtop,int *chan,double partial,dataptr dz)
{
	int n;
	double chtop;
	chtop = *lastchtop;
	for(n=*botpchan; n<=dz->clength ;n++) {
		if(partial < chtop) {
			*botpchan = n;
			*lastchtop = chtop;
			*chan = n;
			return(FINISHED);
		}
		chtop += dz->chwidth;
	}
	return(GOAL_FAILED);
}

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

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

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

	display_virtual_time(0L,dz);

	switch(dz->process) {
	case(ALT):		return outer_loop(dz);
	case(OCT):		return outer_loop(dz);
	case(SHIFTP):	return outer_loop(dz);
	case(TUNE):		return outer_loop(dz);
	case(PICK):		return outer_loop(dz);
	case(MULTRANS):	return outer_loop(dz);
	case(CHORD):	return outer_loop(dz);
	default:
		sprintf(errstr,"Unknown process in procspec()\n");
		return(PROGRAM_ERROR);
	}
	return(FINISHED);	/* NOTREACHED */
}

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

int inner_loop
(int *peakscore,int *descnt,int *in_start_portion,int *least,int *pitchcnt,int windows_in_buf,dataptr dz)
{
	int exit_status;
	int local_zero_set = FALSE;
	int wc;
   	for(wc=0; wc<windows_in_buf; wc++) {
		if(dz->total_windows==0) {
			if((exit_status = skip_or_special_operation_on_window_zero(dz))<0)
				return(exit_status);
			if(exit_status==TRUE) {
				dz->flbufptr[0] += dz->wanted;
				dz->total_windows++;
				dz->time = (float)(dz->time + dz->frametime);
				continue;
			}
		}
		if((exit_status = read_values_from_all_existing_brktables((double)dz->time,dz))<0)
			return(exit_status);

		switch(dz->process) {
		case(ALT):		exit_status = specalt(pitchcnt,dz);	  				break;		
		case(OCT):		exit_status = specoct(dz);	  						break;
		case(CHORD):	exit_status = specchord(dz);  						break;
		case(MULTRANS):	exit_status = specchord2(dz); 						break;
		case(PICK):		exit_status = specpick(dz);	  						break;
		case(SHIFTP):	exit_status = specshiftp(dz); 						break;
		case(TUNE):		exit_status = spectune(dz);	  						break;
		default:
			sprintf(errstr,"unknown process in inner_loop()\n");
			return(PROGRAM_ERROR);
		}
		if(exit_status<0)
			return(exit_status);
		dz->flbufptr[0] += dz->wanted;
		dz->total_windows++;
		dz->time = (float)(dz->time + dz->frametime);
	}
	if(!dz->zeroset && local_zero_set==TRUE) {
		fprintf(stdout,"WARNING: Zero-amp spectral window(s) encountered: orig window(s) substituted.\n"); 
		fflush(stdout);
		dz->zeroset = TRUE;
	}
	return(FINISHED);
}

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

int skip_or_special_operation_on_window_zero(dataptr dz)
{
	int vc;
	switch(dz->process) {
	case(CHORD):   case(OCT):   case(MULTRANS):
		switch(dz->process) {
		case(CHORD):
		case(MULTRANS):
			for(vc = 0; vc < dz->wanted; vc += 2)
				dz->windowbuf[0][FREQ] = dz->flbufptr[0][FREQ];
			break;
		}
		return(TRUE);
	}
	return(FALSE);
}

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

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

int check_param_validity_and_consistency(dataptr dz)
{
	handle_pitch_zeros(dz);
	switch(dz->process) {
	case(SHIFTP):	   return check_viability_and_compatibility_of_shiftp_params(dz);
	}
	return(FINISHED);
}

/***************** CHECK_VIABILITY_AND_COMPATIBILITY_OF_SHIFTP_PARAMS ******************/

int check_viability_and_compatibility_of_shiftp_params(dataptr dz)
{
	int exit_status;
	double thistime = 0.0;
	if(dz->vflag[SHP_IS_DEPTH]) {
		if((exit_status = check_depth_vals(SHIFTP_DEPTH,dz))<0)
			return(exit_status);
	}
	if(dz->brksize[SHIFTP_FFRQ] || dz->brksize[SHIFTP_SHF1] || dz->brksize[SHIFTP_SHF2]) {
		while(thistime < dz->duration + dz->frametime) {
			if((exit_status = read_values_from_all_existing_brktables(thistime,dz))<0)
				return(exit_status);
			if((exit_status = sub_check_shiftp(dz))<0)
				return(exit_status);
			thistime += dz->frametime;
		}
		return(FINISHED);
	}
	return sub_check_shiftp(dz);
}

/*********************** SUB_CHECK_SHIFTP ***********************/

int sub_check_shiftp(dataptr dz)
{
	double frq = dz->param[SHIFTP_FFRQ] + dz->chwidth/2.0;
	int fdcno = (int)floor(frq/dz->chwidth);
	switch(dz->mode) {
	case(P_SHFT_UP_AND_DN):
		dz->param[SHIFTP_SHF1] *= OCTAVES_PER_SEMITONE;
		dz->param[SHIFTP_SHF1] = pow(2.0,dz->param[SHIFTP_SHF1]);
		dz->param[SHIFTP_SHF2] *= OCTAVES_PER_SEMITONE;
		dz->param[SHIFTP_SHF2] = pow(2.0,dz->param[SHIFTP_SHF2]);

		if(dz->param[SHIFTP_SHF1] > 1.0
		&& round((double)(dz->clength-1)/dz->param[SHIFTP_SHF1]) < fdcno) {
			sprintf(errstr,"Shift above frq split is too great to work.\n");
			return(DATA_ERROR);
		}
		if(dz->param[SHIFTP_SHF1] <= 1.0
		&& round((double)(dz->clength-1)*dz->param[SHIFTP_SHF1]) <= fdcno) {
			sprintf(errstr,"Shift above frq split is too great to work.\n");
			return(DATA_ERROR);
		}
		if(dz->param[SHIFTP_SHF2] > dz->param[SHIFTP_FFRQ]/SPEC_MINFRQ) {
			sprintf(errstr,"Shift below frq split is too great to work.\n");
			return(DATA_ERROR);
		}
		if(dz->param[SHIFTP_SHF2] <= 1.0
		&& (1.0/dz->param[SHIFTP_SHF2]) >= dz->param[SHIFTP_FFRQ]/SPEC_MINFRQ) {
			sprintf(errstr,"Shift below frq split is too great to work.\n");
			return(DATA_ERROR);
		}
		break;
	case(P_SHFT_DN):
		dz->param[SHIFTP_SHF1] *= OCTAVES_PER_SEMITONE;
		dz->param[SHIFTP_SHF1] = pow(2.0,dz->param[SHIFTP_SHF1]);
		if(dz->param[SHIFTP_SHF1] > 1.0
		&& round((double)(dz->clength-1)/dz->param[SHIFTP_SHF1]) < fdcno) {
			sprintf(errstr,"Shift incompatible with frqsplit.\n");
			return(DATA_ERROR);
		}
		if(dz->param[SHIFTP_SHF1] <= 1.0
		&& round((double)(dz->clength-1)*dz->param[SHIFTP_SHF1]) < fdcno) {
			sprintf(errstr,"Shift incompatible with frqsplit.\n");
			return(DATA_ERROR);
		}
		break;
	case(P_SHFT_UP):
		dz->param[SHIFTP_SHF1] *= OCTAVES_PER_SEMITONE;
		dz->param[SHIFTP_SHF1] = pow(2.0,dz->param[SHIFTP_SHF1]);
		if(dz->param[SHIFTP_SHF1] > 1.0
		&& round((double)(dz->clength-1)/dz->param[SHIFTP_SHF1]) < fdcno) {
			sprintf(errstr,"Shift incompatible with frqsplit.\n");
			return(DATA_ERROR);
		}
		if(dz->param[SHIFTP_SHF1] <= 1.0
		&& round((double)(dz->clength-1)*dz->param[SHIFTP_SHF1]) <= fdcno) {
			sprintf(errstr,"Shift incompatible with frqsplit.\n");
			return(DATA_ERROR);
		}
		break;
	}
	return(FINISHED);
}

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

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

int allocate_large_buffers(dataptr dz)
{
	switch(dz->process) {
	case(ALT):		case(OCT):		case(SHIFTP):	
	case(TUNE):		case(PICK):		case(MULTRANS):	
	case(CHORD):
		return allocate_single_buffer(dz);
	}
	sprintf(errstr,"Unknown program no. in allocate_large_buffers()\n");
	return(PROGRAM_ERROR);
}

/********************************************************************************************/
/********************************** FORMERLY IN cmdline.c ***********************************/
/********************************************************************************************/

int get_process_no(char *prog_identifier_from_cmdline,dataptr dz)
{
	if     (!strcmp(prog_identifier_from_cmdline,"altharms"))	   	dz->process = ALT;
	else if(!strcmp(prog_identifier_from_cmdline,"octmove"))	   	dz->process = OCT;
	else if(!strcmp(prog_identifier_from_cmdline,"transp"))    	    dz->process = SHIFTP;
	else if(!strcmp(prog_identifier_from_cmdline,"tune"))	   		dz->process = TUNE;
	else if(!strcmp(prog_identifier_from_cmdline,"pick"))	   		dz->process = PICK;
	else if(!strcmp(prog_identifier_from_cmdline,"chord"))    		dz->process = MULTRANS;
	else if(!strcmp(prog_identifier_from_cmdline,"chordf"))	   		dz->process = CHORD;
	else {
		sprintf(errstr,"Unknown program identification string '%s'\n",prog_identifier_from_cmdline);
		return(USAGE_ONLY);
	}
//TW UPDATE
	return(FINISHED);
}

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

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

int usage1(void)
{
	sprintf(errstr,
	"\nPITCH OPERATIONS ON A SPECTRAL FILE\n\n"
	"USAGE: pitch NAME (mode) infile outfile parameters: \n"
	"\n"
	"where NAME can be any one of\n"
	"\n"
	"altharms    octmove    transp    tune    pick    chordf    chord\n\n"
	"Type 'pitch altharms' for more info on pitch altharms..ETC.\n");
	return(USAGE_ONLY);
}

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

int usage2(char *str)
{
	if(!strcmp(str,"altharms")) {
		fprintf(stdout,
		"pitch altharms mode infile pitchfile outfile [-x]\n"
		"\n"
		"DELETE ALTERNATE HARMONICS\n"
		"\n"
		"MODES :-\n"
		"1   delete odd harmonics.\n"
		"    Usually produces octave up transposition with no formant change.\n"
		"2   delete even harmonics.\n"
		"-x  alternative spectral reconstruction.\n\n"
		"PITCHFILE must be derived from infile\n");
	} else if(!strcmp(str,"octmove")) {
		fprintf(stdout,
		"pitch octmove 1-2 infile pitchfile outfile [-i] transposition\n"
		"pitch octmove 3   infile pitchfile outfile [-i] transposition bassboost\n"
		"\n"
		"OCTAVE TRANSPOSE WITHOUT FORMANT SHIFT\n"
		"\n"
		"MODES :-\n"
		"1   transpose up.\n"
		"2   transpose down.\n"
		"3   transpose down, with bass-reinforcement.\n"
		"\n"
		"PITCHFILE must be derived from infile.\n"
		"transposition an integer transposition-ratio: 2 is 8va, 3 is 12th etc.\n"
		"              as in harmonic series.\n"
		"bassboost     bass reinforcement: values >=0.0\n"
		"-i            quicksearch for formants (less accurate).\n"
		"\n"
		"bassboost may vary over time.\n");
	} else if(!strcmp(str,"transp")) {	  /* SHIFTP */
		fprintf(stdout,
		"pitch transp 1-3 infile outfile frq_split                     [-ddepth]\n"
		"pitch transp 4-5 infile outfile frq_split transpos            [-ddepth]\n"
		"pitch transp 6   infile outfile frq_split transpos1 transpos2 [-ddepth]\n"
		"\n"
		"SHIFT PITCH OF (PART OF) SPECTRUM\n"
		"\n"
		"MODES :-\n"
		"1   Octave transpose up, above freq_split.\n"
		"2   Octave transpose down, below freq_split.\n"
		"3   Octave transpose up and down.\n"
		"4   Pitch  transpose up, above freq_split.\n"
		"5   Pitch  transpose down, below freq_split.\n"
		"6   Pitch  transpose up and down.\n"
		"\n"
		"frq_split is frequency above or below which transposition takes place.\n"
		"transpos  is transposition above or below freq_split.\n"
		"transpos1 is transposition above freq_split. (semitones)\n"
		"transpos2 is transposition below freq_split. (semitones)\n"
		"depth     transposition effect on source (from 0(no effect) to 1(full effect))\n"
		"\n"
		"depth,frq_split,transpos1 & transpos2 can vary over time.\n");
	} else if(!strcmp(str,"tune")) {
		fprintf(stdout,
		"pitch tune mode infile outfile pitch_template\n"
		"               [-ffocus] [-cclarity] [-ttrace] [-bbcut] \n"
		"\n"
		"REPLACE SPECTRAL FRQS BY HARMONICS OF SPECIFIED PITCH(ES)\n"
		"\n"
		"MODES :-\n"
		"1   enter pitch_template data as frq (in Hz).\n"
		"2   enter pitch_template data as (possibly fractional) MIDI values.\n"
		"\n"
		"pitch_template   a value, or a textfile containing values (as hz or midi).\n"
		"\n"
		"-f  FOCUS determines degree of focusing of partial pitches onto template.\n"
	    "    (range 0-1: val or brkpnt file: default 1).\n"
		"-c  CLARITY determines degree to which non-template partials are suppressed.\n"
	    "    (range 0-1: val or brkpnt file: default 0).\n"
		"-t  TRACE specifies no. of (window_by_window) most prominent channels\n"
		"    to be replaced by template frqs.\n"
		"-b  Ignore frqs below BCUT, Bass cutoff frq.\n"
		"\n"
		"All parameters may vary over time.\n");
	} else if(!strcmp(str,"pick")) {
		fprintf(stdout,
		"pitch pick 1-3 infile outfile fundamental         [-cclarity]\n"
		"pitch pick 4-5 infile outfile fundamental frqstep [-cclarity]\n"
		"\n"
		"ONLY RETAIN CHANNELS WHICH MIGHT HOLD SPECIFIED PARTIALS\n"
		"\n"
		"MODES :-\n"
		"1   Harmonic Series.\n"
		"2   Octaves.\n"
		"3   Odd partials of harmonic series only.\n"
		"4   Partials are successive linear steps (each of frqstep) from 'fundamental'.\n"
		"5   Add linear displacement (frqstep) to harmonic partials over fundamental.\n"
		"\n"
		"fundamental  Fundamental frequency of harmonic series, (or of calculation).\n"
		"frqstep      Frequency step to be added to another frequency.\n"
		"clarity      extent to which data in other channels is suppressed.\n"
	    "             Range 0-1: Default 1.\n"
		"\n"
		"clarity may vary over time.\n");
	} else if(!strcmp(str,"chordf")) {
		fprintf(stdout,
		"pitch chordf infile outfile -fN|-pN [-i] transpose_file [-bbot] [-ttop] [-x]\n"
		"\n"
		"TRANSPOSED VERSIONS OF SPECTRUM SUPERIMPOSED WITHIN EXISTING SPECTRAL ENVELOPE\n"
		"\n"
		"-f   extract spectral envelope linear-freqwise, using N chans per point.\n"
		"-p   extract spectral envelope linear-pitchwise, using N bands per octave.\n"
		"     (recommeded value 1.0)\n"
		"-i   quicksearch for formants (less accurate).\n"
		"\n"
		"transpose_file is file of (possibly fractional) semitone transposition values.\n"
		"\n"
		"-b   BOT = bottom frq, below which data is filtered out.\n"
		"-t   TOP = top frq, above which data is filtered out.\n"
		"-x   Fuller spectrum.\n"
		"\n"
		"top frq and bottom frq may vary over time.\n"
		"\n");
	} else if(!strcmp(str,"chord")) {
		fprintf(stdout,
		"pitch chord infile outfile transpose_file [-bbot] [-ttop] [-x]\n"
		"\n"
		"TRANSPOSED VERSIONS OF SOUND SUPERIMPOSED ON ORIGINAL\n"
		"\n"
		"transpose_file is file of (possibly fractional) semitone transposition values.\n"
		"\n"
		"-t   TOP = top frq, above which data is filtered out.\n"
		"-b   BOT = bottom frq, below which data is filtered out.\n"
		"-x   Fuller spectrum.\n"
		"\n"
		"top frq and bottom frq may vary over time.\n"
		"\n");
	} else
		fprintf(stdout,"Unknown option '%s'\n",str);
	return(USAGE_ONLY);
}

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

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