diff options
Diffstat (limited to 'pd/extra/fiddle~')
| -rw-r--r-- | pd/extra/fiddle~/fiddle~.c | 1527 |
1 files changed, 759 insertions, 768 deletions
diff --git a/pd/extra/fiddle~/fiddle~.c b/pd/extra/fiddle~/fiddle~.c index 594c2ff4..d959b00f 100644 --- a/pd/extra/fiddle~/fiddle~.c +++ b/pd/extra/fiddle~/fiddle~.c @@ -102,15 +102,10 @@ static fts_symbol_t *dsp_symbol = 0; #endif /* MSP */ #ifdef MSP -#define t_floatarg double // this is a guess based on MAX26 +#define t_floatarg double #include "ext.h" #include "z_dsp.h" #include "fft_mayer.proto.h" -//#include "fiddle_header.h" -// #include "MacHeaders.h" -//#include <MacHeadersPPC> - -//#include "fiddledoit.h" #endif /* MSP */ @@ -129,25 +124,25 @@ static fts_symbol_t *dsp_symbol = 0; #define MINFREQINBINS 5 /* minimum frequency in bins for reliable output */ #define MAXNPITCH 3 -#define MAXHIST 3 /* find N hottest peaks in histogram */ +#define MAXHIST 3 /* find N hottest peaks in histogram */ #define MAXPOINTS 8192 #define MINPOINTS 128 #define DEFAULTPOINTS 1024 #define HISTORY 20 -#define MAXPEAK 100 /* maximum number of peaks */ -#define DEFNPEAK 20 /* default number of peaks */ +#define MAXPEAK 100 /* maximum number of peaks */ +#define DEFNPEAK 20 /* default number of peaks */ #define MAXNPEAK (MAXLOWPEAK + MAXSTRONGPEAK) -#define MINBW (0.03f) /* consider BW >= 0.03 FFT bins */ +#define MINBW (0.03f) /* consider BW >= 0.03 FFT bins */ -#define BINPEROCT 48 /* bins per octave */ -#define BPERO_OVER_LOG2 69.24936196f /* BINSPEROCT/log(2) */ -#define FACTORTOBINS (float)(4/0.0145453) /* 4 / (pow(2.,1/48.) - 1) */ -#define BINGUARD 10 /* extra bins to throw in front */ -#define PARTIALDEVIANCE 0.023f /* acceptable partial detuning in % */ -#define LOGTODB 4.34294481903f /* 20/log(10) */ +#define BINPEROCT 48 /* bins per octave */ +#define BPERO_OVER_LOG2 69.24936196f /* BINSPEROCT/log(2) */ +#define FACTORTOBINS (float)(4/0.0145453) /* 4 / (pow(2.,1/48.) - 1) */ +#define BINGUARD 10 /* extra bins to throw in front */ +#define PARTIALDEVIANCE 0.023f /* acceptable partial detuning in % */ +#define LOGTODB 4.34294481903f /* 20/log(10) */ #define KNOCKTHRESH 10.f /* don't know how to describe this */ @@ -207,79 +202,79 @@ sample rate. I got these by trial and error. */ #define FILT5 ((float)(.5 * 0.002533)) #define FILTSIZE 5 -typedef struct peakout /* a peak for output */ +typedef struct peakout /* a peak for output */ { - float po_freq; /* frequency in hz */ - float po_amp; /* amplitude */ + float po_freq; /* frequency in hz */ + float po_amp; /* amplitude */ } t_peakout; -typedef struct peak /* a peak for analysis */ +typedef struct peak /* a peak for analysis */ { - float p_freq; /* frequency in bins */ - float p_width; /* peak width in bins */ - float p_pow; /* peak power */ - float p_loudness; /* 4th root of power */ - float *p_fp; /* pointer back to spectrum */ + float p_freq; /* frequency in bins */ + float p_width; /* peak width in bins */ + float p_pow; /* peak power */ + float p_loudness; /* 4th root of power */ + float *p_fp; /* pointer back to spectrum */ } t_peak; typedef struct histopeak { - float h_pitch; /* estimated pitch */ - float h_value; /* value of peak */ - float h_loud; /* combined strength of found partials */ - int h_index; /* index of bin holding peak */ - int h_used; /* true if an x_hist entry points here */ + float h_pitch; /* estimated pitch */ + float h_value; /* value of peak */ + float h_loud; /* combined strength of found partials */ + int h_index; /* index of bin holding peak */ + int h_used; /* true if an x_hist entry points here */ } t_histopeak; -typedef struct pitchhist /* struct for keeping history by pitch */ +typedef struct pitchhist /* struct for keeping history by pitch */ { - float h_pitch; /* pitch to output */ - float h_amps[HISTORY]; /* past amplitudes */ - float h_pitches[HISTORY]; /* past pitches */ - float h_noted; /* last pitch output */ - int h_age; /* number of frames pitch has been there */ - t_histopeak *h_wherefrom; /* new histogram peak to incorporate */ + float h_pitch; /* pitch to output */ + float h_amps[HISTORY]; /* past amplitudes */ + float h_pitches[HISTORY]; /* past pitches */ + float h_noted; /* last pitch output */ + int h_age; /* number of frames pitch has been there */ + t_histopeak *h_wherefrom; /* new histogram peak to incorporate */ void *h_outlet; } t_pitchhist; -typedef struct sigfiddle /* instance struct */ +typedef struct sigfiddle /* instance struct */ { #ifdef JMAX - fts_object_t x_h; /* object header */ - fts_alarm_t x_clock; /* callback for timeouts */ + fts_object_t x_h; /* object header */ + fts_alarm_t x_clock; /* callback for timeouts */ #endif #ifdef MAX26 - t_head x_h; /* header for tilde objects */ - t_sig *x_io[IN1+OUT0]; /* number of signal inputs and outputs */ - void *x_clock; /* a "clock" object */ + t_head x_h; /* header for tilde objects */ + t_sig *x_io[IN1+OUT0]; /* number of signal inputs and outputs */ + void *x_clock; /* a "clock" object */ #endif #ifdef PD - t_object x_ob; /* object header */ - t_clock *x_clock; /* callback for timeouts */ + t_object x_ob; /* object header */ + t_clock *x_clock; /* callback for timeouts */ #endif #ifdef MSP - t_pxobject x_obj; - void *x_clock; - long x_downsample; // downsample feature because of - // MSP's large sig vector sizes + t_pxobject x_obj; + void *x_clock; + long x_downsample; /* downsample feature because of + MSP's large sig vector sizes */ #endif - float *x_inbuf; /* buffer to analyze, npoints/2 elems */ - float *x_lastanalysis; /* FT of last buffer (see main comment) */ - float *x_spiral; /* 1/4-wave complex exponential */ - t_peakout *x_peakbuf; /* spectral peaks for output */ - int x_npeakout; /* number of spectral peaks to output */ - int x_npeakanal; /* number of spectral peaks to analyze */ - int x_phase; /* number of points since last output */ - int x_histphase; /* phase into amplitude history vector */ - int x_hop; /* period of output, npoints/2 */ - float x_sr; /* sample rate */ + float *x_inbuf; /* buffer to analyze, npoints/2 elems */ + float *x_lastanalysis; /* FT of last buffer (see main comment) */ + float *x_spiral; /* 1/4-wave complex exponential */ + t_peakout *x_peakbuf; /* spectral peaks for output */ + int x_npeakout; /* number of spectral peaks to output */ + int x_npeakanal; /* number of spectral peaks to analyze */ + int x_phase; /* number of points since last output */ + int x_histphase; /* phase into amplitude history vector */ + int x_hop; /* period of output, npoints/2 */ + float x_sr; /* sample rate */ t_pitchhist x_hist[MAXNPITCH]; /* history of current pitches */ - int x_nprint; /* how many periods to print */ - int x_npitch; /* number of simultaneous pitches */ - float x_dbs[HISTORY]; /* DB history, indexed by "histphase" */ - float x_peaked; /* peak since last attack */ - int x_dbage; /* number of bins DB has met threshold */ - int x_auto; /* true if generating continuous output */ + int x_nprint; /* how many periods to print */ + int x_npitch; /* number of simultaneous pitches */ + float x_dbs[HISTORY]; /* DB history, indexed by "histphase" */ + float x_peaked; /* peak since last attack */ + int x_dbage; /* number of bins DB has met threshold */ + int x_auto; /* true if generating continuous output */ /* parameters */ float x_amplo; float x_amphi; @@ -303,7 +298,7 @@ float fiddle_checker[1024]; #endif #ifdef MSP -// Mac compiler requires prototypes for everything +/* Mac compiler requires prototypes for everything */ int sigfiddle_ilog2(int n); float fiddle_mtof(float f); @@ -327,7 +322,6 @@ void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp); void sigfiddle_tick(t_sigfiddle *x); void sigfiddle_bang(t_sigfiddle *x); void sigfiddle_ff(t_sigfiddle *x); -//void *sigfiddle_new(long npoints, long npitch); void *sigfiddle_new(long npoints, long npitch, long npeakanal, long npeakout); void msp_fft(float *buf, long np, long inv); @@ -340,20 +334,20 @@ int sigfiddle_ilog2(int n) int ret = -1; while (n) { - n >>= 1; - ret++; + n >>= 1; + ret++; } return (ret); } float fiddle_mtof(float f) { - return (8.17579891564 * exp(.0577622650 * f)); + return (8.17579891564 * exp(.0577622650 * f)); } float fiddle_ftom(float f) { - return (17.3123405046 * log(.12231220585 * f)); + return (17.3123405046 * log(.12231220585 * f)); } #define ftom fiddle_ftom #define mtof fiddle_mtof @@ -361,7 +355,7 @@ float fiddle_ftom(float f) void sigfiddle_doit(t_sigfiddle *x) { #ifdef MSP - // prevents interrupt-level stack overflow crash with Netscape. + /* prevents interrupt-level stack overflow crash with Netscape. */ static float spect1[4*MAXPOINTS]; static float spect2[MAXPOINTS + 4*FILTSIZE]; #else @@ -389,13 +383,13 @@ void sigfiddle_doit(t_sigfiddle *x) if (newphase == HISTORY) newphase = 0; x->x_histphase = newphase; - /* - * multiply the H points by a 1/4-wave complex exponential, - * and take FFT of the result. - */ + /* + * multiply the H points by a 1/4-wave complex exponential, + * and take FFT of the result. + */ for (i = 0, fp1 = x->x_inbuf, fp2 = x->x_spiral, fp3 = spect1; - i < hop; i++, fp1++, fp2 += 2, fp3 += 2) - fp3[0] = fp1[0] * fp2[0], fp3[1] = fp1[0] * fp2[1]; + i < hop; i++, fp1++, fp2 += 2, fp3 += 2) + fp3[0] = fp1[0] * fp2[0], fp3[1] = fp1[0] * fp2[1]; #ifdef MAX26 fft(spect1, hop, 0); @@ -407,123 +401,123 @@ void sigfiddle_doit(t_sigfiddle *x) fts_cfft_inplc((complex *)spect1, hop); #endif #ifdef MSP - msp_fft(spect1,hop,0); + msp_fft(spect1,hop,0); #endif - /* - * now redistribute the points to get in effect the odd-numbered - * points of the FFT of the H points, zero padded to 4*H in length. - */ + /* + * now redistribute the points to get in effect the odd-numbered + * points of the FFT of the H points, zero padded to 4*H in length. + */ for (i = 0, fp1 = spect1, fp2 = spect2 + (2*FILTSIZE); - i < (hop>>1); i++, fp1 += 2, fp2 += 4) - fp2[0] = fp1[0], fp2[1] = fp1[1]; + i < (hop>>1); i++, fp1 += 2, fp2 += 4) + fp2[0] = fp1[0], fp2[1] = fp1[1]; for (i = 0, fp1 = spect1 + n - 2, fp2 = spect2 + (2*FILTSIZE+2); - i < (hop>>1); i++, fp1 -= 2, fp2 += 4) - fp2[0] = fp1[0], fp2[1] = -fp1[1]; + i < (hop>>1); i++, fp1 -= 2, fp2 += 4) + fp2[0] = fp1[0], fp2[1] = -fp1[1]; for (i = 0, fp1 = spect2 + (2*FILTSIZE), fp2 = spect2 + (2*FILTSIZE-2); - i<FILTSIZE; i++, fp1+=2, fp2-=2) - fp2[0] = fp1[0], fp2[1] = -fp1[1]; + i<FILTSIZE; i++, fp1+=2, fp2-=2) + fp2[0] = fp1[0], fp2[1] = -fp1[1]; for (i = 0, fp1 = spect2 + (2*FILTSIZE+n-2), fp2 = spect2 + (2*FILTSIZE+n); - i<FILTSIZE; i++, fp1-=2, fp2+=2) - fp2[0] = fp1[0], fp2[1] = -fp1[1]; + i<FILTSIZE; i++, fp1-=2, fp2+=2) + fp2[0] = fp1[0], fp2[1] = -fp1[1]; #if 0 { - fp = spect2 + 2*FILTSIZE; - post("x1 re %12.4f %12.4f %12.4f %12.4f %12.4f", - fp[0], fp[2], fp[4], fp[6], fp[8]); - post("x1 im %12.4f %12.4f %12.4f %12.4f %12.4f", - fp[1], fp[3], fp[5], fp[7], fp[9]); + fp = spect2 + 2*FILTSIZE; + post("x1 re %12.4f %12.4f %12.4f %12.4f %12.4f", + fp[0], fp[2], fp[4], fp[6], fp[8]); + post("x1 im %12.4f %12.4f %12.4f %12.4f %12.4f", + fp[1], fp[3], fp[5], fp[7], fp[9]); } #endif - /* spect2 is now prepared; now combine spect2 and lastanalysis into - * spect1. Odd-numbered points of spect1 are the points of "last" - * plus (-i, i, -i, ...) times spect1. Even-numbered points are - * the interpolated points of "last" plus (1, -1, 1, ...) times the - * interpolated points of spect1. - * - * To interpolate, take FILT1 exp(-pi/4) times - * the previous point, FILT2*exp(-3*pi/4) times 3 bins before, - * etc, and FILT1 exp(pi/4), FILT2 exp(3pi/4), etc., to weight - * the +1, +3, etc., points. - * - * In this calculation, we take (1, i, -1, -i, 1) times the - * -9, -7, ..., -1 points, and (i, -1, -i, 1, i) times the 1, 3,..., 9 - * points of the OLD spectrum, alternately adding and subtracting - * the new spectrum to the old; then we multiply the whole thing - * by exp(-i pi/4). - */ + /* spect2 is now prepared; now combine spect2 and lastanalysis into + * spect1. Odd-numbered points of spect1 are the points of "last" + * plus (-i, i, -i, ...) times spect1. Even-numbered points are + * the interpolated points of "last" plus (1, -1, 1, ...) times the + * interpolated points of spect1. + * + * To interpolate, take FILT1 exp(-pi/4) times + * the previous point, FILT2*exp(-3*pi/4) times 3 bins before, + * etc, and FILT1 exp(pi/4), FILT2 exp(3pi/4), etc., to weight + * the +1, +3, etc., points. + * + * In this calculation, we take (1, i, -1, -i, 1) times the + * -9, -7, ..., -1 points, and (i, -1, -i, 1, i) times the 1, 3,..., 9 + * points of the OLD spectrum, alternately adding and subtracting + * the new spectrum to the old; then we multiply the whole thing + * by exp(-i pi/4). + */ for (i = 0, fp1 = spect1, fp2 = x->x_lastanalysis + 2*FILTSIZE, - fp3 = spect2 + 2*FILTSIZE; - i < (hop>>1); i++) + fp3 = spect2 + 2*FILTSIZE; + i < (hop>>1); i++) { - float re, im; - - re= FILT1 * ( fp2[ -2] -fp2[ 1] +fp3[ -2] -fp3[ 1]) + - FILT2 * ( fp2[ -3] -fp2[ 2] +fp3[ -3] -fp3[ 2]) + - FILT3 * (-fp2[ -6] +fp2[ 5] -fp3[ -6] +fp3[ 5]) + - FILT4 * (-fp2[ -7] +fp2[ 6] -fp3[ -7] +fp3[ 6]) + - FILT5 * ( fp2[-10] -fp2[ 9] +fp3[-10] -fp3[ 9]); - - im= FILT1 * ( fp2[ -1] +fp2[ 0] +fp3[ -1] +fp3[ 0]) + - FILT2 * (-fp2[ -4] -fp2[ 3] -fp3[ -4] -fp3[ 3]) + - FILT3 * (-fp2[ -5] -fp2[ 4] -fp3[ -5] -fp3[ 4]) + - FILT4 * ( fp2[ -8] +fp2[ 7] +fp3[ -8] +fp3[ 7]) + - FILT5 * ( fp2[ -9] +fp2[ 8] +fp3[ -9] +fp3[ 8]); - - fp1[0] = 0.7071f * (re + im); - fp1[1] = 0.7071f * (im - re); - fp1[4] = fp2[0] + fp3[1]; - fp1[5] = fp2[1] - fp3[0]; - - fp1 += 8, fp2 += 2, fp3 += 2; - re= FILT1 * ( fp2[ -2] -fp2[ 1] -fp3[ -2] +fp3[ 1]) + - FILT2 * ( fp2[ -3] -fp2[ 2] -fp3[ -3] +fp3[ 2]) + - FILT3 * (-fp2[ -6] +fp2[ 5] +fp3[ -6] -fp3[ 5]) + - FILT4 * (-fp2[ -7] +fp2[ 6] +fp3[ -7] -fp3[ 6]) + - FILT5 * ( fp2[-10] -fp2[ 9] -fp3[-10] +fp3[ 9]); - - im= FILT1 * ( fp2[ -1] +fp2[ 0] -fp3[ -1] -fp3[ 0]) + - FILT2 * (-fp2[ -4] -fp2[ 3] +fp3[ -4] +fp3[ 3]) + - FILT3 * (-fp2[ -5] -fp2[ 4] +fp3[ -5] +fp3[ 4]) + - FILT4 * ( fp2[ -8] +fp2[ 7] -fp3[ -8] -fp3[ 7]) + - FILT5 * ( fp2[ -9] +fp2[ 8] -fp3[ -9] -fp3[ 8]); - - fp1[0] = 0.7071f * (re + im); - fp1[1] = 0.7071f * (im - re); - fp1[4] = fp2[0] - fp3[1]; - fp1[5] = fp2[1] + fp3[0]; - - fp1 += 8, fp2 += 2, fp3 += 2; + float re, im; + + re= FILT1 * ( fp2[ -2] -fp2[ 1] +fp3[ -2] -fp3[ 1]) + + FILT2 * ( fp2[ -3] -fp2[ 2] +fp3[ -3] -fp3[ 2]) + + FILT3 * (-fp2[ -6] +fp2[ 5] -fp3[ -6] +fp3[ 5]) + + FILT4 * (-fp2[ -7] +fp2[ 6] -fp3[ -7] +fp3[ 6]) + + FILT5 * ( fp2[-10] -fp2[ 9] +fp3[-10] -fp3[ 9]); + + im= FILT1 * ( fp2[ -1] +fp2[ 0] +fp3[ -1] +fp3[ 0]) + + FILT2 * (-fp2[ -4] -fp2[ 3] -fp3[ -4] -fp3[ 3]) + + FILT3 * (-fp2[ -5] -fp2[ 4] -fp3[ -5] -fp3[ 4]) + + FILT4 * ( fp2[ -8] +fp2[ 7] +fp3[ -8] +fp3[ 7]) + + FILT5 * ( fp2[ -9] +fp2[ 8] +fp3[ -9] +fp3[ 8]); + + fp1[0] = 0.7071f * (re + im); + fp1[1] = 0.7071f * (im - re); + fp1[4] = fp2[0] + fp3[1]; + fp1[5] = fp2[1] - fp3[0]; + + fp1 += 8, fp2 += 2, fp3 += 2; + re= FILT1 * ( fp2[ -2] -fp2[ 1] -fp3[ -2] +fp3[ 1]) + + FILT2 * ( fp2[ -3] -fp2[ 2] -fp3[ -3] +fp3[ 2]) + + FILT3 * (-fp2[ -6] +fp2[ 5] +fp3[ -6] -fp3[ 5]) + + FILT4 * (-fp2[ -7] +fp2[ 6] +fp3[ -7] -fp3[ 6]) + + FILT5 * ( fp2[-10] -fp2[ 9] -fp3[-10] +fp3[ 9]); + + im= FILT1 * ( fp2[ -1] +fp2[ 0] -fp3[ -1] -fp3[ 0]) + + FILT2 * (-fp2[ -4] -fp2[ 3] +fp3[ -4] +fp3[ 3]) + + FILT3 * (-fp2[ -5] -fp2[ 4] +fp3[ -5] +fp3[ 4]) + + FILT4 * ( fp2[ -8] +fp2[ 7] -fp3[ -8] -fp3[ 7]) + + FILT5 * ( fp2[ -9] +fp2[ 8] -fp3[ -9] -fp3[ 8]); + + fp1[0] = 0.7071f * (re + im); + fp1[1] = 0.7071f * (im - re); + fp1[4] = fp2[0] - fp3[1]; + fp1[5] = fp2[1] + fp3[0]; + + fp1 += 8, fp2 += 2, fp3 += 2; } #if 0 if (x->x_nprint) { - for (i = 0, fp = spect1; i < 16; i++, fp+= 4) - post("spect %d %f %f --> %f", i, fp[0], fp[1], - sqrt(fp[0] * fp[0] + fp[1] * fp[1])); + for (i = 0, fp = spect1; i < 16; i++, fp+= 4) + post("spect %d %f %f --> %f", i, fp[0], fp[1], + sqrt(fp[0] * fp[0] + fp[1] * fp[1])); } #endif - /* copy new spectrum out */ + /* copy new spectrum out */ for (i = 0, fp1 = spect2, fp2 = x->x_lastanalysis; - i < n + 4*FILTSIZE; i++) *fp2++ = *fp1++; + i < n + 4*FILTSIZE; i++) *fp2++ = *fp1++; for (i = 0; i < MINBIN; i++) spect1[4*i + 2] = spect1[4*i + 3] = 0; - /* starting at bin MINBIN, compute hanning windowed power spectrum */ + /* starting at bin MINBIN, compute hanning windowed power spectrum */ for (i = MINBIN, fp1 = spect1+4*MINBIN, total_power = 0; - i < n-2; i++, fp1 += 4) + i < n-2; i++, fp1 += 4) { - float re = fp1[0] - 0.5f * (fp1[-8] + fp1[8]); - float im = fp1[1] - 0.5f * (fp1[-7] + fp1[9]); - fp1[3] = (total_power += (fp1[2] = re * re + im * im)); + float re = fp1[0] - 0.5f * (fp1[-8] + fp1[8]); + float im = fp1[1] - 0.5f * (fp1[-7] + fp1[9]); + fp1[3] = (total_power += (fp1[2] = re * re + im * im)); } if (total_power > 1e-9f) { - total_db = (100.f - DBFUDGE) + LOGTODB * log(total_power/n); - total_loudness = fsqrt(fsqrt(total_power)); - if (total_db < 0) total_db = 0; + total_db = (100.f - DBFUDGE) + LOGTODB * log(total_power/n); + total_loudness = fsqrt(fsqrt(total_power)); + if (total_db < 0) total_db = 0; } else total_db = total_loudness = 0; - /* store new db in history vector */ + /* store new db in history vector */ x->x_dbs[newphase] = total_db; if (total_db < x->x_amplo) goto nopow; #if 1 @@ -531,467 +525,467 @@ void sigfiddle_doit(t_sigfiddle *x) #endif #if CHECKER - /* verify that our FFT resampling thing is putting out good results */ + /* verify that our FFT resampling thing is putting out good results */ for (i = 0; i < hop; i++) { - checker3[2*i] = fiddle_checker[i]; - checker3[2*i + 1] = 0; - checker3[n + 2*i] = fiddle_checker[i] = x->x_inbuf[i]; - checker3[n + 2*i + 1] = 0; + checker3[2*i] = fiddle_checker[i]; + checker3[2*i + 1] = 0; + checker3[n + 2*i] = fiddle_checker[i] = x->x_inbuf[i]; + checker3[n + 2*i + 1] = 0; } for (i = 2*n; i < 4*n; i++) checker3[i] = 0; fft(checker3, 2*n, 0); if (x->x_nprint) { - for (i = 0, fp = checker3; i < 16; i++, fp += 2) - post("spect %d %f %f --> %f", i, fp[0], fp[1], - sqrt(fp[0] * fp[0] + fp[1] * fp[1])); + for (i = 0, fp = checker3; i < 16; i++, fp += 2) + post("spect %d %f %f --> %f", i, fp[0], fp[1], + sqrt(fp[0] * fp[0] + fp[1] * fp[1])); } #endif npeak = 0; - /* search for peaks */ + /* search for peaks */ for (i = MINBIN, fp = spect1+4*MINBIN, pk1 = peaklist; - i < n-2 && npeak < npeaktot; i++, fp += 4) + i < n-2 && npeak < npeaktot; i++, fp += 4) { - float height = fp[2], h1 = fp[-2], h2 = fp[6]; - float totalfreq, pfreq, f1, f2, m, var, stdev; - - if (height < h1 || height < h2 || - h1 < 0.00001f*total_power || h2 < 0.00001f*total_power) - continue; - - /* use an informal phase vocoder to estimate the frequency. - Do this for the two adjacent bins too. */ - pfreq= ((fp[-8] - fp[8]) * (2.0f * fp[0] - fp[8] - fp[-8]) + - (fp[-7] - fp[9]) * (2.0f * fp[1] - fp[9] - fp[-7])) / - (2.0f * height); - f1= ((fp[-12] - fp[4]) * (2.0f * fp[-4] - fp[4] - fp[-12]) + - (fp[-11] - fp[5]) * (2.0f * fp[-3] - fp[5] - fp[-11])) / - (2.0f * h1) - 1; - f2= ((fp[-4] - fp[12]) * (2.0f * fp[4] - fp[12] - fp[-4]) + - (fp[-3] - fp[13]) * (2.0f * fp[5] - fp[13] - fp[-3])) / - (2.0f * h2) + 1; - - /* get sample mean and variance of the three */ - m = 0.333333f * (pfreq + f1 + f2); - var = 0.5f * ((pfreq-m)*(pfreq-m) + (f1-m)*(f1-m) + (f2-m)*(f2-m)); - - totalfreq = i + m; - if (var * total_power > KNOCKTHRESH * height || var < 1e-30) - { + float height = fp[2], h1 = fp[-2], h2 = fp[6]; + float totalfreq, pfreq, f1, f2, m, var, stdev; + + if (height < h1 || height < h2 || + h1 < 0.00001f*total_power || h2 < 0.00001f*total_power) + continue; + + /* use an informal phase vocoder to estimate the frequency. + Do this for the two adjacent bins too. */ + pfreq= ((fp[-8] - fp[8]) * (2.0f * fp[0] - fp[8] - fp[-8]) + + (fp[-7] - fp[9]) * (2.0f * fp[1] - fp[9] - fp[-7])) / + (2.0f * height); + f1= ((fp[-12] - fp[4]) * (2.0f * fp[-4] - fp[4] - fp[-12]) + + (fp[-11] - fp[5]) * (2.0f * fp[-3] - fp[5] - fp[-11])) / + (2.0f * h1) - 1; + f2= ((fp[-4] - fp[12]) * (2.0f * fp[4] - fp[12] - fp[-4]) + + (fp[-3] - fp[13]) * (2.0f * fp[5] - fp[13] - fp[-3])) / + (2.0f * h2) + 1; + + /* get sample mean and variance of the three */ + m = 0.333333f * (pfreq + f1 + f2); + var = 0.5f * ((pfreq-m)*(pfreq-m) + (f1-m)*(f1-m) + (f2-m)*(f2-m)); + + totalfreq = i + m; + if (var * total_power > KNOCKTHRESH * height || var < 1e-30) + { #if 0 - if (x->x_nprint) - post("cancel: %.2f hz, index %.1f, power %.5f, stdev=%.2f", - totalfreq * hzperbin, BPERO_OVER_LOG2 * log(totalfreq) - 96, - height, sqrt(var)); + if (x->x_nprint) + post("cancel: %.2f hz, index %.1f, power %.5f, stdev=%.2f", + totalfreq * hzperbin, BPERO_OVER_LOG2 * log(totalfreq) - 96, + height, sqrt(var)); #endif - continue; - } - stdev = fsqrt(var); - if (totalfreq < 4) - { - if (x->x_nprint) post("oops: was %d, freq %f, m %f, stdev %f h %f", - i, totalfreq, m, stdev, height); - totalfreq = 4; - } - pk1->p_width = stdev; - - pk1->p_pow = height; - pk1->p_loudness = fsqrt(fsqrt(height)); - pk1->p_fp = fp; - pk1->p_freq = totalfreq; - npeak++; + continue; + } + stdev = fsqrt(var); + if (totalfreq < 4) + { + if (x->x_nprint) post("oops: was %d, freq %f, m %f, stdev %f h %f", + i, totalfreq, m, stdev, height); + totalfreq = 4; + } + pk1->p_width = stdev; + + pk1->p_pow = height; + pk1->p_loudness = fsqrt(fsqrt(height)); + pk1->p_fp = fp; + pk1->p_freq = totalfreq; + npeak++; #if 1 - if (x->x_nprint) - { - post("peak: %.2f hz. index %.1f, power %.5f, stdev=%.2f", - pk1->p_freq * hzperbin, - BPERO_OVER_LOG2 * log(pk1->p_freq) - 96, - height, stdev); - } + if (x->x_nprint) + { + post("peak: %.2f hz. index %.1f, power %.5f, stdev=%.2f", + pk1->p_freq * hzperbin, + BPERO_OVER_LOG2 * log(pk1->p_freq) - 96, + height, stdev); + } #endif - pk1++; + pk1++; } - /* prepare the raw peaks for output */ + /* prepare the raw peaks for output */ for (i = 0, pk1 = peaklist, pk2 = x->x_peakbuf; i < npeak; - i++, pk1++, pk2++) + i++, pk1++, pk2++) { - float loudness = pk1->p_loudness; - if (i >= npeakout) break; - pk2->po_freq = hzperbin * pk1->p_freq; - pk2->po_amp = (2.f / (float)n) * (loudness * loudness); + float loudness = pk1->p_loudness; + if (i >= npeakout) break; + pk2->po_freq = hzperbin * pk1->p_freq; + pk2->po_amp = (2.f / (float)n) * (loudness * loudness); } for (; i < npeakout; i++, pk2++) pk2->po_amp = pk2->po_freq = 0; - /* now, working back into spect2, make a sort of "liklihood" - * spectrum. Proceeding in 48ths of an octave, from 2 to - * n/2 (in bins), the likelihood of each pitch range is contributed - * to by every peak in peaklist that's an integer multiple of it - * in frequency. - */ + /* now, working back into spect2, make a sort of "liklihood" + * spectrum. Proceeding in 48ths of an octave, from 2 to + * n/2 (in bins), the likelihood of each pitch range is contributed + * to by every peak in peaklist that's an integer multiple of it + * in frequency. + */ if (npeak > npeakanal) npeak = npeakanal; /* max # peaks to analyze */ for (i = 0, fp1 = histogram; i < maxbin; i++) *fp1++ = 0; for (i = 0, pk1 = peaklist; i < npeak; i++, pk1++) { - float pit = BPERO_OVER_LOG2 * flog(pk1->p_freq) - 96.0f; - float binbandwidth = FACTORTOBINS * pk1->p_width/pk1->p_freq; - float putbandwidth = (binbandwidth < 2 ? 2 : binbandwidth); - float weightbandwidth = (binbandwidth < 1.0f ? 1.0f : binbandwidth); - /* float weightamp = 1.0f + 3.0f * pk1->p_pow / pow; */ - float weightamp = 4. * pk1->p_loudness / total_loudness; - for (j = 0, fp2 = sigfiddle_partialonset; j < NPARTIALONSET; j++, fp2++) - { - float bin = pit - *fp2; - if (bin < maxbin) - { - float para, pphase, score = 30.0f * weightamp / - ((j+x->x_npartial) * weightbandwidth); - int firstbin = bin + 0.5f - 0.5f * putbandwidth; - int lastbin = bin + 0.5f + 0.5f * putbandwidth; - int ibw = lastbin - firstbin; - if (firstbin < -BINGUARD) break; - para = 1.0f / (putbandwidth * putbandwidth); - for (k = 0, fp3 = histogram + firstbin, - pphase = firstbin-bin; k <= ibw; - k++, fp3++, pphase += 1.0f) - { - *fp3 += score * (1.0f - para * pphase * pphase); - } - } - } + float pit = BPERO_OVER_LOG2 * flog(pk1->p_freq) - 96.0f; + float binbandwidth = FACTORTOBINS * pk1->p_width/pk1->p_freq; + float putbandwidth = (binbandwidth < 2 ? 2 : binbandwidth); + float weightbandwidth = (binbandwidth < 1.0f ? 1.0f : binbandwidth); + /* float weightamp = 1.0f + 3.0f * pk1->p_pow / pow; */ + float weightamp = 4. * pk1->p_loudness / total_loudness; + for (j = 0, fp2 = sigfiddle_partialonset; j < NPARTIALONSET; j++, fp2++) + { + float bin = pit - *fp2; + if (bin < maxbin) + { + float para, pphase, score = 30.0f * weightamp / + ((j+x->x_npartial) * weightbandwidth); + int firstbin = bin + 0.5f - 0.5f * putbandwidth; + int lastbin = bin + 0.5f + 0.5f * putbandwidth; + int ibw = lastbin - firstbin; + if (firstbin < -BINGUARD) break; + para = 1.0f / (putbandwidth * putbandwidth); + for (k = 0, fp3 = histogram + firstbin, + pphase = firstbin-bin; k <= ibw; + k++, fp3++, pphase += 1.0f) + { + *fp3 += score * (1.0f - para * pphase * pphase); + } + } + } } #if 1 if (x->x_nprint) { - for (i = 0; i < 6*5; i++) - { - float fhz = hzperbin * exp ((8*i + 96) * (1./BPERO_OVER_LOG2)); - if (!(i % 6)) post("-- bin %d pitch %f freq %f----", 8*i, - ftom(fhz), fhz);; - post("%3d %3d %3d %3d %3d %3d %3d %3d", - (int)(histogram[8*i]), - (int)(histogram[8*i+1]), - (int)(histogram[8*i+2]), - (int)(histogram[8*i+3]), - (int)(histogram[8*i+4]), - (int)(histogram[8*i+5]), - (int)(histogram[8*i+6]), - (int)(histogram[8*i+7])); - } + for (i = 0; i < 6*5; i++) + { + float fhz = hzperbin * exp ((8*i + 96) * (1./BPERO_OVER_LOG2)); + if (!(i % 6)) post("-- bin %d pitch %f freq %f----", 8*i, + ftom(fhz), fhz);; + post("%3d %3d %3d %3d %3d %3d %3d %3d", + (int)(histogram[8*i]), + (int)(histogram[8*i+1]), + (int)(histogram[8*i+2]), + (int)(histogram[8*i+3]), + (int)(histogram[8*i+4]), + (int)(histogram[8*i+5]), + (int)(histogram[8*i+6]), + (int)(histogram[8*i+7])); + } } #endif - /* - * Next we find up to NPITCH strongest peaks in the histogram. - * if a peak is related to a stronger one via an interval in - * the sigfiddle_partialonset array, we suppress it. - */ + /* + * Next we find up to NPITCH strongest peaks in the histogram. + * if a peak is related to a stronger one via an interval in + * the sigfiddle_partialonset array, we suppress it. + */ for (npitch = 0; npitch < x->x_npitch; npitch++) { - int indx; - float best; - if (npitch) - { - for (best = 0, indx = -1, j=1; j < maxbin-1; j++) - { - if (histogram[j] > best && histogram[j] > histogram[j-1] && - histogram[j] > histogram[j+1]) - { - for (k = 0; k < npitch; k++) - if (histvec[k].h_index == j) - goto peaknogood; - for (k = 0; k < NPARTIALONSET; k++) - { - if (j - sigfiddle_intpartialonset[k] < 0) break; - if (histogram[j - sigfiddle_intpartialonset[k]] - > histogram[j]) goto peaknogood; - } - for (k = 0; k < NPARTIALONSET; k++) - { - if (j + sigfiddle_intpartialonset[k] >= maxbin) break; - if (histogram[j + sigfiddle_intpartialonset[k]] - > histogram[j]) goto peaknogood; - } - indx = j; - best = histogram[j]; - } - peaknogood: ; - } - } - else - { - for (best = 0, indx = -1, j=0; j < maxbin; j++) - if (histogram[j] > best) - indx = j, best = histogram[j]; - } - if (indx < 0) break; - histvec[npitch].h_value = best; - histvec[npitch].h_index = indx; + int indx; + float best; + if (npitch) + { + for (best = 0, indx = -1, j=1; j < maxbin-1; j++) + { + if (histogram[j] > best && histogram[j] > histogram[j-1] && + histogram[j] > histogram[j+1]) + { + for (k = 0; k < npitch; k++) + if (histvec[k].h_index == j) + goto peaknogood; + for (k = 0; k < NPARTIALONSET; k++) + { + if (j - sigfiddle_intpartialonset[k] < 0) break; + if (histogram[j - sigfiddle_intpartialonset[k]] + > histogram[j]) goto peaknogood; + } + for (k = 0; k < NPARTIALONSET; k++) + { + if (j + sigfiddle_intpartialonset[k] >= maxbin) break; + if (histogram[j + sigfiddle_intpartialonset[k]] + > histogram[j]) goto peaknogood; + } + indx = j; + best = histogram[j]; + } + peaknogood: ; + } + } + else + { + for (best = 0, indx = -1, j=0; j < maxbin; j++) + if (histogram[j] > best) + indx = j, best = histogram[j]; + } + if (indx < 0) break; + histvec[npitch].h_value = best; + histvec[npitch].h_index = indx; } #if 1 if (x->x_nprint) { - for (i = 0; i < npitch; i++) - { - post("index %d freq %f --> value %f", histvec[i].h_index, - exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 96)), - histvec[i].h_value); - post("next %f , prev %f", - exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 97)), - exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 95)) ); - } + for (i = 0; i < npitch; i++) + { + post("index %d freq %f --> value %f", histvec[i].h_index, + exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 96)), + histvec[i].h_value); + post("next %f , prev %f", + exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 97)), + exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 95)) ); + } } #endif - /* for each histogram peak, we now search back through the - * FFT peaks. A peak is a pitch if either there are several - * harmonics that match it, or else if (a) the fundamental is - * present, and (b) the sum of the powers of the contributing peaks - * is at least 1/100 of the total power. - * - * A peak is a contributor if its frequency is within 25 cents of - * a partial from 1 to 16. - * - * Finally, we have to be at least 5 bins in frequency, which - * corresponds to 2-1/5 periods fitting in the analysis window. - */ + /* for each histogram peak, we now search back through the + * FFT peaks. A peak is a pitch if either there are several + * harmonics that match it, or else if (a) the fundamental is + * present, and (b) the sum of the powers of the contributing peaks + * is at least 1/100 of the total power. + * + * A peak is a contributor if its frequency is within 25 cents of + * a partial from 1 to 16. + * + * Finally, we have to be at least 5 bins in frequency, which + * corresponds to 2-1/5 periods fitting in the analysis window. + */ for (i = 0; i < npitch; i++) { - float cumpow = 0, cumstrength = 0, freqnum = 0, freqden = 0; - int npartials = 0, nbelow8 = 0; - /* guessed-at frequency in bins */ - float putfreq = fexp((1.0f / BPERO_OVER_LOG2) * - (histvec[i].h_index + 96.0f)); - for (j = 0; j < npeak; j++) - { - float fpnum = peaklist[j].p_freq/putfreq; - int pnum = fpnum + 0.5f; - float fipnum = pnum; - float deviation; - if (pnum > 16 || pnum < 1) continue; - deviation = 1.0f - fpnum/fipnum; - if (deviation > -PARTIALDEVIANCE && deviation < PARTIALDEVIANCE) - { - /* - * we figure this is a partial since it's within 1/4 of - * a halftone of a multiple of the putative frequency. - */ - - float stdev, weight; - npartials++; - if (pnum < 8) nbelow8++; - cumpow += peaklist[j].p_pow; - cumstrength += fsqrt(fsqrt(peaklist[j].p_pow)); - stdev = (peaklist[j].p_width > MINBW ? - peaklist[j].p_width : MINBW); - weight = 1.0f / ((stdev*fipnum) * (stdev*fipnum)); - freqden += weight; - freqnum += weight * peaklist[j].p_freq/fipnum; + float cumpow = 0, cumstrength = 0, freqnum = 0, freqden = 0; + int npartials = 0, nbelow8 = 0; + /* guessed-at frequency in bins */ + float putfreq = fexp((1.0f / BPERO_OVER_LOG2) * + (histvec[i].h_index + 96.0f)); + for (j = 0; j < npeak; j++) + { + float fpnum = peaklist[j].p_freq/putfreq; + int pnum = fpnum + 0.5f; + float fipnum = pnum; + float deviation; + if (pnum > 16 || pnum < 1) continue; + deviation = 1.0f - fpnum/fipnum; + if (deviation > -PARTIALDEVIANCE && deviation < PARTIALDEVIANCE) + { + /* + * we figure this is a partial since it's within 1/4 of + * a halftone of a multiple of the putative frequency. + */ + + float stdev, weight; + npartials++; + if (pnum < 8) nbelow8++; + cumpow += peaklist[j].p_pow; + cumstrength += fsqrt(fsqrt(peaklist[j].p_pow)); + stdev = (peaklist[j].p_width > MINBW ? + peaklist[j].p_width : MINBW); + weight = 1.0f / ((stdev*fipnum) * (stdev*fipnum)); + freqden += weight; + freqnum += weight * peaklist[j].p_freq/fipnum; #if 1 - if (x->x_nprint) - { - post("peak %d partial %d f=%f w=%f", - j, pnum, peaklist[j].p_freq/fipnum, weight); - } + if (x->x_nprint) + { + post("peak %d partial %d f=%f w=%f", + j, pnum, peaklist[j].p_freq/fipnum, weight); + } #endif - } + } #if 1 - else if (x->x_nprint) post("peak %d partial %d dev %f", - j, pnum, deviation); + else if (x->x_nprint) post("peak %d partial %d dev %f", + j, pnum, deviation); #endif - } - if ((nbelow8 < 4 || npartials < 7) && cumpow < 0.01f * total_power) - histvec[i].h_value = 0; - else - { - float pitchpow = (cumstrength * cumstrength) * - (cumstrength * cumstrength); - float freqinbins = freqnum/freqden; - /* check for minimum output frequency */ - - if (freqinbins < MINFREQINBINS) - histvec[i].h_value = 0; - else - { - /* we passed all tests... save the values we got */ - histvec[i].h_pitch = ftom(hzperbin * freqnum/freqden); - histvec[i].h_loud = (100.0f -DBFUDGE) + - (LOGTODB) * log(pitchpow/n); - } - } + } + if ((nbelow8 < 4 || npartials < 7) && cumpow < 0.01f * total_power) + histvec[i].h_value = 0; + else + { + float pitchpow = (cumstrength * cumstrength) * + (cumstrength * cumstrength); + float freqinbins = freqnum/freqden; + /* check for minimum output frequency */ + + if (freqinbins < MINFREQINBINS) + histvec[i].h_value = 0; + else + { + /* we passed all tests... save the values we got */ + histvec[i].h_pitch = ftom(hzperbin * freqnum/freqden); + histvec[i].h_loud = (100.0f -DBFUDGE) + + (LOGTODB) * log(pitchpow/n); + } + } } #if 1 if (x->x_nprint) { - for (i = 0; i < npitch; i++) - { - if (histvec[i].h_value > 0) - post("index %d pit %f loud %f", histvec[i].h_index, - histvec[i].h_pitch, histvec[i].h_loud); - else post("-- cancelled --"); - } + for (i = 0; i < npitch; i++) + { + if (histvec[i].h_value > 0) + post("index %d pit %f loud %f", histvec[i].h_index, + histvec[i].h_pitch, histvec[i].h_loud); + else post("-- cancelled --"); + } } #endif - /* now try to find continuous pitch tracks that match the new - * pitches. First mark each peak unmatched. - */ + /* now try to find continuous pitch tracks that match the new + * pitches. First mark each peak unmatched. + */ for (i = 0, hp1 = histvec; i < npitch; i++, hp1++) - hp1->h_used = 0; + hp1->h_used = 0; - /* for each old pitch, try to match a new one to it. */ + /* for each old pitch, try to match a new one to it. */ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++) { - float thispitch = phist->h_pitches[oldphase]; - phist->h_pitch = 0; /* no output, thanks */ - phist->h_wherefrom = 0; - if (thispitch == 0.0f) continue; - for (j = 0, hp1 = histvec; j < npitch; j++, hp1++) - if ((hp1->h_value > 0) && hp1->h_pitch > thispitch - GLISS - && hp1->h_pitch < thispitch + GLISS) - { - phist->h_wherefrom = hp1; - hp1->h_used = 1; - } + float thispitch = phist->h_pitches[oldphase]; + phist->h_pitch = 0; /* no output, thanks */ + phist->h_wherefrom = 0; + if (thispitch == 0.0f) continue; + for (j = 0, hp1 = histvec; j < npitch; j++, hp1++) + if ((hp1->h_value > 0) && hp1->h_pitch > thispitch - GLISS + && hp1->h_pitch < thispitch + GLISS) + { + phist->h_wherefrom = hp1; + hp1->h_used = 1; + } } for (i = 0, hp1 = histvec; i < npitch; i++, hp1++) - if ((hp1->h_value > 0) && !hp1->h_used) + if ((hp1->h_value > 0) && !hp1->h_used) { - for (j = 0, phist = x->x_hist; j < x->x_npitch; j++, phist++) - if (!phist->h_wherefrom) - { - phist->h_wherefrom = hp1; - phist->h_age = 0; - phist->h_noted = 0; - hp1->h_used = 1; - goto happy; - } - break; + for (j = 0, phist = x->x_hist; j < x->x_npitch; j++, phist++) + if (!phist->h_wherefrom) + { + phist->h_wherefrom = hp1; + phist->h_age = 0; + phist->h_noted = 0; + hp1->h_used = 1; + goto happy; + } + break; happy: ; } - /* copy the pitch info into the history vector */ + /* copy the pitch info into the history vector */ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++) { - if (phist->h_wherefrom) - { - phist->h_amps[newphase] = phist->h_wherefrom->h_loud; - phist->h_pitches[newphase] = - phist->h_wherefrom->h_pitch; - (phist->h_age)++; - } - else - { - phist->h_age = 0; - phist->h_amps[newphase] = phist->h_pitches[newphase] = 0; - } + if (phist->h_wherefrom) + { + phist->h_amps[newphase] = phist->h_wherefrom->h_loud; + phist->h_pitches[newphase] = + phist->h_wherefrom->h_pitch; + (phist->h_age)++; + } + else + { + phist->h_age = 0; + phist->h_amps[newphase] = phist->h_pitches[newphase] = 0; + } } #if 1 if (x->x_nprint) { - post("vibrato %d %f", x->x_vibbins, x->x_vibdepth); - for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++) - { - post("noted %f, age %d", phist->h_noted, phist->h_age); + post("vibrato %d %f", x->x_vibbins, x->x_vibdepth); + for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++) + { + post("noted %f, age %d", phist->h_noted, phist->h_age); #ifndef I860 - post("values %f %f %f %f %f", - phist->h_pitches[newphase], - phist->h_pitches[(newphase + HISTORY-1)%HISTORY], - phist->h_pitches[(newphase + HISTORY-2)%HISTORY], - phist->h_pitches[(newphase + HISTORY-3)%HISTORY], - phist->h_pitches[(newphase + HISTORY-4)%HISTORY]); + post("values %f %f %f %f %f", + phist->h_pitches[newphase], + phist->h_pitches[(newphase + HISTORY-1)%HISTORY], + phist->h_pitches[(newphase + HISTORY-2)%HISTORY], + phist->h_pitches[(newphase + HISTORY-3)%HISTORY], + phist->h_pitches[(newphase + HISTORY-4)%HISTORY]); #endif - } + } } #endif - /* look for envelope attacks */ + /* look for envelope attacks */ x->x_attackvalue = 0; if (x->x_peaked) { - if (total_db > x->x_amphi) - { - int binlook = newphase - x->x_attackbins; - if (binlook < 0) binlook += HISTORY; - if (total_db > x->x_dbs[binlook] + x->x_attackthresh) - { - x->x_attackvalue = 1; - x->x_peaked = 0; - } - } + if (total_db > x->x_amphi) + { + int binlook = newphase - x->x_attackbins; + if (binlook < 0) binlook += HISTORY; + if (total_db > x->x_dbs[binlook] + x->x_attackthresh) + { + x->x_attackvalue = 1; + x->x_peaked = 0; + } + } } else { - int binlook = newphase - x->x_attackbins; - if (binlook < 0) binlook += HISTORY; - if (x->x_dbs[binlook] > x->x_amphi && x->x_dbs[binlook] > total_db) - x->x_peaked = 1; + int binlook = newphase - x->x_attackbins; + if (binlook < 0) binlook += HISTORY; + if (x->x_dbs[binlook] > x->x_amphi && x->x_dbs[binlook] > total_db) + x->x_peaked = 1; } - /* for each current frequency track, test for a new note using a - * stability criterion. Later perhaps we should also do as in - * pitch~ and check for unstable notes a posteriori when - * there's a new attack with no note found since the last onset; - * but what's an attack &/or onset when we're polyphonic? - */ + /* for each current frequency track, test for a new note using a + * stability criterion. Later perhaps we should also do as in + * pitch~ and check for unstable notes a posteriori when + * there's a new attack with no note found since the last onset; + * but what's an attack &/or onset when we're polyphonic? + */ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++) { - /* - * if we've found a pitch but we've now strayed from it turn - * it off. - */ - if (phist->h_noted) - { - if (phist->h_pitches[newphase] > phist->h_noted + x->x_vibdepth - || phist->h_pitches[newphase] < phist->h_noted - x->x_vibdepth) - phist->h_noted = 0; - } - else - { - if (phist->h_wherefrom && phist->h_age >= x->x_vibbins) - { - float centroid = 0; - int not = 0; - for (j = 0, k = newphase; j < x->x_vibbins; j++) - { - centroid += phist->h_pitches[k]; - k--; - if (k < 0) k = HISTORY-1; - } - centroid /= x->x_vibbins; - for (j = 0, k = newphase; j < x->x_vibbins; j++) - { - /* calculate deviation from norm */ - float dev = centroid - phist->h_pitches[k]; - k--; - if (k < 0) k = HISTORY-1; - if (dev > x->x_vibdepth || - -dev > x->x_vibdepth) not = 1; - } - if (!not) - { - phist->h_pitch = phist->h_noted = centroid; - } - } - } + /* + * if we've found a pitch but we've now strayed from it turn + * it off. + */ + if (phist->h_noted) + { + if (phist->h_pitches[newphase] > phist->h_noted + x->x_vibdepth + || phist->h_pitches[newphase] < phist->h_noted - x->x_vibdepth) + phist->h_noted = 0; + } + else + { + if (phist->h_wherefrom && phist->h_age >= x->x_vibbins) + { + float centroid = 0; + int not = 0; + for (j = 0, k = newphase; j < x->x_vibbins; j++) + { + centroid += phist->h_pitches[k]; + k--; + if (k < 0) k = HISTORY-1; + } + centroid /= x->x_vibbins; + for (j = 0, k = newphase; j < x->x_vibbins; j++) + { + /* calculate deviation from norm */ + float dev = centroid - phist->h_pitches[k]; + k--; + if (k < 0) k = HISTORY-1; + if (dev > x->x_vibdepth || + -dev > x->x_vibdepth) not = 1; + } + if (!not) + { + phist->h_pitch = phist->h_noted = centroid; + } + } + } } return; nopow: for (i = 0; i < x->x_npitch; i++) { - x->x_hist[i].h_pitch = x->x_hist[i].h_noted = - x->x_hist[i].h_pitches[newphase] = - x->x_hist[i].h_amps[newphase] = 0; - x->x_hist[i].h_age = 0; + x->x_hist[i].h_pitch = x->x_hist[i].h_noted = + x->x_hist[i].h_pitches[newphase] = + x->x_hist[i].h_amps[newphase] = 0; + x->x_hist[i].h_age = 0; } x->x_peaked = 1; x->x_dbage = 0; @@ -1057,19 +1051,19 @@ static void sigfiddle_freebird(t_sigfiddle *x) { if (x->x_inbuf) { - freebytes(x->x_inbuf, sizeof(float) * x->x_hop); - x->x_inbuf = 0; + freebytes(x->x_inbuf, sizeof(float) * x->x_hop); + x->x_inbuf = 0; } if (x->x_lastanalysis) { - freebytes(x->x_lastanalysis, - sizeof(float) * (2 * x->x_hop + 4 * FILTSIZE)); - x->x_lastanalysis = 0; + freebytes(x->x_lastanalysis, + sizeof(float) * (2 * x->x_hop + 4 * FILTSIZE)); + x->x_lastanalysis = 0; } if (x->x_spiral) { - freebytes(x->x_spiral, sizeof(float) * 2 * x->x_hop); - x->x_spiral = 0; + freebytes(x->x_spiral, sizeof(float) * 2 * x->x_hop); + x->x_spiral = 0; } x->x_hop = 0; } @@ -1080,29 +1074,29 @@ int sigfiddle_setnpoints(t_sigfiddle *x, t_floatarg fnpoints) sigfiddle_freebird(x); if (npoints < MINPOINTS || npoints > MAXPOINTS) { - error("fiddle~: npoints out of range; using %d", - npoints = DEFAULTPOINTS); + error("fiddle~: npoints out of range; using %d", + npoints = DEFAULTPOINTS); } if (npoints != (1 << sigfiddle_ilog2(npoints))) { - error("fiddle~: npoints not a power of 2; using %d", - npoints = (1 << sigfiddle_ilog2(npoints))); + error("fiddle~: npoints not a power of 2; using %d", + npoints = (1 << sigfiddle_ilog2(npoints))); } x->x_hop = npoints >> 1; if (!(x->x_inbuf = (float *)getbytes(sizeof(float) * x->x_hop))) - goto fail; + goto fail; if (!(x->x_lastanalysis = (float *)getbytes( - sizeof(float) * (2 * x->x_hop + 4 * FILTSIZE)))) - goto fail; + sizeof(float) * (2 * x->x_hop + 4 * FILTSIZE)))) + goto fail; if (!(x->x_spiral = (float *)getbytes(sizeof(float) * 2 * x->x_hop))) - goto fail; + goto fail; for (i = 0; i < x->x_hop; i++) - x->x_inbuf[i] = 0; + x->x_inbuf[i] = 0; for (i = 0; i < npoints + 4 * FILTSIZE; i++) - x->x_lastanalysis[i] = 0; + x->x_lastanalysis[i] = 0; for (i = 0; i < x->x_hop; i++) - x->x_spiral[2*i] = cos((3.14159*i)/(npoints)), - x->x_spiral[2*i+1] = -sin((3.14159*i)/(npoints)); + x->x_spiral[2*i] = cos((3.14159*i)/(npoints)), + x->x_spiral[2*i+1] = -sin((3.14159*i)/(npoints)); x->x_phase = 0; return (1); fail: @@ -1126,36 +1120,36 @@ int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch, else if (npitch > MAXNPITCH) npitch = MAXNPITCH; if (npeakanal && !npitch) npitch = 1; if (!npoints) - npoints = DEFAULTPOINTS; + npoints = DEFAULTPOINTS; if (!sigfiddle_setnpoints(x, npoints)) { - error("fiddle~: out of memory"); - return (0); + error("fiddle~: out of memory"); + return (0); } if (!(buf4 = (t_peakout *)getbytes(sizeof(*buf4) * npeakout))) { - sigfiddle_freebird(x); - error("fiddle~: out of memory"); - return (0); + sigfiddle_freebird(x); + error("fiddle~: out of memory"); + return (0); } for (i = 0; i < npeakout; i++) - buf4[i].po_freq = buf4[i].po_amp = 0; + buf4[i].po_freq = buf4[i].po_amp = 0; x->x_peakbuf = buf4; x->x_npeakout = npeakout; x->x_npeakanal = npeakanal; x->x_phase = 0; x->x_histphase = 0; - x->x_sr = 44100; /* this and the next are filled in later */ + x->x_sr = 44100; /* this and the next are filled in later */ for (i = 0; i < MAXNPITCH; i++) { - int j; - x->x_hist[i].h_pitch = x->x_hist[i].h_noted = 0; - x->x_hist[i].h_age = 0; - x->x_hist[i].h_wherefrom = 0; - x->x_hist[i].h_outlet = 0; - for (j = 0; j < HISTORY; j++) - x->x_hist[i].h_amps[j] = x->x_hist[i].h_pitches[j] = 0; + int j; + x->x_hist[i].h_pitch = x->x_hist[i].h_noted = 0; + x->x_hist[i].h_age = 0; + x->x_hist[i].h_wherefrom = 0; + x->x_hist[i].h_outlet = 0; + for (j = 0; j < HISTORY; j++) + x->x_hist[i].h_amps[j] = x->x_hist[i].h_pitches[j] = 0; } x->x_nprint = 0; x->x_npitch = npitch; @@ -1166,10 +1160,10 @@ int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch, x->x_amplo = DEFAMPLO; x->x_amphi = DEFAMPHI; x->x_attacktime = DEFATTACKTIME; - x->x_attackbins = 1; /* real value calculated afterward */ + x->x_attackbins = 1; /* real value calculated afterward */ x->x_attackthresh = DEFATTACKTHRESH; x->x_vibtime = DEFVIBTIME; - x->x_vibbins = 1; /* real value calculated afterward */ + x->x_vibbins = 1; /* real value calculated afterward */ x->x_vibdepth = DEFVIBDEPTH; x->x_npartial = 7; x->x_attackvalue = 0; @@ -1238,15 +1232,15 @@ void ftl_sigfiddle(fts_word_t *a) int count; float *fp, *fp2; for (count = 0, fp = x->x_inbuf + x->x_phase; - count < n_tick; count++) *fp++ = *in++; + count < n_tick; count++) *fp++ = *in++; if (fp == x->x_inbuf + x->x_hop) { - sigfiddle_doit(x); - x->x_phase = 0; + sigfiddle_doit(x); + x->x_phase = 0; fts_alarm_set_delay(&x->x_clock, 0L); /* output bang */ fts_alarm_arm(&x->x_clock); - if (x->x_nprint) x->x_nprint--; + if (x->x_nprint) x->x_nprint--; } else x->x_phase += n_tick; } @@ -1277,14 +1271,14 @@ void sigfiddle_tick(fts_alarm_t *alarm, void *p) fts_outlet_float(o, OUTLETpower, x->x_dbs[x->x_histphase]); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) { - fts_atom_t at[2]; - fts_set_float(at, ph->h_pitches[x->x_histphase]); - fts_set_float(at+1, ph->h_amps[x->x_histphase]); - fts_outlet_list(o, OUTLETmicropitch3 - i, 2, at); + fts_atom_t at[2]; + fts_set_float(at, ph->h_pitches[x->x_histphase]); + fts_set_float(at+1, ph->h_amps[x->x_histphase]); + fts_outlet_list(o, OUTLETmicropitch3 - i, 2, at); } if (x->x_attackvalue) fts_outlet_bang(o, OUTLETattack); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) - if (ph->h_pitch) fts_outlet_float(o, OUTLETpitch, ph->h_pitch); + if (ph->h_pitch) fts_outlet_float(o, OUTLETpitch, ph->h_pitch); } static void sigfiddle_delete(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, @@ -1310,12 +1304,12 @@ static void sigfiddle_init(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout)) { - post("fiddle~: initialization failed"); - return; + post("fiddle~: initialization failed"); + return; } hop = npoints>>1; if (fts_fft_declaresize(hop) != fts_Success) - post("fiddle~: bad FFT size"); + post("fiddle~: bad FFT size"); fts_alarm_init(&(x->x_clock), 0, sigfiddle_tick, x); dsp_list_insert(o); @@ -1344,13 +1338,13 @@ static fts_status_t sigfiddle_instantiate(fts_class_t *cl, int ac, fts_method_define(cl, 0, fts_new_symbol("print"), sigfiddle_print13, 0, a); fts_method_define(cl, 0, fts_new_symbol("debug"), sigfiddle_debug13, 0, a); fts_method_define(cl, 0, fts_new_symbol("amp-range"), sigfiddle_amprange13, - 0, a); + 0, a); fts_method_define(cl, 0, fts_new_symbol("reattack"), sigfiddle_reattack13, - 0, a); + 0, a); fts_method_define(cl, 0, fts_new_symbol("vibrato"), sigfiddle_vibrato13, - 0, a); + 0, a); fts_method_define(cl, 0, fts_new_symbol("npartial"), sigfiddle_npartial13, - 0, a); + 0, a); /* classes signal inlets */ dsp_sig_inlet(cl, 0); /* declare signal input #0 */ @@ -1385,7 +1379,7 @@ void fiddle_config(void) fts_module_t fiddle_module = {"fiddle", "sonic meat fiddle", fiddle_config, 0}; -#endif /* JMAX */ +#endif /* JMAX */ #ifdef PD @@ -1397,15 +1391,15 @@ static t_int *fiddle_perform(t_int *w) int count; float *fp; if (!x->x_hop) - goto nono; + goto nono; for (count = 0, fp = x->x_inbuf + x->x_phase; count < n; count++) - *fp++ = *in++; + *fp++ = *in++; if (fp == x->x_inbuf + x->x_hop) { - sigfiddle_doit(x); - x->x_phase = 0; - if (x->x_auto) clock_delay(x->x_clock, 0L); - if (x->x_nprint) x->x_nprint--; + sigfiddle_doit(x); + x->x_phase = 0; + if (x->x_auto) clock_delay(x->x_clock, 0L); + if (x->x_nprint) x->x_nprint--; } else x->x_phase += n; nono: @@ -1430,39 +1424,39 @@ void sigfiddle_bang(t_sigfiddle *x) t_pitchhist *ph; if (x->x_npeakout) { - int npeakout = x->x_npeakout; - t_peakout *po; - for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++) - { - t_atom at[3]; - SETFLOAT(at, i+1); - SETFLOAT(at+1, po->po_freq); - SETFLOAT(at+2, po->po_amp); - outlet_list(x->x_peakout, 0, 3, at); - } + int npeakout = x->x_npeakout; + t_peakout *po; + for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++) + { + t_atom at[3]; + SETFLOAT(at, i+1); + SETFLOAT(at+1, po->po_freq); + SETFLOAT(at+2, po->po_amp); + outlet_list(x->x_peakout, 0, 3, at); + } } outlet_float(x->x_envout, x->x_dbs[x->x_histphase]); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) { - t_atom at[2]; - SETFLOAT(at, ph->h_pitches[x->x_histphase]); - SETFLOAT(at+1, ph->h_amps[x->x_histphase]); - outlet_list(ph->h_outlet, 0, 2, at); + t_atom at[2]; + SETFLOAT(at, ph->h_pitches[x->x_histphase]); + SETFLOAT(at+1, ph->h_amps[x->x_histphase]); + outlet_list(ph->h_outlet, 0, 2, at); } if (x->x_attackvalue) outlet_bang(x->x_attackout); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) - if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); + if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); } -void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free */ +void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free */ { if (x->x_inbuf) { - freebytes(x->x_inbuf, sizeof(float) * x->x_hop); - freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE)); - freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop); - freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout); - clock_free(x->x_clock); + freebytes(x->x_inbuf, sizeof(float) * x->x_hop); + freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE)); + freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop); + freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout); + clock_free(x->x_clock); } } @@ -1477,19 +1471,19 @@ void *sigfiddle_new(t_floatarg npoints, t_floatarg npitch, if (!sigfiddle_doinit(x, npoints, npitch, - npeakanal, npeakout)) + npeakanal, npeakout)) { - x->x_inbuf = 0; /* prevent the free routine from cleaning up */ - pd_free(&x->x_ob.ob_pd); - return (0); + x->x_inbuf = 0; /* prevent the free routine from cleaning up */ + pd_free(&x->x_ob.ob_pd); + return (0); } x->x_noteout = outlet_new(&x->x_ob, gensym("float")); x->x_attackout = outlet_new(&x->x_ob, gensym("bang")); for (i = 0; i < x->x_npitch; i++) - x->x_hist[i].h_outlet = outlet_new(&x->x_ob, gensym("list")); + x->x_hist[i].h_outlet = outlet_new(&x->x_ob, gensym("list")); x->x_envout = outlet_new(&x->x_ob, gensym("float")); if (x->x_npeakout) - x->x_peakout = outlet_new(&x->x_ob, gensym("list")); + x->x_peakout = outlet_new(&x->x_ob, gensym("list")); else x->x_peakout = 0; x->x_clock = clock_new(&x->x_ob.ob_pd, (t_method)sigfiddle_bang); return (x); @@ -1498,30 +1492,30 @@ void *sigfiddle_new(t_floatarg npoints, t_floatarg npitch, void fiddle_tilde_setup(void) { sigfiddle_class = class_new(gensym("fiddle~"), (t_newmethod)sigfiddle_new, - (t_method)sigfiddle_ff, sizeof(t_sigfiddle), 0, - A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + (t_method)sigfiddle_ff, sizeof(t_sigfiddle), 0, + A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_dsp, - gensym("dsp"), 0); + gensym("dsp"), 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_debug, - gensym("debug"), 0); + gensym("debug"), 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_setnpoints, - gensym("npoints"), A_FLOAT, 0); + gensym("npoints"), A_FLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_amprange, - gensym("amp-range"), A_FLOAT, A_FLOAT, 0); + gensym("amp-range"), A_FLOAT, A_FLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_reattack, - gensym("reattack"), A_FLOAT, A_FLOAT, 0); + gensym("reattack"), A_FLOAT, A_FLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_vibrato, - gensym("vibrato"), A_FLOAT, A_FLOAT, 0); + gensym("vibrato"), A_FLOAT, A_FLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_npartial, - gensym("npartial"), A_FLOAT, 0); + gensym("npartial"), A_FLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_auto, - gensym("auto"), A_FLOAT, 0); + gensym("auto"), A_FLOAT, 0); class_addmethod(sigfiddle_class, (t_method)sigfiddle_print, - gensym("print"), 0); + gensym("print"), 0); class_addmethod(sigfiddle_class, nullfn, gensym("signal"), 0); class_addbang(sigfiddle_class, sigfiddle_bang); class_addcreator((t_newmethod)sigfiddle_new, gensym("fiddle"), - A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); + A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0); post(fiddle_version); } @@ -1538,13 +1532,13 @@ void cu_fiddle(float *in1, t_sigfiddle *x, int n) int count; float *fp, *fp2; for (count = 0, fp = x->x_inbuf + x->x_phase; - count < n; count++) *fp++ = *in1++; + count < n; count++) *fp++ = *in1++; if (fp == x->x_inbuf + x->x_hop) { - sigfiddle_doit(x); - x->x_phase = 0; - if (x->x_auto) clock_delay(x->x_clock, 0L); - if (x->x_nprint) x->x_nprint--; + sigfiddle_doit(x); + x->x_phase = 0; + if (x->x_auto) clock_delay(x->x_clock, 0L); + if (x->x_nprint) x->x_nprint--; } else x->x_phase += n; } @@ -1553,41 +1547,41 @@ void sigfiddle_put(t_sigfiddle *x, long whether) { if (whether) { - u_stdout(x); - x->x_sr = x->x_io[0]->s_sr; - sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh); - sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth); - dspchain_addc(cu_fiddle, 3, - x->x_io[0]->s_shit, x, x->x_io[0]->s_n); + u_stdout(x); + x->x_sr = x->x_io[0]->s_sr; + sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh); + sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth); + dspchain_addc(cu_fiddle, 3, + x->x_io[0]->s_shit, x, x->x_io[0]->s_n); } } -void sigfiddle_tick(t_sigfiddle *x) /* callback function for the clock */ +void sigfiddle_tick(t_sigfiddle *x) /* callback function for the clock */ { int i; t_pitchhist *ph; outlet_float(x->x_envout, x->x_dbs[x->x_histphase]); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) { - t_atom at[2]; - SETFLOAT(at, ph->h_pitches[x->x_histphase]); - SETFLOAT(at+1, ph->h_amps[x->x_histphase]); - outlet_list(ph->h_outlet, NIL, 2, at); + t_atom at[2]; + SETFLOAT(at, ph->h_pitches[x->x_histphase]); + SETFLOAT(at+1, ph->h_amps[x->x_histphase]); + outlet_list(ph->h_outlet, NIL, 2, at); } if (x->x_attackvalue) outlet_bang(x->x_attackout); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) - if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); + if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); } -void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free */ +void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free */ { if (x->x_inbuf) { - freebytes(x->x_inbuf, sizeof(float) * x->x_hop); - freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE)); - freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop); - clock_free(x->x_clock); - u_clean(x); + freebytes(x->x_inbuf, sizeof(float) * x->x_hop); + freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE)); + freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop); + clock_free(x->x_clock); + u_clean(x); } } @@ -1601,14 +1595,14 @@ void *sigfiddle_new(long npoints, long npitch, if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout)) { - x->x_inbuf = 0; /* prevent the free routine from cleaning up */ - obj_free(x); - return (0); + x->x_inbuf = 0; /* prevent the free routine from cleaning up */ + obj_free(x); + return (0); } u_setup(x, IN1, OUT0); x->x_envout = outlet_new(x, gensym("float")); for (i = 0; i < x->x_npitch; i++) - x->x_hist[i].h_outlet = outlet_new(x, gensym("list")); + x->x_hist[i].h_outlet = outlet_new(x, gensym("list")); x->x_attackout = outlet_new(x, gensym("bang")); x->x_noteout = outlet_new(x, gensym("float")); x->x_clock = clock_new(x, sigfiddle_tick); @@ -1618,8 +1612,8 @@ void *sigfiddle_new(long npoints, long npitch, void fiddle_setup() { c_extern(&sigfiddle_class, sigfiddle_new, sigfiddle_ff, - gensym("fiddle"), sizeof(t_sigfiddle), 0, A_DEFLONG, A_DEFLONG, - A_DEFLONG, A_DEFLONG, 0); + gensym("fiddle"), sizeof(t_sigfiddle), 0, A_DEFLONG, A_DEFLONG, + A_DEFLONG, A_DEFLONG, 0); c_addmess(sigfiddle_put, gensym("put"), A_CANT, 0); c_addmess(sigfiddle_debug, gensym("debug"), 0); c_addmess(sigfiddle_amprange, gensym("amp-range"), A_FLOAT, A_FLOAT, 0); @@ -1627,7 +1621,7 @@ void fiddle_setup() c_addmess(sigfiddle_vibrato, gensym("vibrato"), A_LONG, A_FLOAT, 0); c_addmess(sigfiddle_npartial, gensym("npartial"), A_FLOAT, 0); c_addmess(sigfiddle_print, gensym("print"), 0); - u_inletmethod(0); /* one signal input */ + u_inletmethod(0); /* one signal input */ #ifdef MAX post(fiddle_version); #endif @@ -1648,17 +1642,17 @@ static t_int *fiddle_perform(t_int *w) float *fp; if (x->x_obj.z_disabled) - goto skip; + goto skip; for (count = 0, fp = x->x_inbuf + x->x_phase; count < n; count+=inc) { - *fp++ = *in; - in += inc; + *fp++ = *in; + in += inc; } if (fp == x->x_inbuf + x->x_hop) { - sigfiddle_doit(x); - x->x_phase = 0; - if (x->x_auto) clock_delay(x->x_clock, 0L); - if (x->x_nprint) x->x_nprint--; + sigfiddle_doit(x); + x->x_phase = 0; + if (x->x_auto) clock_delay(x->x_clock, 0L); + if (x->x_nprint) x->x_nprint--; } else x->x_phase += n; skip: @@ -1668,147 +1662,142 @@ skip: void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp) { if (sp[0]->s_n > x->x_hop) { - x->x_downsample = sp[0]->s_n / x->x_hop; - post("* warning: fiddle~: will downsample input by %ld",x->x_downsample); - x->x_sr = sp[0]->s_sr / x->x_downsample; + x->x_downsample = sp[0]->s_n / x->x_hop; + post("* warning: fiddle~: will downsample input by %ld",x->x_downsample); + x->x_sr = sp[0]->s_sr / x->x_downsample; } else { - x->x_downsample = 1; - x->x_sr = sp[0]->s_sr; - } - sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh); + x->x_downsample = 1; + x->x_sr = sp[0]->s_sr; + } + sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh); sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth); dsp_add(fiddle_perform, 3, sp[0]->s_vec, x, sp[0]->s_n); } -void sigfiddle_tick(t_sigfiddle *x) /* callback function for the clock MSP*/ +void sigfiddle_tick(t_sigfiddle *x) /* callback function for the clock MSP*/ { int i; t_pitchhist *ph; if (x->x_npeakout) { - int npeakout = x->x_npeakout; - t_peakout *po; - for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++) - { - t_atom at[3]; - SETINT(at, i+1); - SETFLOAT(at+1, po->po_freq); - SETFLOAT(at+2, po->po_amp); - outlet_list(x->x_peakout, 0, 3, at); - } + int npeakout = x->x_npeakout; + t_peakout *po; + for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++) + { + t_atom at[3]; + SETINT(at, i+1); + SETFLOAT(at+1, po->po_freq); + SETFLOAT(at+2, po->po_amp); + outlet_list(x->x_peakout, 0, 3, at); + } } outlet_float(x->x_envout, x->x_dbs[x->x_histphase]); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) { - t_atom at[2]; - SETFLOAT(at, ph->h_pitches[x->x_histphase]); - SETFLOAT(at+1, ph->h_amps[x->x_histphase]); - outlet_list(ph->h_outlet, 0, 2, at); + t_atom at[2]; + SETFLOAT(at, ph->h_pitches[x->x_histphase]); + SETFLOAT(at+1, ph->h_amps[x->x_histphase]); + outlet_list(ph->h_outlet, 0, 2, at); } if (x->x_attackvalue) outlet_bang(x->x_attackout); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) - if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); + if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); } -void sigfiddle_bang(t_sigfiddle *x) // MSP +void sigfiddle_bang(t_sigfiddle *x) { int i; t_pitchhist *ph; if (x->x_npeakout) { - int npeakout = x->x_npeakout; - t_peakout *po; - for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++) - { - t_atom at[3]; - SETLONG(at, i+1); - SETFLOAT(at+1, po->po_freq); - SETFLOAT(at+2, po->po_amp); - outlet_list(x->x_peakout, 0, 3, at); - } + int npeakout = x->x_npeakout; + t_peakout *po; + for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++) + { + t_atom at[3]; + SETLONG(at, i+1); + SETFLOAT(at+1, po->po_freq); + SETFLOAT(at+2, po->po_amp); + outlet_list(x->x_peakout, 0, 3, at); + } } outlet_float(x->x_envout, x->x_dbs[x->x_histphase]); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) { - t_atom at[2]; - SETFLOAT(at, ph->h_pitches[x->x_histphase]); - SETFLOAT(at+1, ph->h_amps[x->x_histphase]); - outlet_list(ph->h_outlet, 0, 2, at); + t_atom at[2]; + SETFLOAT(at, ph->h_pitches[x->x_histphase]); + SETFLOAT(at+1, ph->h_amps[x->x_histphase]); + outlet_list(ph->h_outlet, 0, 2, at); } if (x->x_attackvalue) outlet_bang(x->x_attackout); for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++) - if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); + if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch); } -void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free MSP */ +void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free MSP */ { if (x->x_inbuf) { - t_freebytes(x->x_inbuf, sizeof(float) * x->x_hop); - t_freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * + t_freebytes(x->x_inbuf, sizeof(float) * x->x_hop); + t_freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE)); - t_freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop); - t_freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout); - //clock_free(x->x_clock); + t_freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop); + t_freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout); } - dsp_free((t_pxobject *)x); // Free the object + dsp_free((t_pxobject *)x); } void *sigfiddle_class; -void *sigfiddle_new(long npoints, long npitch, // MSP +void *sigfiddle_new(long npoints, long npitch, long npeakanal, long npeakout) { t_sigfiddle *x = (t_sigfiddle *)newobject(sigfiddle_class); int i; if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout)) - // MSP { - x->x_inbuf = 0; /* prevent the free routine from cleaning up */ - return (0); + x->x_inbuf = 0; /* prevent the free routine from cleaning up */ + return (0); } - // post("npeak %d, npitch %d", npeakout, npitch); - // set up the inlets and outlets. - dsp_setup((t_pxobject *)x,1); // 1 input + dsp_setup((t_pxobject *)x,1); x->x_clock = clock_new(x, (method)sigfiddle_tick); if (x->x_npeakout) - x->x_peakout = listout((t_object *)x); // listout? + x->x_peakout = listout((t_object *)x); else x->x_peakout = 0; x->x_envout = floatout((t_object *)x); for (i = 0; i < x->x_npitch; i++) - x->x_hist[i].h_outlet = listout((t_object *)x); - x->x_attackout = bangout((t_object *)x); - x->x_noteout = floatout((t_object *)x); - return (x); + x->x_hist[i].h_outlet = listout((t_object *)x); + x->x_attackout = bangout((t_object *)x); + x->x_noteout = floatout((t_object *)x); + return (x); } -void main() // this can be called fiddle_setup if that name is the "Main" -in PPC Linker prefs +void main() { - setup(&sigfiddle_class, sigfiddle_new, (method)sigfiddle_ff, - (short)sizeof(t_sigfiddle), 0L, A_DEFLONG, A_DEFLONG, + setup(&sigfiddle_class, sigfiddle_new, (method)sigfiddle_ff, + (short)sizeof(t_sigfiddle), 0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0); - addmess((method)sigfiddle_dsp, "dsp", - A_CANT, 0); - addmess((method)sigfiddle_debug, "debug", 0); - addmess((method)sigfiddle_setnpoints, "npoints", A_FLOAT, 0); - addmess((method)sigfiddle_amprange, "amp-range", A_FLOAT, A_FLOAT, 0); - addmess((method)sigfiddle_reattack, "reattack", A_FLOAT, A_FLOAT, 0); - addmess((method)sigfiddle_vibrato, "vibrato", A_FLOAT, + addmess((method)sigfiddle_dsp, "dsp", + A_CANT, 0); + addmess((method)sigfiddle_debug, "debug", 0); + addmess((method)sigfiddle_setnpoints, "npoints", A_FLOAT, 0); + addmess((method)sigfiddle_amprange, "amp-range", A_FLOAT, A_FLOAT, 0); + addmess((method)sigfiddle_reattack, "reattack", A_FLOAT, A_FLOAT, 0); + addmess((method)sigfiddle_vibrato, "vibrato", A_FLOAT, A_FLOAT, 0); - addmess((method)sigfiddle_npartial, "npartial", A_FLOAT, 0); - addmess((method)sigfiddle_auto, "auto", - A_FLOAT, 0); - addmess((method)sigfiddle_print, "print", 0); - addmess((method)sigfiddle_assist, "assist", - A_CANT, 0); - addbang((method)sigfiddle_bang); + addmess((method)sigfiddle_npartial, "npartial", A_FLOAT, 0); + addmess((method)sigfiddle_auto, "auto", + A_FLOAT, 0); + addmess((method)sigfiddle_print, "print", 0); + addmess((method)sigfiddle_assist, "assist", + A_CANT, 0); + addbang((method)sigfiddle_bang); dsp_initclass(); rescopy('STR#',3748); post(fiddle_version); @@ -1816,39 +1805,41 @@ A_FLOAT, 0); void sigfiddle_assist(t_sigfiddle *x, void *b, long m, long a, char *s) { - assist_string(3748,m,a,1,2,s); + assist_string(3748,m,a,1,2,s); } void msp_fft(float *buf, long np, long inv) { - float *src,*real,*rp,*imag,*ip; - long i; - - // because this fft algorithm uses separate real and imaginary - // buffers - // we must split the real and imaginary parts into two buffers, - // then do the opposite on output - // a more ambitious person would either do an in-place conversion - // or rewrite the fft algorithm - - real = rp = msp_ffttemp; - imag = ip = real + MAXPOINTS; - src = buf; - for (i = 0; i < np; i++) { - *rp++ = *src++; - *ip++ = *src++; - } - if (inv) - ifft(np,real,imag); - else - fft(np,real,imag); - rp = real; - ip = imag; - src = buf; - for (i = 0; i < np; i++) { - *src++ = *rp++; - *src++ = *ip++; - } + float *src,*real,*rp,*imag,*ip; + long i; + + /* + // because this fft algorithm uses separate real and imaginary + // buffers + // we must split the real and imaginary parts into two buffers, + // then do the opposite on output + // a more ambitious person would either do an in-place conversion + // or rewrite the fft algorithm + */ + + real = rp = msp_ffttemp; + imag = ip = real + MAXPOINTS; + src = buf; + for (i = 0; i < np; i++) { + *rp++ = *src++; + *ip++ = *src++; + } + if (inv) + ifft(np,real,imag); + else + fft(np,real,imag); + rp = real; + ip = imag; + src = buf; + for (i = 0; i < np; i++) { + *src++ = *rp++; + *src++ = *ip++; + } } #endif /* MSP */ |