mirror of
https://github.com/cookiengineer/audacity
synced 2025-05-11 14:41:06 +02:00
15b9bb96cd
------------------------------------------------------------------------ r331 | rbd | 2020-10-13 12:40:12 -0500 (Tue, 13 Oct 2020) | 2 lines Also forgot to install NyquistWords.txt ------------------------------------------------------------------------ r330 | rbd | 2020-10-13 12:34:06 -0500 (Tue, 13 Oct 2020) | 2 lines Forgot to move nyquistman.pdf from docsrc/s2h to release ------------------------------------------------------------------------ r329 | rbd | 2020-10-13 11:32:33 -0500 (Tue, 13 Oct 2020) | 2 lines Updated some version numbers for 3.16. ------------------------------------------------------------------------ r328 | rbd | 2020-10-13 11:20:52 -0500 (Tue, 13 Oct 2020) | 2 lines Fixed NyquistIDE antialiasing for plot text, fix format of message. ------------------------------------------------------------------------ r327 | rbd | 2020-10-12 21:01:53 -0500 (Mon, 12 Oct 2020) | 2 lines Fixed a couple of format problems in manual. This version of Nyquist has been tested wtih macOS, Linux, 32&64-bit Windows. ------------------------------------------------------------------------ r326 | rbd | 2020-10-12 20:21:38 -0500 (Mon, 12 Oct 2020) | 1 line Modified WIN32 32-bit XLisp to use 64-bit FIXNUMs. This allows XLisp and Nyquist to handle big sounds even on 32-bit machines. Probably at some cost, but inner loops are mostly float and int32, and the Nyquist release is 64-bit anyway. Maybe we'll have to run some benchmarks on Audacity, which is still 32-bit on Windows. ------------------------------------------------------------------------ r325 | rbd | 2020-10-12 13:16:57 -0500 (Mon, 12 Oct 2020) | 1 line Win64 passes bigfiletest.lsp now. This version should work on all 64-bit systems now. These changes untested on Linux and macOS. ------------------------------------------------------------------------ r324 | rbd | 2020-10-11 21:31:53 -0500 (Sun, 11 Oct 2020) | 2 lines I couldn't free enough space on my linux box, so I adjusted the bigfiletest to write 8-bit ulaw. It's still >4GB and >4G samples. Works on Linux. ------------------------------------------------------------------------ r323 | rbd | 2020-10-11 19:41:25 -0500 (Sun, 11 Oct 2020) | 2 lines Missing file from last commit. ------------------------------------------------------------------------ r322 | rbd | 2020-10-11 19:36:08 -0500 (Sun, 11 Oct 2020) | 1 line Found another case where WIN64 needs int64_t instead of long for sample count. ------------------------------------------------------------------------ r321 | rbd | 2020-10-11 19:33:25 -0500 (Sun, 11 Oct 2020) | 3 lines Fixed s-save to handle optional and keyword parameters (which should never have been mixed in the first place). Documentation cleanup - should be final for this version. ------------------------------------------------------------------------ r320 | rbd | 2020-10-11 14:44:37 -0500 (Sun, 11 Oct 2020) | 2 lines Fixes to handle IRCAM sound format and tests for big file io working on macOS. ------------------------------------------------------------------------ r319 | rbd | 2020-10-10 21:31:58 -0500 (Sat, 10 Oct 2020) | 2 lines Changes for linux and to avoid compiler warnings on linux. ------------------------------------------------------------------------ r318 | rbd | 2020-10-10 20:50:23 -0500 (Sat, 10 Oct 2020) | 1 line This is the test used for Win64 version. ------------------------------------------------------------------------ r317 | rbd | 2020-10-10 20:34:34 -0500 (Sat, 10 Oct 2020) | 1 line This version works on Win64. Need to test changes on macOS and linux. ------------------------------------------------------------------------ r316 | rbd | 2020-10-10 19:59:15 -0500 (Sat, 10 Oct 2020) | 2 lines PWL changes to avoid compiler warning. ------------------------------------------------------------------------ r315 | rbd | 2020-10-10 19:34:04 -0500 (Sat, 10 Oct 2020) | 2 lines A few more changes for 64-bit sample counts on Win64 ------------------------------------------------------------------------ r314 | rbd | 2020-10-10 13:19:42 -0500 (Sat, 10 Oct 2020) | 2 lines Fixed int64_t declaration in gate.alg ------------------------------------------------------------------------ r313 | rbd | 2020-10-10 12:07:40 -0500 (Sat, 10 Oct 2020) | 2 lines Fixes to gate for long sounds ------------------------------------------------------------------------ r312 | rbd | 2020-10-10 11:47:29 -0500 (Sat, 10 Oct 2020) | 2 lines Fixed sound_save types for intgen ------------------------------------------------------------------------ r311 | rbd | 2020-10-10 11:09:01 -0500 (Sat, 10 Oct 2020) | 2 lines Fixed a 64-bit sample count problem in siosc.alg ------------------------------------------------------------------------ r310 | rbd | 2020-10-10 11:03:12 -0500 (Sat, 10 Oct 2020) | 2 lines Fixed sndmax to handle 64-bit sample counts. ------------------------------------------------------------------------ r309 | rbd | 2020-10-10 10:57:04 -0500 (Sat, 10 Oct 2020) | 2 lines Forgot to re-translate all tran/*.alg files with fix for int64 cast to int32. This version compiles on macOS and ready for test on Win64. ------------------------------------------------------------------------ r308 | rbd | 2020-10-10 10:16:05 -0500 (Sat, 10 Oct 2020) | 2 lines Everything seems to compile and run on macOS now. Moving changes to Windows for test. ------------------------------------------------------------------------ r307 | rbd | 2020-10-10 09:23:45 -0500 (Sat, 10 Oct 2020) | 1 line Added casts to avoid compiler warnings and to review changes to support 64-bit sample counts on Windows. Still not complete, and waiting to regenerate and compile tran directory code after updates to translation code that will insert more casts. ------------------------------------------------------------------------ r306 | rbd | 2020-10-09 21:55:15 -0500 (Fri, 09 Oct 2020) | 2 lines Rebuilt seqfnint.c from header files. ------------------------------------------------------------------------ r305 | rbd | 2020-10-09 21:53:33 -0500 (Fri, 09 Oct 2020) | 1 line Changed some FIXNUMS to LONG to avoid compiler warnings in seqfnint.c ------------------------------------------------------------------------ r304 | rbd | 2020-10-09 21:44:03 -0500 (Fri, 09 Oct 2020) | 2 lines I discovered forgotten regression-test.lsp and added test that requires 64-bit sample counts to pass. Fixed a few bugs revealed by running the type-checking regression tests. ------------------------------------------------------------------------ r303 | rbd | 2020-10-09 12:28:58 -0500 (Fri, 09 Oct 2020) | 2 lines Changes for 64-bit sample counts broke mult-channel s-save. Fixed in the commit for macOS. ------------------------------------------------------------------------ r302 | rbd | 2020-10-09 10:03:39 -0500 (Fri, 09 Oct 2020) | 2 lines Changed snd-play to return samples computed and used that to make a test for computing long sounds that would overflow 32-bit length counts. ------------------------------------------------------------------------ r301 | rbd | 2020-10-09 09:11:26 -0500 (Fri, 09 Oct 2020) | 2 lines corrected mistake in delaycv.alg and re-translated ------------------------------------------------------------------------ r300 | rbd | 2020-10-09 09:09:06 -0500 (Fri, 09 Oct 2020) | 2 lines Fix to delaycv.alg -- "s" changed to "input" to avoid matching "s" in "sample_type". ------------------------------------------------------------------------ r299 | rbd | 2020-10-09 09:03:33 -0500 (Fri, 09 Oct 2020) | 4 lines To avoid compiler warnings, XLisp interfaces to C int and long are now specified as LONG rather than FIXNUM, and the stubs that call the C functions cast FIXNUMs from XLisp into longs before calling C functions. ------------------------------------------------------------------------ r298 | rbd | 2020-10-08 22:20:26 -0500 (Thu, 08 Oct 2020) | 2 lines This commit has many more fixes to handle long (64-bit) sounds, including a lot of fixes for warnings by Visual Studio assigning int64_t to long (works on macOS, doesn't work on VS). This was compiled and tested on macOS, and even computed a 27.1-hour sound using OSC, LP, SUM and MULT (haven't tested I/O yet). ------------------------------------------------------------------------ r297 | rbd | 2020-10-07 13:04:02 -0500 (Wed, 07 Oct 2020) | 2 lines This is a major cleanup. It started with the goal of changing long to int64_t for sample counts so that on 64-bit windows, where long is only 32-bits, the sample counts would nevertheless be 64-bit allowing long sounds, which was a limitation for long recordings in Audacity. Since I was using compiler warnings to track possible loss-of-precision conversions from 64-bit sample counts, and there were *many* warnings, I started cleaning up *all* the warnings and ended up with a very large set of changes, including "modernizing" C declarations that date back to XLisp and CMU MIDI Toolkit code and were never changed. This version runs all the examples.sal code on macOS, but will surely have problems on Windows and Linux given the number of changes. ------------------------------------------------------------------------ r296 | rbd | 2020-10-06 13:34:20 -0500 (Tue, 06 Oct 2020) | 2 lines More changes from long to int64_t for sample counts. ------------------------------------------------------------------------ r295 | rbd | 2020-10-06 11:53:49 -0500 (Tue, 06 Oct 2020) | 2 lines More work on using 64-bit sample counts. Changed MAX_STOP from 32-bit to 64-bit limit. ------------------------------------------------------------------------ r294 | rbd | 2020-10-06 11:48:05 -0500 (Tue, 06 Oct 2020) | 2 lines Made some changes so that sample counts are int64_t (for windows) instead of long to support sample counts above 31 bits. ------------------------------------------------------------------------ r293 | rbd | 2020-10-04 21:30:55 -0500 (Sun, 04 Oct 2020) | 2 lines Fixed a few minor things for Linux and tested on Linux. ------------------------------------------------------------------------ r292 | rbd | 2020-10-04 21:00:28 -0500 (Sun, 04 Oct 2020) | 2 lines Update extensions: all are minor changes. ------------------------------------------------------------------------ r291 | rbd | 2020-09-24 13:59:31 -0500 (Thu, 24 Sep 2020) | 2 lines New implementation of seq and seqrep, added get-real-time, documented get-real-time, fixed examples.sal and examples.lsp which are now in lib rather than extensions (so they are now back in the basic installation), other cleanup. ------------------------------------------------------------------------ r290 | rbd | 2020-08-16 16:24:52 -0500 (Sun, 16 Aug 2020) | 2 lines Fixed bug in snd-gate, revised GATE and NOISE-GATE to handle multi-channel sound. RMS now handles multi-channel input. S-AVG added to take multichannel input (but not used, because RMS could not be written without making SND-SRATE convert multichannel sound to vector of floats. That seems to be going toward a fully vectorized model. Not going there for now. ------------------------------------------------------------------------ r289 | rbd | 2020-07-09 16:27:45 -0500 (Thu, 09 Jul 2020) | 2 lines Added GET-REAL-TIME function to XLISP. May not work yet on Windows. Various fixes for compiler warnings. I noticed FLAC doesn't work (I guess it never did) and I cannot figure out how this even links because flac_min seems to be undefined. Something to look at later.
1955 lines
80 KiB
C
1955 lines
80 KiB
C
#include "stdio.h"
|
|
#ifndef mips
|
|
#include "stdlib.h"
|
|
#endif
|
|
#include "xlisp.h"
|
|
#include "sound.h"
|
|
|
|
#include "falloc.h"
|
|
#include "cext.h"
|
|
#include "alpassvv.h"
|
|
|
|
void alpassvv_free(snd_susp_type a_susp);
|
|
|
|
|
|
typedef struct alpassvv_susp_struct {
|
|
snd_susp_node susp;
|
|
boolean started;
|
|
int64_t terminate_cnt;
|
|
sound_type input;
|
|
int input_cnt;
|
|
sample_block_values_type input_ptr;
|
|
sound_type delaysnd;
|
|
int delaysnd_cnt;
|
|
sample_block_values_type delaysnd_ptr;
|
|
|
|
/* support for interpolation of delaysnd */
|
|
sample_type delaysnd_x1_sample;
|
|
double delaysnd_pHaSe;
|
|
double delaysnd_pHaSe_iNcR;
|
|
|
|
/* support for ramp between samples of delaysnd */
|
|
double output_per_delaysnd;
|
|
int64_t delaysnd_n;
|
|
sound_type feedback;
|
|
int feedback_cnt;
|
|
sample_block_values_type feedback_ptr;
|
|
|
|
/* support for interpolation of feedback */
|
|
sample_type feedback_x1_sample;
|
|
double feedback_pHaSe;
|
|
double feedback_pHaSe_iNcR;
|
|
|
|
/* support for ramp between samples of feedback */
|
|
double output_per_feedback;
|
|
int64_t feedback_n;
|
|
|
|
float delay_scale_factor;
|
|
long buflen;
|
|
sample_type *delaybuf;
|
|
sample_type *delayptr;
|
|
sample_type *endptr;
|
|
} alpassvv_susp_node, *alpassvv_susp_type;
|
|
|
|
|
|
void alpassvv_nnn_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_block_values_type feedback_ptr_reg;
|
|
register sample_block_values_type delaysnd_ptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nnn_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past the delaysnd input sample block: */
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
togo = min(togo, susp->delaysnd_cnt);
|
|
|
|
/* don't run past the feedback input sample block: */
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
togo = min(togo, susp->feedback_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_ptr_reg = susp->feedback_ptr;
|
|
delaysnd_ptr_reg = susp->delaysnd_ptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) *feedback_ptr_reg++;
|
|
delaysamp = (sample_type) (*delaysnd_ptr_reg++ * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
} while (--n); /* inner loop */
|
|
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using feedback_ptr_reg is a bad idea on RS/6000: */
|
|
susp->feedback_ptr += togo;
|
|
/* using delaysnd_ptr_reg is a bad idea on RS/6000: */
|
|
susp->delaysnd_ptr += togo;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp_took(delaysnd_cnt, togo);
|
|
susp_took(feedback_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nnn_fetch */
|
|
|
|
|
|
void alpassvv_nns_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_type feedback_scale_reg = susp->feedback->scale;
|
|
register sample_block_values_type feedback_ptr_reg;
|
|
register sample_block_values_type delaysnd_ptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nns_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past the delaysnd input sample block: */
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
togo = min(togo, susp->delaysnd_cnt);
|
|
|
|
/* don't run past the feedback input sample block: */
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
togo = min(togo, susp->feedback_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_ptr_reg = susp->feedback_ptr;
|
|
delaysnd_ptr_reg = susp->delaysnd_ptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) (feedback_scale_reg * *feedback_ptr_reg++);
|
|
delaysamp = (sample_type) (*delaysnd_ptr_reg++ * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
} while (--n); /* inner loop */
|
|
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using feedback_ptr_reg is a bad idea on RS/6000: */
|
|
susp->feedback_ptr += togo;
|
|
/* using delaysnd_ptr_reg is a bad idea on RS/6000: */
|
|
susp->delaysnd_ptr += togo;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp_took(delaysnd_cnt, togo);
|
|
susp_took(feedback_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nns_fetch */
|
|
|
|
|
|
void alpassvv_nni_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type feedback_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register double feedback_pHaSe_iNcR_rEg = susp->feedback_pHaSe_iNcR;
|
|
register double feedback_pHaSe_ReG;
|
|
register sample_type feedback_x1_sample_reg;
|
|
register sample_block_values_type delaysnd_ptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nni_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
susp->feedback_x1_sample = susp_fetch_sample(feedback, feedback_ptr, feedback_cnt);
|
|
}
|
|
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past the delaysnd input sample block: */
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
togo = min(togo, susp->delaysnd_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_pHaSe_ReG = susp->feedback_pHaSe;
|
|
feedback_x1_sample_reg = susp->feedback_x1_sample;
|
|
delaysnd_ptr_reg = susp->delaysnd_ptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
if (feedback_pHaSe_ReG >= 1.0) {
|
|
feedback_x1_sample_reg = feedback_x2_sample;
|
|
/* pick up next sample as feedback_x2_sample: */
|
|
susp->feedback_ptr++;
|
|
susp_took(feedback_cnt, 1);
|
|
feedback_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(feedback, feedback_ptr, feedback_cnt, feedback_x2_sample);
|
|
}
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type)
|
|
(feedback_x1_sample_reg * (1 - feedback_pHaSe_ReG) + feedback_x2_sample * feedback_pHaSe_ReG);
|
|
delaysamp = (sample_type) (*delaysnd_ptr_reg++ * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
feedback_pHaSe_ReG += feedback_pHaSe_iNcR_rEg;
|
|
} while (--n); /* inner loop */
|
|
|
|
togo -= n;
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
susp->feedback_pHaSe = feedback_pHaSe_ReG;
|
|
susp->feedback_x1_sample = feedback_x1_sample_reg;
|
|
/* using delaysnd_ptr_reg is a bad idea on RS/6000: */
|
|
susp->delaysnd_ptr += togo;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp_took(delaysnd_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nni_fetch */
|
|
|
|
|
|
void alpassvv_nnr_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type feedback_DeLtA;
|
|
sample_type feedback_val;
|
|
sample_type feedback_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_block_values_type delaysnd_ptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nnr_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp->feedback_pHaSe = 1.0;
|
|
}
|
|
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past the delaysnd input sample block: */
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
togo = min(togo, susp->delaysnd_cnt);
|
|
|
|
/* grab next feedback_x2_sample when phase goes past 1.0; */
|
|
/* we use feedback_n (computed below) to avoid roundoff errors: */
|
|
if (susp->feedback_n <= 0) {
|
|
susp->feedback_x1_sample = feedback_x2_sample;
|
|
susp->feedback_ptr++;
|
|
susp_took(feedback_cnt, 1);
|
|
susp->feedback_pHaSe -= 1.0;
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
/* feedback_n gets number of samples before phase exceeds 1.0: */
|
|
susp->feedback_n = (int64_t) ((1.0 - susp->feedback_pHaSe) *
|
|
susp->output_per_feedback);
|
|
}
|
|
togo = (int) min(togo, susp->feedback_n);
|
|
feedback_DeLtA = (sample_type) ((feedback_x2_sample - susp->feedback_x1_sample) * susp->feedback_pHaSe_iNcR);
|
|
feedback_val = (sample_type) (susp->feedback_x1_sample * (1.0 - susp->feedback_pHaSe) +
|
|
feedback_x2_sample * susp->feedback_pHaSe);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
delaysnd_ptr_reg = susp->delaysnd_ptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) feedback_val;
|
|
delaysamp = (sample_type) (*delaysnd_ptr_reg++ * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
feedback_val += feedback_DeLtA;
|
|
} while (--n); /* inner loop */
|
|
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using delaysnd_ptr_reg is a bad idea on RS/6000: */
|
|
susp->delaysnd_ptr += togo;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp_took(delaysnd_cnt, togo);
|
|
susp->feedback_pHaSe += togo * susp->feedback_pHaSe_iNcR;
|
|
susp->feedback_n -= togo;
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nnr_fetch */
|
|
|
|
|
|
void alpassvv_nin_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_block_values_type feedback_ptr_reg;
|
|
register double delaysnd_pHaSe_iNcR_rEg = susp->delaysnd_pHaSe_iNcR;
|
|
register double delaysnd_pHaSe_ReG;
|
|
register sample_type delaysnd_x1_sample_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nin_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
susp->delaysnd_cnt--;
|
|
susp->delaysnd_x1_sample = *(susp->delaysnd_ptr);
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past the feedback input sample block: */
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
togo = min(togo, susp->feedback_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_ptr_reg = susp->feedback_ptr;
|
|
delaysnd_pHaSe_ReG = susp->delaysnd_pHaSe;
|
|
delaysnd_x1_sample_reg = susp->delaysnd_x1_sample;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
if (delaysnd_pHaSe_ReG >= 1.0) {
|
|
delaysnd_x1_sample_reg = delaysnd_x2_sample;
|
|
/* pick up next sample as delaysnd_x2_sample: */
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
delaysnd_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(delaysnd, delaysnd_ptr, delaysnd_cnt, delaysnd_x2_sample);
|
|
}
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) *feedback_ptr_reg++;
|
|
delaysamp = (sample_type) (
|
|
(delaysnd_x1_sample_reg * (1 - delaysnd_pHaSe_ReG) + delaysnd_x2_sample * delaysnd_pHaSe_ReG) * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_pHaSe_ReG += delaysnd_pHaSe_iNcR_rEg;
|
|
} while (--n); /* inner loop */
|
|
|
|
togo -= n;
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using feedback_ptr_reg is a bad idea on RS/6000: */
|
|
susp->feedback_ptr += togo;
|
|
susp->delaysnd_pHaSe = delaysnd_pHaSe_ReG;
|
|
susp->delaysnd_x1_sample = delaysnd_x1_sample_reg;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp_took(feedback_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nin_fetch */
|
|
|
|
|
|
void alpassvv_nis_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_type feedback_scale_reg = susp->feedback->scale;
|
|
register sample_block_values_type feedback_ptr_reg;
|
|
register double delaysnd_pHaSe_iNcR_rEg = susp->delaysnd_pHaSe_iNcR;
|
|
register double delaysnd_pHaSe_ReG;
|
|
register sample_type delaysnd_x1_sample_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nis_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
susp->delaysnd_cnt--;
|
|
susp->delaysnd_x1_sample = *(susp->delaysnd_ptr);
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past the feedback input sample block: */
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
togo = min(togo, susp->feedback_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_ptr_reg = susp->feedback_ptr;
|
|
delaysnd_pHaSe_ReG = susp->delaysnd_pHaSe;
|
|
delaysnd_x1_sample_reg = susp->delaysnd_x1_sample;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
if (delaysnd_pHaSe_ReG >= 1.0) {
|
|
delaysnd_x1_sample_reg = delaysnd_x2_sample;
|
|
/* pick up next sample as delaysnd_x2_sample: */
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
delaysnd_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(delaysnd, delaysnd_ptr, delaysnd_cnt, delaysnd_x2_sample);
|
|
}
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) (feedback_scale_reg * *feedback_ptr_reg++);
|
|
delaysamp = (sample_type) (
|
|
(delaysnd_x1_sample_reg * (1 - delaysnd_pHaSe_ReG) + delaysnd_x2_sample * delaysnd_pHaSe_ReG) * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_pHaSe_ReG += delaysnd_pHaSe_iNcR_rEg;
|
|
} while (--n); /* inner loop */
|
|
|
|
togo -= n;
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using feedback_ptr_reg is a bad idea on RS/6000: */
|
|
susp->feedback_ptr += togo;
|
|
susp->delaysnd_pHaSe = delaysnd_pHaSe_ReG;
|
|
susp->delaysnd_x1_sample = delaysnd_x1_sample_reg;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp_took(feedback_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nis_fetch */
|
|
|
|
|
|
void alpassvv_nii_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_x2_sample;
|
|
sample_type feedback_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register double feedback_pHaSe_iNcR_rEg = susp->feedback_pHaSe_iNcR;
|
|
register double feedback_pHaSe_ReG;
|
|
register sample_type feedback_x1_sample_reg;
|
|
register double delaysnd_pHaSe_iNcR_rEg = susp->delaysnd_pHaSe_iNcR;
|
|
register double delaysnd_pHaSe_ReG;
|
|
register sample_type delaysnd_x1_sample_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nii_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
susp->delaysnd_cnt--;
|
|
susp->delaysnd_x1_sample = *(susp->delaysnd_ptr);
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
susp->feedback_x1_sample = susp_fetch_sample(feedback, feedback_ptr, feedback_cnt);
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_pHaSe_ReG = susp->feedback_pHaSe;
|
|
feedback_x1_sample_reg = susp->feedback_x1_sample;
|
|
delaysnd_pHaSe_ReG = susp->delaysnd_pHaSe;
|
|
delaysnd_x1_sample_reg = susp->delaysnd_x1_sample;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
if (delaysnd_pHaSe_ReG >= 1.0) {
|
|
delaysnd_x1_sample_reg = delaysnd_x2_sample;
|
|
/* pick up next sample as delaysnd_x2_sample: */
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
delaysnd_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(delaysnd, delaysnd_ptr, delaysnd_cnt, delaysnd_x2_sample);
|
|
}
|
|
if (feedback_pHaSe_ReG >= 1.0) {
|
|
feedback_x1_sample_reg = feedback_x2_sample;
|
|
/* pick up next sample as feedback_x2_sample: */
|
|
susp->feedback_ptr++;
|
|
susp_took(feedback_cnt, 1);
|
|
feedback_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(feedback, feedback_ptr, feedback_cnt, feedback_x2_sample);
|
|
}
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type)
|
|
(feedback_x1_sample_reg * (1 - feedback_pHaSe_ReG) + feedback_x2_sample * feedback_pHaSe_ReG);
|
|
delaysamp = (sample_type) (
|
|
(delaysnd_x1_sample_reg * (1 - delaysnd_pHaSe_ReG) + delaysnd_x2_sample * delaysnd_pHaSe_ReG) * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_pHaSe_ReG += delaysnd_pHaSe_iNcR_rEg;
|
|
feedback_pHaSe_ReG += feedback_pHaSe_iNcR_rEg;
|
|
} while (--n); /* inner loop */
|
|
|
|
togo -= n;
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
susp->feedback_pHaSe = feedback_pHaSe_ReG;
|
|
susp->feedback_x1_sample = feedback_x1_sample_reg;
|
|
susp->delaysnd_pHaSe = delaysnd_pHaSe_ReG;
|
|
susp->delaysnd_x1_sample = delaysnd_x1_sample_reg;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nii_fetch */
|
|
|
|
|
|
void alpassvv_nir_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_x2_sample;
|
|
sample_type feedback_DeLtA;
|
|
sample_type feedback_val;
|
|
sample_type feedback_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register double delaysnd_pHaSe_iNcR_rEg = susp->delaysnd_pHaSe_iNcR;
|
|
register double delaysnd_pHaSe_ReG;
|
|
register sample_type delaysnd_x1_sample_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nir_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
susp->delaysnd_cnt--;
|
|
susp->delaysnd_x1_sample = *(susp->delaysnd_ptr);
|
|
susp->feedback_pHaSe = 1.0;
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* grab next feedback_x2_sample when phase goes past 1.0; */
|
|
/* we use feedback_n (computed below) to avoid roundoff errors: */
|
|
if (susp->feedback_n <= 0) {
|
|
susp->feedback_x1_sample = feedback_x2_sample;
|
|
susp->feedback_ptr++;
|
|
susp_took(feedback_cnt, 1);
|
|
susp->feedback_pHaSe -= 1.0;
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
/* feedback_n gets number of samples before phase exceeds 1.0: */
|
|
susp->feedback_n = (int64_t) ((1.0 - susp->feedback_pHaSe) *
|
|
susp->output_per_feedback);
|
|
}
|
|
togo = (int) min(togo, susp->feedback_n);
|
|
feedback_DeLtA = (sample_type) ((feedback_x2_sample - susp->feedback_x1_sample) * susp->feedback_pHaSe_iNcR);
|
|
feedback_val = (sample_type) (susp->feedback_x1_sample * (1.0 - susp->feedback_pHaSe) +
|
|
feedback_x2_sample * susp->feedback_pHaSe);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
delaysnd_pHaSe_ReG = susp->delaysnd_pHaSe;
|
|
delaysnd_x1_sample_reg = susp->delaysnd_x1_sample;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
if (delaysnd_pHaSe_ReG >= 1.0) {
|
|
delaysnd_x1_sample_reg = delaysnd_x2_sample;
|
|
/* pick up next sample as delaysnd_x2_sample: */
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
delaysnd_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(delaysnd, delaysnd_ptr, delaysnd_cnt, delaysnd_x2_sample);
|
|
}
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) feedback_val;
|
|
delaysamp = (sample_type) (
|
|
(delaysnd_x1_sample_reg * (1 - delaysnd_pHaSe_ReG) + delaysnd_x2_sample * delaysnd_pHaSe_ReG) * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_pHaSe_ReG += delaysnd_pHaSe_iNcR_rEg;
|
|
feedback_val += feedback_DeLtA;
|
|
} while (--n); /* inner loop */
|
|
|
|
togo -= n;
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
susp->delaysnd_pHaSe = delaysnd_pHaSe_ReG;
|
|
susp->delaysnd_x1_sample = delaysnd_x1_sample_reg;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp->feedback_pHaSe += togo * susp->feedback_pHaSe_iNcR;
|
|
susp->feedback_n -= togo;
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nir_fetch */
|
|
|
|
|
|
void alpassvv_nrn_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_DeLtA;
|
|
sample_type delaysnd_val;
|
|
sample_type delaysnd_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_block_values_type feedback_ptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nrn_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp->delaysnd_pHaSe = 1.0;
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* grab next delaysnd_x2_sample when phase goes past 1.0; */
|
|
/* we use delaysnd_n (computed below) to avoid roundoff errors: */
|
|
if (susp->delaysnd_n <= 0) {
|
|
susp->delaysnd_x1_sample = delaysnd_x2_sample;
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
susp->delaysnd_pHaSe -= 1.0;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
/* delaysnd_n gets number of samples before phase exceeds 1.0: */
|
|
susp->delaysnd_n = (int64_t) ((1.0 - susp->delaysnd_pHaSe) *
|
|
susp->output_per_delaysnd);
|
|
}
|
|
togo = (int) min(togo, susp->delaysnd_n);
|
|
delaysnd_DeLtA = (sample_type) ((delaysnd_x2_sample - susp->delaysnd_x1_sample) * susp->delaysnd_pHaSe_iNcR);
|
|
delaysnd_val = (sample_type) (susp->delaysnd_x1_sample * (1.0 - susp->delaysnd_pHaSe) +
|
|
delaysnd_x2_sample * susp->delaysnd_pHaSe);
|
|
|
|
/* don't run past the feedback input sample block: */
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
togo = min(togo, susp->feedback_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_ptr_reg = susp->feedback_ptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) *feedback_ptr_reg++;
|
|
delaysamp = (sample_type) (delaysnd_val * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_val += delaysnd_DeLtA;
|
|
} while (--n); /* inner loop */
|
|
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using feedback_ptr_reg is a bad idea on RS/6000: */
|
|
susp->feedback_ptr += togo;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp->delaysnd_pHaSe += togo * susp->delaysnd_pHaSe_iNcR;
|
|
susp->delaysnd_n -= togo;
|
|
susp_took(feedback_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nrn_fetch */
|
|
|
|
|
|
void alpassvv_nrs_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_DeLtA;
|
|
sample_type delaysnd_val;
|
|
sample_type delaysnd_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_type feedback_scale_reg = susp->feedback->scale;
|
|
register sample_block_values_type feedback_ptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nrs_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp->delaysnd_pHaSe = 1.0;
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* grab next delaysnd_x2_sample when phase goes past 1.0; */
|
|
/* we use delaysnd_n (computed below) to avoid roundoff errors: */
|
|
if (susp->delaysnd_n <= 0) {
|
|
susp->delaysnd_x1_sample = delaysnd_x2_sample;
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
susp->delaysnd_pHaSe -= 1.0;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
/* delaysnd_n gets number of samples before phase exceeds 1.0: */
|
|
susp->delaysnd_n = (int64_t) ((1.0 - susp->delaysnd_pHaSe) *
|
|
susp->output_per_delaysnd);
|
|
}
|
|
togo = (int) min(togo, susp->delaysnd_n);
|
|
delaysnd_DeLtA = (sample_type) ((delaysnd_x2_sample - susp->delaysnd_x1_sample) * susp->delaysnd_pHaSe_iNcR);
|
|
delaysnd_val = (sample_type) (susp->delaysnd_x1_sample * (1.0 - susp->delaysnd_pHaSe) +
|
|
delaysnd_x2_sample * susp->delaysnd_pHaSe);
|
|
|
|
/* don't run past the feedback input sample block: */
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
togo = min(togo, susp->feedback_cnt);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_ptr_reg = susp->feedback_ptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) (feedback_scale_reg * *feedback_ptr_reg++);
|
|
delaysamp = (sample_type) (delaysnd_val * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_val += delaysnd_DeLtA;
|
|
} while (--n); /* inner loop */
|
|
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using feedback_ptr_reg is a bad idea on RS/6000: */
|
|
susp->feedback_ptr += togo;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp->delaysnd_pHaSe += togo * susp->delaysnd_pHaSe_iNcR;
|
|
susp->delaysnd_n -= togo;
|
|
susp_took(feedback_cnt, togo);
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nrs_fetch */
|
|
|
|
|
|
void alpassvv_nri_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_DeLtA;
|
|
sample_type delaysnd_val;
|
|
sample_type delaysnd_x2_sample;
|
|
sample_type feedback_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register double feedback_pHaSe_iNcR_rEg = susp->feedback_pHaSe_iNcR;
|
|
register double feedback_pHaSe_ReG;
|
|
register sample_type feedback_x1_sample_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nri_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp->delaysnd_pHaSe = 1.0;
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
susp->feedback_x1_sample = susp_fetch_sample(feedback, feedback_ptr, feedback_cnt);
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* grab next delaysnd_x2_sample when phase goes past 1.0; */
|
|
/* we use delaysnd_n (computed below) to avoid roundoff errors: */
|
|
if (susp->delaysnd_n <= 0) {
|
|
susp->delaysnd_x1_sample = delaysnd_x2_sample;
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
susp->delaysnd_pHaSe -= 1.0;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
/* delaysnd_n gets number of samples before phase exceeds 1.0: */
|
|
susp->delaysnd_n = (int64_t) ((1.0 - susp->delaysnd_pHaSe) *
|
|
susp->output_per_delaysnd);
|
|
}
|
|
togo = (int) min(togo, susp->delaysnd_n);
|
|
delaysnd_DeLtA = (sample_type) ((delaysnd_x2_sample - susp->delaysnd_x1_sample) * susp->delaysnd_pHaSe_iNcR);
|
|
delaysnd_val = (sample_type) (susp->delaysnd_x1_sample * (1.0 - susp->delaysnd_pHaSe) +
|
|
delaysnd_x2_sample * susp->delaysnd_pHaSe);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
feedback_pHaSe_ReG = susp->feedback_pHaSe;
|
|
feedback_x1_sample_reg = susp->feedback_x1_sample;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
if (feedback_pHaSe_ReG >= 1.0) {
|
|
feedback_x1_sample_reg = feedback_x2_sample;
|
|
/* pick up next sample as feedback_x2_sample: */
|
|
susp->feedback_ptr++;
|
|
susp_took(feedback_cnt, 1);
|
|
feedback_pHaSe_ReG -= 1.0;
|
|
susp_check_samples_break(feedback, feedback_ptr, feedback_cnt, feedback_x2_sample);
|
|
}
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type)
|
|
(feedback_x1_sample_reg * (1 - feedback_pHaSe_ReG) + feedback_x2_sample * feedback_pHaSe_ReG);
|
|
delaysamp = (sample_type) (delaysnd_val * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_val += delaysnd_DeLtA;
|
|
feedback_pHaSe_ReG += feedback_pHaSe_iNcR_rEg;
|
|
} while (--n); /* inner loop */
|
|
|
|
togo -= n;
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
susp->feedback_pHaSe = feedback_pHaSe_ReG;
|
|
susp->feedback_x1_sample = feedback_x1_sample_reg;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp->delaysnd_pHaSe += togo * susp->delaysnd_pHaSe_iNcR;
|
|
susp->delaysnd_n -= togo;
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nri_fetch */
|
|
|
|
|
|
void alpassvv_nrr_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
int cnt = 0; /* how many samples computed */
|
|
sample_type delaysnd_DeLtA;
|
|
sample_type delaysnd_val;
|
|
sample_type delaysnd_x2_sample;
|
|
sample_type feedback_DeLtA;
|
|
sample_type feedback_val;
|
|
sample_type feedback_x2_sample;
|
|
int togo;
|
|
int n;
|
|
sample_block_type out;
|
|
register sample_block_values_type out_ptr;
|
|
|
|
register sample_block_values_type out_ptr_reg;
|
|
|
|
register float delay_scale_factor_reg;
|
|
register long buflen_reg;
|
|
register sample_type * delayptr_reg;
|
|
register sample_type * endptr_reg;
|
|
register sample_block_values_type input_ptr_reg;
|
|
falloc_sample_block(out, "alpassvv_nrr_fetch");
|
|
out_ptr = out->samples;
|
|
snd_list->block = out;
|
|
|
|
/* make sure sounds are primed with first values */
|
|
if (!susp->started) {
|
|
susp->started = true;
|
|
susp->delaysnd_pHaSe = 1.0;
|
|
susp->feedback_pHaSe = 1.0;
|
|
}
|
|
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
|
|
while (cnt < max_sample_block_len) { /* outer loop */
|
|
/* first compute how many samples to generate in inner loop: */
|
|
/* don't overflow the output sample block: */
|
|
togo = max_sample_block_len - cnt;
|
|
|
|
/* don't run past the input input sample block: */
|
|
susp_check_term_samples(input, input_ptr, input_cnt);
|
|
togo = min(togo, susp->input_cnt);
|
|
|
|
/* grab next delaysnd_x2_sample when phase goes past 1.0; */
|
|
/* we use delaysnd_n (computed below) to avoid roundoff errors: */
|
|
if (susp->delaysnd_n <= 0) {
|
|
susp->delaysnd_x1_sample = delaysnd_x2_sample;
|
|
susp->delaysnd_ptr++;
|
|
susp_took(delaysnd_cnt, 1);
|
|
susp->delaysnd_pHaSe -= 1.0;
|
|
susp_check_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
delaysnd_x2_sample = *(susp->delaysnd_ptr);
|
|
/* delaysnd_n gets number of samples before phase exceeds 1.0: */
|
|
susp->delaysnd_n = (int64_t) ((1.0 - susp->delaysnd_pHaSe) *
|
|
susp->output_per_delaysnd);
|
|
}
|
|
togo = (int) min(togo, susp->delaysnd_n);
|
|
delaysnd_DeLtA = (sample_type) ((delaysnd_x2_sample - susp->delaysnd_x1_sample) * susp->delaysnd_pHaSe_iNcR);
|
|
delaysnd_val = (sample_type) (susp->delaysnd_x1_sample * (1.0 - susp->delaysnd_pHaSe) +
|
|
delaysnd_x2_sample * susp->delaysnd_pHaSe);
|
|
|
|
/* grab next feedback_x2_sample when phase goes past 1.0; */
|
|
/* we use feedback_n (computed below) to avoid roundoff errors: */
|
|
if (susp->feedback_n <= 0) {
|
|
susp->feedback_x1_sample = feedback_x2_sample;
|
|
susp->feedback_ptr++;
|
|
susp_took(feedback_cnt, 1);
|
|
susp->feedback_pHaSe -= 1.0;
|
|
susp_check_samples(feedback, feedback_ptr, feedback_cnt);
|
|
feedback_x2_sample = susp_current_sample(feedback, feedback_ptr);
|
|
/* feedback_n gets number of samples before phase exceeds 1.0: */
|
|
susp->feedback_n = (int64_t) ((1.0 - susp->feedback_pHaSe) *
|
|
susp->output_per_feedback);
|
|
}
|
|
togo = (int) min(togo, susp->feedback_n);
|
|
feedback_DeLtA = (sample_type) ((feedback_x2_sample - susp->feedback_x1_sample) * susp->feedback_pHaSe_iNcR);
|
|
feedback_val = (sample_type) (susp->feedback_x1_sample * (1.0 - susp->feedback_pHaSe) +
|
|
feedback_x2_sample * susp->feedback_pHaSe);
|
|
|
|
/* don't run past terminate time */
|
|
if (susp->terminate_cnt != UNKNOWN &&
|
|
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
|
|
togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
|
|
if (togo < 0) togo = 0; /* avoids rounding errros */
|
|
if (togo == 0) break;
|
|
}
|
|
|
|
n = togo;
|
|
delay_scale_factor_reg = susp->delay_scale_factor;
|
|
buflen_reg = susp->buflen;
|
|
delayptr_reg = susp->delayptr;
|
|
endptr_reg = susp->endptr;
|
|
input_ptr_reg = susp->input_ptr;
|
|
out_ptr_reg = out_ptr;
|
|
if (n) do { /* the inner sample computation loop */
|
|
register sample_type y, z, delaysamp;
|
|
register int delayi;
|
|
register sample_type *yptr;
|
|
{
|
|
/* compute where to read y, we want y to be delay_snd samples
|
|
* after delay_ptr, where we write the new sample. First,
|
|
* conver from seconds to samples. Note: don't use actual sound_type
|
|
* names in comments! The translator isn't smart enough.
|
|
*/
|
|
register sample_type fb = (sample_type) feedback_val;
|
|
delaysamp = (sample_type) (delaysnd_val * delay_scale_factor_reg);
|
|
delayi = (int) delaysamp; /* get integer part */
|
|
delaysamp = delaysamp - delayi; /* get phase */
|
|
yptr = delayptr_reg + buflen_reg - (delayi + 1);
|
|
if (yptr >= endptr_reg) yptr -= buflen_reg;
|
|
/* now get y, the out-put of the delay, using interpolation */
|
|
/* note that as phase increases, we use more of yptr[0] because
|
|
positive phase means longer buffer means read earlier sample */
|
|
y = (float) ((yptr[0] * delaysamp) + (yptr[1] * (1.0 - delaysamp)));
|
|
/* WARNING: no check to keep delaysamp in range, so
|
|
do this in LISP */
|
|
|
|
*delayptr_reg++ = z = (sample_type) (fb * y + *input_ptr_reg++);
|
|
/* Time out to update the buffer:
|
|
* this is a tricky buffer: buffer[0] == buffer[bufflen]
|
|
* the logical length is bufflen, but the actual length
|
|
* is bufflen + 1 to allow for a repeated sample at the
|
|
* end. This allows for efficient interpolation.
|
|
*/
|
|
if (delayptr_reg > endptr_reg) {
|
|
delayptr_reg = susp->delaybuf;
|
|
*delayptr_reg++ = *endptr_reg;
|
|
}
|
|
*out_ptr_reg++ = (sample_type) (y - fb * z);
|
|
};
|
|
delaysnd_val += delaysnd_DeLtA;
|
|
feedback_val += feedback_DeLtA;
|
|
} while (--n); /* inner loop */
|
|
|
|
susp->buflen = buflen_reg;
|
|
susp->delayptr = delayptr_reg;
|
|
/* using input_ptr_reg is a bad idea on RS/6000: */
|
|
susp->input_ptr += togo;
|
|
out_ptr += togo;
|
|
susp_took(input_cnt, togo);
|
|
susp->delaysnd_pHaSe += togo * susp->delaysnd_pHaSe_iNcR;
|
|
susp->delaysnd_n -= togo;
|
|
susp->feedback_pHaSe += togo * susp->feedback_pHaSe_iNcR;
|
|
susp->feedback_n -= togo;
|
|
cnt += togo;
|
|
} /* outer loop */
|
|
|
|
/* test for termination */
|
|
if (togo == 0 && cnt == 0) {
|
|
snd_list_terminate(snd_list);
|
|
} else {
|
|
snd_list->block_len = cnt;
|
|
susp->susp.current += cnt;
|
|
}
|
|
} /* alpassvv_nrr_fetch */
|
|
|
|
|
|
void alpassvv_toss_fetch(snd_susp_type a_susp, snd_list_type snd_list)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
time_type final_time = susp->susp.t0;
|
|
int n;
|
|
|
|
/* fetch samples from input up to final_time for this block of zeros */
|
|
while ((ROUNDBIG((final_time - susp->input->t0) * susp->input->sr)) >=
|
|
susp->input->current)
|
|
susp_get_samples(input, input_ptr, input_cnt);
|
|
/* fetch samples from delaysnd up to final_time for this block of zeros */
|
|
while ((ROUNDBIG((final_time - susp->delaysnd->t0) * susp->delaysnd->sr)) >=
|
|
susp->delaysnd->current)
|
|
susp_get_samples(delaysnd, delaysnd_ptr, delaysnd_cnt);
|
|
/* fetch samples from feedback up to final_time for this block of zeros */
|
|
while ((ROUNDBIG((final_time - susp->feedback->t0) * susp->feedback->sr)) >=
|
|
susp->feedback->current)
|
|
susp_get_samples(feedback, feedback_ptr, feedback_cnt);
|
|
/* convert to normal processing when we hit final_count */
|
|
/* we want each signal positioned at final_time */
|
|
n = (int) ROUNDBIG((final_time - susp->input->t0) * susp->input->sr -
|
|
(susp->input->current - susp->input_cnt));
|
|
susp->input_ptr += n;
|
|
susp_took(input_cnt, n);
|
|
n = (int) ROUNDBIG((final_time - susp->delaysnd->t0) * susp->delaysnd->sr -
|
|
(susp->delaysnd->current - susp->delaysnd_cnt));
|
|
susp->delaysnd_ptr += n;
|
|
susp_took(delaysnd_cnt, n);
|
|
n = (int) ROUNDBIG((final_time - susp->feedback->t0) * susp->feedback->sr -
|
|
(susp->feedback->current - susp->feedback_cnt));
|
|
susp->feedback_ptr += n;
|
|
susp_took(feedback_cnt, n);
|
|
susp->susp.fetch = susp->susp.keep_fetch;
|
|
(*(susp->susp.fetch))(a_susp, snd_list);
|
|
}
|
|
|
|
|
|
void alpassvv_mark(snd_susp_type a_susp)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
sound_xlmark(susp->input);
|
|
sound_xlmark(susp->delaysnd);
|
|
sound_xlmark(susp->feedback);
|
|
}
|
|
|
|
|
|
void alpassvv_free(snd_susp_type a_susp)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
free(susp->delaybuf); sound_unref(susp->input);
|
|
sound_unref(susp->delaysnd);
|
|
sound_unref(susp->feedback);
|
|
ffree_generic(susp, sizeof(alpassvv_susp_node), "alpassvv_free");
|
|
}
|
|
|
|
|
|
void alpassvv_print_tree(snd_susp_type a_susp, int n)
|
|
{
|
|
alpassvv_susp_type susp = (alpassvv_susp_type) a_susp;
|
|
indent(n);
|
|
stdputstr("input:");
|
|
sound_print_tree_1(susp->input, n);
|
|
|
|
indent(n);
|
|
stdputstr("delaysnd:");
|
|
sound_print_tree_1(susp->delaysnd, n);
|
|
|
|
indent(n);
|
|
stdputstr("feedback:");
|
|
sound_print_tree_1(susp->feedback, n);
|
|
}
|
|
|
|
|
|
sound_type snd_make_alpassvv(sound_type input, sound_type delaysnd, sound_type feedback, double maxdelay)
|
|
{
|
|
register alpassvv_susp_type susp;
|
|
rate_type sr = input->sr;
|
|
time_type t0 = max(input->t0, delaysnd->t0);
|
|
int interp_desc = 0;
|
|
sample_type scale_factor = 1.0F;
|
|
time_type t0_min = t0;
|
|
/* combine scale factors of linear inputs (INPUT) */
|
|
scale_factor *= input->scale;
|
|
input->scale = 1.0F;
|
|
|
|
/* try to push scale_factor back to a low sr input */
|
|
if (input->sr < sr) { input->scale = scale_factor; scale_factor = 1.0F; }
|
|
|
|
falloc_generic(susp, alpassvv_susp_node, "snd_make_alpassvv");
|
|
susp->delay_scale_factor = (float) (input->sr * delaysnd->scale);
|
|
susp->buflen = max(2, (long) (input->sr * maxdelay + 2.5));
|
|
susp->delaybuf = (sample_type *) calloc (susp->buflen + 1, sizeof(sample_type));
|
|
susp->delayptr = susp->delaybuf;
|
|
susp->endptr = susp->delaybuf + susp->buflen;
|
|
|
|
/* make sure no sample rate is too high */
|
|
if (delaysnd->sr > sr) {
|
|
sound_unref(delaysnd);
|
|
snd_badsr();
|
|
}
|
|
if (feedback->sr > sr) {
|
|
sound_unref(feedback);
|
|
snd_badsr();
|
|
}
|
|
|
|
/* select a susp fn based on sample rates */
|
|
interp_desc = (interp_desc << 2) + interp_style(input, sr);
|
|
interp_desc = (interp_desc << 2) + interp_style(delaysnd, sr);
|
|
interp_desc = (interp_desc << 2) + interp_style(feedback, sr);
|
|
switch (interp_desc) {
|
|
case INTERP_nsn: /* handled below */
|
|
case INTERP_nnn: susp->susp.fetch = alpassvv_nnn_fetch; break;
|
|
case INTERP_nss: /* handled below */
|
|
case INTERP_nns: susp->susp.fetch = alpassvv_nns_fetch; break;
|
|
case INTERP_nsi: /* handled below */
|
|
case INTERP_nni: susp->susp.fetch = alpassvv_nni_fetch; break;
|
|
case INTERP_nsr: /* handled below */
|
|
case INTERP_nnr: susp->susp.fetch = alpassvv_nnr_fetch; break;
|
|
case INTERP_nin: susp->susp.fetch = alpassvv_nin_fetch; break;
|
|
case INTERP_nis: susp->susp.fetch = alpassvv_nis_fetch; break;
|
|
case INTERP_nii: susp->susp.fetch = alpassvv_nii_fetch; break;
|
|
case INTERP_nir: susp->susp.fetch = alpassvv_nir_fetch; break;
|
|
case INTERP_nrn: susp->susp.fetch = alpassvv_nrn_fetch; break;
|
|
case INTERP_nrs: susp->susp.fetch = alpassvv_nrs_fetch; break;
|
|
case INTERP_nri: susp->susp.fetch = alpassvv_nri_fetch; break;
|
|
case INTERP_nrr: susp->susp.fetch = alpassvv_nrr_fetch; break;
|
|
default: snd_badsr(); break;
|
|
}
|
|
|
|
susp->terminate_cnt = UNKNOWN;
|
|
/* handle unequal start times, if any */
|
|
if (t0 < input->t0) sound_prepend_zeros(input, t0);
|
|
if (t0 < delaysnd->t0) sound_prepend_zeros(delaysnd, t0);
|
|
if (t0 < feedback->t0) sound_prepend_zeros(feedback, t0);
|
|
/* minimum start time over all inputs: */
|
|
t0_min = min(input->t0, min(delaysnd->t0, min(feedback->t0, t0)));
|
|
/* how many samples to toss before t0: */
|
|
susp->susp.toss_cnt = (long) ((t0 - t0_min) * sr + 0.5);
|
|
if (susp->susp.toss_cnt > 0) {
|
|
susp->susp.keep_fetch = susp->susp.fetch;
|
|
susp->susp.fetch = alpassvv_toss_fetch;
|
|
}
|
|
|
|
/* initialize susp state */
|
|
susp->susp.free = alpassvv_free;
|
|
susp->susp.sr = sr;
|
|
susp->susp.t0 = t0;
|
|
susp->susp.mark = alpassvv_mark;
|
|
susp->susp.print_tree = alpassvv_print_tree;
|
|
susp->susp.name = "alpassvv";
|
|
susp->susp.log_stop_cnt = UNKNOWN;
|
|
susp->started = false;
|
|
susp->susp.current = 0;
|
|
susp->input = input;
|
|
susp->input_cnt = 0;
|
|
susp->delaysnd = delaysnd;
|
|
susp->delaysnd_cnt = 0;
|
|
susp->delaysnd_pHaSe = 0.0;
|
|
susp->delaysnd_pHaSe_iNcR = delaysnd->sr / sr;
|
|
susp->delaysnd_n = 0;
|
|
susp->output_per_delaysnd = sr / delaysnd->sr;
|
|
susp->feedback = feedback;
|
|
susp->feedback_cnt = 0;
|
|
susp->feedback_pHaSe = 0.0;
|
|
susp->feedback_pHaSe_iNcR = feedback->sr / sr;
|
|
susp->feedback_n = 0;
|
|
susp->output_per_feedback = sr / feedback->sr;
|
|
return sound_create((snd_susp_type)susp, t0, sr, scale_factor);
|
|
}
|
|
|
|
|
|
sound_type snd_alpassvv(sound_type input, sound_type delaysnd, sound_type feedback, double maxdelay)
|
|
{
|
|
sound_type input_copy = sound_copy(input);
|
|
sound_type delaysnd_copy = sound_copy(delaysnd);
|
|
sound_type feedback_copy = sound_copy(feedback);
|
|
return snd_make_alpassvv(input_copy, delaysnd_copy, feedback_copy, maxdelay);
|
|
}
|