void aresonvc_nr_fetch(register aresonvc_susp_type susp, snd_list_type snd_list)
{
int cnt = 0; /* how many samples computed */
sample_type hz_val;
int togo;
int n;
sample_block_type out;
register sample_block_values_type out_ptr;
register sample_block_values_type out_ptr_reg;
register double c3co_reg;
register double c3p1_reg;
register double c3t4_reg;
register double omc3_reg;
register double c2_reg;
register double c1_reg;
register int normalization_reg;
register double y1_reg;
register double y2_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "aresonvc_nr_fetch");
out_ptr = out->samples;
snd_list->block = out;
/* make sure sounds are primed with first values */
if (!susp->started) {
susp->started = true;
susp->hz_pHaSe = 1.0;
}
susp_check_term_samples(hz, hz_ptr, hz_cnt);
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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* grab next hz_x1_sample when phase goes past 1.0; */
/* use hz_n (computed below) to avoid roundoff errors: */
if (susp->hz_n <= 0) {
susp_check_term_samples(hz, hz_ptr, hz_cnt);
susp->hz_x1_sample = susp_fetch_sample(hz, hz_ptr, hz_cnt);
susp->hz_pHaSe -= 1.0;
/* hz_n gets number of samples before phase exceeds 1.0: */
susp->hz_n = (long) ((1.0 - susp->hz_pHaSe) *
susp->output_per_hz);
susp->c2 = susp->c3t4 * cos(susp->hz_x1_sample) / susp->c3p1;
susp->c1 = (susp->normalization == 0 ? 0.0 :
(susp->normalization == 1 ? 1.0 - susp->omc3 * sqrt(1.0 - susp->c2 * susp->c2 / susp->c3t4) :
1.0 - sqrt(susp->c3p1 * susp->c3p1 - susp->c2 * susp->c2) * susp->omc3 / susp->c3p1));
}
togo = min(togo, susp->hz_n);
hz_val = susp->hz_x1_sample;
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
c3co_reg = susp->c3co;
c3p1_reg = susp->c3p1;
c3t4_reg = susp->c3t4;
omc3_reg = susp->omc3;
c2_reg = susp->c2;
c1_reg = susp->c1;
normalization_reg = susp->normalization;
y1_reg = susp->y1;
y2_reg = susp->y2;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
register double y0, current;current = *s1_ptr_reg++;
y0 = c1_reg * current + c2_reg * y1_reg - c3co_reg * y2_reg;
*out_ptr_reg++ = (sample_type) y0;
y2_reg = y1_reg; y1_reg = y0 - current;
} while (--n); /* inner loop */
susp->y1 = y1_reg;
susp->y2 = y2_reg;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_cnt, togo);
susp->hz_pHaSe += togo * susp->hz_pHaSe_iNcR;
susp->hz_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* aresonvc_nr_fetch */
void aresonvc_ns_fetch(register aresonvc_susp_type susp, snd_list_type snd_list)
{
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 double c3co_reg;
register double c3p1_reg;
register double c3t4_reg;
register double omc3_reg;
register double c2_reg;
register double c1_reg;
register int normalization_reg;
register double y1_reg;
register double y2_reg;
register sample_type hz_scale_reg = susp->hz->scale;
register sample_block_values_type hz_ptr_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "aresonvc_ns_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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past the hz input sample block: */
susp_check_term_samples(hz, hz_ptr, hz_cnt);
togo = min(togo, susp->hz_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
c3co_reg = susp->c3co;
c3p1_reg = susp->c3p1;
c3t4_reg = susp->c3t4;
omc3_reg = susp->omc3;
c2_reg = susp->c2;
c1_reg = susp->c1;
normalization_reg = susp->normalization;
y1_reg = susp->y1;
y2_reg = susp->y2;
hz_ptr_reg = susp->hz_ptr;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
register double y0, current; c2_reg = c3t4_reg * cos((hz_scale_reg * *hz_ptr_reg++)) / c3p1_reg;
c1_reg = (normalization_reg == 0 ? 0.0 :
(normalization_reg == 1 ? 1.0 - omc3_reg * sqrt(1.0 - c2_reg * c2_reg / c3t4_reg) :
1.0 - sqrt(c3p1_reg * c3p1_reg - c2_reg * c2_reg) * omc3_reg / c3p1_reg));
current = *s1_ptr_reg++;
y0 = c1_reg * current + c2_reg * y1_reg - c3co_reg * y2_reg;
*out_ptr_reg++ = (sample_type) y0;
y2_reg = y1_reg; y1_reg = y0 - current;
} while (--n); /* inner loop */
susp->y1 = y1_reg;
susp->y2 = y2_reg;
/* using hz_ptr_reg is a bad idea on RS/6000: */
susp->hz_ptr += togo;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_cnt, togo);
susp_took(hz_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* aresonvc_ns_fetch */
void congen_s_fetch(register congen_susp_type susp, snd_list_type snd_list)
{
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 double value_reg;
register double rise_factor_reg;
register double fall_factor_reg;
register sample_type sndin_scale_reg = susp->sndin->scale;
register sample_block_values_type sndin_ptr_reg;
falloc_sample_block(out, "congen_s_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 sndin input sample block: */
susp_check_term_samples(sndin, sndin_ptr, sndin_cnt);
togo = MIN(togo, susp->sndin_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
n = togo;
value_reg = susp->value;
rise_factor_reg = susp->rise_factor;
fall_factor_reg = susp->fall_factor;
sndin_ptr_reg = susp->sndin_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
sample_type current = (sndin_scale_reg * *sndin_ptr_reg++);
if (current > value_reg) {
value_reg = current - (current - value_reg) * rise_factor_reg;
} else {
value_reg = current - (current - value_reg) * fall_factor_reg;
}
*out_ptr_reg++ = (sample_type) value_reg;;
} while (--n); /* inner loop */
susp->value = value_reg;
/* using sndin_ptr_reg is a bad idea on RS/6000: */
susp->sndin_ptr += togo;
out_ptr += togo;
susp_took(sndin_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;
}
} /* congen_s_fetch */
void tapv_sn_fetch(register tapv_susp_type susp, snd_list_type snd_list)
{
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 double offset_reg;
register double vdscale_reg;
register double maxdelay_reg;
register long bufflen_reg;
register long index_reg;
register sample_type * buffer_reg;
register sample_block_values_type vardelay_ptr_reg;
register sample_type s1_scale_reg = susp->s1->scale;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "tapv_sn_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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past the vardelay input sample block: */
susp_check_term_samples(vardelay, vardelay_ptr, vardelay_cnt);
togo = min(togo, susp->vardelay_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
offset_reg = susp->offset;
vdscale_reg = susp->vdscale;
maxdelay_reg = susp->maxdelay;
bufflen_reg = susp->bufflen;
index_reg = susp->index;
buffer_reg = susp->buffer;
vardelay_ptr_reg = susp->vardelay_ptr;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
double phase;
long i;
phase = *vardelay_ptr_reg++ * vdscale_reg + offset_reg;
/* now phase should give number of samples of delay */
if (phase < 0) phase = 0;
else if (phase > maxdelay_reg) phase = maxdelay_reg;
phase = (double) index_reg - phase;
/* now phase is a location in the buffer_reg (before modulo) */
/* Time out to update the buffer_reg:
* this is a tricky buffer_reg: buffer_reg[0] == buffer_reg[bufflen_reg]
* the logical length is bufflen_reg, but the actual length
* is bufflen_reg + 1 to allow for a repeated sample at the
* end. This allows for efficient interpolation.
*/
buffer_reg[index_reg++] = (s1_scale_reg * *s1_ptr_reg++);
if (index_reg > bufflen_reg) {
buffer_reg[0] = buffer_reg[bufflen_reg];
index_reg = 1;
}
/* back to the phase calculation:
* use conditional instead of modulo
*/
if (phase < 0) phase += bufflen_reg;
i = (long) phase; /* put integer part in i */
phase -= (double) i; /* put fractional part in phase */
*out_ptr_reg++ = (sample_type) (buffer_reg[i] * (1.0 - phase) +
buffer_reg[i + 1] * phase);;
} while (--n); /* inner loop */
susp->bufflen = bufflen_reg;
susp->index = index_reg;
/* using vardelay_ptr_reg is a bad idea on RS/6000: */
susp->vardelay_ptr += togo;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_cnt, togo);
susp_took(vardelay_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* tapv_sn_fetch */
void atonev_ns_fetch(register atonev_susp_type susp, snd_list_type snd_list)
{
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 double cc_reg;
register double prev_reg;
register sample_type hz_scale_reg = susp->hz->scale;
register sample_block_values_type hz_ptr_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "atonev_ns_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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past the hz input sample block: */
susp_check_term_samples(hz, hz_ptr, hz_cnt);
togo = min(togo, susp->hz_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
cc_reg = susp->cc;
prev_reg = susp->prev;
hz_ptr_reg = susp->hz_ptr;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
double current;
register double bb;
bb = 2.0 - cos((hz_scale_reg * *hz_ptr_reg++));
cc_reg = bb - sqrt((bb * bb) - 1.0);
current = *s1_ptr_reg++;
prev_reg = cc_reg * (prev_reg + current);
*out_ptr_reg++ = (sample_type) prev_reg;
prev_reg -= current;;
} while (--n); /* inner loop */
susp->prev = prev_reg;
/* using hz_ptr_reg is a bad idea on RS/6000: */
susp->hz_ptr += togo;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_cnt, togo);
susp_took(hz_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* atonev_ns_fetch */
void sax_all_nsnnnn_fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
sax_all_susp_type susp = (sax_all_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 struct instr * sax_reg;
register double frequency_reg;
register float breath_scale_reg;
register float reed_scale_reg;
register float noise_scale_reg;
register float blow_scale_reg;
register float offset_scale_reg;
register sample_block_values_type reed_table_offset_ptr_reg;
register sample_block_values_type blow_pos_ptr_reg;
register sample_block_values_type noise_env_ptr_reg;
register sample_block_values_type reed_stiffness_ptr_reg;
register sample_type freq_env_scale_reg = susp->freq_env->scale;
register sample_block_values_type freq_env_ptr_reg;
register sample_block_values_type breath_env_ptr_reg;
falloc_sample_block(out, "sax_all_nsnnnn_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 breath_env input sample block: */
susp_check_term_samples(breath_env, breath_env_ptr, breath_env_cnt);
togo = min(togo, susp->breath_env_cnt);
/* don't run past the freq_env input sample block: */
susp_check_samples(freq_env, freq_env_ptr, freq_env_cnt);
togo = min(togo, susp->freq_env_cnt);
/* don't run past the reed_stiffness input sample block: */
susp_check_samples(reed_stiffness, reed_stiffness_ptr, reed_stiffness_cnt);
togo = min(togo, susp->reed_stiffness_cnt);
/* don't run past the noise_env input sample block: */
susp_check_samples(noise_env, noise_env_ptr, noise_env_cnt);
togo = min(togo, susp->noise_env_cnt);
/* don't run past the blow_pos input sample block: */
susp_check_samples(blow_pos, blow_pos_ptr, blow_pos_cnt);
togo = min(togo, susp->blow_pos_cnt);
/* don't run past the reed_table_offset input sample block: */
susp_check_samples(reed_table_offset, reed_table_offset_ptr, reed_table_offset_cnt);
togo = min(togo, susp->reed_table_offset_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo < 0) togo = 0; /* avoids rounding errros */
if (togo == 0) break;
}
n = togo;
sax_reg = susp->sax;
frequency_reg = susp->frequency;
breath_scale_reg = susp->breath_scale;
reed_scale_reg = susp->reed_scale;
noise_scale_reg = susp->noise_scale;
blow_scale_reg = susp->blow_scale;
offset_scale_reg = susp->offset_scale;
reed_table_offset_ptr_reg = susp->reed_table_offset_ptr;
blow_pos_ptr_reg = susp->blow_pos_ptr;
noise_env_ptr_reg = susp->noise_env_ptr;
reed_stiffness_ptr_reg = susp->reed_stiffness_ptr;
freq_env_ptr_reg = susp->freq_env_ptr;
breath_env_ptr_reg = susp->breath_env_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
controlChange(sax_reg, 128, breath_scale_reg * *breath_env_ptr_reg++);
controlChange(sax_reg, 2, reed_scale_reg * *reed_stiffness_ptr_reg++);
controlChange(sax_reg, 4, noise_scale_reg * *noise_env_ptr_reg++);
controlChange(sax_reg, 11, blow_scale_reg * *blow_pos_ptr_reg++);
controlChange(sax_reg, 26, offset_scale_reg * *reed_table_offset_ptr_reg++);
setFrequency(sax_reg, frequency_reg + (freq_env_scale_reg * *freq_env_ptr_reg++));
*out_ptr_reg++ = (sample_type) tick(sax_reg);
} while (--n); /* inner loop */
susp->sax = sax_reg;
/* using reed_table_offset_ptr_reg is a bad idea on RS/6000: */
susp->reed_table_offset_ptr += togo;
/* using blow_pos_ptr_reg is a bad idea on RS/6000: */
susp->blow_pos_ptr += togo;
/* using noise_env_ptr_reg is a bad idea on RS/6000: */
susp->noise_env_ptr += togo;
/* using reed_stiffness_ptr_reg is a bad idea on RS/6000: */
susp->reed_stiffness_ptr += togo;
/* using freq_env_ptr_reg is a bad idea on RS/6000: */
susp->freq_env_ptr += togo;
/* using breath_env_ptr_reg is a bad idea on RS/6000: */
susp->breath_env_ptr += togo;
out_ptr += togo;
susp_took(breath_env_cnt, togo);
susp_took(freq_env_cnt, togo);
susp_took(reed_stiffness_cnt, togo);
susp_took(noise_env_cnt, togo);
susp_took(blow_pos_cnt, togo);
susp_took(reed_table_offset_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;
}
} /* sax_all_nsnnnn_fetch */
void trigger_fetch(trigger_susp_type susp, snd_list_type snd_list)
{
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 sample_block_values_type input_ptr_reg;
falloc_sample_block(out, "trigger_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 sample block: */
susp_check_term_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
n = togo;
input_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
sample_type s = *input_ptr_reg++;
if (susp->previous <= 0 && s > 0) {
trigger_susp_type new_trigger;
sound_type new_trigger_snd;
LVAL result;
long delay; /* sample delay to s2 */
time_type now;
susp->previous = s; /* don't retrigger */
/**** close off block ****/
togo = togo - n;
susp->s1_ptr += togo;
susp_took(s1_cnt, togo);
cnt += togo;
snd_list->block_len = cnt;
susp->susp.current += cnt;
now = susp->susp.t0 + susp->susp.current / susp->susp.sr;
/**** eval closure and add result ****/
D nyquist_printf("trigger_fetch: about to eval closure at %g, "
"susp->susp.t0 %g, susp.current %d:\n",
now, susp->susp.t0, (int)susp->susp.current);
xlsave1(result);
result = xleval(cons(susp->closure, consa(cvflonum(now))));
if (exttypep(result, a_sound)) {
susp->s2 = sound_copy(getsound(result));
D nyquist_printf("trigger: copied result from closure is %p\n",
susp->s2);
} else xlerror("closure did not return a (monophonic) sound",
result);
D nyquist_printf("in trigger: after evaluation; "
"%p returned from evform\n",
susp->s2);
result = NIL;
/**** cloan this trigger to become s1 ****/
falloc_generic(new_trigger, trigger_susp_node,
"new_trigger");
memcpy(new_trigger, susp, sizeof(trigger_susp_node));
/* don't copy s2 -- it should only be referenced by add */
new_trigger->s2 = NULL;
new_trigger_snd = sound_create((snd_susp_type) new_trigger,
now, susp->susp.sr, 1.0F);
susp->s1 = new_trigger_snd;
/* add will have to ask new_trigger for samples, new_trigger
* will continue reading samples from s1 (the original input)
*/
susp->s1_cnt = 0;
susp->s1_ptr = NULL;
/**** convert to add ****/
susp->susp.mark = add_mark;
/* logical stop will be recomputed by add: */
susp->susp.log_stop_cnt = UNKNOWN;
susp->susp.print_tree = add_print_tree;
/* assume sample rates are the same */
if (susp->s1->sr != susp->s2->sr)
xlfail("in trigger: sample rates must match");
/* take care of scale factor, if any */
if (susp->s2->scale != 1.0) {
// stdputstr("normalizing next sound in a seq\n");
susp->s2 = snd_make_normalize(susp->s2);
}
/* figure out which add fetch routine to use */
delay = ROUND((susp->s2->t0 - now) * susp->s1->sr);
if (delay > 0) { /* fill hole between s1 and s2 */
D stdputstr("using add_s1_nn_fetch\n");
susp->susp.fetch = add_s1_nn_fetch;
susp->susp.name = "trigger:add_s1_nn_fetch";
} else {
susp->susp.fetch = add_s1_s2_nn_fetch;
susp->susp.name = "trigger:add_s1_s2_nn_fetch";
}
D stdputstr("in trigger: calling add's fetch\n");
/* fetch will get called later ..
(*(susp->susp.fetch))(susp, snd_list); */
D stdputstr("in trigger: returned from add's fetch\n");
xlpop();
susp->closure = NULL; /* allow garbage collection now */
/**** calculation tree modified, time to exit ****/
/* but if cnt == 0, then we haven't computed any samples */
/* call on new fetch routine to get some samples */
if (cnt == 0) {
ffree_sample_block(out, "trigger-pre-adder"); // because adder will reallocate
(*susp->susp.fetch)(susp, snd_list);
}
return;
} else {
susp->previous = s;
/* output zero until ready to add in closure */
*out_ptr_reg++ = 0;
}
} while (--n); /* inner loop */
/* using input_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_cnt, togo);
cnt += togo;
} /* outer loop */
if (togo == 0 && cnt == 0) {
snd_list_terminate(snd_list);
} else {
snd_list->block_len = cnt;
susp->susp.current += cnt;
}
} /* trigger_fetch */
void aresoncv_ni_fetch(register aresoncv_susp_type susp, snd_list_type snd_list)
{
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 double c3co_reg;
register double coshz_reg;
register double c2_reg;
register double c1_reg;
register int normalization_reg;
register double y1_reg;
register double y2_reg;
register double bw_pHaSe_iNcR_rEg = susp->bw_pHaSe_iNcR;
register double bw_pHaSe_ReG;
register sample_type bw_x1_sample_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "aresoncv_ni_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_term_samples(bw, bw_ptr, bw_cnt);
susp->bw_x1_sample = susp_fetch_sample(bw, bw_ptr, bw_cnt);
}
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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
c3co_reg = susp->c3co;
coshz_reg = susp->coshz;
c2_reg = susp->c2;
c1_reg = susp->c1;
normalization_reg = susp->normalization;
y1_reg = susp->y1;
y2_reg = susp->y2;
bw_pHaSe_ReG = susp->bw_pHaSe;
bw_x1_sample_reg = susp->bw_x1_sample;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
register double y0, current; if (bw_pHaSe_ReG >= 1.0) {
/* fixup-depends bw */
/* pick up next sample as bw_x1_sample: */
susp->bw_ptr++;
susp_took(bw_cnt, 1);
bw_pHaSe_ReG -= 1.0;
susp_check_term_samples_break(bw, bw_ptr, bw_cnt, bw_x1_sample_reg);
bw_x1_sample_reg = susp_current_sample(bw, bw_ptr);
}
current = *s1_ptr_reg++;
*out_ptr_reg++ = (float) (y0 = c1_reg * current + c2_reg * y1_reg - c3co_reg * y2_reg);
y2_reg = y1_reg; y1_reg = y0 - current;
bw_pHaSe_ReG += bw_pHaSe_iNcR_rEg;
} while (--n); /* inner loop */
togo -= n;
susp->y1 = y1_reg;
susp->y2 = y2_reg;
susp->bw_pHaSe = bw_pHaSe_ReG;
susp->bw_x1_sample = bw_x1_sample_reg;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* aresoncv_ni_fetch */
void alpassvv_nss_fetch(register alpassvv_susp_type susp, snd_list_type snd_list)
{
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_type delaysnd_scale_reg = susp->delaysnd->scale;
register sample_block_values_type delaysnd_ptr_reg;
register sample_block_values_type input_ptr_reg;
falloc_sample_block(out, "alpassvv_nss_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 = susp->terminate_cnt - (susp->susp.current + cnt);
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 = (feedback_scale_reg * *feedback_ptr_reg++);
delaysamp = (delaysnd_scale_reg * *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_nss_fetch */
void flute_freq_ns_fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
flute_freq_susp_type susp = (flute_freq_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 struct instr * myflute_reg;
register float breath_scale_reg;
register double frequency_reg;
register sample_type freq_env_scale_reg = susp->freq_env->scale;
register sample_block_values_type freq_env_ptr_reg;
register sample_block_values_type breath_env_ptr_reg;
falloc_sample_block(out, "flute_freq_ns_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 breath_env input sample block: */
susp_check_term_samples(breath_env, breath_env_ptr, breath_env_cnt);
togo = min(togo, susp->breath_env_cnt);
/* don't run past the freq_env input sample block: */
susp_check_samples(freq_env, freq_env_ptr, freq_env_cnt);
togo = min(togo, susp->freq_env_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo < 0) togo = 0; /* avoids rounding errros */
if (togo == 0) break;
}
n = togo;
myflute_reg = susp->myflute;
breath_scale_reg = susp->breath_scale;
frequency_reg = susp->frequency;
freq_env_ptr_reg = susp->freq_env_ptr;
breath_env_ptr_reg = susp->breath_env_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
controlChange(myflute_reg, 128, breath_scale_reg * *breath_env_ptr_reg++);
setFrequency(myflute_reg, frequency_reg + (freq_env_scale_reg * *freq_env_ptr_reg++));
*out_ptr_reg++ = (sample_type) tick(myflute_reg);
} while (--n); /* inner loop */
susp->myflute = myflute_reg;
/* using freq_env_ptr_reg is a bad idea on RS/6000: */
susp->freq_env_ptr += togo;
/* using breath_env_ptr_reg is a bad idea on RS/6000: */
susp->breath_env_ptr += togo;
out_ptr += togo;
susp_took(breath_env_cnt, togo);
susp_took(freq_env_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;
}
} /* flute_freq_ns_fetch */
void tonev_ni_fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
tonev_susp_type susp = (tonev_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 double scale1_reg;
register double c2_reg;
register double c1_reg;
register double prev_reg;
register double hz_pHaSe_iNcR_rEg = susp->hz_pHaSe_iNcR;
register double hz_pHaSe_ReG;
register sample_type hz_x1_sample_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "tonev_ni_fetch");
out_ptr = out->samples;
snd_list->block = out;
/* make sure sounds are primed with first values */
if (!susp->started) {
register double b;
susp->started = true;
susp_check_term_samples(hz, hz_ptr, hz_cnt);
susp->hz_x1_sample = susp_fetch_sample(hz, hz_ptr, hz_cnt);
b = 2.0 - cos(susp->hz_x1_sample);
susp->c2 = b - sqrt((b * b) - 1.0);
susp->c1 = (1.0 - susp->c2) * susp->scale1;
}
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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo < 0) togo = 0; /* avoids rounding errros */
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < 0) to_stop = 0; /* avoids rounding errors */
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
scale1_reg = susp->scale1;
c2_reg = susp->c2;
c1_reg = susp->c1;
prev_reg = susp->prev;
hz_pHaSe_ReG = susp->hz_pHaSe;
hz_x1_sample_reg = susp->hz_x1_sample;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
if (hz_pHaSe_ReG >= 1.0) {
/* fixup-depends hz */
register double b;
/* pick up next sample as hz_x1_sample: */
susp->hz_ptr++;
susp_took(hz_cnt, 1);
hz_pHaSe_ReG -= 1.0;
susp_check_term_samples_break(hz, hz_ptr, hz_cnt, hz_x1_sample_reg);
hz_x1_sample_reg = susp_current_sample(hz, hz_ptr);
b = 2.0 - cos(hz_x1_sample_reg);
c2_reg = b - sqrt((b * b) - 1.0);
c1_reg = (1.0 - c2_reg) * scale1_reg;
}
*out_ptr_reg++ = (sample_type) (prev_reg = c1_reg * *s1_ptr_reg++ + c2_reg * prev_reg);
hz_pHaSe_ReG += hz_pHaSe_iNcR_rEg;
} while (--n); /* inner loop */
togo -= n;
susp->prev = prev_reg;
susp->hz_pHaSe = hz_pHaSe_ReG;
susp->hz_x1_sample = hz_x1_sample_reg;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* tonev_ni_fetch */
void alpassvc_nr_fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
alpassvc_susp_type susp = (alpassvc_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 double feedback_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, "alpassvc_nr_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 = (long) ((1.0 - susp->delaysnd_pHaSe) *
susp->output_per_delaysnd);
}
togo = 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 = 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;
feedback_reg = susp->feedback;
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.
*/
delaysamp = 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) (feedback_reg * 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 - feedback_reg * z);
delaysnd_val += delaysnd_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;
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;
}
} /* alpassvc_nr_fetch */
void alpass_n_fetch(register alpass_susp_type susp, snd_list_type snd_list)
{
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 double feedback_reg;
register sample_type * delayptr_reg;
register sample_type * endptr_reg;
register sample_block_values_type input_ptr_reg;
falloc_sample_block(out, "alpass_n_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 terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
n = togo;
feedback_reg = susp->feedback;
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;
y = *delayptr_reg;
*delayptr_reg++ = z = (sample_type) (feedback_reg * y + *input_ptr_reg++);
*out_ptr_reg++ = (sample_type) (y - feedback_reg * z);
if (delayptr_reg >= endptr_reg) delayptr_reg = susp->delaybuf;;
} while (--n); /* inner loop */
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);
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;
}
} /* alpass_n_fetch */
void follow_s_fetch(snd_susp_type a_susp, snd_list_type snd_list)
{
follow_susp_type susp = (follow_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 long lookahead_reg;
register sample_type * delayptr_reg;
register sample_type * prevptr_reg;
register sample_type * endptr_reg;
register double floor_reg;
register double rise_factor_reg;
register double fall_factor_reg;
register sample_type sndin_scale_reg = susp->sndin->scale;
register sample_block_values_type sndin_ptr_reg;
falloc_sample_block(out, "follow_s_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 sndin input sample block: */
susp_check_term_samples(sndin, sndin_ptr, sndin_cnt);
togo = min(togo, susp->sndin_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo < 0) togo = 0; /* avoids rounding errros */
if (togo == 0) break;
}
n = togo;
lookahead_reg = susp->lookahead;
delayptr_reg = susp->delayptr;
prevptr_reg = susp->prevptr;
endptr_reg = susp->endptr;
floor_reg = susp->floor;
rise_factor_reg = susp->rise_factor;
fall_factor_reg = susp->fall_factor;
sndin_ptr_reg = susp->sndin_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
sample_type current = (sndin_scale_reg * *sndin_ptr_reg++);
sample_type high = (sample_type) (*prevptr_reg * rise_factor_reg);
sample_type low = (sample_type) (*prevptr_reg * fall_factor_reg);
if (low < floor_reg) low = (sample_type) floor_reg;
if (current < low) *delayptr_reg = (sample_type) low;
else if (current < high) *delayptr_reg = current;
else /* current > high */ {
/* work back from current */
double rise_inverse = 1.0 / rise_factor_reg;
double temp = current * rise_inverse;
boolean ok = false;
sample_type *ptr = prevptr_reg;
int i;
for (i = 0; i < lookahead_reg - 2; i++) {
if (*ptr < temp) {
*ptr-- = (sample_type) temp;
temp *= rise_inverse;
if (ptr < susp->delaybuf)
ptr = endptr_reg - 1;
} else {
ok = true;
break;
}
}
if (!ok && (*ptr < temp)) {
temp = *ptr;
for (i = 0; i < lookahead_reg - 1; i++) {
ptr++;
if (ptr == endptr_reg) ptr = susp->delaybuf;
temp *= rise_factor_reg;
*ptr = (sample_type) temp;
}
} else *delayptr_reg = current;
}
prevptr_reg = delayptr_reg++;
if (delayptr_reg == endptr_reg) delayptr_reg = susp->delaybuf;
*out_ptr_reg++ = *delayptr_reg;
} while (--n); /* inner loop */
togo -= n;
susp->lookahead = lookahead_reg;
susp->delayptr = delayptr_reg;
susp->prevptr = prevptr_reg;
susp->floor = floor_reg;
/* using sndin_ptr_reg is a bad idea on RS/6000: */
susp->sndin_ptr += togo;
out_ptr += togo;
susp_took(sndin_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;
}
} /* follow_s_fetch */
void atonev_nr_fetch(register atonev_susp_type susp, snd_list_type snd_list)
{
int cnt = 0; /* how many samples computed */
sample_type hz_val;
int togo;
int n;
sample_block_type out;
register sample_block_values_type out_ptr;
register sample_block_values_type out_ptr_reg;
register double cc_reg;
register double prev_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "atonev_nr_fetch");
out_ptr = out->samples;
snd_list->block = out;
/* make sure sounds are primed with first values */
if (!susp->started) {
susp->started = true;
susp->hz_pHaSe = 1.0;
}
susp_check_term_samples(hz, hz_ptr, hz_cnt);
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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* grab next hz_x1_sample when phase goes past 1.0; */
/* use hz_n (computed below) to avoid roundoff errors: */
if (susp->hz_n <= 0) {
register double bb;
susp_check_term_samples(hz, hz_ptr, hz_cnt);
susp->hz_x1_sample = susp_fetch_sample(hz, hz_ptr, hz_cnt);
susp->hz_pHaSe -= 1.0;
/* hz_n gets number of samples before phase exceeds 1.0: */
susp->hz_n = (long) ((1.0 - susp->hz_pHaSe) *
susp->output_per_hz);
bb = 2.0 - cos(susp->hz_x1_sample);
susp->cc = bb - sqrt((bb * bb) - 1.0);
}
togo = min(togo, susp->hz_n);
hz_val = susp->hz_x1_sample;
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
cc_reg = susp->cc;
prev_reg = susp->prev;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
double current;
current = *s1_ptr_reg++;
prev_reg = cc_reg * (prev_reg + current);
*out_ptr_reg++ = (sample_type) prev_reg;
prev_reg -= current;;
} while (--n); /* inner loop */
susp->prev = prev_reg;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_cnt, togo);
susp->hz_pHaSe += togo * susp->hz_pHaSe_iNcR;
susp->hz_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* atonev_nr_fetch */
void delaycv_nn_fetch(register delaycv_susp_type susp, snd_list_type snd_list)
{
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 sample_type * delayptr_reg;
register sample_type * endptr_reg;
register sample_block_values_type feedback_ptr_reg;
register sample_block_values_type s_ptr_reg;
falloc_sample_block(out, "delaycv_nn_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 s input sample block: */
susp_check_term_samples(s, s_ptr, s_cnt);
togo = min(togo, susp->s_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 = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
n = togo;
delayptr_reg = susp->delayptr;
endptr_reg = susp->endptr;
feedback_ptr_reg = susp->feedback_ptr;
s_ptr_reg = susp->s_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
*out_ptr_reg++ = *delayptr_reg;
*delayptr_reg = *delayptr_reg * *feedback_ptr_reg++ + *s_ptr_reg++;
if (++delayptr_reg >= endptr_reg) delayptr_reg = susp->delaybuf;;
} while (--n); /* inner loop */
susp->delayptr = delayptr_reg;
susp->endptr = endptr_reg;
/* using feedback_ptr_reg is a bad idea on RS/6000: */
susp->feedback_ptr += togo;
/* using s_ptr_reg is a bad idea on RS/6000: */
susp->s_ptr += togo;
out_ptr += togo;
susp_took(s_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;
}
} /* delaycv_nn_fetch */
void resonvc_ni_fetch(register resonvc_susp_type susp, snd_list_type snd_list)
{
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 double scale1_reg;
register double c3co_reg;
register double c3p1_reg;
register double c3t4_reg;
register double omc3_reg;
register double c2_reg;
register double c1_reg;
register int normalization_reg;
register double y1_reg;
register double y2_reg;
register double hz_pHaSe_iNcR_rEg = susp->hz_pHaSe_iNcR;
register double hz_pHaSe_ReG;
register sample_type hz_x1_sample_reg;
register sample_block_values_type s1_ptr_reg;
falloc_sample_block(out, "resonvc_ni_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_term_samples(hz, hz_ptr, hz_cnt);
susp->hz_x1_sample = susp_fetch_sample(hz, hz_ptr, hz_cnt);
susp->c2 = susp->c3t4 * cos(susp->hz_x1_sample) / susp->c3p1;
susp->c1 = (susp->normalization == 0 ? susp->scale1 :
(susp->normalization == 1 ? susp->omc3 * sqrt(1.0 - susp->c2 * susp->c2 / susp->c3t4) :
sqrt(susp->c3p1 * susp->c3p1 - susp->c2 * susp->c2) * susp->omc3 / susp->c3p1)) * susp->scale1;
}
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 s1 input sample block: */
susp_check_term_log_samples(s1, s1_ptr, s1_cnt);
togo = min(togo, susp->s1_cnt);
/* don't run past terminate time */
if (susp->terminate_cnt != UNKNOWN &&
susp->terminate_cnt <= susp->susp.current + cnt + togo) {
togo = susp->terminate_cnt - (susp->susp.current + cnt);
if (togo == 0) break;
}
/* don't run past logical stop time */
if (!susp->logically_stopped && susp->susp.log_stop_cnt != UNKNOWN) {
int to_stop = susp->susp.log_stop_cnt - (susp->susp.current + cnt);
/* break if to_stop == 0 (we're at the logical stop)
* AND cnt > 0 (we're not at the beginning of the
* output block).
*/
if (to_stop < togo) {
if (to_stop == 0) {
if (cnt) {
togo = 0;
break;
} else /* keep togo as is: since cnt == 0, we
* can set the logical stop flag on this
* output block
*/
susp->logically_stopped = true;
} else /* limit togo so we can start a new
* block at the LST
*/
togo = to_stop;
}
}
n = togo;
scale1_reg = susp->scale1;
c3co_reg = susp->c3co;
c3p1_reg = susp->c3p1;
c3t4_reg = susp->c3t4;
omc3_reg = susp->omc3;
c2_reg = susp->c2;
c1_reg = susp->c1;
normalization_reg = susp->normalization;
y1_reg = susp->y1;
y2_reg = susp->y2;
hz_pHaSe_ReG = susp->hz_pHaSe;
hz_x1_sample_reg = susp->hz_x1_sample;
s1_ptr_reg = susp->s1_ptr;
out_ptr_reg = out_ptr;
if (n) do { /* the inner sample computation loop */
if (hz_pHaSe_ReG >= 1.0) {
/* fixup-depends hz */
/* pick up next sample as hz_x1_sample: */
susp->hz_ptr++;
susp_took(hz_cnt, 1);
hz_pHaSe_ReG -= 1.0;
susp_check_term_samples_break(hz, hz_ptr, hz_cnt, hz_x1_sample_reg);
hz_x1_sample_reg = susp_current_sample(hz, hz_ptr);
c2_reg = susp->c2 = c3t4_reg * cos(hz_x1_sample_reg) / c3p1_reg;
c1_reg = susp->c1 = (normalization_reg == 0 ? scale1_reg :
(normalization_reg == 1 ? omc3_reg * sqrt(1.0 - c2_reg * c2_reg / c3t4_reg) :
sqrt(c3p1_reg * c3p1_reg - c2_reg * c2_reg) * omc3_reg / c3p1_reg)) * scale1_reg;
}
{ double y0 = c1_reg * *s1_ptr_reg++ + c2_reg * y1_reg - c3co_reg * y2_reg;
*out_ptr_reg++ = (sample_type) y0;
y2_reg = y1_reg;
y1_reg = y0;
};
hz_pHaSe_ReG += hz_pHaSe_iNcR_rEg;
} while (--n); /* inner loop */
togo -= n;
susp->y1 = y1_reg;
susp->y2 = y2_reg;
susp->hz_pHaSe = hz_pHaSe_ReG;
susp->hz_x1_sample = hz_x1_sample_reg;
/* using s1_ptr_reg is a bad idea on RS/6000: */
susp->s1_ptr += togo;
out_ptr += togo;
susp_took(s1_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;
}
/* test for logical stop */
if (susp->logically_stopped) {
snd_list->logically_stopped = true;
} else if (susp->susp.log_stop_cnt == susp->susp.current) {
susp->logically_stopped = true;
}
} /* resonvc_ni_fetch */
