/* inverse.c -- compute the inverse of a sampled function *//* CHANGE LOG * -------------------------------------------------------------------- * 28Apr03  dm  changes for portability and fix compiler warnings */#include "stdio.h"#ifndef mips#include "stdlib.h"#endif#include "xlisp.h"#include "sound.h"#include "cext.h"#include "falloc.h"#include "inverse.h"void inverse_free();typedef struct inverse_susp_struct {    snd_susp_node susp;    long terminate_cnt;    boolean logically_stopped;    sound_type s;    long s_cnt;    sample_block_values_type s_ptr;    double s_prev;    double s_time;    double s_time_increment;    double out_time_increment;    boolean started;} inverse_susp_node, *inverse_susp_type;void inverse_fetch(register inverse_susp_type susp, snd_list_type snd_list){    int cnt = 0; /* how many samples read from s */    int out_cnt = 0; /* how many samples output */    int togo = 0; /* how many more to read from s in inner loop */    int n;    sample_block_type out;    double out_time = susp->susp.current * susp->out_time_increment;        register sample_block_values_type out_ptr;    register sample_block_values_type s_ptr_reg;    falloc_sample_block(out, "inverse_fetch");    out_ptr = out->samples;    snd_list->block = out;    /* make sure we are primed with first value */    /* This is a lot of work just to prefetch susp->s_prev! */    if (!susp->started) {        susp->started = true;        /* see comments below about susp_check_term_log_samples() */        if (susp->s_cnt == 0) {            susp_get_samples(s, s_ptr, s_cnt);            if (susp->s_ptr == zero_block->samples) {                susp->terminate_cnt = susp->susp.current;            }        }        susp->s_prev = susp_fetch_sample(s, s_ptr, s_cnt);    }    while (out_cnt < max_sample_block_len) { /* outer loop */        /* first compute how many samples to generate in inner loop: */        /* don't run past the s input sample block: */        /* most fetch routines call susp_check_term_log_samples() here         * but we can't becasue susp_check_term_log_samples() assumes          * that output time progresses at the same rate as input time.         * Here, some time warping is going on, so this doesn't work.         * Instead, check for termination of s and fix terminate_cnt to         * be the current output count rather than the current input time.         */        if (susp->s_cnt == 0) {            susp_get_samples(s, s_ptr, s_cnt);            if (susp->s_ptr == zero_block->samples) {                susp->terminate_cnt = susp->susp.current + out_cnt;                /* we can't simply terminate here because we might have                  * some output samples computed already, in which case we                 * want to return them now and terminate the NEXT time we're                 * called.                 */            }        }        togo = susp->s_cnt;        /* if we ran past terminate time, fix up output */        if (susp->terminate_cnt != UNKNOWN &&            susp->terminate_cnt <= susp->susp.current + out_cnt) {            /* pretend like we computed the correct number of samples */            togo = 0;            out_cnt = susp->terminate_cnt - susp->susp.current;            /* exit the loop to complete the termination */            break;        }        n = togo;        s_ptr_reg = susp->s_ptr;        if (n) do { /* the inner sample computation loop */            /* scan s_ptr_reg to time t, output and loop */            register double next_value = *s_ptr_reg++;            while (out_time < next_value) {                *out_ptr++ = (float) (susp->s_time +                             (out_time - susp->s_prev) /                             (susp->s->sr * (next_value - susp->s_prev)));                out_time += susp->out_time_increment;                if (++out_cnt >= max_sample_block_len) goto output_full;            }            susp->s_prev = next_value;            susp->s_time += susp->s_time_increment;        } while (--n); /* inner loop */  output_full:        /* using s_ptr_reg is a bad idea on RS/6000: */        susp->s_ptr += (togo - n);        susp_took(s_cnt, (togo - n));        cnt += (togo - n);    } /* outer loop */    /* test for termination */    if (togo == 0 && out_cnt == 0) {        snd_list_terminate(snd_list);    } else {        snd_list->block_len = out_cnt;        susp->susp.current += out_cnt;    }} /* inverse_fetch */void inverse_toss_fetch(susp, snd_list)  register inverse_susp_type susp;  snd_list_type snd_list;{    long final_count = MIN(susp->susp.current + max_sample_block_len,                           susp->susp.toss_cnt);    time_type final_time = susp->susp.t0 + final_count / susp->susp.sr;    long n;    /* fetch samples from s up to final_time for this block of zeros */    while (((long) ((final_time - susp->s->t0) * susp->s->sr + 0.5)) >=           susp->s->current)        susp_get_samples(s, s_ptr, s_cnt);    /* convert to normal processing when we hit final_count */    /* we want each signal positioned at final_time */    if (final_count == susp->susp.toss_cnt) {        n = ROUND((final_time - susp->s->t0) * susp->s->sr -                       (susp->s->current - susp->s_cnt));        susp->s_ptr += n;        susp_took(s_cnt, n);        susp->susp.fetch = susp->susp.keep_fetch;    }    snd_list->block_len = (short) (final_count - susp->susp.current);    susp->susp.current = final_count;    snd_list->u.next = snd_list_create((snd_susp_type) susp);    snd_list->block = internal_zero_block;}void inverse_mark(inverse_susp_type susp){    sound_xlmark(susp->s);}void inverse_free(inverse_susp_type susp){    sound_unref(susp->s);    ffree_generic(susp, sizeof(inverse_susp_node), "inverse_free");}void inverse_print_tree(inverse_susp_type susp, int n){    indent(n);    stdputstr("s:");    sound_print_tree_1(susp->s, n);}sound_type snd_make_inverse(sound_type s, time_type t0, rate_type sr){    register inverse_susp_type susp;    falloc_generic(susp, inverse_susp_node, "snd_make_inverse");    susp->susp.fetch = inverse_fetch;    susp->terminate_cnt = UNKNOWN;    /* initialize susp state */    susp->susp.free = inverse_free;    susp->susp.sr = sr;    susp->susp.t0 = t0;    susp->susp.mark = inverse_mark;    susp->susp.print_tree = inverse_print_tree;    susp->susp.name = "inverse";    susp->logically_stopped = false;    susp->susp.log_stop_cnt = UNKNOWN; /* log stop time = term time */    susp->susp.current = 0;    susp->s = s;    susp->s_cnt = 0;    susp->s_prev = 0;    susp->s_time = 0;    susp->s_time_increment = 1 / s->sr;    susp->out_time_increment = 1 / (sr * s->scale);    susp->started = false;    return sound_create((snd_susp_type)susp, t0, sr, 1.0 /* scale */);}sound_type snd_inverse(sound_type s, time_type t0, rate_type sr){    sound_type s_copy = sound_copy(s);    return snd_make_inverse(s_copy, t0, sr);}