// _cdprogs\splinter splinter 1 testfrac.wav testsplint2.wav 0.710884 240 16 16 10 10 -e0 -s1 -p1 -f6000 -r0 -v0 //CRASHES ..... seems to be the waveset count that crashes it #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef unix #define round(x) lround((x)) #endif char errstr[2400]; #define QCYCLEMIN 2 // Minimum size of a shrunk quartercycle #define SPLENVWIN 20 // Windowsize, in mS, for extracting envelope, used to normalise output, if "-i" flag set. #define SPLMAXSPL 10 // Max duration of selected waveset-group = 10 seconds #define SPLSPLICE 2 // Splicelen in mS #define quartercyclecnt is_mapping // number of values marking the zero-crossings, maxima and minima of wavesetgroup #define envwindowsize rampbrksize // sample-size of window used for normalising envelope #define wavesetgrplen total_windows // Length of original wavesetgroup (samples) #define target wlength // Position of wavesetgroup in infile (samples) #define splintoffset wanted // Length of splinter-set prior to wavesetgroup #define arraysize itemcnt #define wmaxmpos extra_word #define splicelen ringsize #define enddur all_words #define minlen numsize int anal_infiles = 1; int sloom = 0; int sloombatch = 0; const char* cdp_version = "6.1.0"; //CDP LIB REPLACEMENTS static int check_splinter_param_validity_and_consistency(dataptr dz); static int setup_splinter_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_splinter_param_ranges_and_defaults(dataptr dz); static int handle_the_outfile(int *cmdlinecnt,char ***cmdline,dataptr dz); static int setup_and_init_input_param_activity(dataptr dz,int tipc); static int setup_input_param_defaultval_stores(int tipc,aplptr ap); static int establish_application(dataptr dz); static int initialise_vflags(dataptr dz); static int setup_parameter_storage_and_constants(int storage_cnt,dataptr dz); static int initialise_is_int_and_no_brk_constants(int storage_cnt,dataptr dz); static int mark_parameter_types(dataptr dz,aplptr ap); static int assign_file_data_storage(int infilecnt,dataptr dz); static int get_tk_cmdline_word(int *cmdlinecnt,char ***cmdline,char *q); static int get_the_process_no(char *prog_identifier_from_cmdline,dataptr dz); static int get_the_mode_from_cmdline(char *str,dataptr dz); static int setup_and_init_input_brktable_constants(dataptr dz,int brkcnt); static int splinter_param_preprocess(int *initial_phase,dataptr dz); static int create_splinter_sndbufs1(dataptr dz); static int generate_envelope_array_storage(dataptr dz); static int create_splinter_sndbufs2(dataptr dz); static int find_wavesets(int *initial_phase,dataptr dz); static int store_wavesets(int initial_phase,dataptr dz); static int generate_shrinkage_set(dataptr dz); static int generate_timing_set(dataptr dz); static int shrink_waveset(double shrink,int *splinterlen,dataptr dz); static int normalise_buffer(int windowing_end,dataptr dz); static int create_temp_sndbuf(dataptr dz); static int splinter(dataptr dz); /**************************************** MAIN *********************************************/ int main(int argc,char *argv[]) { int exit_status, initial_phase = 0; 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--; dz->maxmode = 4; 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--; // setup_particular_application = if((exit_status = setup_splinter_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_splinter_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() : redundant // handle_outfile() = if((exit_status = handle_the_outfile(&cmdlinecnt,&cmdline,dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } // handle_formants() redundant // handle_formant_quiksearch() redundant // handle_special_data() redundant 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_splinter_param_validity_and_consistency(dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } is_launched = TRUE; dz->bufcnt = 5; 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 bufcnt; n++) dz->sampbuf[n] = dz->sbufptr[n] = (float *)0; dz->sampbuf[n] = (float *)0; //param_preprocess() ... if((exit_status = splinter_param_preprocess(&initial_phase,dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } //spec_process_file = if((exit_status = create_splinter_sndbufs1(dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } if((exit_status = generate_envelope_array_storage(dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } if((exit_status = create_splinter_sndbufs2(dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } if((exit_status = store_wavesets(initial_phase,dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } if((exit_status = splinter(dz))<0) { print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } if((exit_status = complete_output(dz))<0) { // CDP LIB print_messages_and_close_sndfiles(exit_status,is_launched,dz); return(FAILED); } exit_status = print_messages_and_close_sndfiles(FINISHED,is_launched,dz); // CDP LIB free(dz); return(SUCCEEDED); } /********************************************** REPLACED CDP LIB FUNCTIONS **********************************************/ /****************************** SET_PARAM_DATA *********************************/ int set_param_data(aplptr ap, int special_data,int maxparamcnt,int paramcnt,char *paramlist) { ap->special_data = (char)special_data; ap->param_cnt = (char)paramcnt; ap->max_param_cnt = (char)maxparamcnt; if(ap->max_param_cnt>0) { if((ap->param_list = (char *)malloc((size_t)(ap->max_param_cnt+1)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY: for param_list\n"); return(MEMORY_ERROR); } strcpy(ap->param_list,paramlist); } return(FINISHED); } /****************************** SET_VFLGS *********************************/ int set_vflgs (aplptr ap,char *optflags,int optcnt,char *optlist,char *varflags,int vflagcnt, int vparamcnt,char *varlist) { ap->option_cnt = (char) optcnt; /*RWD added cast */ if(optcnt) { if((ap->option_list = (char *)malloc((size_t)(optcnt+1)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY: for option_list\n"); return(MEMORY_ERROR); } strcpy(ap->option_list,optlist); if((ap->option_flags = (char *)malloc((size_t)(optcnt+1)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY: for option_flags\n"); return(MEMORY_ERROR); } strcpy(ap->option_flags,optflags); } ap->vflag_cnt = (char) vflagcnt; ap->variant_param_cnt = (char) vparamcnt; if(vflagcnt) { if((ap->variant_list = (char *)malloc((size_t)(vflagcnt+1)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY: for variant_list\n"); return(MEMORY_ERROR); } strcpy(ap->variant_list,varlist); if((ap->variant_flags = (char *)malloc((size_t)(vflagcnt+1)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY: for variant_flags\n"); return(MEMORY_ERROR); } strcpy(ap->variant_flags,varflags); } return(FINISHED); } /***************************** APPLICATION_INIT **************************/ int application_init(dataptr dz) { int exit_status; int storage_cnt; int tipc, brkcnt; aplptr ap = dz->application; if(ap->vflag_cnt>0) initialise_vflags(dz); tipc = ap->max_param_cnt + ap->option_cnt + ap->variant_param_cnt; ap->total_input_param_cnt = (char)tipc; if(tipc>0) { if((exit_status = setup_input_param_range_stores(tipc,ap))<0) return(exit_status); if((exit_status = setup_input_param_defaultval_stores(tipc,ap))<0) return(exit_status); if((exit_status = setup_and_init_input_param_activity(dz,tipc))<0) return(exit_status); } brkcnt = tipc; //THERE ARE NO INPUTFILE brktables USED IN THIS PROCESS if(brkcnt>0) { if((exit_status = setup_and_init_input_brktable_constants(dz,brkcnt))<0) return(exit_status); } if((storage_cnt = tipc + ap->internal_param_cnt)>0) { if((exit_status = setup_parameter_storage_and_constants(storage_cnt,dz))<0) return(exit_status); if((exit_status = initialise_is_int_and_no_brk_constants(storage_cnt,dz))<0) return(exit_status); } if((exit_status = mark_parameter_types(dz,ap))<0) return(exit_status); // establish_infile_constants() replaced by dz->infilecnt = 1; //establish_bufptrs_and_extra_buffers(): return(FINISHED); } /********************** SETUP_PARAMETER_STORAGE_AND_CONSTANTS ********************/ /* RWD mallo changed to calloc; helps debug verison run as release! */ int setup_parameter_storage_and_constants(int storage_cnt,dataptr dz) { if((dz->param = (double *)calloc(storage_cnt, sizeof(double)))==NULL) { sprintf(errstr,"setup_parameter_storage_and_constants(): 1\n"); return(MEMORY_ERROR); } if((dz->iparam = (int *)calloc(storage_cnt, sizeof(int) ))==NULL) { sprintf(errstr,"setup_parameter_storage_and_constants(): 2\n"); return(MEMORY_ERROR); } if((dz->is_int = (char *)calloc(storage_cnt, sizeof(char)))==NULL) { sprintf(errstr,"setup_parameter_storage_and_constants(): 3\n"); return(MEMORY_ERROR); } if((dz->no_brk = (char *)calloc(storage_cnt, sizeof(char)))==NULL) { sprintf(errstr,"setup_parameter_storage_and_constants(): 5\n"); return(MEMORY_ERROR); } return(FINISHED); } /************** INITIALISE_IS_INT_AND_NO_BRK_CONSTANTS *****************/ int initialise_is_int_and_no_brk_constants(int storage_cnt,dataptr dz) { int n; for(n=0;nis_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;nmax_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;noption_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; ninternal_param_cnt; n++,m++) { switch(ap->internal_param_list[n]) { case('0'): break; /* dummy variables: variables not used: but important for internal paream numbering!! */ case('i'): dz->is_int[m] = (char)1; dz->no_brk[m] = (char)1; break; case('d'): dz->no_brk[m] = (char)1; break; default: sprintf(errstr,"Programming error: invalid internal param type in mark_parameter_types()\n"); return(PROGRAM_ERROR); } } return(FINISHED); } /************************ HANDLE_THE_OUTFILE *********************/ int handle_the_outfile(int *cmdlinecnt,char ***cmdline,dataptr dz) { int exit_status; char *filename = (*cmdline)[0]; if(filename[0]=='-' && filename[1]=='f') { dz->floatsam_output = 1; dz->true_outfile_stype = SAMP_FLOAT; filename+= 2; } if(!sloom) { if(file_has_invalid_startchar(filename) || value_is_numeric(filename)) { sprintf(errstr,"Outfile name %s has invalid start character(s) or looks too much like a number.\n",filename); return(DATA_ERROR); } } strcpy(dz->outfilename,filename); if((exit_status = create_sized_outfile(filename,dz))<0) return(exit_status); (*cmdline)++; (*cmdlinecnt)--; return(FINISHED); } /***************************** ESTABLISH_APPLICATION **************************/ int establish_application(dataptr dz) { aplptr ap; if((dz->application = (aplptr)malloc(sizeof (struct applic)))==NULL) { sprintf(errstr,"establish_application()\n"); return(MEMORY_ERROR); } ap = dz->application; memset((char *)ap,0,sizeof(struct applic)); return(FINISHED); } /************************* INITIALISE_VFLAGS *************************/ int initialise_vflags(dataptr dz) { int n; if((dz->vflag = (char *)malloc(dz->application->vflag_cnt * sizeof(char)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY: vflag store,\n"); return(MEMORY_ERROR); } for(n=0;napplication->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;ndefault_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;nis_active[n] = (char)0; return(FINISHED); } /************************* SETUP_SPLINTER_APPLICATION *******************/ int setup_splinter_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((exit_status = set_param_data(ap,0 ,6,6,"diiidd"))<0) return(FAILED); if(dz->mode <= 1) exit_status = set_vflgs(ap,"espfrv",6,"idddDD","iI",2,0,"00"); else exit_status = set_vflgs(ap,"espdrv",6,"idddDD","iI",2,0,"00"); 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 != 1) { sprintf(errstr,"File %s is not of correct type (must be mono)\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); } /************************* SETUP_SPLINTER_PARAM_RANGES_AND_DEFAULTS *******************/ int setup_splinter_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[SPL_TIME] = 0.0; ap->hi[SPL_TIME] = dz->duration; ap->default_val[SPL_TIME] = 0.0; ap->lo[SPL_WCNT] = 0; ap->hi[SPL_WCNT] = 256; ap->default_val[SPL_WCNT] = 1; ap->lo[SPL_SHRCNT] = 2; ap->hi[SPL_SHRCNT] = 256; ap->default_val[SPL_SHRCNT] = SHRCNT_DFLT; ap->lo[SPL_OCNT] = 0; ap->hi[SPL_OCNT] = 256; ap->default_val[SPL_OCNT] = OCNT_DFLT; ap->lo[SPL_PULS1] = 0; ap->hi[SPL_PULS1] = 50; ap->default_val[SPL_PULS1] = PULS_DFLT; ap->lo[SPL_PULS2] = 0; ap->hi[SPL_PULS2] = 50; ap->default_val[SPL_PULS2] = PULS_DFLT; ap->lo[SPL_ECNT] = 0; ap->hi[SPL_ECNT] = 10000; ap->default_val[SPL_ECNT] = 0; ap->lo[SPL_SCURVE] = 0.1; ap->hi[SPL_SCURVE] = 10.0; ap->default_val[SPL_SCURVE] = 1; ap->lo[SPL_PCURVE] = 0.1; ap->hi[SPL_PCURVE] = 10.0; ap->default_val[SPL_PCURVE] = 1; if(dz->mode <= 1) { ap->lo[SPL_FRQ] = 1000.0; ap->hi[SPL_FRQ] = dz->nyquist/2.0; ap->default_val[SPL_FRQ] = FREQ_DFLT; } else { ap->lo[SPL_DUR] = 5.0; ap->hi[SPL_DUR] = 50.0; ap->default_val[SPL_DUR] = 5.0; } ap->lo[SPL_RND] = 0.0; ap->hi[SPL_RND] = 1.0; ap->default_val[SPL_RND] = 0; ap->lo[SPL_SHRND] = 0.0; ap->hi[SPL_SHRND] = 1.0; ap->default_val[SPL_SHRND] = 0; dz->maxmode = 4; if(!sloom) put_default_vals_in_all_params(dz); return(FINISHED); } /********************************* PARSE_SLOOM_DATA *********************************/ int parse_sloom_data(int argc,char *argv[],char ***cmdline,int *cmdlinecnt,dataptr dz) { int exit_status; int cnt = 1, infilecnt; int filesize, insams, inbrksize; double dummy; int true_cnt = 0; aplptr ap; while(cnt<=PRE_CMDLINE_DATACNT) { if(cnt > argc) { sprintf(errstr,"Insufficient data sent from TK\n"); return(DATA_ERROR); } switch(cnt) { case(1): if(sscanf(argv[cnt],"%d",&dz->process)!=1) { sprintf(errstr,"Cannot read process no. sent from TK\n"); return(DATA_ERROR); } break; case(2): if(sscanf(argv[cnt],"%d",&dz->mode)!=1) { sprintf(errstr,"Cannot read mode no. sent from TK\n"); return(DATA_ERROR); } if(dz->mode > 0) dz->mode--; //setup_particular_application() = if((exit_status = setup_splinter_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) { usage2("splinter"); return(USAGE_ONLY); } /**************************** CHECK_SPLINTER_PARAM_VALIDITY_AND_CONSISTENCY *****************************/ int check_splinter_param_validity_and_consistency(dataptr dz) { if(dz->param[SPL_PULS1] > 0.0 && dz->param[SPL_PULS1] < 0.1) { fprintf(stderr,"Pulse frq where splinters join the original sound, cannot be less than 0.1.\n"); return DATA_ERROR; } if(dz->param[SPL_PULS2] > 0.0 && dz->param[SPL_PULS2] < 0.1) { if(dz->mode == 0 || dz->mode == 2) fprintf(stderr,"Pulse frq where splintering begins, cannot be less than 0.1.\n"); else fprintf(stderr,"Pulse frq where splintering ends, cannot be less than 0.1.\n"); return DATA_ERROR; } return FINISHED; } /**************************** SPLINTER_PARAM_PREPROCESS *****************************/ int splinter_param_preprocess(int *initial_phase,dataptr dz) { int exit_status; double *shrinkage; ; if((dz->iparray = (int **)malloc(sizeof(int *)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to envelope peak-position array.\n"); return(MEMORY_ERROR); } if((dz->lparray = (int **)malloc(sizeof(int *)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create minina/maxima store (0).\n"); return(MEMORY_ERROR); } if((dz->lparray[0] = (int *)malloc(dz->iparam[SPL_WCNT] * 4 * sizeof(int)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create minina/maxima store.\n"); return(MEMORY_ERROR); // Arrays stores sample position max(or min) in each half-waveset, and end-samples of half-waveset } if((dz->parray = (double **)malloc(3 * sizeof(double *)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create splintering arrays.\n"); return(MEMORY_ERROR); } if((dz->parray[0] = (double *)malloc(dz->iparam[SPL_SHRCNT] * sizeof(double)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create shrinkage data array.\n"); return(MEMORY_ERROR); // Arrays stores shrink factor dor successive shrunk waveset-groups } shrinkage = dz->parray[0]; if((dz->parray[1] = (double *)malloc((dz->iparam[SPL_SHRCNT] + dz->iparam[SPL_OCNT] + 1) * sizeof(double)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create splinter timing array.\n"); return(MEMORY_ERROR); // Arrays stores timings of successive pulses } if((exit_status = create_temp_sndbuf(dz))<0) // Find and store the the required waveset-group return exit_status; if((exit_status = find_wavesets(initial_phase,dz))<0) // Find and store the the required waveset-group return exit_status; free(dz->bigbuf); if((exit_status = generate_shrinkage_set(dz))<0) // Generate the sequence of wavesetgroup-shrinkages return exit_status; if((exit_status = generate_timing_set(dz))<0) // Generate onset times for the shrinking wavesetgroups return exit_status; dz->splicelen = (int)round(SPLSPLICE * MS_TO_SECS * dz->infile->srate); return FINISHED; } /**************************** GENERATE_ENVELOPE_ARRAY_STORAGE ************************************* * * Buflen (so far) is a multiple of F_SECSIZE (256) . * So this algorithm will, in the last resort, always find 256 or its divisors !! */ int generate_envelope_array_storage(dataptr dz) { double srate = (double)dz->infile->srate; int ewcnt = 0, orig_envwindowsize = 0, hifound = 0, lofound = 0; dz->envwindowsize = (int)round(SPLENVWIN * MS_TO_SECS * srate); // Envelope window-length, in samples ewcnt = dz->buflen/dz->envwindowsize; // Number of windows that will fit inside buffer if(ewcnt * dz->envwindowsize != dz->buflen) { // If window is not an exact divisor of buflen // adjust envelope length to be an exact divisor of buflen orig_envwindowsize = dz->envwindowsize; hifound = 0; while(!hifound) { // Enlarge the window until windows fit exactly into buffer dz->envwindowsize++; ewcnt = dz->buflen/dz->envwindowsize; if(dz->envwindowsize * ewcnt == dz->buflen) { hifound = 1; } } hifound = dz->envwindowsize; // set "hifound" to size of this (larger) window dz->envwindowsize = orig_envwindowsize; lofound = 0; while(!lofound) { // Shrink the window until windows fit exactly into buffer dz->envwindowsize--; ewcnt = dz->buflen/dz->envwindowsize; if(dz->envwindowsize * ewcnt == dz->buflen) { lofound = 1; break; } } lofound = dz->envwindowsize; // set "lofound" to size of this (smaller) window if(hifound - orig_envwindowsize > orig_envwindowsize - lofound) dz->envwindowsize = lofound; // use windowsize nearest to original size else dz->envwindowsize = hifound; } dz->arraysize = (int)ceil(dz->buflen/dz->envwindowsize) + 64; // 64=SAFETY (but 2 of these are needed for the bracketing envelope segments if((dz->parray[2] = (double *)malloc(dz->arraysize * sizeof(double)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create enveloping array.\n"); return(MEMORY_ERROR); } if((dz->iparray[0] = (int *)malloc(dz->arraysize * sizeof(int)))==NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create enveloping peak-position array.\n"); return(MEMORY_ERROR); } return FINISHED; } /************************** GET_THE_PROCESS_NO **********************************/ int get_the_process_no(char *prog_identifier_from_cmdline,dataptr dz) { if(!strcmp(prog_identifier_from_cmdline,"splinter")) dz->process = SPLINTER; 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;nbrk[n] = NULL; dz->brkptr[n] = NULL; dz->brkinit[n] = 0; dz->brksize[n] = 0; } return(FINISHED); } /******************************** USAGE2 ********************************/ int usage2(char *str) { if(!strcmp(str,"splinter")) { fprintf(stderr, "USAGE:\n" "splinter splinter 1-4 infile outfile target wcnt shrcnt ocnt p1 p2\n" " [-eecnt] [-sscv] [-ppcv] [-ffrq | -ddur] [-rrand] [-vshrand] [-i] [-I]\n" "\n" "Creates splinters by repeating & shrinking selected waveset-group in sound.\n" "Either splinters repeat before merging with orig snd at time-in-src specified.\n" "OR original sound plays up to selected time, then splinters,\n" "\n" "Mode 1+3: Splinters lead into original sound. Mode 1 splinters change pitch.\n" "Mode 2+4: Splinters emerge from original sound. Mode 2 splinters change pitch.\n" "\n" "TARGET Time in src immediately before desired waveset-group.\n" " Waveset group selected should not be longer than 1 minute.\n" "WCNT Number of wavesets to use to create splinter group.\n" "SHRCNT Number of waveset-group repets over which shrinkage takes place.\n" "OCNT Number of max-shrunken splinters beyond shrink.\n" "P1 Pulse-speed of waveset repetitions (Hz) at originating waveset.\n" "P2 Pulse-speed of shrunken wavesets (Hz) SHRCNT+OCNT splinters away.\n" "ECNT Number of additional regular pulses beyond SHRCNT+OCNT.\n" "\n" "SCV Shrinkage curve: 1 = linear:\n" " >1 contracts more rapidly near originating waveset; <1 less rapidly.\n" "PCV Pulse-speed curve: 1 = linear:\n" " >1 accels more rapidly near originating waveset; <1 less rapidly.\n" "\n" "FRQ Modes1+2: approx Frq (1/wavelen) of max-shrunk splinters (dflt c6000Hz).\n" " Resultant wavelen must be > average wavesetlen in wavesets chosen\n" " and less than nyquist/2.\n" "DUR Modes3+4: approx Duration (mS) of max-shrunk splinters.\n" "\n" "RAND Randomisation of pulse timing. Time-variable parameter.\n" "SHRAND Randomisation of pulse shrinkage. Time-variable parameter.\n" "-i Mix all source into output. (Default: use source only where no splinters)\n" "-I Mix none of source into output.\n" "\n" "If P1 set to zero, Pulse-speed 1 determined by duration of selected waveset-group.\n" "If P2 set to zero, Pulse-speed 2 same as Pulse-speed 1.\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); } /******************************** SPLINTER ********************************/ int splinter(dataptr dz) { int exit_status; int samps_to_read, obufpos = 0, startobufpos, lastobufpos, thisobufpos = 0, ibufpos = 0, sampstep = 0, envend, maxwrite, ovflw; int subtarget, splinterlen = 0, k, n, m, eventscnt, samps_to_write, rndstep,initialobufpos, advance; float *ibuf = dz->sampbuf[0], *obuf = dz->sampbuf[1], *ovflwbuf = dz->sampbuf[2], *shrbuf = dz->sampbuf[4]; double srate = (double)dz->infile->srate, shrink = 1.0, last_shrink, initialshrink, thisshrink, finalshrink; double *shrinkage = dz->parray[0], *timeset = dz->parray[1], shrinkstep = 0, dur, time, thistime, rnd; sndseekEx(dz->ifd[0],0,0); dz->total_samps_read = 0; memset((char *)ibuf,0,dz->buflen * sizeof(float)); memset((char *)obuf,0,dz->buflen * sizeof(float)); if(dz->mode == 0 || dz->mode == 2) { // MODE 0 or 2: attack-type // IN ALL CASE we read to dz->target + dz->wavesetgrplen in infile and write (whatever part required) into outfile if(dz->vflag[0]) { // If we're mixing-in the original source if((exit_status = read_samps(ibuf,dz))<0) // Read the infile : NB bufsize calcd to accept all of infile up to target + wavesetgrplen return(exit_status); samps_to_read = dz->target + dz->wavesetgrplen; if(dz->target >= dz->splintoffset) { // IF infile start is BEFORE OR AT start of splinters, then // the read will be up to (and beyond) the wavesetgroup (buffersize calcd thus) memcpy((char *)obuf,(char *)ibuf,samps_to_read * sizeof(float)); obufpos = dz->target - dz->splintoffset; // Set obuf pointer to start of splinters } else { // Infile starts AFTER start of splinters obufpos = dz->splintoffset - dz->target; // Find appropriate place in obuf to copy this to, and copy it memcpy((char *)(obuf+obufpos),(char *)ibuf,samps_to_read * sizeof(float)); obufpos = 0; } ibufpos = samps_to_read; } else { // Not mixing in INBUF sndseekEx(dz->ifd[0],dz->target,0); // Seek to wavesetgrp start dz->total_samps_read = dz->target; if((exit_status = read_samps(ibuf,dz))<0) // Read the infile return(exit_status); obufpos = dz->splintoffset; // Write to obuf at place where wavesetgrp will be in output samps_to_read = dz->wavesetgrplen; // Copy the wavesetgrp into obuf memcpy((char *)(obuf+obufpos),(char *)ibuf,samps_to_read * sizeof(float)); obufpos = 0; ibufpos = samps_to_read; } initialshrink = shrinkage[0]; // Get maximal shrink if((exit_status = shrink_waveset(initialshrink,&splinterlen,dz))<0)//and shrink waveset return exit_status; if(dz->param[SPL_PULS2] <= 0.0) { // Get goal timestep if(dz->param[SPL_PULS1] <= 0.0) // ... in samples sampstep = dz->wavesetgrplen; else { dur = 1.0/dz->param[SPL_PULS1]; sampstep = (int)ceil(dur * srate); } } else { dur = 1.0/dz->param[SPL_PULS2]; sampstep = (int)round(dur * srate); } // If shrinakge can be randomised .. if((dz->brksize[SPL_SHRND]) || (dz->param[SPL_SHRND] > 0.0)) shrinkstep = shrinkage[1] - initialshrink; // IF THERE'S A PREQUEL thisobufpos = obufpos; if(dz->iparam[SPL_ECNT] > 0) { for(n=0;n iparam[SPL_ECNT]; n++) { obufpos = thisobufpos; if(n > 0 && n < dz->iparam[SPL_ECNT] - 1) { if(dz->brksize[SPL_RND]) { thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_RND,dz))<0) return exit_status; } if(dz->param[SPL_RND] > 0.0) { rnd = ((drand48() * 2.0) - 1.0)/2.0; // range +1/2, -1/2 rnd *= dz->param[SPL_RND]; rndstep = (int)round(rnd * sampstep); obufpos += rndstep; } // If no randomisation of shrink, shrunk-waveset remains in original state if(dz->brksize[SPL_SHRND]) { // But if shrink is randomised, find current randomisation thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_SHRND,dz))<0) return exit_status; } if(dz->param[SPL_SHRND] > 0.0) { // If randomised > 0 rnd = drand48() * dz->param[SPL_SHRND]; // range 0 to SPL_SHRND shrink = initialshrink + (shrinkstep * rnd);// Possibly expand-or-contract shrinkage if((exit_status = shrink_waveset(shrink,&splinterlen,dz))<0)//and shrink waveset return exit_status; } else if(dz->brksize[SPL_SHRND]) { // If varying randomisation, but currently zero if((exit_status = shrink_waveset(initialshrink,&splinterlen,dz))<0) return exit_status; // still need to reshrink waveset (in case shrink-size changed previously) } } for(m=0;m= dz->buflen) { sprintf(errstr,"Buffer should be long enough to contain all prequel splinters. (1)\n"); return PROGRAM_ERROR; } } lastobufpos = thisobufpos; thisobufpos += sampstep; if(thisobufpos >= dz->buflen) { sprintf(errstr,"Buffer should be long enough to contain all prequel splinters. (2)\n"); return PROGRAM_ERROR; } } } // TIMESET ITSELF eventscnt = dz->iparam[SPL_SHRCNT] + dz->iparam[SPL_OCNT]; startobufpos = obufpos; lastobufpos = startobufpos; for(n=0,k = -dz->iparam[SPL_OCNT];n 0 && n < eventscnt - 1) { if(dz->brksize[SPL_RND]) { thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_RND,dz))<0) return exit_status; } if(dz->param[SPL_RND] > 0.0) { rnd = ((drand48() * 2.0) - 1.0)/2.0; // range +1/2, -1/2 rnd *= dz->param[SPL_RND]; rndstep = (int)round(rnd * advance); obufpos += rndstep; } } if(obufpos >= dz->buflen) { sprintf(errstr,"Buffer should be long enough to contain all time-sequence splinters. (1)\n"); return PROGRAM_ERROR; } if(k > 0) { // If splinter-shrink starting to change shrink = shrinkage[k]; // Get next shrink value if(n < eventscnt - 1) { // If not at last of shrunk events if(dz->brksize[SPL_SHRND]) { // possibly randomise shrinking thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_RND,dz))<0) return exit_status; } if(dz->param[SPL_SHRND] > 0.0) { // If shrink to be randomised shrinkstep = shrinkage[k+1] - shrink; // do it (shrinkkage[k+1] exists if n < eventscnt - 1) rnd = drand48() * dz->param[SPL_SHRND]; // range 0 to SPL_SHRND shrink += (shrinkstep * rnd); // Possibly expand-or-contract shrinkage } } if((exit_status = shrink_waveset(shrink,&splinterlen,dz))<0) return exit_status; // and re-shrink waveset } for(m=0;m= dz->buflen) { sprintf(errstr,"Buffer should be long enough to contain all time-sequence splinters. (2)\n"); return PROGRAM_ERROR; } } lastobufpos = thisobufpos; } // Set obufpos at end of target wavesetgrp in obuf envend = max(dz->splintoffset,dz->target) + dz->wavesetgrplen; envend = max(envend,dz->buflen); if((exit_status = normalise_buffer(envend,dz))<0) return exit_status; // WRITE REMAINDER OF INFILE if(!dz->vflag[1]) { while(dz->ssampsread > 0) { while(ibufpos < dz->ssampsread) { obuf[obufpos++] = ibuf[ibufpos++]; if(obufpos >= dz->buflen) { if((exit_status = write_samps(obuf,dz->buflen,dz))<0) return(exit_status); obufpos = 0; } } if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); ibufpos = 0; } } } else { // MODE 1 or 3: post-event splinter // IN ALL CASES we read to dz->target - dz->envwindowsize in infile and write all this to output subtarget = dz->target - dz->envwindowsize; // subtarget is 1 envelope-windowlen before target (which is start of target wavesetgroup) if(!dz->vflag[1]) { while(dz->total_samps_read < subtarget) { // Read all of src, up to the subtarget if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); if(dz->total_samps_read <= subtarget) { if((exit_status = write_samps(ibuf,dz->buflen,dz))<0) return(exit_status); } else { samps_to_write = subtarget % dz->buflen; // and write it directly to the output if((exit_status = write_samps(ibuf,samps_to_write,dz))<0) return(exit_status); } } } memset((char *)ibuf,0,dz->buflen * sizeof(float)); sndseekEx(dz->ifd[0],subtarget,0); // Seek to the subtarget dz->total_samps_read = subtarget; if((exit_status = read_samps(ibuf,dz))<0) // should read whole of remainder of sound, if buffers set up correctly!!! return(exit_status); if(dz->total_samps_read != dz->insams[0]) { sprintf(errstr,"Error in buffersize to accomodate all of end of source. total samps read = %d filesize = %d\n",dz->total_samps_read,dz->insams[0]); return PROGRAM_ERROR; } if(dz->vflag[0]) // If source remnant to be mixed into output, read all of it samps_to_read = dz->ssampsread; else // If not, read up to the target waveset and to the end of it. samps_to_read = dz->envwindowsize + dz->wavesetgrplen; memcpy((char *)obuf,(char *)ibuf,samps_to_read * sizeof(float)); maxwrite = samps_to_read; obufpos = dz->envwindowsize; // Set obufpos to START OF WAVESET GROUP (splinters are timed from this point) eventscnt = dz->iparam[SPL_SHRCNT]+dz->iparam[SPL_OCNT];// Number of events in the rit of pulses last_shrink = 0; initialobufpos = obufpos; lastobufpos = obufpos; for(n=0;n < eventscnt; n++) { // Generate splinters and every time in the timing set: (wavesetgroup time assumed to be zero) k = min(n,dz->iparam[SPL_SHRCNT]-1); // Step through sequence of shrinks as far as dz->iparam[SPL_SHRCNT], where shrink is (and remains at) max. shrink = shrinkage[k]; // Get shrink for this splinter. sampstep = (int)round(timeset[n] * srate); // Time step to next splinter, in samples thisobufpos = initialobufpos + sampstep; // Advance in outbuf to next splinter start position obufpos = thisobufpos; advance = thisobufpos - lastobufpos; if(n > 0 && n < eventscnt - 1) { if(dz->brksize[SPL_RND]) { thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_RND,dz))<0) return exit_status; } if(dz->param[SPL_RND] > 0.0) { rnd = ((drand48() * 2.0) - 1.0)/2.0; // range +1/2, -1/2 rnd *= dz->param[SPL_RND]; rndstep = (int)round(rnd * advance); obufpos += rndstep; } } if(obufpos >= dz->buflen) { sprintf(errstr,"ERROR: Buffer should be long enough to accomodate all of post-target output.(1)\n"); return PROGRAM_ERROR; } thisshrink = shrink; if(shrink != last_shrink) { // If shrink has changed, shrink the waveset if(k < dz->iparam[SPL_SHRCNT]-1) // Before last shrunk-waveset shrinkstep = shrinkage[k+1] - shrink; // Get change in shrink to next waveset // (last step is retained) if(dz->brksize[SPL_SHRND]) { // Possibly randomise the shrink value thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_SHRND,dz))<0) return exit_status; } if(dz->param[SPL_SHRND] > 0.0) { rnd = drand48() * dz->param[SPL_SHRND]; // range 0 to SPL_SHRND thisshrink += shrinkstep * rnd; // Possibly expand-or-contract shrinkage } if((exit_status = shrink_waveset(thisshrink,&splinterlen,dz))<0) return exit_status; // If the (unrandomised) shrnik is not changing } else { // use the shrunk splinter generated at last pass // UNLESS it's randomised if(n > 0 && n < eventscnt - 1) { if(dz->brksize[SPL_SHRND]) { thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_SHRND,dz))<0) return exit_status; } if(dz->param[SPL_SHRND] > 0.0) { rnd = drand48() * dz->param[SPL_SHRND]; // range 0 to SPL_SHRND thisshrink += shrinkstep * rnd; // Possibly expand-or-contract shrinkage if((exit_status = shrink_waveset(thisshrink,&splinterlen,dz))<0) return exit_status; } else if(dz->brksize[SPL_SHRND]) { // IF SHRND varies, but currently 0, still remake splinter, at unrandomised len if((exit_status = shrink_waveset(shrink,&splinterlen,dz))<0) return exit_status; } } } last_shrink = shrink; // Remember the (unrandomised) shrink value just used. if(obufpos + splinterlen >= dz->buflen) { sprintf(errstr,"ERROR: Buffer should be long enough to accomodate all of post-target output. (2)\n"); return PROGRAM_ERROR; } for(m = 0; m < splinterlen; m++) { // Add the shrunk splinter to the output obuf[obufpos] = (float)(obuf[obufpos] + shrbuf[m]); obufpos++; } lastobufpos = thisobufpos; } maxwrite = max(maxwrite,obufpos); // maxwrite = end of insams, obufpos = end of shrink-sequence if((exit_status = normalise_buffer(maxwrite,dz))<0) return exit_status; sampstep = dz->enddur; finalshrink = shrink; // Once all timed set of splinters have been written... for(n = 0; n < dz->iparam[SPL_ECNT]; n++) { // If there's any extension (splinters repeating at regular pulse) thisobufpos = lastobufpos + sampstep; // Advance (regular sampstep set previously), and check for overflow obufpos = thisobufpos; if(dz->brksize[SPL_RND]) { // Possibly randomise timing thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_RND,dz))<0) return exit_status; } if(dz->param[SPL_RND] > 0.0) { rnd = ((drand48() * 2.0) - 1.0)/2.0; // range +1/2, -1/2 rnd *= dz->param[SPL_RND]; rndstep = (int)round(rnd * sampstep); obufpos += rndstep; } if((ovflw = obufpos - dz->buflen) > 0) { if((exit_status = write_samps(obuf,dz->buflen,dz))<0) return(exit_status); memset((char *)obuf,0,dz->buflen * sizeof(float)); memcpy((char *)obuf,(char *)ovflwbuf,dz->buflen2 * sizeof(float)); memset((char *)ovflwbuf,0,dz->buflen2 * sizeof(float)); obufpos -= dz->buflen; thisobufpos -= dz->buflen; } shrink = finalshrink; if(dz->brksize[SPL_SHRND]) { // Possibly randomise shrinkage thistime = (double)(dz->total_samps_written + obufpos)/srate; if((exit_status = read_value_from_brktable(thistime,SPL_SHRND,dz))<0) return exit_status; } if(dz->param[SPL_SHRND] > 0.0) { rnd = drand48() * dz->param[SPL_SHRND]; // range 0 to SPL_SHRND shrink = finalshrink + (shrinkstep * rnd); // Possibly expand-or-contract shrinkage if((exit_status = shrink_waveset(shrink,&splinterlen,dz))<0)//and shrink waveset return exit_status; } else if(dz->brksize[SPL_SHRND]) { // Varying randomisation of shrinkage, but currently 0 if((exit_status = shrink_waveset(finalshrink,&splinterlen,dz))<0)//and shrink waveset return exit_status; } for(m = 0; m < splinterlen; m++) { // Add copy of final splinter to output obuf[obufpos] = (float)(obuf[obufpos] + shrbuf[m]); obufpos++; } lastobufpos = thisobufpos; } } if(obufpos > 0) { // Write any samples remaining in obuf. if((exit_status = write_samps(obuf,obufpos,dz))<0) return(exit_status); } return FINISHED; } /****************************** 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); } /******************************** CREATE_TEMP_SNDBUF ********************************/ int create_temp_sndbuf(dataptr dz) { int bigbufsize, secsize; int framesize = F_SECSIZE; if(dz->sbufptr == 0 || dz->sampbuf == 0) { sprintf(errstr,"buffer pointers not allocated: create_sndbufs()\n"); return(PROGRAM_ERROR); } bigbufsize = (int)Malloc(-1); // Ensure no very tiny buffs (e.g. if attack very near start of sound) dz->buflen = bigbufsize/sizeof(float); secsize = dz->buflen/framesize; if(secsize * framesize != dz->buflen) secsize++; dz->buflen = secsize * framesize; // Ensure bufsize is multiple of F_SECSIZE (256) .. ness for dz->envwindowsize calcs if(dz->buflen < 0) { sprintf(errstr,"INSUFFICIENT MEMORY to create temporary sound buffer (1).\n"); return(PROGRAM_ERROR); } bigbufsize = dz->buflen * sizeof(float); if((dz->bigbuf = (float *)malloc(bigbufsize)) == NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create temporary sound buffer (2).\n"); return(PROGRAM_ERROR); } dz->sbufptr[0] = dz->sampbuf[0] = dz->bigbuf; // Inbuf return(FINISHED); } /******************************** CREATE_SPLINTER_SNDBUFS1 ********************************/ int create_splinter_sndbufs1(dataptr dz) { int bigbufsize, secsize; int framesize = F_SECSIZE; if(dz->sbufptr == 0 || dz->sampbuf == 0) { sprintf(errstr,"buffer pointers not allocated: create_sndbufs()\n"); return(PROGRAM_ERROR); } if(dz->mode == 0 || dz->mode == 2) { // Pre-splinter Allow for src pre-splintering to be mixed with splintered material inside a single buffer dz->buflen = dz->target; // Input buffer must contain infile up to wavesetgroup dz->buflen = max(dz->buflen,dz->splintoffset); // But also, all the pre-splinters dz->buflen += dz->wavesetgrplen; // And the target wavesetgroup } else { // Post-splinter Allow for src post-splintering to be mixed with splintered material inside a single buffer dz->buflen = dz->insams[0] - dz->target; // Input buffer large enough to accomodate all of post-wavesetgroup infile dz->buflen = max(dz->buflen,dz->splintoffset); // And also all post wavesetgroup splinters } bigbufsize = (int)Malloc(-1); // Ensure no very tiny buffs (e.g. if attack very near start of sound) dz->buflen = max((unsigned int)dz->buflen,bigbufsize/sizeof(float)); secsize = dz->buflen/framesize; if(secsize * framesize != dz->buflen) secsize++; dz->buflen = secsize * framesize; // Ensure bufsize is multiple of F_SECSIZE (256) .. ness for dz->envwindowsize calcs if(dz->buflen < 0) { sprintf(errstr,"INSUFFICIENT MEMORY to create output sound buffer.\n"); return(PROGRAM_ERROR); } return(FINISHED); } /******************************** CREATE_SPLINTER_SNDBUFS2 ********************************/ int create_splinter_sndbufs2(dataptr dz) { int bigbufsize, secsize; int framesize = F_SECSIZE; dz->buflen += dz->envwindowsize * 2; // Allow for 2 bracketing envelope windows secsize = dz->buflen/framesize; if(secsize * framesize != dz->buflen) secsize++; dz->buflen = secsize * framesize; // Ensure bufsize is multiple of F_SECSIZE (256) if(dz->buflen < 0) { sprintf(errstr,"INSUFFICIENT MEMORY to create output sound buffer with eveloping brackets.\n"); return(PROGRAM_ERROR); } dz->buflen2 = dz->wavesetgrplen + 64; // Size of pre-shrunk wavesetgroup + SAFETY secsize = dz->buflen2/framesize; if(secsize * framesize != dz->buflen2) secsize++; dz->buflen2 = secsize * framesize; if(dz->buflen2 < 0) { sprintf(errstr,"INSUFFICIENT MEMORY to create wavesetgroup-storage buffer.\n"); return(PROGRAM_ERROR); } bigbufsize = ((dz->buflen * 2) + (dz->buflen2 * 3)) * sizeof(float); if((dz->bigbuf = (float *)malloc(bigbufsize)) == NULL) { sprintf(errstr,"INSUFFICIENT MEMORY to create total sound buffers.\n"); return(PROGRAM_ERROR); } dz->sbufptr[0] = dz->sampbuf[0] = dz->bigbuf; // Inbuf dz->sbufptr[1] = dz->sampbuf[1] = dz->sampbuf[0] + dz->buflen; // Outbuf dz->sbufptr[2] = dz->sampbuf[2] = dz->sampbuf[1] + dz->buflen; // Ovflwbuf dz->sbufptr[3] = dz->sampbuf[3] = dz->sampbuf[2] + dz->buflen2; // Waveset store dz->sbufptr[4] = dz->sampbuf[4] = dz->sampbuf[3] + dz->buflen2; // Shrunk-waveset store dz->sampbuf[5] = dz->sampbuf[4] + dz->buflen2; return(FINISHED); } /******************************** FIND_AND_STORE_WAVESETS ********************************/ int find_wavesets(int *initial_phase,dataptr dz) { int exit_status, changephase = 0, halfcyclecnt = 0, phase; int sampskip, secsize, ibufpos = 0, splsamps, endsample; double spltime = dz->param[SPL_TIME], srate = (double)dz->infile->srate; float *ibuf = dz->sampbuf[0]; splsamps = (int)floor(spltime * srate); // Find how far to skip into infile to find required waveset(s) secsize = dz->target/F_SECSIZE; sampskip = secsize * F_SECSIZE; // curtail to previous secsize boundary sndseekEx(dz->ifd[0],sampskip,0); // Skip into infile to (just before) time of wavesetgrp given by user dz->total_samps_read = sampskip; if((exit_status = read_samps(ibuf,dz))<0) // Read infile return(exit_status); ibufpos = splsamps - sampskip; // Position ibuf pointer to samptime given by user, then search forward for wavesetgrp start if(ibuf[ibufpos] == 0.0) { // Advance to first non-zero sample while(ibuf[ibufpos] == 0.0) { ibufpos++; if(ibufpos >= dz->ssampsread) { sampskip += dz->ssampsread; if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); if(dz->ssampsread == 0) { sprintf(errstr,"No wavesets found after time %lf\n",dz->param[SPL_TIME]); return DATA_ERROR; } else ibufpos = 0; } } if(ibuf[ibufpos] > 0.0) // then note the phase (+ve going or -ve going) phase = 1; else phase = -1; } else if(ibuf[0] > 0.0) { // Or if the signal already +ve while(ibuf[ibufpos] >= 0.0) { // advance to where signal changes phase (to -ve) ibufpos++; // and set the phase value. if(ibufpos >= dz->ssampsread) { sampskip += dz->ssampsread; if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); if(dz->ssampsread == 0) { sprintf(errstr,"No wavesets found after time %lf\n",dz->param[SPL_TIME]); return DATA_ERROR; } else ibufpos = 0; } } phase = -1; } else { // Or if the signal already -ve while(ibuf[ibufpos] <= 0.0) { // advance to where signal changes phase (to +ve) ibufpos++; // and set the phase value. if(ibufpos >= dz->ssampsread) { sampskip += dz->ssampsread; if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); if(dz->ssampsread == 0) { sprintf(errstr,"No wavesets found after time %lf\n",dz->param[SPL_TIME]); return DATA_ERROR; } else ibufpos = 0; } } phase = 1; } dz->target = sampskip + dz->total_samps_read - dz->ssampsread + ibufpos; // dz->target = sampskip + ibufpos; // Position of target wavesetgrp in infile *initial_phase = phase; while(ibufpos < dz->ssampsread) { if(++ibufpos >= dz->ssampsread) { // Advance in inbuf if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); if(dz->ssampsread == 0) { sprintf(errstr,"Insufficient wavesets found after time %lf\n",dz->param[SPL_TIME]); return DATA_ERROR; } else ibufpos = 0; } switch(phase) { case(1): if(ibuf[ibufpos] < 0.0) // If phase changes (signal crosses zero) flag a phase-change changephase = 1; break; case(-1): if(ibuf[ibufpos] > 0.0) changephase = 1; break; } if(changephase) { // If phasechange is flagged halfcyclecnt++; // Count the completed half-cycle phase = -phase; // Change the phase changephase = 0; } if(halfcyclecnt >= 2 * dz->iparam[SPL_WCNT]) // When enough half-cycles are counted, break break; } dz->quartercyclecnt = halfcyclecnt * 2; // No of quaretercycles in wavesetgroup endsample = dz->total_samps_read - dz->ssampsread + ibufpos; dz->wavesetgrplen = endsample - dz->target; return FINISHED; } /******************************** STORE_WAVESETS ********************************/ int store_wavesets(int initial_phase,dataptr dz) { int exit_status, changephase = 0, halfcyclecnt = 0, phase; int ibufpos = 0, wbufpos = 0, maxminstorecnt = 0, maxpos, maxmaxpos = 0; double maxmin, maxmaxmin; float *ibuf = dz->sampbuf[0], *wbuf = dz->sampbuf[3]; int *maxminstore = dz->lparray[0]; maxmin = 0.0; // Initialise the max(min) value and position maxpos = 0; sndseekEx(dz->ifd[0],dz->target,0); if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); ibufpos = 0; wbufpos = 0; wbuf[wbufpos++] = 0.0; phase = initial_phase; maxmaxmin = 0.0; maxmaxpos = 0; while(ibufpos < dz->ssampsread) { wbuf[wbufpos] = ibuf[ibufpos]; // Store wavesets in waveset-store if(fabs(wbuf[wbufpos]) > maxmin) { // Check for max(min) sample in the cycle maxpos = wbufpos; // noting its new position and value, if it changes maxmin = fabs(wbuf[maxpos]); } if(++ibufpos >= dz->ssampsread) { // Advance in inbuf if((exit_status = read_samps(ibuf,dz))<0) return(exit_status); ibufpos = 0; } if(++wbufpos >= dz->buflen2) { // Advance in waveset-store buffer, checking for overflow sprintf(errstr,"Waveset group exceeds %d seconds in length.\n",SPLMAXSPL); return DATA_ERROR; } switch(phase) { case(1): if(ibuf[ibufpos] < 0.0) // If phase changes (signal crosses zero) flag a phase-change changephase = 1; break; case(-1): if(ibuf[ibufpos] > 0.0) changephase = 1; break; } if(changephase) { // If phasechange is flagged if(maxmin > maxmaxmin) { maxmaxmin = maxmin; maxmaxpos = maxpos; } maxminstore[maxminstorecnt++] = maxpos; // Store position of min(max) in completed half-cycle maxmin = 0.0; // and re-initialise maxmin for next cycle maxminstore[maxminstorecnt++] = wbufpos; // Store end of completed half-cycle halfcyclecnt++; // Count the completed half-cycle phase = -phase; // Change the phase changephase = 0; } if(halfcyclecnt >= 2 * dz->iparam[SPL_WCNT]) // When enough half-cycles are stored, break break; } dz->wmaxmpos = maxmaxpos; return FINISHED; } /******************************** SHRINK_WAVESET ********************************/ int shrink_waveset(double shrink,int *splinterlen,dataptr dz) { //HEREH Shrinkage not working correctly ... output too short float *wbuf = dz->sampbuf[3], *shrbuf = dz->sampbuf[4]; int *maxminstore = dz->lparray[0]; int thispos, nextpos, samplen, n, m, thissamp, nextsamp; double dpos, incr, thisval, valdiff, frac, val, splval; int maxmincnt = 0, shrbufpos = 0, incrsteps; int prelen, postlen, preshrunk, startsamp, postshrunk, endsamp; memset((char *)shrbuf,0,dz->buflen2 * sizeof(float)); thispos = 0; switch(dz->mode) { case(0): case(1): while(maxmincnt < dz->quartercyclecnt) { nextpos = maxminstore[maxmincnt]; // Find end of next quartercycle samplen = nextpos - thispos; // Find sample-length of quartercycled if(samplen <= QCYCLEMIN) { // Don't try to shrink any quarter-cycle that is only 1 or 2 samples int incr = 1.0; incrsteps = samplen; } else { incrsteps = (int)round((double)samplen * shrink); // Approx how many sampling steps to cover this quarter-cycle incrsteps = max(QCYCLEMIN,incrsteps); // Don't shrink any quartercycle to less than QCYCLEMIN samples incr = (double)samplen/(double)incrsteps; // Readjust sampling step so its equally spaced over the quarter-cycle } dpos = (double)thispos; shrbuf[shrbufpos++] = wbuf[thispos]; // Retain the start of the quarter-cycle, and the min(max) for(n = 1;n < incrsteps;n++) { dpos += incr; // Shrink quartercycle by interpolation thissamp = (int)floor(dpos); nextsamp = thissamp + 1; thisval = wbuf[thissamp]; valdiff = wbuf[nextsamp] - thisval; frac = dpos - (double)thissamp; val = thisval + (valdiff * frac); shrbuf[shrbufpos] = (float)val; shrbufpos++; } thispos = nextpos; maxmincnt++; } break; case(2): case(3): prelen = dz->wmaxmpos; if(prelen > dz->splicelen) preshrunk = (int)round(prelen * shrink); else preshrunk = prelen; startsamp = prelen - preshrunk; postlen = dz->wavesetgrplen - dz->wmaxmpos; if(postlen > dz->splicelen) postshrunk = (int)round(postlen * shrink); else postshrunk = postlen; endsamp = dz->wmaxmpos + postshrunk; for(n = startsamp; n < endsamp;n++) shrbuf[shrbufpos++] = wbuf[n]; if(prelen > dz->splicelen) { for(n = 0; n < dz->splicelen;n++) { splval = ((double)n/(double)dz->splicelen); shrbuf[n] = (float)(shrbuf[n] * splval); } } if(postlen > dz->splicelen) { for(n = 0,m = shrbufpos-1; n < dz->splicelen;n++,m--) { splval = ((double)n/(double)dz->splicelen); shrbuf[m] = (float)(shrbuf[m] * splval); } } break; } *splinterlen = shrbufpos; // Store size of shrunk waveset return FINISHED; } /******************************** GENERATE_SHRINKAGE_SET ********************************/ int generate_shrinkage_set(dataptr dz) { int n, m, kk; double *shrinkage = dz->parray[0], shrinkcnt = dz->iparam[SPL_SHRCNT]; double temp, srate = (double)dz->infile->srate; int shrinkdiff; if(dz->mode <= 1) { dz->minlen = (int)ceil(srate/dz->param[SPL_FRQ]); // maximally-shrunk-waveset wavelen, in samples dz->minlen *= dz->iparam[SPL_WCNT]; // multiplied by number of wavesets in group if(dz->minlen >= dz->wavesetgrplen) { temp = ((double)dz->minlen/(double)dz->wavesetgrplen) * dz->param[SPL_FRQ]; sprintf(errstr,"Targeted-wavesets frq (c. %.2lf) >= goal frq (%.2lf): Cannot shrink.\n",temp,dz->param[SPL_FRQ]); return DATA_ERROR; } } else dz->minlen = (int)round(dz->param[SPL_DUR]*MS_TO_SECS*srate);//maximally-shrunk-envent length, in samples shrinkdiff = dz->wavesetgrplen - dz->minlen; // Total amount of samples lost in max shortening for(n=0,m=1; m < dz->iparam[SPL_SHRCNT];n++,m++) { shrinkage[n] = (double)m/(double)shrinkcnt; // Values >0 to <1 e.g. for 4 shrinks we get [1/4 1/2 3/4] if(!flteq(dz->param[SPL_SCURVE],1.0)) // Ditto but warped, e.g. with warp 2 [1/16 1/4 9/16] shrinkage[n] = pow(shrinkage[n],dz->param[SPL_SCURVE]); } shrinkage[n] = 1; for(n=0; n < dz->iparam[SPL_SHRCNT];n++) { shrinkage[n] *= (double)shrinkdiff; // Amount of samples lost at each step (small to large vals) shrinkage[n] = (double)dz->wavesetgrplen - shrinkage[n]; // Number of samples remaining at each step(large to small vals) shrinkage[n] = shrinkage[n]/(double)dz->wavesetgrplen; // Shrinkage at each step (large to small vals = less shrinking to more shrinking) } if(dz->mode == 0 || dz->mode == 2) { kk = dz->iparam[SPL_SHRCNT]/2; for(n = 0, m = dz->iparam[SPL_SHRCNT]-1; n < kk; n++, m--) { // Reverse shrinkage sequence for mode 0 temp = shrinkage[n]; shrinkage[n] = shrinkage[m]; shrinkage[m] = temp; } } return FINISHED; } /******************************** GENERATE_TIMING_SET ********************************/ int generate_timing_set(dataptr dz) { double *timeset = dz->parray[1]; double dur1, dur2, durdiff, sum, temp, startdur, maxstep, srate = (double)dz->infile->srate; int eventscnt, n, m, kk, isshrand = 0; int extrasamps = 0, lastdur, minlength; eventscnt = dz->iparam[SPL_SHRCNT] + dz->iparam[SPL_OCNT]; // Number of events in the rit/accel of pulses if(dz->param[SPL_PULS1] == 0) dur1 = (double)dz->wavesetgrplen/srate; else dur1 = 1.0/dz->param[SPL_PULS1]; // Pulse-rate of wavesets where they join original source if(dz->param[SPL_PULS2] == 0) dur2 = dur1; // Goal duration else dur2 = 1.0/dz->param[SPL_PULS2]; // Pulse-rate of wavesets where they start/end durdiff = dur2 - dur1; // Difference in duration for(n=0,m=1; m < eventscnt;n++,m++) { timeset[n] = (double)m/(double)eventscnt; // Values >0 to 1 e.g. for 4 steps [1/4 1/2 3/4 ] if(!flteq(dz->param[SPL_PCURVE],1.0)) // Ditto but warped e.g. by factor 2 [1/16 1/4 9/16] timeset[n] = pow(timeset[n],dz->param[SPL_PCURVE]); } timeset[n] = 1; for(n=0; n < eventscnt;n++) { timeset[n] *= (double)durdiff; // Succesive increments in event separation timeset[n] += dur1; // Succesive event separations } if(dz->mode == 0 || dz->mode == 2) { // If this is an attack (pulses before event) kk = eventscnt/2; // reverse sequence of durations. NB for kk 6/2 = 3 but 5/2 = 2 so ... for(n = 0, m = eventscnt-1; n < kk; n++, m--) { // If eventscnt even, all end events swapped with all start events temp = timeset[n]; // e.g. 6 events a:b:c:d:e:f --- swap 6/2 = 3 pairs a/f b/e c/d --> f:e:d:c:b:a timeset[n] = timeset[m]; // If eventscnt odd, middle event not swapped, remains where it is timeset[m] = temp; // e.g. 5 events a:b:c:d:e ----- swap 5/2 = 2 pairs a/e b/d --> e:d:c:b:a } } if(dz->mode == 0 || dz->mode == 2) { //Splinters BEFORE wavesetgroup startdur = timeset[0]; // Remember duration of first step between splinters sum = 0.0; for(n=0; n < eventscnt;n++) { // Progressively sum event-separations to get relative times temp = timeset[n]; // time[0] gets zero timeset[n] = sum; // time[1] gets separation[0] sum += temp; // time[2] gets separation[0] + separation[1] } // time[3] gets separation[0] + separation[1] + separation[2] etc. // sum ends up as sum of all event-separations, so dz->splintoffset = (int)round(sum * srate); // "splintoffset" gets time where wavesetgroup starts if(dz->iparam[SPL_ECNT] > 0) { // If there's an extension (extra regular pulsed splinters before timeset begins) extrasamps = (int)round(startdur * srate); // Add their duration to "splintoffset" extrasamps *= dz->iparam[SPL_ECNT]; dz->splintoffset += extrasamps; // This is distance from splinter start to wavesetgrp, in output } } else { dz->enddur = (int)round(dur2 * srate); // Find duration of last step between splinters sum = 0.0; maxstep = 0.0; for(n=0; n < eventscnt;n++) { // Progressively sum event-separations to get relative times maxstep = max(maxstep,timeset[n]); sum += timeset[n]; // so time[0] gets separation[0] ... i.e. it is separation[0] AFTER the src-wavesetgroup timeset[n] = sum; // time[1] gets separation[0] + separation[1] } // time[2] gets separation[0] + separation[1] + separation[2] etc. dz->splintoffset = (int)ceil(sum * srate); // "splintoffset" gets time where last splinter of sequence starts dz->splintoffset += (int)ceil(maxstep * srate); // This is AT LEAST length of last splinter in sequence dz->splintoffset += (int)ceil(maxstep * srate); // This allows for posssible randomisation lastdur = dz->enddur; if(dz->brksize[SPL_RND] || dz->param[SPL_RND] > 0.0) // Allow for maximal (random) contraction of step between events lastdur = (int)floor(dz->enddur * 0.5); if(dz->brksize[SPL_SHRND] || dz->param[SPL_SHRND] > 0.0) { // Allow for maximal (random) expansion of pulse-size minlength = (int)ceil(dz->minlen * 1.5); isshrand = 1; } else minlength = dz->minlen; if(lastdur <= minlength) { if(dz->mode == 1) { if(isshrand) sprintf(errstr,"Final pulse-rate may cause randomised-length of max-shrunk pulses to overlap. Reduce rate or increase pulse frq.\n"); else sprintf(errstr,"Final pulse-rate causes max-shrunk pulses to overlap. Reduce rate or increase pulse frq.\n"); } else { if(isshrand) sprintf(errstr,"Final pulse-rate may cause randomised-length of max-shrunk pulses to overlap. Reduce rate or reduce pulse duration.\n"); else sprintf(errstr,"Final pulse-rate causes max-shrunk pulses to overlap. Reduce rate or reduce pulse duration.\n"); } return DATA_ERROR; } } return FINISHED; } /******************************** NORMALISE_BUFFER ********************************/ int normalise_buffer(int windowing_end,dataptr dz) { double *env = dz->parray[2], maxsamp, thiseval, nexteval, diff, eval; float *obuf = dz->sampbuf[1]; int *loc = dz->iparray[0]; int e, n, m, k, envsize, maxloc, windowstart, thispos, goalpos, samppos, gap; int needs_enveloping = 0, ethis, enext, done; int halfwindow = dz->envwindowsize/2; do { // For all the normalisable samples, advance by windowlen blocks for(n = 0,e = 0; n < windowing_end; n+=dz->envwindowsize,e++) { maxsamp = 0.0; maxloc = 0; for(m=0,k=n;m < dz->envwindowsize;m++,k++) { // In each window, find the maxsamp if(fabs(obuf[k]) > maxsamp) { maxsamp = fabs(obuf[k]); maxloc = m; } } if(e >= dz->arraysize) { sprintf(errstr,"envelope arraysize exceeded.\n"); return PROGRAM_ERROR; } env[e] = maxsamp; // And store the envelope val loc[e] = maxloc; // And position of maximum } envsize = e; env[e] = 0.0; // wrap-around point at end loc[e] = halfwindow; needs_enveloping = 0; for(e = 0;e <= envsize;e++) { // Check where signal exceeds max (0.95) if(env[e] > 0.95) { // and force (re-)envelope to reduce level here env[e] = 0.95/env[e]; needs_enveloping = 1; // AND note the re-envelopeing is necessary } else // otherwise leave envelope level at 1.0 (no change) env[e] = 1.0; } if(needs_enveloping) { // If enveloping required ethis = -1; // Interpolate the re-envelope vals, in order to envelope the src, in situ enext = 0; done = 0; for(windowstart = 0; windowstart < windowing_end; windowstart+=dz->envwindowsize) { ethis++; enext++; thiseval = env[ethis]; nexteval = env[enext]; if(thiseval < 1.0 && nexteval == 1.0) { thispos = windowstart + loc[ethis]; // Interp from maximum in this-window to middle of non-normalised next-window goalpos = windowstart + dz->envwindowsize + halfwindow; } else if(thiseval == 1.0 && nexteval < 1.0) { thispos = windowstart + halfwindow; // Interp from middle of non-normalised this-window to maximum in next goalpos = windowstart + dz->envwindowsize + loc[enext]; } else if(thiseval < 1.0 && nexteval < 1.0) { thispos = windowstart + loc[ethis]; // Interp from max in this window to max in next goalpos = windowstart + dz->envwindowsize + loc[enext]; } else { // (thiseval == 1.0 && nexteval == 1.0) do nothing continue; } samppos = thispos; gap = goalpos - thispos; diff = nexteval - thiseval; for(m=0;m < gap;m++,samppos++) { if(samppos >= dz->buflen) { done = 1; break; } eval = (double)m/(double)gap; eval *= diff; eval += thiseval; obuf[samppos] = (float)(obuf[samppos] * eval); } if(done) break; } } } while(needs_enveloping); // Do this recursively until nothing is too loud return FINISHED; }