/* * 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 #include #include #include #include #include #include #include #include #include #include #include #include //TW ADDED #include //#ifdef unix #define round(x) lround((x)) //#endif static int set_output_header_properties(dataptr dz); static int pt_datareduce(double **q,double sharp,double flat,double *thisarray,int *bsize); static int incremental_pt_datareduction(int array_no,int *bsize,double sharpness,dataptr dz); /* OTHER */ static int print_screen_message(void); /* AUGUST 2000 */ unsigned int superzargo; /***************************** COMPLETE_OUTPUT *******************************/ int complete_output(dataptr dz) { if(dz->process_type==PITCH_TO_PITCH || dz->process_type==PITCH_TO_BIGPITCH) { if(dz->is_transpos) dz->outfiletype = TRANSPOS_OUT; else dz->outfiletype = PITCH_OUT; } switch(dz->process_type) { case(UNEQUAL_SNDFILE): case(BIG_ANALFILE): case(UNEQUAL_ENVFILE): case(CREATE_ENVFILE): case(EXTRACT_ENVFILE): case(PITCH_TO_ANAL): case(ANAL_TO_FORMANTS): case(PITCH_TO_BIGPITCH): case(PSEUDOSNDFILE): //TW No longer used: // if((exit_status = truncate_outfile(dz))<0) // return(exit_status); /* fall thro */ case(EQUAL_ANALFILE): case(MAX_ANALFILE): case(MIN_ANALFILE): case(EQUAL_FORMANTS): case(EQUAL_SNDFILE): case(EQUAL_ENVFILE): case(PITCH_TO_PITCH): case(PITCH_TO_PSEUDOSND): return headwrite(dz->ofd,dz); break; case(SCREEN_MESSAGE): return print_screen_message(); case(ANAL_TO_PITCH): sprintf(errstr,"ANAL_TO_PITCH process_type (%d) in complete_output()\n",dz->process_type); return(PROGRAM_ERROR); case(TO_TEXTFILE): if(fclose(dz->fp)<0) { fprintf(stdout,"WARNING: Failed to close output textfile.\n"); fflush(stdout); } break; case(OTHER_PROCESS): break; default: sprintf(errstr,"Unknown process_type (%d) in complete_output()\n",dz->process_type); return(PROGRAM_ERROR); } return(FINISHED); } /***************************** TRUNCATE_OUTFILE *******************************/ #ifdef NOTDEF int truncate_outfile(dataptr dz) { if(sfadjust(dz->ofd,dz->total_bytes_written - dz->outfilesize)<0) { sprintf(errstr,"Cannot truncate output file (Is hard-disk full?).\n"); return(SYSTEM_ERROR); } return(FINISHED); } #endif /***************************** HEADWRITE *******************************/ int headwrite(int ofd,dataptr dz) { int exit_status; int isenv = 1; int property_marker = 1; // int samptype, srate, channels; float window_size = 0.0f; if(!(dz->process == PVOC_ANAL || dz->process == PVOC_EXTRACT || dz->process == PVOC_SYNTH)) { if((exit_status = set_output_header_properties(dz))<0) return(exit_status); } switch(dz->outfiletype) { case(FORMANTS_OUT): if(sndputprop(ofd,"specenvcnt", (char *)&(dz->outfile->specenvcnt), sizeof(int)) < 0){ sprintf(errstr,"Failure to write specenvcnt: headwrite()\n"); return(PROGRAM_ERROR); } /* drop through */ case(PITCH_OUT): case(TRANSPOS_OUT): if(sndputprop(ofd,"orig channels", (char *)&(dz->outfile->origchans), sizeof(int)) < 0){ sprintf(errstr,"Failure to write original channel data: headwrite()\n"); return(PROGRAM_ERROR); } /* drop through */ case(ANALFILE_OUT): if(sndputprop(ofd,"original sampsize", (char *)&(dz->outfile->origstype), sizeof(int)) < 0){ sprintf(errstr,"Failure to write original sample size. headwrite()\n"); return(PROGRAM_ERROR); } if(sndputprop(ofd,"original sample rate", (char *)&(dz->outfile->origrate), sizeof(int)) < 0){ sprintf(errstr,"Failure to write original sample rate. headwrite()\n"); return(PROGRAM_ERROR); } if(sndputprop(ofd,"arate",(char *)&(dz->outfile->arate),sizeof(float)) < 0){ sprintf(errstr,"Failed to write analysis sample rate. headwrite()\n"); return(PROGRAM_ERROR); } if(sndputprop(ofd,"analwinlen",(char *)&(dz->outfile->Mlen),sizeof(int)) < 0){ sprintf(errstr,"Failure to write analysis window length. headwrite()\n"); return(PROGRAM_ERROR); } if(sndputprop(ofd,"decfactor",(char *)&(dz->outfile->Dfac),sizeof(int)) < 0){ sprintf(errstr,"Failure to write decimation factor. headwrite()\n"); return(PROGRAM_ERROR); } /* drop through */ case(SNDFILE_OUT): //TW these properties can either be created at the outset (sndcreat_formatted() // in which case they are not alterable here. // or they can be left open (sndcreat e.g. for PITCH, or CUT for dz->otherfile) sndputprop(ofd,"sample rate", (char *)&(dz->outfile->srate), sizeof(int)); sndputprop(ofd,"channels", (char *)&(dz->outfile->channels), sizeof(int)); break; case(ENVFILE_OUT): // samptype = SAMP_FLOAT; // srate = round(SECS_TO_MS/dz->outfile->window_size); // channels = 1; window_size = dz->outfile->window_size; /* JUNE 2004 if(sndputprop(ofd,"sample rate", (char *)&srate, sizeof(int)) < 0){ sprintf(errstr,"Failure to write sample rate. headwrite()\n"); return(PROGRAM_ERROR); } if(sndputprop(ofd,"channels", (char *)&channels, sizeof(int)) < 0){ sprintf(errstr,"Failure to write channel data. headwrite()\n"); return(PROGRAM_ERROR); } */ if(sndputprop(ofd,"is an envelope",(char *)&isenv, sizeof(int)) < 0){ sprintf(errstr,"Failure to write envelope property. headwrite()\n"); return(PROGRAM_ERROR); } if(sndputprop(ofd,"window size", (char *)(&window_size), sizeof(float)) < 0) { sprintf(errstr,"Failure to write window size. headwrite()\n"); return(DATA_ERROR); } break; default: sprintf(errstr,"Unknown outfile type: headwrite()\n"); return(PROGRAM_ERROR); } switch(dz->outfiletype) { case(PITCH_OUT): if(sndputprop(ofd,"is a pitch file", (char *)&property_marker, sizeof(int)) < 0){ sprintf(errstr,"Failure to write pitch property: headwrite()\n"); return(PROGRAM_ERROR); } break; case(TRANSPOS_OUT): if(sndputprop(ofd,"is a transpos file", (char *)&property_marker, sizeof(int)) < 0){ sprintf(errstr,"Failure to write transposition property: headwrite()\n"); return(PROGRAM_ERROR); } break; case(FORMANTS_OUT): if(sndputprop(ofd,"is a formant file", (char *)&property_marker, sizeof(int)) < 0){ sprintf(errstr,"Failure to write formant property: headwrite()\n"); return(PROGRAM_ERROR); } break; } return(FINISHED); } /***************************** SET_OUTPUT_HEADER_PROPERTIES ******************************/ int set_output_header_properties(dataptr dz) { switch(dz->process_type) { case(EQUAL_SNDFILE): case(UNEQUAL_SNDFILE): case(EQUAL_ENVFILE): case(UNEQUAL_ENVFILE): dz->outfile->channels = dz->infile->channels; dz->outfile->srate = dz->infile->srate; dz->outfile->stype = dz->infile->stype; break; case(EXTRACT_ENVFILE): case(CREATE_ENVFILE): break; case(PSEUDOSNDFILE): /* Assumption of conversion from anal,formant,pitch or transpos filetype */ case(PITCH_TO_PSEUDOSND): dz->outfile->channels = 1; dz->outfile->srate = dz->infile->origrate; dz->outfile->stype = SAMP_SHORT; break; case(ANAL_TO_FORMANTS): dz->outfile->specenvcnt= dz->infile->specenvcnt; /* fall through */ case(ANAL_TO_PITCH): dz->outfile->origchans = dz->infile->channels; dz->outfile->channels = 1; dz->outfile->origstype = dz->infile->origstype; dz->outfile->origrate = dz->infile->origrate; dz->outfile->arate = dz->infile->arate; dz->outfile->Mlen = dz->infile->Mlen; dz->outfile->Dfac = dz->infile->Dfac; dz->outfile->srate = dz->infile->srate; dz->outfile->stype = dz->infile->stype; break; case(EQUAL_FORMANTS): dz->outfile->specenvcnt = dz->infile->specenvcnt; /* fall through */ case(PITCH_TO_PITCH): case(PITCH_TO_BIGPITCH): dz->outfile->origchans = dz->infile->origchans; /* fall through */ case(EQUAL_ANALFILE): case(MAX_ANALFILE): case(MIN_ANALFILE): case(BIG_ANALFILE): case(PITCH_TO_ANAL): dz->outfile->origstype = dz->infile->origstype; dz->outfile->origrate = dz->infile->origrate; dz->outfile->arate = dz->infile->arate; dz->outfile->Mlen = dz->infile->Mlen; dz->outfile->Dfac = dz->infile->Dfac; dz->outfile->srate = dz->infile->srate; dz->outfile->stype = dz->infile->stype; if(dz->process_type==PITCH_TO_ANAL) dz->outfile->channels = dz->infile->origchans; else dz->outfile->channels = dz->infile->channels; break; case(TO_TEXTFILE): case(SCREEN_MESSAGE): break; default: sprintf(errstr,"Unknown process: set_output_header_properties()\n"); return(PROGRAM_ERROR); } return(FINISHED); } /***************************** WRITE_EXACT_SAMPS ****************************** * * Writes a block of known length to file area of same length. * Checks it has all been written. */ #ifdef NOTDEF int write_exact_bytes(char *buffer,int bytes_to_write,dataptr dz) { int pseudo_bytes_to_write = bytes_to_write; int secs_to_write = bytes_to_write/SECSIZE; int bytes_written; if((secs_to_write * SECSIZE)!=bytes_to_write) { secs_to_write++; pseudo_bytes_to_write = secs_to_write * SECSIZE; } if((bytes_written = sfwrite(dz->ofd, buffer, pseudo_bytes_to_write))<0) { sprintf(errstr, "Can't write to output soundfile: (is hard-disk full?).\n"); return(SYSTEM_ERROR); } if(bytes_written != bytes_to_write) { sprintf(errstr, "Incorrect number of bytes written\nbytes_written = %ld\n" "bytes_to_write = %ld\n (is hard-disk full?).\n", bytes_written,bytes_to_write); return(SYSTEM_ERROR); } dz->total_bytes_written += bytes_to_write; display_virtual_time(dz->total_bytes_written,dz); return(FINISHED); } #else int write_exact_samps(float *buffer,int samps_to_write,dataptr dz) { int i,j; int samps_written; float val; if(dz->needpeaks){ for(i=0;i < samps_to_write; i += dz->outchans){ for(j = 0;j < dz->outchans;j++){ val = (float)fabs(buffer[i+j]); /* this way, posiiton of first peak value is stored */ if(val > dz->outpeaks[j].value){ dz->outpeaks[j].value = val; dz->outpeaks[j].position = dz->outpeakpos[j]; } } /* count framepos */ for(j=0;j < dz->outchans;j++) dz->outpeakpos[j]++; } } if((samps_written = fputfbufEx(buffer, samps_to_write,dz->ofd))<=0) { sprintf(errstr, "Can't write to output soundfile: %s\n",sferrstr()); return(SYSTEM_ERROR); } if(samps_written != samps_to_write) { sprintf(errstr, "Incorrect number of samples written\nsamps_written = %d\n" "samps_to_write = %d\n (is hard-disk full?).\n", samps_written,samps_to_write); return(SYSTEM_ERROR); } dz->total_samps_written += samps_to_write; display_virtual_time(dz->total_samps_written,dz); return(FINISHED); } #endif #ifdef NOTDEF /*************************** WRITE_SAMPS ***********************/ int write_bytes(char *bbuf,int bytes_to_write,dataptr dz) { int pseudo_bytes_to_write = bytes_to_write; int secs_to_write = bytes_to_write/SECSIZE; int bytes_written; if((secs_to_write * SECSIZE)!=bytes_to_write) { secs_to_write++; pseudo_bytes_to_write = secs_to_write * SECSIZE; } if((bytes_written = sfwrite(dz->ofd,bbuf,pseudo_bytes_to_write))<0) { sprintf(errstr,"Can't write to output soundfile: (is hard-disk full?).\n"); return(SYSTEM_ERROR); } dz->total_bytes_written += bytes_to_write; dz->total_samps_written = dz->total_bytes_written/sizeof(short); /* IRRELEVANT TO SPEC */ display_virtual_time(dz->total_bytes_written,dz); return(FINISHED); } #else int write_samps(float *bbuf,int samps_to_write,dataptr dz) { int samps_written; int i,j; float val; if(dz->needpeaks){ for(i=0;i < samps_to_write; i += dz->outchans){ for(j = 0;j < dz->outchans;j++){ val = (float)fabs(bbuf[i+j]); /* this way, posiiton of first peak value is stored */ if(val > dz->outpeaks[j].value){ dz->outpeaks[j].value = val; dz->outpeaks[j].position = dz->outpeakpos[j]; } } /* count framepos */ for(j=0;j < dz->outchans;j++) dz->outpeakpos[j]++; } } if((samps_written = fputfbufEx(bbuf,samps_to_write,dz->ofd))<=0) { sprintf(errstr,"Can't write to output soundfile: %s\n",sferrstr()); return(SYSTEM_ERROR); } dz->total_samps_written += samps_written; display_virtual_time(dz->total_samps_written,dz); return(FINISHED); } #endif /*************************** WRITE_SAMPS_NO_REPORT ***********************/ #ifdef NOTDEF int write_bytes_no_report(char *bbuf,int bytes_to_write,dataptr dz) { int pseudo_bytes_to_write = bytes_to_write; int secs_to_write = bytes_to_write/SECSIZE; int bytes_written; if((secs_to_write * SECSIZE)!=bytes_to_write) { secs_to_write++; pseudo_bytes_to_write = secs_to_write * SECSIZE; } if((bytes_written = sfwrite(dz->ofd,bbuf,pseudo_bytes_to_write))<0) { sprintf(errstr,"Can't write to output soundfile: (is hard-disk full?).\n"); return(SYSTEM_ERROR); } dz->total_bytes_written += bytes_to_write; dz->total_samps_written = dz->total_bytes_written/sizeof(short); /* IRRELEVANT TO SPEC */ return(FINISHED); } #else int write_samps_no_report(float *bbuf,int samps_to_write,int *samps_written,dataptr dz) { int i; int j; float val; if(dz->needpeaks){ for(i=0;i < samps_to_write; i += dz->outchans){ for(j = 0;j < dz->outchans;j++){ val = (float)fabs(bbuf[i+j]); /* this way, posiiton of first peak value is stored */ if(val > dz->outpeaks[j].value){ dz->outpeaks[j].value = val; dz->outpeaks[j].position = dz->outpeakpos[j]; } } /* count framepos */ for(j=0;j < dz->outchans;j++) dz->outpeakpos[j]++; } } if((*samps_written = fputfbufEx(bbuf,samps_to_write,dz->ofd))<=0) { sprintf(errstr,"Can't write to output soundfile: %s\n",sferrstr()); return(SYSTEM_ERROR); } dz->total_samps_written += samps_to_write; return(FINISHED); } #endif /*********************** DISPLAY_VIRTUAL_TIME *********************/ void display_virtual_time(int samps_sent,dataptr dz) { int mins; double secs = 0.0; int startwindow, endwindow, windows_to_write, total_samps_to_write = 0, maxlen, minlen, offset; unsigned int zargo = 0; int n, display_time; double float_time = 0.0; if(sloombatch) return; if(!sloom) { if(dz->process==HOUSE_COPY && dz->mode==COPYSF) secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels); else { switch(dz->outfiletype) { case(NO_OUTPUTFILE): if(dz->process==MIXMAX) secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels); else return; case(SNDFILE_OUT): secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels); break; case(ANALFILE_OUT): secs = (double)(samps_sent/dz->wanted) * dz->frametime; break; case(PITCH_OUT): case(TRANSPOS_OUT): secs = (double)(samps_sent) * dz->frametime; break; case(FORMANTS_OUT): secs = (double)((samps_sent - dz->descriptor_samps)/dz->infile->specenvcnt) * dz->frametime; break; case(ENVFILE_OUT): secs = (double)(samps_sent) * dz->outfile->window_size * MS_TO_SECS; break; case(TEXTFILE_OUT): switch(dz->process) { case(INFO_PRNTSND): secs = (double)samps_sent/(double)(dz->infile->srate * dz->infile->channels); break; } break; } } mins = (int)(secs/60.0); /* TRUNCATE */ secs -= (double)(mins * 60); fprintf(stdout,"\r%d min %5.2lf sec", mins, secs); fflush(stdout); } else { switch(dz->process_type) { case(EQUAL_ANALFILE): float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; case(MAX_ANALFILE): switch(dz->process) { case(MAX): /* file 0 is forced to be largest by program */ float_time = (double)samps_sent/(double)dz->insams[0]; break; default: maxlen = dz->insams[0]; for(n=1;ninfilecnt;n++) maxlen = max(maxlen,dz->insams[n]); float_time = (double)samps_sent/(double)maxlen; break; } break; case(MIN_ANALFILE): minlen = dz->insams[0]; for(n=1;ninfilecnt;n++) minlen = min(minlen,dz->insams[n]); float_time = (double)samps_sent/(double)minlen; break; case(BIG_ANALFILE): switch(dz->process) { case(CUT): startwindow = (int)(dz->param[CUT_STIME]/dz->frametime); endwindow = (int)(dz->param[CUT_ETIME]/dz->frametime); endwindow = min(endwindow,dz->wlength); windows_to_write = endwindow - startwindow; total_samps_to_write = windows_to_write * dz->wanted; float_time = (double)samps_sent/(double)total_samps_to_write; break; case(GRAB): total_samps_to_write = dz->wanted; float_time = (double)samps_sent/(double)total_samps_to_write; break; case(MAGNIFY): windows_to_write = dz->total_windows + 1; total_samps_to_write = windows_to_write * dz->wanted; float_time = (double)samps_sent/(double)total_samps_to_write; break; case(TSTRETCH): case(SHUFFLE): case(WEAVE): case(WARP): case(FORM): float_time = (double)dz->total_samps_read/(double)dz->insams[0]; break; case(DRUNK): total_samps_to_write = round((dz->param[DRNK_DUR]/dz->frametime) * dz->wanted); float_time = min((double)samps_sent/(double)total_samps_to_write,1.0); break; case(GLIDE): //TW total_samps_to_write = dz->wlength * dz->sampswanted; total_samps_to_write = dz->wlength * dz->wanted; float_time = (double)samps_sent/(double)total_samps_to_write; break; case(BRIDGE): offset = round(dz->param[BRG_OFFSET]/dz->frametime) * dz->wanted; switch(dz->iparam[BRG_TAILIS]) { case(0): case(1): total_samps_to_write = dz->insams[0]; break; case(2): total_samps_to_write = offset + dz->insams[1]; break; case(3): total_samps_to_write = min(dz->insams[0],offset + dz->insams[1]); break; } float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(MORPH): total_samps_to_write = (dz->iparam[MPH_STAGW] * dz->wanted) + dz->insams[1]; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(SYNTH_SPEC): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(CLICK): if(samps_sent < 0) samps_sent = INT_MAX; float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; default: float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; } break; case(ANAL_TO_FORMANTS): float_time = (double)dz->total_samps_read/(double)dz->insams[0]; break; case(PSEUDOSNDFILE): switch(dz->process) { case(FMNTSEE): case(FORMSEE): case(LEVEL): float_time = (double)dz->total_samps_read/(double)dz->insams[0]; break; } break; case(PITCH_TO_ANAL): switch(dz->process) { case(MAKE): //TW NEW CASE case(MAKE2): /* windows_to_write = dz->wlength, in this case based on specenvcnt-len formant-windows */ total_samps_to_write = dz->wlength * (dz->infile->origchans); float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; //TW NEW CASES ADDED, therefore // case(P_HEAR): default: /* windows_to_write = dz->insams[0] as each pitch is converted to a window */ total_samps_to_write = dz->insams[0] * dz->wanted; float_time = (double)samps_sent/(double)total_samps_to_write; break; } break; case(PITCH_TO_PSEUDOSND): total_samps_to_write = dz->insams[0]; float_time = (double)samps_sent/(double)total_samps_to_write; break; case(UNEQUAL_SNDFILE): switch(dz->process) { case(DISTORT_AVG): case(DISTORT_MLT): case(DISTORT_DIV): case(DISTORT_HRM): case(DISTORT_FRC): case(DISTORT_REV): case(DISTORT_SHUF): case(DISTORT_RPT): case(DISTORT_INTP): case(DISTORT_DEL): case(DISTORT_RPL): case(DISTORT_TEL): case(DISTORT_FLT): case(DISTORT_PCH): //TW NEW CASE case(DISTORT_OVERLOAD): case(DISTORT_RPT2): case(GRAIN_OMIT): case(GRAIN_DUPLICATE): case(GRAIN_REORDER): case(GRAIN_REPITCH): case(GRAIN_RERHYTHM): case(GRAIN_REMOTIF): case(GRAIN_TIMEWARP): case(GRAIN_POSITION): case(GRAIN_ALIGN): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; //TW NEW CASE case(DISTORT_PULSED): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(GRAIN_REVERSE): float_time = (double)dz->total_samps_written/(double)dz->insams[0]; break; case(TOPNTAIL_CLICKS): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->tempsize); break; case(DISTORT_INT): total_samps_to_write = (dz->insams[0] + dz->insams[1]) >> 1;/* averaged,as is bytes_read !! */ float_time = min(1.0,(double)dz->total_samps_read/(double)total_samps_to_write); break; case(HF_PERM1): case(HF_PERM2): zargo = superzargo + samps_sent; float_time = min(1.0,(double)zargo/(double)dz->tempsize); break; case(SCRAMBLE): total_samps_to_write = dz->iparam[SCRAMBLE_OUTLEN]; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(DRUNKWALK): total_samps_to_write = dz->iparam[DRNK_TOTALDUR]; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(SIMPLE_TEX): case(TIMED): case(GROUPS): case(TGROUPS): case(DECORATED): case(PREDECOR): case(POSTDECOR): case(ORNATE): case(PREORNATE): case(POSTORNATE): case(MOTIFS): case(TMOTIFS): case(MOTIFSIN): case(TMOTIFSIN): total_samps_to_write = round(dz->param[TEXTURE_DUR] * dz->infile->srate) * STEREO; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(TEX_MCHAN): total_samps_to_write = round(dz->param[TEXTURE_DUR] * dz->infile->srate) * dz->iparam[TEXTURE_OUTCHANS]; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(ENV_CURTAILING): total_samps_to_write = round(dz->param[ENV_ENDTIME] * dz->infile->srate) * dz->infile->channels; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(ENV_IMPOSE): /* In these cases the 'bytes_sent' may be bytes_written or bytes_read */ case(ENV_REPLACE): //TW NEW CASE case(ENV_PROPOR): float_time = (double)samps_sent/(double)dz->insams[0]; break; case(ENV_PLUCK): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; case(EQ): case(LPHP): case(FSTATVAR): case(FLTBANKN): //TW UPDATE case(FLTBANKU): case(FLTSWEEP): case(ALLPASS): total_samps_to_write = dz->insams[0] + (round(FLT_TAIL * (double)dz->infile->srate) * dz->infile->channels); float_time = (double)samps_sent/(double)total_samps_to_write; break; case(FLTBANKV): total_samps_to_write = dz->insams[0] + ( round(dz->param[FILT_TAILV] * (double)dz->infile->srate) * dz->infile->channels); float_time = (double)samps_sent/(double)total_samps_to_write; break; case(FLTITER): total_samps_to_write = dz->iparam[FLT_OUTDUR]; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(MIXCROSS): float_time = min(1.0,(double)samps_sent/(double)(dz->iparam[MCR_STAGGER] + dz->insams[1])); break; case(MIXINTERL): total_samps_to_write = dz->insams[0]; for(n=0;ninfilecnt;n++) total_samps_to_write = max(total_samps_to_write,dz->insams[n]); total_samps_to_write *= dz->infilecnt; float_time = min(1.0,(double)samps_sent/(double)total_samps_to_write); break; case(MIX): case(MIXMULTI): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; //TW NEW CASES case(HOUSE_BAKUP): case(SEQUENCER): case(SEQUENCER2): case(RRRR_EXTEND): case(CONVOLVE): case(BAKTOBAK): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(MOD_PITCH): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; case(MOD_REVECHO): if(dz->mode==MOD_STADIUM) float_time = min(1.0,(double)samps_sent/(double)(dz->insams[0] * 2)); else float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; case(MOD_SPACE): if(dz->mode==MOD_PAN) float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); else float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; //TW NEW CASE case(SCALED_PAN): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; case(MOD_RADICAL): switch(dz->mode) { case(MOD_SCRUB): float_time = min(1.0,(double)dz->total_samps_written/(double)dz->iparam[SCRUB_TOTALDUR]); break; case(MOD_CROSSMOD): float_time = (double)samps_sent/(double)dz->tempsize; break; default: float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; } break; case(PVOC_SYNTH): case(EDIT_CUT): case(EDIT_CUTEND): case(EDIT_ZCUT): case(EDIT_EXCISE): case(EDIT_EXCISEMANY): case(EDIT_INSERT): case(EDIT_INSERTSIL): case(EDIT_JOIN): case(HOUSE_CHANS): case(HOUSE_ZCHANNEL): case(STOM): case(MTOS): case(ZIGZAG): case(LOOP): case(ITERATE): /* case(HOUSE_BAKUP): */ case(DEL_PERM): case(DEL_PERM2): case(MIXTWO): case(MIXBALANCE): case(HOUSE_SPEC): case(SYNTH_SPEC): case(JOIN_SEQ): case(JOIN_SEQDYN): case(ACC_STREAM): case(ITERATE_EXTEND): case(STACK): case(SYNTH_WAVE): case(SYNTH_NOISE): case(SYNTH_SIL): case(MULTI_SYN): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(DOUBLETS): if(samps_sent < 0) samps_sent = INT_MAX; float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(AUTOMIX): case(MIXMANY): case(EDIT_INSERT2): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(BRASSAGE): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; case(TWIXT): case(SPHINX): float_time = min(1.0,(double)superzargo/(double)dz->tempsize); break; case(EDIT_CUTMANY): case(MANY_ZCUTS): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; case(GREV): float_time = min(1.0,(double)dz->total_samps_written/(double)dz->tempsize); break; default: float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; } break; case(EQUAL_SNDFILE): switch(dz->process) { case(HOUSE_CHANS): //TW NEW CASE case(TIME_GRID): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; //TW NEW CASE case(SHUDDER): float_time = min(1.0,(double)dz->total_samps_written/(double)dz->tempsize); break; case(MOD_RADICAL): if(dz->mode == MOD_SHRED) { /* based on number of shreds completed */ /*RWD NB: SHRED_CNT was in bytes --- make sure it is now in samps */ float_time = min(1.0,(double)samps_sent/(double)dz->iparam[SHRED_CNT]); } /* fall thro */ default: float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; } break; case(EXTRACT_ENVFILE): /* In these cases the 'bytes_sent' is bytes_read */ float_time = (double)samps_sent/(double)dz->insams[0]; break; case(OTHER_PROCESS): switch(dz->process) { case(HOUSE_EXTRACT): case(HOUSE_GATE): float_time = (double)samps_sent/(double)dz->insams[0]; break; case(MIXINBETWEEN): case(CYCINBETWEEN): total_samps_to_write = max(dz->insams[0],dz->insams[1]); float_time = (double)samps_sent/(double)total_samps_to_write; break; case(HOUSE_COPY): switch(dz->mode) { case(COPYSF): float_time = (double)samps_sent/(double)dz->insams[0]; break; case(DUPL): superzargo += samps_sent; float_time = min(1.0,(double)superzargo/(double)dz->tempsize); break; } break; /* NEW */ case(INFO_DIFF): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; } break; case(TO_TEXTFILE): switch(dz->process) { case(INFO_PRNTSND): zargo = (dz->iparam[PRNT_END] - dz->iparam[PRNT_START]); float_time = min(1.0,(double)samps_sent/(double)zargo); break; case(HOUSE_EXTRACT): float_time = min(1.0,(double)samps_sent/(double)dz->insams[0]); break; case(GRAIN_GET): float_time = min(1.0,(double)dz->total_samps_read/(double)dz->insams[0]); break; } break; case(SCREEN_MESSAGE): switch(dz->process) { case(MIXMAX): case(FIND_PANPOS): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; } break; case(CREATE_ENVFILE): switch(dz->process) { case(ENVSYN): float_time = min(1.0,(double)samps_sent/(double)dz->tempsize); break; } } display_time = round(float_time * PBAR_LENGTH); fprintf(stdout,"TIME: %d\n",display_time); fflush(stdout); } } /***************************** PRINT_SCREEN_MESSAGE **************************/ int print_screen_message(void) { if(!sloom && !sloombatch) /*TW May 2001 */ fprintf(stdout,"%s",errstr); else splice_multiline_string(errstr,"INFO:"); fflush(stdout); return(FINISHED); } /***************************** WRITE_SAMPS_TO_ELSEWHERE ****************************** * * Allows bytes to be written to files other than standard outfile. * No byte-count checking. */ #ifdef NOTDEF int write_bytes_to_elsewhere(int ofd, char *buffer,int bytes_to_write,dataptr dz) { int pseudo_bytes_to_write = bytes_to_write; int secs_to_write = bytes_to_write/SECSIZE; int bytes_written; if((secs_to_write * SECSIZE)!=bytes_to_write) { secs_to_write++; pseudo_bytes_to_write = secs_to_write * SECSIZE; } if((bytes_written = sfwrite(ofd, (char *)buffer, pseudo_bytes_to_write))<0) { sprintf(errstr, "Can't write to output soundfile: (is hard-disk full?).\n"); return(SYSTEM_ERROR); } dz->total_bytes_written += bytes_to_write; return(FINISHED); } #else int write_samps_to_elsewhere(int ofd, float *buffer,int samps_to_write,dataptr dz) { int i,j; int samps_written; if(dz->needotherpeaks){ for(i=0;i < samps_to_write; i += dz->otheroutchans){ for(j = 0;j < dz->otheroutchans;j++){ /* this way, posiiton of first peak value is stored */ if(buffer[i+j] > dz->outpeaks[j].value){ dz->otherpeaks[j].value = buffer[i+j]; dz->otherpeaks[j].position = dz->otherpeakpos[j]; } } /* count framepos */ for(j=0;j < dz->otheroutchans;j++) dz->otherpeakpos[j]++; } } if((samps_written = fputfbufEx(buffer, samps_to_write,ofd))<=0) { sprintf(errstr, "Can't write to output soundfile: %s\n",sferrstr()); return(SYSTEM_ERROR); } dz->total_samps_written += samps_to_write; return(FINISHED); } #endif /****************************** WRITE_BRKFILE *************************/ int write_brkfile(FILE *fptext,int brklen,int array_no,dataptr dz) { int n; double *p = dz->parray[array_no]; for(n=0;nwlength; int n, bsize; double sharpness = TONE_CENT; /* sharpness in semitones */ if(dz->wlength<2) { sprintf(errstr,"Not enough pitchdata to convert to brktable.\n"); return(DATA_ERROR); } q = dz->parray[array_no]; n = 0; *q++ = 0.0; *q++ = (double)*p++; *q++ = frametime; *q++ = (double)*p++; n = 2; while(endptab-p > 0) { *q++ = (double)n * frametime; *q++ = (double)*p++; n++; } bsize = q - dz->parray[array_no]; if((exit_status = incremental_pt_datareduction(array_no,&bsize,sharpness,dz))<0) return(exit_status); n = bsize; if((dz->parray[array_no] = (double *)realloc((char *)dz->parray[array_no],n*sizeof(double)))==NULL) { sprintf(errstr,"convert_pch_or_transpos_data_to_brkpnttable()\n"); return(MEMORY_ERROR); } *brksize = n/2; return(FINISHED); } /***************************** PT_DATAREDUCE ********************** * * Reduce data on passing from pitch or transposition to brkpnt representation. * * Note, these are identical, becuase the root-pitch from which pitch-vals are measured * cancels out in the maths (and doesn't of course occur in the transposition calc). * * Take last 3 points, and if middle point has (approx) same value as * a point derived by interpolating between first and last points, then * ommit midpoint from brkpnt representation. */ int pt_datareduce(double **q,double sharp,double flat,double *thisarray,int *bsize) { double interval; double *arrayend; double *p = (*q)-6, *midpair = (*q)-4, *endpair = (*q)-2; double startime = *p++; double startval = LOG2(*p++); /* pitch = LOG(p/root) = LOG(p) - LOG(root) */ double midtime = *p++; double midval = LOG2(*p++); /* pitch = LOG(p/root) = LOG(p) - LOG(root) */ double endtime = *p++; double endval = LOG2(*p); double valrange = endval-startval; /* LOG(root) cancels out */ double midtimeratio = (midtime-startime)/(endtime-startime); double guessval = (valrange * midtimeratio) + startval; /* -LOG(root) reintroduced */ if((interval = (guessval - midval) * SEMITONES_PER_OCTAVE) < sharp && interval > flat) { /* but cancels again */ arrayend = thisarray + *bsize; while(endpair < arrayend) *midpair++ = *endpair++; (*q) -= 2; *bsize -= 2; } return(FINISHED); } /***************************** INCREMENTAL_PT_DATAREDUCTION ******************************/ int incremental_pt_datareduction(int array_no,int *bsize,double sharp,dataptr dz) { int exit_status; double flat; double *q; double sharp_semitones = LOG2(dz->is_sharp) * SEMITONES_PER_OCTAVE; double *thisarray = dz->parray[array_no]; while(*bsize >= 6 && sharp < sharp_semitones) { flat = -sharp; q = thisarray + 4; while(q < thisarray + (*bsize) - 1) { q +=2; if((exit_status = pt_datareduce(&q,sharp,flat,thisarray,bsize))<0) return(exit_status); } sharp *= 2.0; /* interval-size doubles */ } if(*bsize >= 6) { sharp = sharp_semitones; flat = -sharp; q = thisarray + 4; while(q < thisarray + (*bsize) - 1) { q +=2; if((exit_status = pt_datareduce(&q,sharp,flat,thisarray,bsize))<0) return(exit_status); } } return(FINISHED); } /****************************** SPLICE_MULTILINE_STRING ******************************/ void splice_multiline_string(char *str,char *prefix) { char *p, *q, c; p = str; q = str; while(*q != ENDOFSTR) { while(*p != '\n' && *p != ENDOFSTR) p++; c = *p; *p = ENDOFSTR; fprintf(stdout,"%s %s\n",prefix,q); *p = c; if(*p == '\n') p++; while(*p == '\n') { fprintf(stdout,"%s \n",prefix); p++; } q = p; p++; } }