1 #include "stdio.h"
2 #ifndef mips
3 #include "stdlib.h"
4 #endif
5 #include "xlisp.h"
6 #include "sound.h"
7 
8 #include "falloc.h"
9 #include "cext.h"
10 #include "instrbowedfreq.h"
11 
12 void bowed_freq_free(snd_susp_type a_susp);
13 
14 
15 typedef struct bowed_freq_susp_struct {
16     snd_susp_node susp;
17     int64_t terminate_cnt;
18     sound_type bowpress_env;
19     int bowpress_env_cnt;
20     sample_block_values_type bowpress_env_ptr;
21     sound_type freq_env;
22     int freq_env_cnt;
23     sample_block_values_type freq_env_ptr;
24 
25     struct instr *mybow;
26     int temp_ret_value;
27     float bow_scale;
28     double frequency;
29 } bowed_freq_susp_node, *bowed_freq_susp_type;
30 
31 #include "instr.h"
32 #include "upsample.h"
33 
34 
bowed_freq_ns_fetch(snd_susp_type a_susp,snd_list_type snd_list)35 void bowed_freq_ns_fetch(snd_susp_type a_susp, snd_list_type snd_list)
36 {
37     bowed_freq_susp_type susp = (bowed_freq_susp_type) a_susp;
38     int cnt = 0; /* how many samples computed */
39     int togo;
40     int n;
41     sample_block_type out;
42     register sample_block_values_type out_ptr;
43 
44     register sample_block_values_type out_ptr_reg;
45 
46     register struct instr * mybow_reg;
47     register float bow_scale_reg;
48     register double frequency_reg;
49     register sample_type freq_env_scale_reg = susp->freq_env->scale;
50     register sample_block_values_type freq_env_ptr_reg;
51     register sample_block_values_type bowpress_env_ptr_reg;
52     falloc_sample_block(out, "bowed_freq_ns_fetch");
53     out_ptr = out->samples;
54     snd_list->block = out;
55 
56     while (cnt < max_sample_block_len) { /* outer loop */
57         /* first compute how many samples to generate in inner loop: */
58         /* don't overflow the output sample block: */
59         togo = max_sample_block_len - cnt;
60 
61         /* don't run past the bowpress_env input sample block: */
62         susp_check_term_samples(bowpress_env, bowpress_env_ptr, bowpress_env_cnt);
63         togo = min(togo, susp->bowpress_env_cnt);
64 
65         /* don't run past the freq_env input sample block: */
66         susp_check_samples(freq_env, freq_env_ptr, freq_env_cnt);
67         togo = min(togo, susp->freq_env_cnt);
68 
69         /* don't run past terminate time */
70         if (susp->terminate_cnt != UNKNOWN &&
71             susp->terminate_cnt <= susp->susp.current + cnt + togo) {
72             togo = (int) (susp->terminate_cnt - (susp->susp.current + cnt));
73             if (togo < 0) togo = 0;  /* avoids rounding errros */
74             if (togo == 0) break;
75         }
76 
77         n = togo;
78         mybow_reg = susp->mybow;
79         bow_scale_reg = susp->bow_scale;
80         frequency_reg = susp->frequency;
81         freq_env_ptr_reg = susp->freq_env_ptr;
82         bowpress_env_ptr_reg = susp->bowpress_env_ptr;
83         out_ptr_reg = out_ptr;
84         if (n) do { /* the inner sample computation loop */
85             controlChange(mybow_reg, 128, bow_scale_reg * *bowpress_env_ptr_reg++);
86             setFrequency(mybow_reg, frequency_reg + (freq_env_scale_reg * *freq_env_ptr_reg++));
87             *out_ptr_reg++ = (sample_type) tick(mybow_reg);
88         } while (--n); /* inner loop */
89 
90         susp->mybow = mybow_reg;
91         /* using freq_env_ptr_reg is a bad idea on RS/6000: */
92         susp->freq_env_ptr += togo;
93         /* using bowpress_env_ptr_reg is a bad idea on RS/6000: */
94         susp->bowpress_env_ptr += togo;
95         out_ptr += togo;
96         susp_took(bowpress_env_cnt, togo);
97         susp_took(freq_env_cnt, togo);
98         cnt += togo;
99     } /* outer loop */
100 
101     /* test for termination */
102     if (togo == 0 && cnt == 0) {
103         snd_list_terminate(snd_list);
104     } else {
105         snd_list->block_len = cnt;
106         susp->susp.current += cnt;
107     }
108 } /* bowed_freq_ns_fetch */
109 
110 
bowed_freq_toss_fetch(snd_susp_type a_susp,snd_list_type snd_list)111 void bowed_freq_toss_fetch(snd_susp_type a_susp, snd_list_type snd_list)
112 {
113     bowed_freq_susp_type susp = (bowed_freq_susp_type) a_susp;
114     time_type final_time = susp->susp.t0;
115     int n;
116 
117     /* fetch samples from bowpress_env up to final_time for this block of zeros */
118     while ((ROUNDBIG((final_time - susp->bowpress_env->t0) * susp->bowpress_env->sr)) >=
119            susp->bowpress_env->current)
120         susp_get_samples(bowpress_env, bowpress_env_ptr, bowpress_env_cnt);
121     /* fetch samples from freq_env up to final_time for this block of zeros */
122     while ((ROUNDBIG((final_time - susp->freq_env->t0) * susp->freq_env->sr)) >=
123            susp->freq_env->current)
124         susp_get_samples(freq_env, freq_env_ptr, freq_env_cnt);
125     /* convert to normal processing when we hit final_count */
126     /* we want each signal positioned at final_time */
127     n = (int) ROUNDBIG((final_time - susp->bowpress_env->t0) * susp->bowpress_env->sr -
128          (susp->bowpress_env->current - susp->bowpress_env_cnt));
129     susp->bowpress_env_ptr += n;
130     susp_took(bowpress_env_cnt, n);
131     n = (int) ROUNDBIG((final_time - susp->freq_env->t0) * susp->freq_env->sr -
132          (susp->freq_env->current - susp->freq_env_cnt));
133     susp->freq_env_ptr += n;
134     susp_took(freq_env_cnt, n);
135     susp->susp.fetch = susp->susp.keep_fetch;
136     (*(susp->susp.fetch))(a_susp, snd_list);
137 }
138 
139 
bowed_freq_mark(snd_susp_type a_susp)140 void bowed_freq_mark(snd_susp_type a_susp)
141 {
142     bowed_freq_susp_type susp = (bowed_freq_susp_type) a_susp;
143     sound_xlmark(susp->bowpress_env);
144     sound_xlmark(susp->freq_env);
145 }
146 
147 
bowed_freq_free(snd_susp_type a_susp)148 void bowed_freq_free(snd_susp_type a_susp)
149 {
150     bowed_freq_susp_type susp = (bowed_freq_susp_type) a_susp;
151     deleteInstrument(susp->mybow);
152     sound_unref(susp->bowpress_env);
153     sound_unref(susp->freq_env);
154     ffree_generic(susp, sizeof(bowed_freq_susp_node), "bowed_freq_free");
155 }
156 
157 
bowed_freq_print_tree(snd_susp_type a_susp,int n)158 void bowed_freq_print_tree(snd_susp_type a_susp, int n)
159 {
160     bowed_freq_susp_type susp = (bowed_freq_susp_type) a_susp;
161     indent(n);
162     stdputstr("bowpress_env:");
163     sound_print_tree_1(susp->bowpress_env, n);
164 
165     indent(n);
166     stdputstr("freq_env:");
167     sound_print_tree_1(susp->freq_env, n);
168 }
169 
170 
snd_make_bowed_freq(double freq,sound_type bowpress_env,sound_type freq_env,rate_type sr)171 sound_type snd_make_bowed_freq(double freq, sound_type bowpress_env, sound_type freq_env, rate_type sr)
172 {
173     register bowed_freq_susp_type susp;
174     /* sr specified as input parameter */
175     time_type t0 = bowpress_env->t0;
176     sample_type scale_factor = 1.0F;
177     time_type t0_min = t0;
178     falloc_generic(susp, bowed_freq_susp_node, "snd_make_bowed_freq");
179     susp->mybow = initInstrument(BOWED, ROUND32(sr));
180     controlChange(susp->mybow, 1, 0.0);;
181     susp->temp_ret_value = noteOn(susp->mybow, freq, 1.0);
182     susp->bow_scale = bowpress_env->scale * BOW_CONTROL_CHANGE_CONST;
183     susp->frequency = freq;
184 
185     /* make sure no sample rate is too high */
186     if (bowpress_env->sr > sr) {
187         sound_unref(bowpress_env);
188         snd_badsr();
189     } else if (bowpress_env->sr < sr) bowpress_env = snd_make_up(sr, bowpress_env);
190     if (freq_env->sr > sr) {
191         sound_unref(freq_env);
192         snd_badsr();
193     } else if (freq_env->sr < sr) freq_env = snd_make_up(sr, freq_env);
194     susp->susp.fetch = bowed_freq_ns_fetch;
195     susp->terminate_cnt = UNKNOWN;
196     /* handle unequal start times, if any */
197     if (t0 < bowpress_env->t0) sound_prepend_zeros(bowpress_env, t0);
198     if (t0 < freq_env->t0) sound_prepend_zeros(freq_env, t0);
199     /* minimum start time over all inputs: */
200     t0_min = min(bowpress_env->t0, min(freq_env->t0, t0));
201     /* how many samples to toss before t0: */
202     susp->susp.toss_cnt = (long) ((t0 - t0_min) * sr + 0.5);
203     if (susp->susp.toss_cnt > 0) {
204         susp->susp.keep_fetch = susp->susp.fetch;
205         susp->susp.fetch = bowed_freq_toss_fetch;
206     }
207 
208     /* initialize susp state */
209     susp->susp.free = bowed_freq_free;
210     susp->susp.sr = sr;
211     susp->susp.t0 = t0;
212     susp->susp.mark = bowed_freq_mark;
213     susp->susp.print_tree = bowed_freq_print_tree;
214     susp->susp.name = "bowed_freq";
215     susp->susp.log_stop_cnt = UNKNOWN;
216     susp->susp.current = 0;
217     susp->bowpress_env = bowpress_env;
218     susp->bowpress_env_cnt = 0;
219     susp->freq_env = freq_env;
220     susp->freq_env_cnt = 0;
221     return sound_create((snd_susp_type)susp, t0, sr, scale_factor);
222 }
223 
224 
snd_bowed_freq(double freq,sound_type bowpress_env,sound_type freq_env,rate_type sr)225 sound_type snd_bowed_freq(double freq, sound_type bowpress_env, sound_type freq_env, rate_type sr)
226 {
227     sound_type bowpress_env_copy = sound_copy(bowpress_env);
228     sound_type freq_env_copy = sound_copy(freq_env);
229     return snd_make_bowed_freq(freq, bowpress_env_copy, freq_env_copy, sr);
230 }
231