1 /*
2 * JoshUGens.cpp
3 * xSC3plugins
4 *
5 * Created by Josh Parmenter on 2/4/05.
6 * Copyright 2005 __MyCompanyName__. All rights reserved.
7 *
8 */
9 /*
10 SuperCollider real time audio synthesis system
11 Copyright (c) 2002 James McCartney. All rights reserved.
12 http://www.audiosynth.com
13
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 */
28
29
30 #include "SC_PlugIn.h"
31
32 const double sqrt3 = sqrt(3.);
33 const double sqrt3div6 = sqrt(3.) * 0.1666666667;
34 const double sqrt3div2 = sqrt(3.) * 0.5;
35 const double rsqrt6 = 1. / sqrt(6.);
36 const double sqrt6div3 = sqrt(6.) * 0.3333333333;
37 const double twodivsqrt3 = 2 / sqrt(3.);
38
39 static InterfaceTable *ft;
40
41 struct A2B : public Unit
42 {
43 };
44
45 struct B2A : public Unit
46 {
47 };
48
49 struct B2UHJ : public Unit
50 {
51 float m_wy1[12];
52 float m_xy1[12];
53 float m_yy1[12];
54 float m_coefs[12];
55 };
56
57 struct UHJ2B : public Unit
58 {
59 float m_lsy1[12];
60 float m_rsy1[12];
61 float m_coefs[12];
62
63 };
64
65 struct BFEncode1 : public Unit
66 {
67 float m_azimuth, m_elevation, m_rho, m_level, m_W_amp, m_X_amp, m_Y_amp, m_Z_amp;
68 };
69
70 struct BFEncodeSter : public Unit
71 {
72 float m_azimuth, m_width, m_elevation, m_rho, m_level, m_W_ampL, m_X_ampL, m_Y_ampL, m_Z_ampL, m_W_ampR, m_X_ampR, m_Y_ampR, m_Z_ampR;
73 };
74
75 struct BFEncode2 : public Unit
76 {
77 float m_point_x, m_point_y, m_elevation, m_level, m_W_amp, m_X_amp, m_Y_amp, m_Z_amp;
78 };
79
80 struct FMHEncode0 : public Unit
81 {
82 float m_azimuth, m_elevation, m_rho, m_level, m_W_amp, m_X_amp, m_Y_amp, m_Z_amp, m_R_amp, m_S_amp, m_T_amp, m_U_amp, m_V_amp;
83 };
84
85 struct FMHEncode1 : public Unit
86 {
87 float m_azimuth, m_elevation, m_rho, m_level, m_W_amp, m_X_amp, m_Y_amp, m_Z_amp, m_R_amp, m_S_amp, m_T_amp, m_U_amp, m_V_amp;
88 };
89
90 struct FMHEncode2 : public Unit
91 {
92 float m_point_x, m_point_y, m_elevation, m_rho, m_level, m_W_amp, m_X_amp, m_Y_amp, m_Z_amp, m_R_amp, m_S_amp, m_T_amp, m_U_amp, m_V_amp;
93 };
94
95 struct BFDecode1 : public Unit
96 {
97 float m_W_amp, m_X_amp, m_Y_amp, m_Z_amp, m_azimuth, m_elevation;
98 };
99
100 struct FMHDecode1 : public Unit
101 {
102 float m_azimuth, m_elevation;
103 float m_X_amp, m_Y_amp, m_Z_amp, m_R_amp, m_S_amp, m_T_amp, m_U_amp, m_V_amp;
104 };
105
106 struct BFManipulate : public Unit
107 {
108 float m_rotate, m_tilt, m_tumble;
109 };
110
111 struct B2Ster : public Unit
112 {
113 };
114
115 struct BFFreeVerb : public Unit
116 { // the delay line and filter coefs from FreeVerb... we need 4 of these!
117 float *m_dline0[4];
118 float *m_dline1[4];
119 float *m_dline2[4];
120 float *m_dline3[4];
121 float *m_dline4[4];
122 float *m_dline5[4];
123 float *m_dline6[4];
124 float *m_dline7[4];
125 float *m_dline8[4];
126 float *m_dline9[4];
127 float *m_dline10[4];
128 float *m_dline11[4];
129 float *m_iota[4];
130 float *m_r0[4];
131 float *m_r1[4];
132 bool first;
133 };
134
135 extern "C"
136 {
137 void A2B_next(A2B *unit, int inNumSamples);
138 void A2B_Ctor(A2B* unit);
139
140 // B2A and A2B are the same transformation... B2A will call A2B_next
141 void B2A_Ctor(A2B* unit);
142
143 void B2UHJ_next(B2UHJ *unit, int inNumSamples);
144 void B2UHJ_Ctor(B2UHJ* unit);
145
146 void UHJ2B_next(UHJ2B *unit, int inNumSamples);
147 void UHJ2B_Ctor(UHJ2B* unit);
148
149 void BFEncode1_next_kkk(BFEncode1 *unit, int inNumSamples);
150 void BFEncode1_next_aaa(BFEncode1 *unit, int inNumSamples);
151 void BFEncode1_next_akk(BFEncode1 *unit, int inNumSamples);
152 void BFEncode1_next_aak(BFEncode1 *unit, int inNumSamples);
153 void BFEncode1_next_aka(BFEncode1 *unit, int inNumSamples);
154 void BFEncode1_next_kaa(BFEncode1 *unit, int inNumSamples);
155 void BFEncode1_next_kak(BFEncode1 *unit, int inNumSamples);
156 void BFEncode1_next_kka(BFEncode1 *unit, int inNumSamples);
157 void BFEncode1_Ctor(BFEncode1* unit);
158
159 void BFEncode2_next_kkk(BFEncode2 *unit, int inNumSamples);
160 void BFEncode2_Ctor(BFEncode2* unit);
161
162 void BFEncodeSter_next(BFEncodeSter *unit, int inNumSamples);
163 void BFEncodeSter_Ctor(BFEncodeSter* unit);
164
165 void FMHEncode0_next(FMHEncode0 *unit, int inNumSamples);
166 void FMHEncode0_Ctor(FMHEncode0* unit);
167
168 void FMHEncode1_next(FMHEncode1 *unit, int inNumSamples);
169 void FMHEncode1_Ctor(FMHEncode1* unit);
170
171 void FMHEncode2_next(FMHEncode2 *unit, int inNumSamples);
172 void FMHEncode2_Ctor(FMHEncode2* unit);
173
174 void BFDecode1_next(BFDecode1 *unit, int inNumSamples);
175 void BFDecode1_Ctor(BFDecode1* unit);
176
177 void FMHDecode1_next(FMHDecode1 *unit, int inNumSamples);
178 void FMHDecode1_Ctor(FMHDecode1* unit);
179
180 void BFManipulate_next(BFManipulate *unit, int inNumSamples);
181 void BFManipulate_Ctor(BFManipulate* unit);
182
183 void B2Ster_next(B2Ster *unit, int inNumSamples);
184 void B2Ster_Ctor(B2Ster* unit);
185
186 void BFFreeVerb_next(BFFreeVerb *unit, int inNumSamples);
187 void BFFreeVerb_Ctor(BFFreeVerb *unit);
188 void BFFreeVerb_Dtor(BFFreeVerb *unit);
189 }
190
191
192
193 //////////////////////////////////////////////////////////////////////////////////////////////////
194 /////// Basic Ambisonic UGens //////////////////////////////////////////////////////////////
195 //////////////////////////////////////////////////////////////////////////////////////////////////
196
197 // A2B and B2A conversions
198 /* See Ambisonics Ugens (ATK) */
A2B_Ctor(A2B * unit)199 void A2B_Ctor(A2B *unit)
200 {
201 SETCALC(A2B_next);
202 A2B_next(unit, 1);
203 }
204
B2A_Ctor(A2B * unit)205 void B2A_Ctor(A2B *unit)
206 {
207 SETCALC(A2B_next);
208 A2B_next(unit, 1);
209 }
210
211 // four channels in, four channels out...
212 // regardless... call in w, x, y, z and out a, b, c, d
A2B_next(A2B * unit,int inNumSamples)213 void A2B_next(A2B *unit, int inNumSamples)
214 {
215 float *Aout = ZOUT(0);
216 float *Bout = ZOUT(1);
217 float *Cout = ZOUT(2);
218 float *Dout = ZOUT(3);
219
220 float *Win = ZIN(0);
221 float *Xin = ZIN(1);
222 float *Yin = ZIN(2);
223 float *Zin = ZIN(3);
224
225 float lf, rf, rr, lr;
226 float oneHalf = 0.5;
227
228 LOOP(inNumSamples,
229 lf = ZXP(Win) * oneHalf;
230 rf = ZXP(Xin) * oneHalf;
231 lr = ZXP(Yin) * oneHalf;
232 rr = ZXP(Zin) * oneHalf;
233
234 ZXP(Aout) = lf + rf + lr + rr;
235 ZXP(Bout) = lf + rf - lr - rr;
236 ZXP(Cout) = lf - rf + lr - rr;
237 ZXP(Dout) = lf - rf - lr + rr;
238 );
239 }
240
241 ///////////////////////////////////////////////////////////////////////////////////////////////////////
242 // B to UHJ - transform a 3 channel 2d ambisonic signal into a 2 channel UHJ
243 //
244 // L = 0.5 * (0.9397*W + 0.1856*X - j*0.342*W + j*0.5099*X + 0.655*Y)
245 // R = 0.5 * (0.9397*W+ 0.1856*X + j*0.342*W - j*0.5099*X - 0.655*Y)
246 //
247 // Where j is a 90 shift
248
B2UHJ_Ctor(B2UHJ * unit)249 void B2UHJ_Ctor(B2UHJ *unit)
250 {
251 SETCALC(B2UHJ_next);
252 float gamconst = (15.0 * pi) / SAMPLERATE;
253 float gamma01 = gamconst * 0.3609;
254 float gamma02 = gamconst * 2.7412;
255 float gamma03 = gamconst * 11.1573;
256 float gamma04 = gamconst * 44.7581;
257 float gamma05 = gamconst * 179.6242;
258 float gamma06 = gamconst * 798.4578;
259 float gamma07 = gamconst * 1.2524;
260 float gamma08 = gamconst * 5.5671;
261 float gamma09 = gamconst * 22.3423;
262 float gamma10 = gamconst * 89.6271;
263 float gamma11 = gamconst * 364.7914;
264 float gamma12 = gamconst * 2770.1114;
265 unit->m_coefs[0] = (gamma01 - 1) / (gamma01 + 1);
266 unit->m_coefs[1] = (gamma02 - 1) / (gamma02 + 1);
267 unit->m_coefs[2] = (gamma03 - 1) / (gamma03 + 1);
268 unit->m_coefs[3] = (gamma04 - 1) / (gamma04 + 1);
269 unit->m_coefs[4] = (gamma05 - 1) / (gamma05 + 1);
270 unit->m_coefs[5] = (gamma06 - 1) / (gamma06 + 1);
271 unit->m_coefs[6] = (gamma07 - 1) / (gamma07 + 1);
272 unit->m_coefs[7] = (gamma08 - 1) / (gamma08 + 1);
273 unit->m_coefs[8] = (gamma09 - 1) / (gamma09 + 1);
274 unit->m_coefs[9] = (gamma10 - 1) / (gamma10 + 1);
275 unit->m_coefs[10] = (gamma11 - 1) / (gamma11 + 1);
276 unit->m_coefs[11] = (gamma12 - 1) / (gamma12 + 1);
277 // clear out the storage variables for the filters
278 for(int i = 0; i < 12; ++i){
279 unit->m_wy1[i] = 0.0;
280 unit->m_xy1[i] = 0.0;
281 unit->m_yy1[i] = 0.0;
282 }
283 ClearUnitOutputs(unit, 1);
284 }
285
B2UHJ_next(B2UHJ * unit,int inNumSamples)286 void B2UHJ_next(B2UHJ *unit, int inNumSamples)
287 {
288 float *Win = IN(0);
289 float *Xin = IN(1);
290 float *Yin = IN(2);
291 float *lsout = OUT(0);
292 float *rsout = OUT(1);
293
294 float wy1[12];
295 float xy1[12];
296 float yy1[12];
297
298 // each filter's last sample
299 for(int i = 0; i < 12; ++i){
300 wy1[i] = unit->m_wy1[i];
301 xy1[i] = unit->m_xy1[i];
302 yy1[i] = unit->m_yy1[i];
303 }
304
305 for (int i = 0; i < inNumSamples; ++i){
306 float wsig, w, wj, xsig, x, xj, ysig, y;
307
308 float way1, way2, way3, way4, way5, way6;
309 float way7, way8, way9, way10, way11, way12;
310
311 float xay1, xay2, xay3, xay4, xay5, xay6;
312 float xay7, xay8, xay9, xay10, xay11, xay12;
313
314 float yay1, yay2, yay3, yay4, yay5, yay6;
315
316 float wy0_1, wy0_2, wy0_3, wy0_4, wy0_5, wy0_6;
317 float wy0_7, wy0_8, wy0_9, wy0_10, wy0_11, wy0_12;
318
319 float xy0_1, xy0_2, xy0_3, xy0_4, xy0_5, xy0_6;
320 float xy0_7, xy0_8, xy0_9, xy0_10, xy0_11, xy0_12;
321
322 float yy0_1, yy0_2, yy0_3, yy0_4, yy0_5, yy0_6;
323
324 wsig = Win[i];
325 xsig = Xin[i];
326 ysig = Yin[i];
327
328 // pull out some values with a Shift90 - 6 cascading First order sections
329 wy0_1 = wsig - (unit->m_coefs[0]) * wy1[0];
330 way1 = unit->m_coefs[0] * wy0_1 + 1 * wy1[0];
331 wy1[0] = wy0_1;
332 wy0_2 = way1 - (unit->m_coefs[1]) * wy1[1];
333 way2 = unit->m_coefs[1] * wy0_2 + 1 * wy1[1];
334 wy1[1] = wy0_2;
335 wy0_3 = way2 - (unit->m_coefs[2]) * wy1[2];
336 way3 = unit->m_coefs[2] * wy0_3 + 1 * wy1[2];
337 wy1[2] = wy0_3;
338 wy0_4 = way3 - (unit->m_coefs[3]) * wy1[3];
339 way4 = unit->m_coefs[3] * wy0_4 + 1 * wy1[3];
340 wy1[3] = wy0_4;
341 wy0_5 = way4 - (unit->m_coefs[4]) * wy1[4];
342 way5 = unit->m_coefs[4] * wy0_5 + 1 * wy1[4];
343 wy1[4] = wy0_5;
344 wy0_6 = way5 - (unit->m_coefs[5]) * wy1[5];
345 w = way6 = unit->m_coefs[5] * wy0_6 + 1 * wy1[5];
346 wy1[5] = wy0_6;
347
348 wy0_7 = wsig - (unit->m_coefs[6]) * wy1[6];
349 way7 = unit->m_coefs[6] * wy0_7 + 1 * wy1[6];
350 wy1[6] = wy0_7;
351 wy0_8 = way7 - (unit->m_coefs[7]) * wy1[7];
352 way8 = unit->m_coefs[7] * wy0_8 + 1 * wy1[7];
353 wy1[7] = wy0_8;
354 wy0_9 = way8 - (unit->m_coefs[8]) * wy1[8];
355 way9 = unit->m_coefs[8] * wy0_9 + 1 * wy1[8];
356 wy1[8] = wy0_9;
357 wy0_10 = way9 - (unit->m_coefs[9]) * wy1[9];
358 way10 = unit->m_coefs[9] * wy0_10 + 1 * wy1[9];
359 wy1[9] = wy0_10;
360 wy0_11 = way10 - (unit->m_coefs[10]) * wy1[10];
361 way11 = unit->m_coefs[10] * wy0_11 + 1 * wy1[10];
362 wy1[10] = wy0_11;
363 wy0_12 = way11 - (unit->m_coefs[11]) * wy1[11];
364 wj = way12 = unit->m_coefs[11] * wy0_12 + 1 * wy1[11];
365 wy1[11] = wy0_12;
366
367 xy0_1 = xsig - (unit->m_coefs[0]) * xy1[0];
368 xay1 = unit->m_coefs[0] * xy0_1 + 1 * xy1[0];
369 xy1[0] = xy0_1;
370 xy0_2 = xay1 - (unit->m_coefs[1]) * xy1[1];
371 xay2 = unit->m_coefs[1] * xy0_2 + 1 * xy1[1];
372 xy1[1] = xy0_2;
373 xy0_3 = xay2 - (unit->m_coefs[2]) * xy1[2];
374 xay3 = unit->m_coefs[2] * xy0_3 + 1 * xy1[2];
375 xy1[2] = xy0_3;
376 xy0_4 = xay3 - (unit->m_coefs[3]) * xy1[3];
377 xay4 = unit->m_coefs[3] * xy0_4 + 1 * xy1[3];
378 xy1[3] = xy0_4;
379 xy0_5 = xay4 - (unit->m_coefs[4]) * xy1[4];
380 xay5 = unit->m_coefs[4] * xy0_5 + 1 * xy1[4];
381 xy1[4] = xy0_5;
382 xy0_6 = xay5 - (unit->m_coefs[5]) * xy1[5];
383 x = xay6 = unit->m_coefs[5] * xy0_6 + 1 * xy1[5];
384 xy1[5] = xy0_6;
385
386 xy0_7 = xsig - (unit->m_coefs[6]) * xy1[6];
387 xay7 = unit->m_coefs[6] * xy0_7 + 1 * xy1[6];
388 xy1[6] = xy0_7;
389 xy0_8 = xay7 - (unit->m_coefs[7]) * xy1[7];
390 xay8 = unit->m_coefs[7] * xy0_8 + 1 * xy1[7];
391 xy1[7] = xy0_8;
392 xy0_9 = xay8 - (unit->m_coefs[8]) * xy1[8];
393 xay9 = unit->m_coefs[8] * xy0_9 + 1 * xy1[8];
394 xy1[8] = xy0_9;
395 xy0_10 = xay9 - (unit->m_coefs[9]) * xy1[9];
396 xay10 = unit->m_coefs[9] * xy0_10 + 1 * xy1[9];
397 xy1[9] = xy0_10;
398 xy0_11 = xay10 - (unit->m_coefs[10]) * xy1[10];
399 xay11 = unit->m_coefs[10] * xy0_11 + 1 * xy1[10];
400 xy1[10] = xy0_11;
401 xy0_12 = xay11 - (unit->m_coefs[11]) * xy1[11];
402 xj = xay12 = unit->m_coefs[11] * xy0_12 + 1 * xy1[11];
403 xy1[11] = xy0_12;
404
405 yy0_1 = ysig - (unit->m_coefs[0]) * yy1[0];
406 yay1 = unit->m_coefs[0] * yy0_1 + 1 * yy1[0];
407 yy1[0] = yy0_1;
408 yy0_2 = yay1 - (unit->m_coefs[1]) * yy1[1];
409 yay2 = unit->m_coefs[1] * yy0_2 + 1 * yy1[1];
410 yy1[1] = yy0_2;
411 yy0_3 = yay2 - (unit->m_coefs[2]) * yy1[2];
412 yay3 = unit->m_coefs[2] * yy0_3 + 1 * yy1[2];
413 yy1[2] = yy0_3;
414 yy0_4 = yay3 - (unit->m_coefs[3]) * yy1[3];
415 yay4 = unit->m_coefs[3] * yy0_4 + 1 * yy1[3];
416 yy1[3] = yy0_4;
417 yy0_5 = yay4 - (unit->m_coefs[4]) * yy1[4];
418 yay5 = unit->m_coefs[4] * yy0_5 + 1 * yy1[4];
419 yy1[4] = yy0_5;
420 yy0_6 = yay5 - (unit->m_coefs[5]) * yy1[5];
421 y = yay6 = unit->m_coefs[5] * yy0_6 + 1 * yy1[5];
422 yy1[5] = yy0_6;
423
424 w = 0.9397 * w;
425 wj = 0.342 * wj;
426 x = 0.1856 * x;
427 xj = 0.5099 * xj;
428 y = y * 0.655;
429
430 lsout[i] = ((((w + x) - wj) + xj) + y) * 0.5;
431 rsout[i] = ((((w + x) + wj) - xj) - y) * 0.5;
432 }
433
434 for(int i = 0; i < 12; ++i){
435 unit->m_wy1[i] = zapgremlins(wy1[i]);
436 unit->m_xy1[i] = zapgremlins(xy1[i]);
437 unit->m_yy1[i] = zapgremlins(yy1[i]);
438 }
439
440 }
441
442
UHJ2B_Ctor(UHJ2B * unit)443 void UHJ2B_Ctor(UHJ2B *unit)
444 {
445 SETCALC(UHJ2B_next);
446 float gamconst = (15.0 * pi) / SAMPLERATE;
447 float gamma01 = gamconst * 0.3609;
448 float gamma02 = gamconst * 2.7412;
449 float gamma03 = gamconst * 11.1573;
450 float gamma04 = gamconst * 44.7581;
451 float gamma05 = gamconst * 179.6242;
452 float gamma06 = gamconst * 798.4578;
453 float gamma07 = gamconst * 1.2524;
454 float gamma08 = gamconst * 5.5671;
455 float gamma09 = gamconst * 22.3423;
456 float gamma10 = gamconst * 89.6271;
457 float gamma11 = gamconst * 364.7914;
458 float gamma12 = gamconst * 2770.1114;
459 unit->m_coefs[0] = (gamma01 - 1) / (gamma01 + 1);
460 unit->m_coefs[1] = (gamma02 - 1) / (gamma02 + 1);
461 unit->m_coefs[2] = (gamma03 - 1) / (gamma03 + 1);
462 unit->m_coefs[3] = (gamma04 - 1) / (gamma04 + 1);
463 unit->m_coefs[4] = (gamma05 - 1) / (gamma05 + 1);
464 unit->m_coefs[5] = (gamma06 - 1) / (gamma06 + 1);
465 unit->m_coefs[6] = (gamma07 - 1) / (gamma07 + 1);
466 unit->m_coefs[7] = (gamma08 - 1) / (gamma08 + 1);
467 unit->m_coefs[8] = (gamma09 - 1) / (gamma09 + 1);
468 unit->m_coefs[9] = (gamma10 - 1) / (gamma10 + 1);
469 unit->m_coefs[10] = (gamma11 - 1) / (gamma11 + 1);
470 unit->m_coefs[11] = (gamma12 - 1) / (gamma12 + 1);
471 // clear out the storage variables for the filters
472 for(int i = 0; i < 12; ++i){
473 unit->m_lsy1[i] = 0.0;
474 unit->m_rsy1[i] = 0.0;}
475 UHJ2B_next(unit, 1);
476
477 }
478
UHJ2B_next(UHJ2B * unit,int inNumSamples)479 void UHJ2B_next(UHJ2B *unit, int inNumSamples)
480 {
481 float *Lsin = IN(0);
482 float *Rsin = IN(1);
483 float *Wout = OUT(0);
484 float *Xout = OUT(1);
485 float *Yout = OUT(2);
486
487 float lsy1[12];
488 float rsy1[12];
489 float lsig, l, lj, rsig, r, rj;
490
491 float lay1, lay2, lay3, lay4, lay5, lay6;
492 float lay7, lay8, lay9, lay10, lay11, lay12;
493
494 float ray1, ray2, ray3, ray4, ray5, ray6;
495 float ray7, ray8, ray9, ray10, ray11, ray12;
496
497 float ly0_1, ly0_2, ly0_3, ly0_4, ly0_5, ly0_6;
498 float ly0_7, ly0_8, ly0_9, ly0_10, ly0_11, ly0_12;
499
500 float ry0_1, ry0_2, ry0_3, ry0_4, ry0_5, ry0_6;
501 float ry0_7, ry0_8, ry0_9, ry0_10, ry0_11, ry0_12;
502
503 // each filter's last sample
504 for(int i = 0; i < 12; ++i){
505 lsy1[i] = unit->m_lsy1[i];
506 rsy1[i] = unit->m_rsy1[i];
507 }
508
509 for (int i = 0; i < inNumSamples; ++i){
510
511 lsig = Lsin[i];
512 rsig = Rsin[i];
513
514 // pull out some values with a Shift90 - 6 cascading First order sections
515 ly0_1 = lsig - (unit->m_coefs[0]) * lsy1[0];
516 lay1 = unit->m_coefs[0] * ly0_1 + 1 * lsy1[0];
517 lsy1[0] = ly0_1;
518 ly0_2 = lay1 - (unit->m_coefs[1]) * lsy1[1];
519 lay2 = unit->m_coefs[1] * ly0_2 + 1 * lsy1[1];
520 lsy1[1] = ly0_2;
521 ly0_3 = lay2 - (unit->m_coefs[2]) * lsy1[2];
522 lay3 = unit->m_coefs[2] * ly0_3 + 1 * lsy1[2];
523 lsy1[2] = ly0_3;
524 ly0_4 = lay3 - (unit->m_coefs[3]) * lsy1[3];
525 lay4 = unit->m_coefs[3] * ly0_4 + 1 * lsy1[3];
526 lsy1[3] = ly0_4;
527 ly0_5 = lay4 - (unit->m_coefs[4]) * lsy1[4];
528 lay5 = unit->m_coefs[4] * ly0_5 + 1 * lsy1[4];
529 lsy1[4] = ly0_5;
530 ly0_6 = lay5 - (unit->m_coefs[5]) * lsy1[5];
531 l = lay6 = unit->m_coefs[5] * ly0_6 + 1 * lsy1[5];
532 lsy1[5] = ly0_6;
533
534 ly0_7 = lsig - (unit->m_coefs[6]) * lsy1[6];
535 lay7 = unit->m_coefs[6] * ly0_7 + 1 * lsy1[6];
536 lsy1[6] = ly0_7;
537 ly0_8 = lay7 - (unit->m_coefs[7]) * lsy1[7];
538 lay8 = unit->m_coefs[7] * ly0_8 + 1 * lsy1[7];
539 lsy1[7] = ly0_8;
540 ly0_9 = lay8 - (unit->m_coefs[8]) * lsy1[8];
541 lay9 = unit->m_coefs[8] * ly0_9 + 1 * lsy1[8];
542 lsy1[8] = ly0_9;
543 ly0_10 = lay9 - (unit->m_coefs[9]) * lsy1[9];
544 lay10 = unit->m_coefs[9] * ly0_10 + 1 * lsy1[9];
545 lsy1[9] = ly0_10;
546 ly0_11 = lay10 - (unit->m_coefs[10]) * lsy1[10];
547 lay11 = unit->m_coefs[10] * ly0_11 + 1 * lsy1[10];
548 lsy1[10] = ly0_11;
549 ly0_12 = lay11 - (unit->m_coefs[11]) * lsy1[11];
550 lj = lay12 = unit->m_coefs[11] * ly0_12 + 1 * lsy1[11];
551 lsy1[11] = ly0_12;
552
553 ry0_1 = rsig - (unit->m_coefs[0]) * rsy1[0];
554 ray1 = unit->m_coefs[0] * ry0_1 + 1 * rsy1[0];
555 rsy1[0] = ry0_1;
556 ry0_2 = ray1 - (unit->m_coefs[1]) * rsy1[1];
557 ray2 = unit->m_coefs[1] * ry0_2 + 1 * rsy1[1];
558 rsy1[1] = ry0_2;
559 ry0_3 = ray2 - (unit->m_coefs[2]) * rsy1[2];
560 ray3 = unit->m_coefs[2] * ry0_3 + 1 * rsy1[2];
561 rsy1[2] = ry0_3;
562 ry0_4 = ray3 - (unit->m_coefs[3]) * rsy1[3];
563 ray4 = unit->m_coefs[3] * ry0_4 + 1 * rsy1[3];
564 rsy1[3] = ry0_4;
565 ry0_5 = ray4 - (unit->m_coefs[4]) * rsy1[4];
566 ray5 = unit->m_coefs[4] * ry0_5 + 1 * rsy1[4];
567 rsy1[4] = ry0_5;
568 ry0_6 = ray5 - (unit->m_coefs[5]) * rsy1[5];
569 r = ray6 = unit->m_coefs[5] * ry0_6 + 1 * rsy1[5];
570 rsy1[5] = ry0_6;
571
572 ry0_7 = rsig - (unit->m_coefs[6]) * rsy1[6];
573 ray7 = unit->m_coefs[6] * ry0_7 + 1 * rsy1[6];
574 rsy1[6] = ry0_7;
575 ry0_8 = ray7 - (unit->m_coefs[7]) * rsy1[7];
576 ray8 = unit->m_coefs[7] * ry0_8 + 1 * rsy1[7];
577 rsy1[7] = ry0_8;
578 ry0_9 = ray8 - (unit->m_coefs[8]) * rsy1[8];
579 ray9 = unit->m_coefs[8] * ry0_9 + 1 * rsy1[8];
580 rsy1[8] = ry0_9;
581 ry0_10 = ray9 - (unit->m_coefs[9]) * rsy1[9];
582 ray10 = unit->m_coefs[9] * ry0_10 + 1 * rsy1[9];
583 rsy1[9] = ry0_10;
584 ry0_11 = ray10 - (unit->m_coefs[10]) * rsy1[10];
585 ray11 = unit->m_coefs[10] * ry0_11 + 1 * rsy1[10];
586 rsy1[10] = ry0_11;
587 ry0_12 = ray11 - (unit->m_coefs[11]) * rsy1[11];
588 rj = ray12 = unit->m_coefs[11] * ry0_12 + 1 * rsy1[11];
589 rsy1[11] = ry0_12;
590
591 Wout[i] = ((0.982 * l) + (0.982 * r) + (0.164 * lj) - (0.164 * rj)) * 0.5;
592 Xout[i] = ((0.419 * l) + (0.419 * r) - (0.828 * lj) + (0.828 * rj)) * 0.5;
593 Yout[i] = ((0.763 * l) - (0.763 * r) + (0.385 * lj) + (0.385 * rj)) * 0.5;
594 }
595
596 for(int i = 0; i < 12; ++i){
597 unit->m_lsy1[i] = zapgremlins(lsy1[i]);
598 unit->m_rsy1[i] = zapgremlins(rsy1[i]);
599 }
600
601 }
602
603
604 ////////////////////////////////////////////////////////////////////////
605
BFManipulate_Ctor(BFManipulate * unit)606 void BFManipulate_Ctor(BFManipulate *unit)
607 {
608 SETCALC(BFManipulate_next);
609 unit->m_rotate = ZIN0(4);
610 unit->m_tilt = ZIN0(5);
611 unit->m_tumble = ZIN0(6);
612 BFManipulate_next(unit, 1);
613 }
614
BFManipulate_next(BFManipulate * unit,int inNumSamples)615 void BFManipulate_next(BFManipulate *unit, int inNumSamples)
616 {
617 float *Wout = ZOUT(0);
618 float *Xout = ZOUT(1);
619 float *Yout = ZOUT(2);
620 float *Zout = ZOUT(3);
621
622 float *Win = ZIN(0);
623 float *Xin = ZIN(1);
624 float *Yin = ZIN(2);
625 float *Zin = ZIN(3);
626
627 float w, x, y, z;
628 float sina, sinb, sinc, cosa, cosb, cosc;
629
630 float rotate = unit->m_rotate;
631 float tilt = unit->m_tilt;
632 float tumble = unit->m_tumble;
633
634 float endrotate = ZIN0(4);
635 float endtilt = ZIN0(5);
636 float endtumble = ZIN0(6);
637
638 float rotate_slope = CALCSLOPE(endrotate, rotate);
639 float tilt_slope = CALCSLOPE(endtilt, tilt);
640 float tumble_slope = CALCSLOPE(endtumble, tumble);
641
642 LOOP(inNumSamples,
643 sina = sin(rotate);
644 sinb = sin(tilt);
645 sinc = sin(tumble);
646
647 cosa = cos(rotate);
648 cosb = cos(tilt);
649 cosc = cos(tumble);
650
651 w = ZXP(Win);
652 x = ZXP(Xin);
653 y = ZXP(Yin);
654 z = ZXP(Zin);
655
656 ZXP(Wout) = w;
657 ZXP(Xout) = ((x * cosa * cosc) - (y * sina) - (z * sinc));
658 ZXP(Yout) = ((x * sina) + (y * cosa * cosb) - (z * sinb));
659 ZXP(Zout) = ((x * sinc) + (y * sinb) + (z * cosb * cosc));
660
661 rotate += rotate_slope;
662 tilt += tilt_slope;
663 tumble += tumble_slope;
664 );
665
666 unit->m_rotate = endrotate;
667 unit->m_tilt = endtilt;
668 unit->m_tumble = endtumble;
669 }
670
671 ///////////////////////////////////////////////////////////////////////////////////////////////////////
672
B2Ster_Ctor(B2Ster * unit)673 void B2Ster_Ctor(B2Ster *unit)
674 {
675 SETCALC(B2Ster_next);
676 B2Ster_next(unit, 1);
677 }
678
679 // http://www.cyber.rdg.ac.uk/P.Sharkey/WWW/icdvrat/WWW96/Papers/keating.htm
680 // L = W + 0.35X + 0.61Y
681 // R = W + 0.35X - 0.61Y
682
B2Ster_next(B2Ster * unit,int inNumSamples)683 void B2Ster_next(B2Ster *unit, int inNumSamples)
684 {
685 float *Win = IN(0);
686 float *Xin = IN(1);
687 float *Yin = IN(2);
688 float *lout = OUT(0);
689 float *rout = OUT(1);
690
691 float w, x, y;
692 for(int i = 0; i < inNumSamples; ++i){
693 w = Win[i];
694 x = Xin[i] * 0.35;
695 y = Yin[i] * 0.61;
696
697 lout[i] = w + x + y;
698 rout[i] = w + x - y;
699 }
700 }
701
702
703 #define SIN_COS \
704 sina = sin(azimuth); \
705 sinb = sin(elevation); \
706 \
707 cosa = cos(azimuth); \
708 cosb = cos(elevation); \
709
710 #define CALC_INT \
711 if(rho >= 1) { \
712 intrho = 1 / pow(rho, 1.5); \
713 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; \
714 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} \
715 else \
716 { \
717 sinint = rsqrt2 * (sin(0.78539816339745 * rho)); \
718 cosint = rsqrt2 * (cos(0.78539816339745 * rho)); \
719 }; \
720 \
721 levelsinint = level * sinint; \
722
723 #define CALC_AMPS \
724 W_amp = level * cosint; \
725 X_amp = cosa * cosb * levelsinint; \
726 Y_amp = sina * cosb * levelsinint; \
727 Z_amp = sinb * levelsinint; \
728
729 // vary w according to x, y and z
730 #define BF_VALS_OUT \
731 z = in[i]; \
732 if(wComp > 0.){ \
733 wScale = (W_amp * (1 - (0.293 * ((X_amp * X_amp) + (Y_amp * Y_amp) + (Z_amp * Z_amp))))); \
734 } else { \
735 wScale = 0.707 * W_amp; \
736 } \
737 Wout[i] = z * wScale; \
738 Xout[i] = z * X_amp; \
739 Yout[i] = z * Y_amp; \
740 Zout[i] = z * Z_amp; \
741
742 ///////////////////////////////////////////////////////////////////////////////////
743
BFEncode2_Ctor(BFEncode2 * unit)744 void BFEncode2_Ctor(BFEncode2 *unit)
745 {
746 float intrho, levelsinint, sina, sinb, cosa, cosb;
747
748
749 if (INRATE(1) == calc_FullRate) {
750 if (INRATE(2) == calc_FullRate) {
751 if (INRATE(3) == calc_FullRate) {
752 SETCALC(BFEncode2_next_kkk); //aaa
753 } else {
754 SETCALC(BFEncode2_next_kkk); //aak
755 }
756 } else {
757 if (INRATE(3) == calc_FullRate) {
758 SETCALC(BFEncode2_next_kkk); //aka
759 } else {
760 SETCALC(BFEncode2_next_kkk); //akk
761 }
762 }
763 } else {
764 if (INRATE(2) == calc_FullRate) {
765 if (INRATE(3) == calc_FullRate) {
766 SETCALC(BFEncode2_next_kkk); //kaa
767 } else {
768 SETCALC(BFEncode2_next_kkk); //kak
769 }
770 } else {
771 if (INRATE(3) == calc_FullRate) {
772 SETCALC(BFEncode2_next_kkk); //kka
773 } else {
774 SETCALC(BFEncode2_next_kkk);
775 }
776 }
777 }
778
779 float sinint, cosint, azimuth, rho;
780 float point_x = unit->m_point_x = IN0(1);
781 float point_y = unit->m_point_y = IN0(2);
782 float elevation = unit->m_elevation = IN0(3);
783 float level = unit->m_level = IN0(4);
784
785 azimuth = atan2(point_x, point_y);
786 rho = hypot(point_x, point_y);
787
788 SIN_COS
789 CALC_INT
790
791 unit->m_W_amp = level * cosint;
792 unit->m_X_amp = cosa * cosb * levelsinint;
793 unit->m_Y_amp = sina * cosb * levelsinint;
794 unit->m_Z_amp = sinb * levelsinint;
795
796 BFEncode2_next_kkk(unit, 1);
797 }
798
BFEncode2_next_kkk(BFEncode2 * unit,int inNumSamples)799 void BFEncode2_next_kkk(BFEncode2 *unit, int inNumSamples)
800 {
801 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
802 float sinint, cosint, azimuth, rho, z;
803 float *Wout = OUT(0);
804 float *Xout = OUT(1);
805 float *Yout = OUT(2);
806 float *Zout = OUT(3);
807
808 float *in = IN(0);
809 float point_x = IN0(1);
810 float point_y = IN0(2);
811 float elevation = IN0(3);
812 float level = IN0(4);
813 float wComp = IN0(5);
814
815 azimuth = atan2(point_x, point_y);
816 rho = hypot(point_x, point_y);
817
818 float last_W_amp = W_amp = unit->m_W_amp;
819 float last_X_amp = X_amp = unit->m_X_amp;
820 float last_Y_amp = Y_amp = unit->m_Y_amp;
821 float last_Z_amp = Z_amp = unit->m_Z_amp;
822
823 float wScale;
824
825 if (point_x != unit->m_point_x || point_y != unit->m_point_y ||elevation != unit->m_elevation || level != unit->m_level) {
826 unit->m_point_x = point_x;
827 unit->m_point_y = point_y;
828 unit->m_elevation = elevation;
829 unit->m_level = level;
830
831 SIN_COS
832 CALC_INT
833 CALC_AMPS
834
835 float W_slope = CALCSLOPE(W_amp, last_W_amp);
836 float X_slope = CALCSLOPE(X_amp, last_X_amp);
837 float Y_slope = CALCSLOPE(Y_amp, last_Y_amp);
838 float Z_slope = CALCSLOPE(Z_amp, last_Z_amp);
839
840 // for the macros to work, reset W_amp (etc.) to the old values
841 W_amp = last_W_amp;
842 X_amp = last_X_amp;
843 Y_amp = last_Y_amp;
844 Z_amp = last_Z_amp;
845
846 for(int i = 0; i < inNumSamples; i++){
847 BF_VALS_OUT
848 W_amp += W_slope;
849 X_amp += X_slope;
850 Y_amp += Y_slope;
851 Z_amp += Z_slope;
852 }
853 unit->m_W_amp = W_amp;
854 unit->m_X_amp = X_amp;
855 unit->m_Y_amp = Y_amp;
856 unit->m_Z_amp = Z_amp;
857 } else {
858 for(int i = 0; i < inNumSamples; i++){
859 BF_VALS_OUT
860 };
861 }
862 }
863
864 ////////////////////////////////////////////////////////////////////////////////////////////////////////
865
BFEncode1_Ctor(BFEncode1 * unit)866 void BFEncode1_Ctor(BFEncode1 *unit)
867 {
868
869 if (INRATE(1) == calc_FullRate) {
870 if (INRATE(2) == calc_FullRate) {
871 if (INRATE(3) == calc_FullRate) {
872 SETCALC(BFEncode1_next_aaa);
873 } else {
874 SETCALC(BFEncode1_next_aak);
875 }
876 } else {
877 if (INRATE(3) == calc_FullRate) {
878 SETCALC(BFEncode1_next_aka);
879 } else {
880 SETCALC(BFEncode1_next_akk);
881 }
882 }
883 } else {
884 if (INRATE(2) == calc_FullRate) {
885 if (INRATE(3) == calc_FullRate) {
886 SETCALC(BFEncode1_next_kaa);
887 } else {
888 SETCALC(BFEncode1_next_kak);
889 }
890 } else {
891 if (INRATE(3) == calc_FullRate) {
892 SETCALC(BFEncode1_next_kka);
893 } else {
894 SETCALC(BFEncode1_next_kkk);
895 }
896 }
897 }
898 float intrho, levelsinint, sina, sinb, cosa, cosb;
899 float sinint, cosint;
900 float azimuth = unit->m_azimuth = IN0(1);
901 float elevation = unit->m_elevation = IN0(2);
902 float rho = unit->m_rho = IN0(3);
903 float level = unit->m_level = IN0(4);
904
905 SIN_COS
906 CALC_INT
907
908 unit->m_W_amp = level * cosint;
909 unit->m_X_amp = cosa * cosb * levelsinint;
910 unit->m_Y_amp = sina * cosb * levelsinint;
911 unit->m_Z_amp = sinb * levelsinint;
912
913 BFEncode1_next_kkk(unit, 1);
914 }
915
BFEncode1_next_kkk(BFEncode1 * unit,int inNumSamples)916 void BFEncode1_next_kkk(BFEncode1 *unit, int inNumSamples)
917 {
918 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
919 float sinint, cosint, z = 0.0;
920 float *Wout = OUT(0);
921 float *Xout = OUT(1);
922 float *Yout = OUT(2);
923 float *Zout = OUT(3);
924
925 float *in = IN(0);
926 float azimuth = IN0(1);
927 float elevation = IN0(2);
928 float rho = IN0(3);
929 float level = IN0(4);
930 float wComp = IN0(5);
931 float wScale;
932
933 float last_W_amp = W_amp = unit->m_W_amp;
934 float last_X_amp = X_amp = unit->m_X_amp;
935 float last_Y_amp = Y_amp = unit->m_Y_amp;
936 float last_Z_amp = Z_amp = unit->m_Z_amp;
937
938 if (azimuth != unit->m_azimuth || rho != unit->m_rho || elevation != unit->m_elevation || level != unit->m_level) {
939 unit->m_azimuth = azimuth;
940 unit->m_elevation = elevation;
941 unit->m_level = level;
942 unit->m_rho = rho;
943
944 SIN_COS
945 CALC_INT
946 CALC_AMPS
947
948 float W_slope = CALCSLOPE(W_amp, last_W_amp);
949 float X_slope = CALCSLOPE(X_amp, last_X_amp);
950 float Y_slope = CALCSLOPE(Y_amp, last_Y_amp);
951 float Z_slope = CALCSLOPE(Z_amp, last_Z_amp);
952
953 // for the macros to work, reset W_amp (etc.) to the old values
954 W_amp = last_W_amp;
955 X_amp = last_X_amp;
956 Y_amp = last_Y_amp;
957 Z_amp = last_Z_amp;
958
959 for(int i = 0; i < inNumSamples; i++){
960 BF_VALS_OUT
961
962 W_amp += W_slope;
963 X_amp += X_slope;
964 Y_amp += Y_slope;
965 Z_amp += Z_slope;
966 }
967 unit->m_W_amp = W_amp;
968 unit->m_X_amp = X_amp;
969 unit->m_Y_amp = Y_amp;
970 unit->m_Z_amp = Z_amp;
971 } else {
972 for(int i = 0; i < inNumSamples; i++)
973 {
974 BF_VALS_OUT
975 }
976 }
977 }
978
979
BFEncode1_next_aaa(BFEncode1 * unit,int inNumSamples)980 void BFEncode1_next_aaa(BFEncode1 *unit, int inNumSamples)
981 {
982 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
983 float sinint, cosint, z = 0.0;
984 float *Wout = OUT(0);
985 float *Xout = OUT(1);
986 float *Yout = OUT(2);
987 float *Zout = OUT(3);
988
989 float *in = IN(0);
990 float *azimuthar = IN(1);
991 float *elevationar = IN(2);
992 float *rhoar = IN(3);
993 float newlevel = IN0(4);
994 float level = unit->m_level;
995 float levelslope = 0.f;
996 float wComp = IN0(5);
997 float wScale;
998
999 if(newlevel != unit->m_level){
1000 levelslope = CALCSLOPE(newlevel, unit->m_level);
1001 }
1002
1003 for(int i = 0; i < inNumSamples; i++){
1004 float azimuth = azimuthar[i];
1005 float elevation = elevationar[i];
1006 float rho = rhoar[i];
1007
1008 SIN_COS
1009 CALC_INT
1010 CALC_AMPS
1011 BF_VALS_OUT
1012
1013 level += levelslope;
1014
1015 }
1016 unit->m_level = level;
1017 }
1018
1019
BFEncode1_next_akk(BFEncode1 * unit,int inNumSamples)1020 void BFEncode1_next_akk(BFEncode1 *unit, int inNumSamples)
1021 {
1022 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
1023 float sinint, cosint, z = 0.0;
1024 float *Wout = OUT(0);
1025 float *Xout = OUT(1);
1026 float *Yout = OUT(2);
1027 float *Zout = OUT(3);
1028
1029 float *in = IN(0);
1030 float *azimuthar = IN(1);
1031 float newelevation = IN0(2);
1032 float newrho = IN0(3);
1033 float newlevel = IN0(4);
1034 float elevation = unit->m_elevation;
1035 float rho = unit->m_rho;
1036 float level = unit->m_level;
1037 float elslope = 0.f;
1038 float rhoslope = 0.f;
1039 float levelslope = 0.f;
1040 float wComp = IN0(5);
1041 float wScale;
1042 if(newelevation != unit->m_elevation || newrho != unit->m_rho || newlevel != unit->m_level){
1043 elslope = CALCSLOPE(newelevation, unit->m_elevation);
1044 rhoslope = CALCSLOPE(newrho, unit->m_rho);
1045 levelslope = CALCSLOPE(newlevel, unit->m_level);
1046 }
1047
1048 for(int i = 0; i < inNumSamples; i++){
1049 float azimuth = azimuthar[i];
1050
1051 SIN_COS
1052 CALC_INT
1053 CALC_AMPS
1054 BF_VALS_OUT
1055
1056 elevation += elslope;
1057 rho += rhoslope;
1058 level += levelslope;
1059
1060 }
1061 unit->m_elevation = elevation;
1062 unit->m_level = level;
1063 unit->m_rho = rho;
1064 }
1065
BFEncode1_next_aak(BFEncode1 * unit,int inNumSamples)1066 void BFEncode1_next_aak(BFEncode1 *unit, int inNumSamples)
1067 {
1068 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
1069 float sinint, cosint, z = 0.0;
1070 float *Wout = OUT(0);
1071 float *Xout = OUT(1);
1072 float *Yout = OUT(2);
1073 float *Zout = OUT(3);
1074
1075 float *in = IN(0);
1076 float *azimuthar = IN(1);
1077 float *elevationar = IN(2);
1078 float newrho = IN0(3);
1079 float newlevel = IN0(4);
1080 float rho = unit->m_rho;
1081 float level = unit->m_level;
1082 float rhoslope = 0.f;
1083 float levelslope = 0.f;
1084 float wComp = IN0(5);
1085 float wScale;
1086 if(newrho != unit->m_rho || newlevel != unit->m_level){
1087 rhoslope = CALCSLOPE(newrho, unit->m_rho);
1088 levelslope = CALCSLOPE(newlevel, unit->m_level);
1089 }
1090
1091 for(int i = 0; i < inNumSamples; i++){
1092 float azimuth = azimuthar[i];
1093 float elevation = elevationar[i];
1094 SIN_COS
1095 CALC_INT
1096 CALC_AMPS
1097 BF_VALS_OUT
1098
1099 rho += rhoslope;
1100 level += levelslope;
1101
1102 }
1103 unit->m_level = level;
1104 unit->m_rho = rho;
1105 }
1106
1107
BFEncode1_next_aka(BFEncode1 * unit,int inNumSamples)1108 void BFEncode1_next_aka(BFEncode1 *unit, int inNumSamples)
1109 {
1110 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
1111 float sinint, cosint, z = 0.0;
1112 float *Wout = OUT(0);
1113 float *Xout = OUT(1);
1114 float *Yout = OUT(2);
1115 float *Zout = OUT(3);
1116
1117 float *in = IN(0);
1118 float *azimuthar = IN(1);
1119 float newelevation = IN0(2);
1120 float *rhoar = IN(3);
1121 float newlevel = IN0(4);
1122 float elevation = unit->m_elevation;
1123 float level = unit->m_level;
1124 float elslope = 0.f;
1125 float levelslope = 0.f;
1126 float wComp = IN0(5);
1127 float wScale;
1128 if(newelevation != unit->m_elevation || newlevel != unit->m_level){
1129 elslope = CALCSLOPE(newelevation, unit->m_elevation);
1130 levelslope = CALCSLOPE(newlevel, unit->m_level);
1131 }
1132
1133 for(int i = 0; i < inNumSamples; i++){
1134 float azimuth = azimuthar[i];
1135 float rho = rhoar[i];
1136
1137 SIN_COS
1138 CALC_INT
1139 CALC_AMPS
1140 BF_VALS_OUT
1141
1142 elevation += elslope;
1143 level += levelslope;
1144
1145 }
1146 unit->m_elevation = elevation;
1147 unit->m_level = level;
1148 }
1149
BFEncode1_next_kaa(BFEncode1 * unit,int inNumSamples)1150 void BFEncode1_next_kaa(BFEncode1 *unit, int inNumSamples)
1151 {
1152 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
1153 float sinint, cosint, z = 0.0;
1154 float *Wout = OUT(0);
1155 float *Xout = OUT(1);
1156 float *Yout = OUT(2);
1157 float *Zout = OUT(3);
1158
1159 float *in = IN(0);
1160 float newazimuth = IN0(1);
1161 float *elevationar = IN(2);
1162 float *rhoar = IN(3);
1163 float newlevel = IN0(4);
1164 float azimuth = unit->m_azimuth;
1165 float level = unit->m_level;
1166 float azslope = 0.f;
1167 float levelslope = 0.f;
1168 float wComp = IN0(5);
1169 float wScale;
1170 if(newazimuth != unit->m_azimuth || newlevel != unit->m_level){
1171 azslope = CALCSLOPE(newazimuth, unit->m_azimuth);
1172 levelslope = CALCSLOPE(newlevel, unit->m_level);
1173 }
1174
1175 for(int i = 0; i < inNumSamples; i++){
1176 float rho = rhoar[i];
1177 float elevation = elevationar[i];
1178
1179 SIN_COS
1180 CALC_INT
1181 CALC_AMPS
1182 BF_VALS_OUT
1183
1184 azimuth += azslope;
1185 level += levelslope;
1186
1187 }
1188 unit->m_level = level;
1189 unit->m_azimuth = azimuth;
1190 }
1191
1192
BFEncode1_next_kak(BFEncode1 * unit,int inNumSamples)1193 void BFEncode1_next_kak(BFEncode1 *unit, int inNumSamples)
1194 {
1195 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
1196 float sinint, cosint, z = 0.0;
1197 float *Wout = OUT(0);
1198 float *Xout = OUT(1);
1199 float *Yout = OUT(2);
1200 float *Zout = OUT(3);
1201
1202 float *in = IN(0);
1203 float newazimuth = IN0(1);
1204 float *elevationar = IN(2);
1205 float newrho = IN0(3);
1206 float newlevel = IN0(4);
1207 float azimuth = unit->m_azimuth;
1208 float rho = unit->m_rho;
1209 float level = unit->m_level;
1210 float azslope = 0.f;
1211 float rhoslope = 0.f;
1212 float levelslope = 0.f;
1213 float wComp = IN0(5);
1214 float wScale;
1215 if(newazimuth != unit->m_azimuth || newrho != unit->m_rho || newlevel != unit->m_level){
1216 rhoslope = CALCSLOPE(newrho, unit->m_rho);
1217 azslope = CALCSLOPE(newazimuth, unit->m_azimuth);
1218 levelslope = CALCSLOPE(newlevel, unit->m_level);
1219 }
1220
1221 for(int i = 0; i < inNumSamples; i++){
1222 float elevation = elevationar[i];
1223
1224 SIN_COS
1225 CALC_INT
1226 CALC_AMPS
1227 BF_VALS_OUT
1228
1229 azimuth += azslope;
1230 rho += rhoslope;
1231 level += levelslope;
1232
1233 }
1234 unit->m_level = level;
1235 unit->m_rho = rho;
1236 unit->m_azimuth = azimuth;
1237 }
1238
BFEncode1_next_kka(BFEncode1 * unit,int inNumSamples)1239 void BFEncode1_next_kka(BFEncode1 *unit, int inNumSamples)
1240 {
1241 float intrho, levelsinint, sina, sinb, cosa, cosb, W_amp, X_amp, Y_amp, Z_amp;
1242 float sinint, cosint, z = 0.0;
1243 float *Wout = OUT(0);
1244 float *Xout = OUT(1);
1245 float *Yout = OUT(2);
1246 float *Zout = OUT(3);
1247
1248 float *in = IN(0);
1249 float newazimuth = IN0(1);
1250 float newelevation = IN0(2);
1251 float *rhoar = IN(3);
1252 float newlevel = IN0(4);
1253 float azimuth = unit->m_azimuth;
1254 float elevation = unit->m_elevation;
1255 float level = unit->m_level;
1256 float azslope = 0.f;
1257 float elslope = 0.f;
1258 float levelslope = 0.f;
1259 float wComp = IN0(5);
1260 float wScale;
1261 if(newazimuth != unit->m_azimuth || newelevation != unit->m_elevation || newlevel != unit->m_level){
1262 elslope = CALCSLOPE(newelevation, unit->m_elevation);
1263 azslope = CALCSLOPE(newazimuth, unit->m_azimuth);
1264 levelslope = CALCSLOPE(newlevel, unit->m_level);
1265 }
1266
1267 for(int i = 0; i < inNumSamples; i++){
1268 float rho = rhoar[i];
1269
1270 SIN_COS
1271 CALC_INT
1272 CALC_AMPS
1273 BF_VALS_OUT
1274
1275 azimuth += azslope;
1276 elevation += elslope;
1277 level += levelslope;
1278
1279 }
1280 unit->m_level = level;
1281 unit->m_elevation = elevation;
1282 unit->m_azimuth = azimuth;
1283 }
1284
1285
1286 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1287
1288 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1289
BFEncodeSter_Ctor(BFEncodeSter * unit)1290 void BFEncodeSter_Ctor(BFEncodeSter *unit)
1291 {
1292 SETCALC(BFEncodeSter_next);
1293 float sinint, cosint;
1294 float azimuth = unit->m_azimuth = IN0(2);
1295 float width = unit->m_width = IN0(3);
1296 float elevation = unit->m_elevation = IN0(4);
1297 float rho = unit->m_rho = IN0(5);
1298 float level = unit->m_level = IN0(6);
1299 float width2 = width * 0.5;
1300 float azplus = azimuth + width2;
1301 float azminus = azimuth - width2;
1302 float sinal = sin(azplus);
1303 float sinar = sin(azminus);
1304 float sinb= sin(elevation);
1305
1306
1307 float cosar = cos(azplus);
1308 float cosal = cos(azminus);
1309 float cosb = cos(elevation);
1310
1311 if(rho >= 1) {
1312 float intrho = 1 / pow(rho, 1.5);
1313 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; // pow(rho, (float)1.5);
1314 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} // pow(rho, (float)1.5);}
1315 else
1316 {
1317 sinint = rsqrt2 * (sin(0.78539816339745 * rho));
1318 cosint = rsqrt2 * (cos(0.78539816339745 * rho));
1319 };
1320 float levelsinint = level * sinint;
1321
1322 unit->m_W_ampL = level * cosint;
1323 unit->m_X_ampL = cosal * cosb * levelsinint;
1324 unit->m_Y_ampL = sinal * cosb * levelsinint;
1325 unit->m_Z_ampL = sinb * levelsinint;
1326
1327 unit->m_W_ampR = level * cosint;
1328 unit->m_X_ampR = cosar * cosb * levelsinint;
1329 unit->m_Y_ampR = sinar * cosb * levelsinint;
1330 unit->m_Z_ampR = sinb * levelsinint;
1331
1332 BFEncodeSter_next(unit, 1);
1333 }
1334
BFEncodeSter_next(BFEncodeSter * unit,int inNumSamples)1335 void BFEncodeSter_next(BFEncodeSter *unit, int inNumSamples)
1336 {
1337 float sinint, cosint, z, y = 0.0;
1338 float *Wout = OUT(0);
1339 float *Xout = OUT(1);
1340 float *Yout = OUT(2);
1341 float *Zout = OUT(3);
1342
1343 float *l = IN(0);
1344 float *r = IN(1);
1345 float azimuth = IN0(2);
1346 float width = IN0(3);
1347 float elevation = IN0(4);
1348 float rho = IN0(5);
1349 float level = IN0(6);
1350 float wComp = IN0(7);
1351 float wScaleL, wScaleR;
1352
1353 float W_ampL = unit->m_W_ampL;
1354 float X_ampL = unit->m_X_ampL;
1355 float Y_ampL = unit->m_Y_ampL;
1356 float Z_ampL = unit->m_Z_ampL;
1357 float W_ampR = unit->m_W_ampR;
1358 float X_ampR = unit->m_X_ampR;
1359 float Y_ampR = unit->m_Y_ampR;
1360 float Z_ampR = unit->m_Z_ampR;
1361
1362 if (azimuth != unit->m_azimuth || width != unit->m_width || rho != unit->m_rho || elevation != unit->m_elevation || level != unit->m_level) {
1363 unit->m_azimuth = azimuth;
1364 unit->m_width = width;
1365 unit->m_elevation = elevation;
1366 unit->m_level = level;
1367 unit->m_rho = rho;
1368
1369 float width2 = width * 0.5;
1370 float azplus = azimuth + width2;
1371 float azminus = azimuth - width2;
1372 float sinal = sin(azplus);
1373 float sinar = sin(azminus);
1374 float sinb = sin(elevation);
1375
1376 float cosal = cos(azplus);
1377 float cosar = cos(azminus);
1378 float cosb = cos(elevation);
1379
1380 if(rho >= 1) {
1381 float intrho = 1 / pow(rho, 1.5);
1382 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; // pow(rho, (float)1.5);
1383 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} // pow(rho, (float)1.5);}
1384 else {
1385 sinint = rsqrt2 * (sin(0.78539816339745 * rho));
1386 cosint = rsqrt2 * (cos(0.78539816339745 * rho));
1387 };
1388
1389 float levelsinint = level * sinint;
1390
1391 float next_W_ampL = level * cosint;
1392 float next_X_ampL = cosal * cosb * levelsinint;
1393 float next_Y_ampL = sinal * cosb * levelsinint;
1394 float next_Z_ampL = sinb * levelsinint;
1395
1396 float next_W_ampR = level * cosint;
1397 float next_X_ampR = cosar * cosb * levelsinint;
1398 float next_Y_ampR = sinar * cosb * levelsinint;
1399 float next_Z_ampR = sinb * levelsinint;
1400
1401 float W_slopeL = CALCSLOPE(next_W_ampL, W_ampL);
1402 float X_slopeL = CALCSLOPE(next_X_ampL, X_ampL);
1403 float Y_slopeL = CALCSLOPE(next_Y_ampL, Y_ampL);
1404 float Z_slopeL = CALCSLOPE(next_Z_ampL, Z_ampL);
1405
1406 float W_slopeR = CALCSLOPE(next_W_ampR, W_ampR);
1407 float X_slopeR = CALCSLOPE(next_X_ampR, X_ampR);
1408 float Y_slopeR = CALCSLOPE(next_Y_ampR, Y_ampR);
1409 float Z_slopeR = CALCSLOPE(next_Z_ampR, Z_ampR);
1410
1411 for(int i = 0; i < inNumSamples; i++){
1412 y = l[i];
1413 z = r[i];
1414 // vary w according to x, y and z
1415 if(wComp > 0.){
1416 wScaleL = (W_ampL * (1 - (0.293 * ((X_ampL * X_ampL) + (Y_ampL * Y_ampL) + (Z_ampL * Z_ampL)))));
1417 wScaleR = (W_ampR * (1 - (0.293 * ((X_ampR * X_ampR) + (Y_ampR * Y_ampR) + (Z_ampR * Z_ampR)))));
1418 } else {
1419 wScaleL = 0.707 * W_ampL;
1420 wScaleR = 0.707 * W_ampR;
1421 }
1422 Wout[i] = (y * wScaleL) + (z * wScaleR);
1423 Xout[i] = (y * X_ampL) + (z * X_ampR);
1424 Yout[i] = (y * Y_ampL) + (z * Y_ampR);
1425 Zout[i] = (y * Z_ampL) + (z * Z_ampR);
1426 W_ampL += W_slopeL;
1427 X_ampL += X_slopeL;
1428 Y_ampL += Y_slopeL;
1429 Z_ampL += Z_slopeL;
1430 W_ampR += W_slopeR;
1431 X_ampR += X_slopeR;
1432 Y_ampR += Y_slopeR;
1433 Z_ampR += Z_slopeR;
1434 }
1435 unit->m_W_ampL = W_ampL;
1436 unit->m_X_ampL = X_ampL;
1437 unit->m_Y_ampL = Y_ampL;
1438 unit->m_Z_ampL = Z_ampL;
1439 unit->m_W_ampR = W_ampR;
1440 unit->m_X_ampR = X_ampR;
1441 unit->m_Y_ampR = Y_ampR;
1442 unit->m_Z_ampR = Z_ampR;
1443 } else {
1444 for(int i = 0; i < inNumSamples; i++)
1445 {
1446 y = l[i];
1447 z = r[i];
1448 // vary w according to x, y and z
1449 if(wComp > 0.){
1450 wScaleL = (W_ampL * (1 - (0.293 * ((X_ampL * X_ampL) + (Y_ampL * Y_ampL) + (Z_ampL * Z_ampL)))));
1451 wScaleR = (W_ampR * (1 - (0.293 * ((X_ampR * X_ampR) + (Y_ampR * Y_ampR) + (Z_ampR * Z_ampR)))));
1452 } else {
1453 wScaleL = 0.707 * W_ampL;
1454 wScaleR = 0.707 * W_ampR;
1455 }
1456 Wout[i] = (y * wScaleL) + (z * wScaleR);
1457 Xout[i] = (y * X_ampL) + (z * X_ampR);
1458 Yout[i] = (y * Y_ampL) + (z * Y_ampR);
1459 Zout[i] = (y * Z_ampL) + (z * Z_ampR);
1460 }
1461 }
1462 }
1463
1464 // S, T, U, and V are scaled according to FuMa scalings
1465
1466 #define CALC_FMH_COEFS \
1467 unit->m_W_amp = level * cosint; \
1468 unit->m_X_amp = cosa * cosb * levelsinint; \
1469 unit->m_Y_amp = sina * cosb * levelsinint; \
1470 unit->m_Z_amp = sinb * levelsinint; \
1471 unit->m_R_amp = (1.5 * sinbsq - 0.5) * levelsinint; \
1472 unit->m_S_amp = cosa * sinelevationtimes2 * levelsinint * twodivsqrt3; \
1473 unit->m_T_amp = sina * sinelevationtimes2 * levelsinint * twodivsqrt3; \
1474 unit->m_U_amp = cos(azimuthtimes2) * cosbsq * levelsinint * twodivsqrt3; \
1475 unit->m_V_amp = sin(azimuthtimes2) * cosbsq * levelsinint * twodivsqrt3; \
1476
1477 #define CALC_STANDARD_FMH_COEFS \
1478 unit->m_W_amp = level * 0.707; \
1479 unit->m_X_amp = cosa * cosb * level; \
1480 unit->m_Y_amp = sina * cosb * level; \
1481 unit->m_Z_amp = sinb * level; \
1482 unit->m_R_amp = (1.5 * sinbsq - 0.5) * level; \
1483 unit->m_S_amp = cosa * sinelevationtimes2 * level * twodivsqrt3; \
1484 unit->m_T_amp = sina * sinelevationtimes2 * level * twodivsqrt3; \
1485 unit->m_U_amp = cos(azimuthtimes2) * cosbsq * level * twodivsqrt3; \
1486 unit->m_V_amp = sin(azimuthtimes2) * cosbsq * level * twodivsqrt3; \
1487
FMHEncode1_Ctor(FMHEncode1 * unit)1488 void FMHEncode1_Ctor(FMHEncode1 *unit)
1489 {
1490 SETCALC(FMHEncode1_next);
1491 float sinint, cosint;
1492 float azimuth = unit->m_azimuth = IN0(1);
1493 float elevation = unit->m_elevation = IN0(2);
1494 float rho = unit->m_rho = IN0(3);
1495 float level = unit->m_level = IN0(4);
1496
1497 float azimuthtimes2 = azimuth * 2.;
1498 float elevationtimes2 = elevation * 2.;
1499 float sina = sin(azimuth);
1500 float sinb = sin(elevation);
1501
1502 float cosa = cos(azimuth);
1503 float cosb = cos(elevation);
1504
1505 float cosbsq = cosb * cosb;
1506 float sinbsq = sinb * sinb;
1507 float sinelevationtimes2 = sin(elevationtimes2);
1508
1509 // the whole rho thing just may not work... let's try anyways!
1510 if(rho >= 1) {
1511 float intrho = 1 / pow(rho, 1.5);
1512 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; // pow(rho, (float)1.5);
1513 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} // pow(rho, (float)1.5);}
1514 else
1515 {
1516 sinint = rsqrt2 * (sin(0.78539816339745 * rho));
1517 cosint = rsqrt2 * (cos(0.78539816339745 * rho));
1518 };
1519
1520 float levelsinint = level * sinint;
1521
1522 CALC_FMH_COEFS
1523
1524 FMHEncode1_next(unit, 1);
1525 }
1526
1527
1528
FMHEncode1_next(FMHEncode1 * unit,int inNumSamples)1529 void FMHEncode1_next(FMHEncode1 *unit, int inNumSamples)
1530 {
1531 float sinint, cosint, z = 0.0;
1532 float *Wout = OUT(0);
1533 float *Xout = OUT(1);
1534 float *Yout = OUT(2);
1535 float *Zout = OUT(3);
1536 float *Rout = OUT(4);
1537 float *Sout = OUT(5);
1538 float *Tout = OUT(6);
1539 float *Uout = OUT(7);
1540 float *Vout = OUT(8);
1541
1542 float *in = IN(0);
1543 float azimuth = IN0(1);
1544 float elevation = IN0(2);
1545 float rho = IN0(3);
1546 float level = IN0(4);
1547 float wComp = IN0(5);
1548 float wScale;
1549
1550 float W_amp = unit->m_W_amp;
1551 float X_amp = unit->m_X_amp;
1552 float Y_amp = unit->m_Y_amp;
1553 float Z_amp = unit->m_Z_amp;
1554 float R_amp = unit->m_R_amp;
1555 float S_amp = unit->m_S_amp;
1556 float T_amp = unit->m_T_amp;
1557 float U_amp = unit->m_U_amp;
1558 float V_amp = unit->m_V_amp;
1559
1560 if (azimuth != unit->m_azimuth || rho != unit->m_rho || elevation != unit->m_elevation || level != unit->m_level) {
1561 unit->m_azimuth = azimuth;
1562 unit->m_elevation = elevation;
1563 unit->m_level = level;
1564 unit->m_rho = rho;
1565
1566 float azimuthtimes2 = azimuth * 2.;
1567 float elevationtimes2 = elevation * 2.;
1568 float sina = sin(azimuth);
1569 float sinb = sin(elevation);
1570
1571 float cosa = cos(azimuth);
1572 float cosb = cos(elevation);
1573
1574 float cosbsq = cosb * cosb;
1575 float sinbsq = sinb * sinb;
1576 float sinelevationtimes2 = sin(elevationtimes2);
1577
1578 if(rho >= 1) {
1579 float intrho = 1 / pow(rho, 1.5);
1580 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; // pow(rho, (float)1.5);
1581 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} // pow(rho, (float)1.5);}
1582 else {
1583 sinint = rsqrt2 * (sin(0.78539816339745 * rho));
1584 cosint = rsqrt2 * (cos(0.78539816339745 * rho));
1585 };
1586
1587 float levelsinint = level * sinint;
1588
1589 CALC_FMH_COEFS
1590
1591 float W_slope = CALCSLOPE(unit->m_W_amp, W_amp);
1592 float X_slope = CALCSLOPE(unit->m_X_amp, X_amp);
1593 float Y_slope = CALCSLOPE(unit->m_Y_amp, Y_amp);
1594 float Z_slope = CALCSLOPE(unit->m_Z_amp, Z_amp);
1595 float R_slope = CALCSLOPE(unit->m_R_amp, R_amp);
1596 float S_slope = CALCSLOPE(unit->m_S_amp, S_amp);
1597 float T_slope = CALCSLOPE(unit->m_T_amp, T_amp);
1598 float U_slope = CALCSLOPE(unit->m_U_amp, U_amp);
1599 float V_slope = CALCSLOPE(unit->m_V_amp, V_amp);
1600
1601 for(int i = 0; i < inNumSamples; i++){
1602 z = in[i];
1603 if(wComp > 0){
1604 wScale = (W_amp * (1 - (0.293 * ((X_amp * X_amp) + (Y_amp * Y_amp) + (Z_amp * Z_amp) + (R_amp * R_amp) + (S_amp * S_amp) +
1605 (T_amp * T_amp) + (U_amp * U_amp) + (V_amp * V_amp)))));
1606 } else {
1607 wScale = 0.707 * W_amp;
1608 }
1609 // vary w according to x, y and z
1610 Wout[i] = z * wScale;
1611 Xout[i] = z * X_amp;
1612 Yout[i] = z * Y_amp;
1613 Zout[i] = z * Z_amp;
1614 Rout[i] = z * R_amp;
1615 Sout[i] = z * S_amp;
1616 Tout[i] = z * T_amp;
1617 Uout[i] = z * U_amp;
1618 Vout[i] = z * V_amp;
1619
1620 W_amp += W_slope;
1621 X_amp += X_slope;
1622 Y_amp += Y_slope;
1623 Z_amp += Z_slope;
1624 R_amp += R_slope;
1625 S_amp += S_slope;
1626 T_amp += T_slope;
1627 U_amp += U_slope;
1628 V_amp += V_slope;
1629
1630 }
1631 } else {
1632 for(int i = 0; i < inNumSamples; i++)
1633 {
1634 z = in[i];
1635 if(wComp > 0){
1636 wScale = (W_amp * (1 - (0.293 * ((X_amp * X_amp) + (Y_amp * Y_amp) + (Z_amp * Z_amp) + (R_amp * R_amp) + (S_amp * S_amp) +
1637 (T_amp * T_amp) + (U_amp * U_amp) + (V_amp * V_amp)))));
1638 } else {
1639 wScale = 0.707 * W_amp;
1640 }
1641 // vary w according to x, y and z
1642 Wout[i] = z * wScale;
1643 Xout[i] = z * X_amp;
1644 Yout[i] = z * Y_amp;
1645 Zout[i] = z * Z_amp;
1646 Rout[i] = z * R_amp;
1647 Sout[i] = z * S_amp;
1648 Tout[i] = z * T_amp;
1649 Uout[i] = z * U_amp;
1650 Vout[i] = z * V_amp;
1651 }
1652 }
1653 }
1654
FMHEncode0_Ctor(FMHEncode0 * unit)1655 void FMHEncode0_Ctor(FMHEncode0 *unit)
1656 {
1657 SETCALC(FMHEncode0_next);
1658 float azimuth = unit->m_azimuth = IN0(1);
1659 float elevation = unit->m_elevation = IN0(2);
1660 float level = unit->m_level = IN0(3);
1661
1662 float azimuthtimes2 = azimuth * 2.;
1663 float elevationtimes2 = elevation * 2.;
1664 float sina = sin(azimuth);
1665 float sinb = sin(elevation);
1666
1667 float cosa = cos(azimuth);
1668 float cosb = cos(elevation);
1669
1670 float cosbsq = cosb * cosb;
1671 float sinbsq = sinb * sinb;
1672 float sinelevationtimes2 = sin(elevationtimes2);
1673
1674 CALC_STANDARD_FMH_COEFS
1675
1676 FMHEncode0_next(unit, 1);
1677 }
1678
1679
1680
FMHEncode0_next(FMHEncode0 * unit,int inNumSamples)1681 void FMHEncode0_next(FMHEncode0 *unit, int inNumSamples)
1682 {
1683 float z = 0.0;
1684 float *Wout = OUT(0);
1685 float *Xout = OUT(1);
1686 float *Yout = OUT(2);
1687 float *Zout = OUT(3);
1688 float *Rout = OUT(4);
1689 float *Sout = OUT(5);
1690 float *Tout = OUT(6);
1691 float *Uout = OUT(7);
1692 float *Vout = OUT(8);
1693
1694 float *in = IN(0);
1695 float azimuth = IN0(1);
1696 float elevation = IN0(2);
1697 float level = IN0(3);
1698
1699 float W_amp = unit->m_W_amp;
1700 float X_amp = unit->m_X_amp;
1701 float Y_amp = unit->m_Y_amp;
1702 float Z_amp = unit->m_Z_amp;
1703 float R_amp = unit->m_R_amp;
1704 float S_amp = unit->m_S_amp;
1705 float T_amp = unit->m_T_amp;
1706 float U_amp = unit->m_U_amp;
1707 float V_amp = unit->m_V_amp;
1708
1709 if (azimuth != unit->m_azimuth || elevation != unit->m_elevation || level != unit->m_level) {
1710 unit->m_azimuth = azimuth;
1711 unit->m_elevation = elevation;
1712 unit->m_level = level;
1713 float azimuthtimes2 = azimuth * 2.;
1714 float elevationtimes2 = elevation * 2.;
1715 float sina = sin(azimuth);
1716 float sinb = sin(elevation);
1717
1718 float cosa = cos(azimuth);
1719 float cosb = cos(elevation);
1720
1721 float cosbsq = cosb * cosb;
1722 float sinbsq = sinb * sinb;
1723 float sinelevationtimes2 = sin(elevationtimes2);
1724
1725 CALC_STANDARD_FMH_COEFS
1726
1727 float W_slope = CALCSLOPE(unit->m_W_amp, W_amp);
1728 float X_slope = CALCSLOPE(unit->m_X_amp, X_amp);
1729 float Y_slope = CALCSLOPE(unit->m_Y_amp, Y_amp);
1730 float Z_slope = CALCSLOPE(unit->m_Z_amp, Z_amp);
1731 float R_slope = CALCSLOPE(unit->m_R_amp, R_amp);
1732 float S_slope = CALCSLOPE(unit->m_S_amp, S_amp);
1733 float T_slope = CALCSLOPE(unit->m_T_amp, T_amp);
1734 float U_slope = CALCSLOPE(unit->m_U_amp, U_amp);
1735 float V_slope = CALCSLOPE(unit->m_V_amp, V_amp);
1736
1737 for(int i = 0; i < inNumSamples; i++){
1738 z = in[i];
1739 // vary w according to x, y and z
1740 Wout[i] = z * W_amp;
1741 Xout[i] = z * X_amp;
1742 Yout[i] = z * Y_amp;
1743 Zout[i] = z * Z_amp;
1744 Rout[i] = z * R_amp;
1745 Sout[i] = z * S_amp;
1746 Tout[i] = z * T_amp;
1747 Uout[i] = z * U_amp;
1748 Vout[i] = z * V_amp;
1749
1750 W_amp += W_slope;
1751 X_amp += X_slope;
1752 Y_amp += Y_slope;
1753 Z_amp += Z_slope;
1754 R_amp += R_slope;
1755 S_amp += S_slope;
1756 T_amp += T_slope;
1757 U_amp += U_slope;
1758 V_amp += V_slope;
1759
1760 }
1761 } else {
1762 for(int i = 0; i < inNumSamples; i++)
1763 {
1764 z = in[i];
1765 Wout[i] = z * W_amp;
1766 Xout[i] = z * X_amp;
1767 Yout[i] = z * Y_amp;
1768 Zout[i] = z * Z_amp;
1769 Rout[i] = z * R_amp;
1770 Sout[i] = z * S_amp;
1771 Tout[i] = z * T_amp;
1772 Uout[i] = z * U_amp;
1773 Vout[i] = z * V_amp;
1774 }
1775 }
1776 }
1777
1778
1779
FMHEncode2_Ctor(FMHEncode2 * unit)1780 void FMHEncode2_Ctor(FMHEncode2 *unit)
1781 {
1782 SETCALC(FMHEncode2_next);
1783 float sinint, cosint, azimuth, rho;
1784 float point_x = unit->m_point_x = IN0(1);
1785 float point_y = unit->m_point_y = IN0(2);
1786 float elevation = unit->m_elevation = IN0(3);
1787 float level = unit->m_level = IN0(4);
1788 float wComp = IN0(5);
1789
1790 azimuth = atan2(point_x, point_y);
1791 rho = hypot(point_x, point_y);
1792
1793 float azimuthtimes2 = azimuth * 2.;
1794 float elevationtimes2 = elevation * 2.;
1795 float sina = sin(azimuth);
1796 float sinb = sin(elevation);
1797
1798 float cosa = cos(azimuth);
1799 float cosb = cos(elevation);
1800
1801 float cosbsq = cosb * cosb;
1802 float sinbsq = sinb * sinb;
1803 float sinelevationtimes2 = sin(elevationtimes2);
1804
1805 // the whole rho thing just may not work... let's try anyways!
1806 if(rho >= 1) {
1807 float intrho = 1 / pow(rho, 1.5);
1808 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; // pow(rho, (float)1.5);
1809 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} // pow(rho, (float)1.5);}
1810 else
1811 {
1812 sinint = rsqrt2 * (sin(0.78539816339745 * rho));
1813 cosint = rsqrt2 * (cos(0.78539816339745 * rho));
1814 };
1815
1816 float levelsinint = level * sinint;
1817
1818 CALC_FMH_COEFS
1819
1820 FMHEncode2_next(unit, 1);
1821 }
1822
FMHEncode2_next(FMHEncode2 * unit,int inNumSamples)1823 void FMHEncode2_next(FMHEncode2 *unit, int inNumSamples)
1824 {
1825 float sinint, cosint, z, azimuth, rho = 0.0;
1826 float *Wout = OUT(0);
1827 float *Xout = OUT(1);
1828 float *Yout = OUT(2);
1829 float *Zout = OUT(3);
1830 float *Rout = OUT(4);
1831 float *Sout = OUT(5);
1832 float *Tout = OUT(6);
1833 float *Uout = OUT(7);
1834 float *Vout = OUT(8);
1835
1836 float *in = IN(0);
1837 float point_x = IN0(1);
1838 float point_y = IN0(2);
1839 float elevation = unit->m_elevation = IN0(3);
1840 float level = unit->m_level = IN0(4);
1841 float wComp = IN0(5);
1842 float wScale;
1843
1844 float W_amp = unit->m_W_amp;
1845 float X_amp = unit->m_X_amp;
1846 float Y_amp = unit->m_Y_amp;
1847 float Z_amp = unit->m_Z_amp;
1848 float R_amp = unit->m_R_amp;
1849 float S_amp = unit->m_S_amp;
1850 float T_amp = unit->m_T_amp;
1851 float U_amp = unit->m_U_amp;
1852 float V_amp = unit->m_V_amp;
1853
1854 if (point_x != unit->m_point_x || point_y != unit->m_point_y || rho != unit->m_rho || elevation != unit->m_elevation || level != unit->m_level) {
1855 unit->m_point_x = point_x;
1856 unit->m_point_y = point_y;
1857 unit->m_elevation = elevation;
1858 unit->m_level = level;
1859 unit->m_rho = rho;
1860
1861 azimuth = atan2(point_x, point_y);
1862 rho = hypot(point_x, point_y);
1863
1864 float azimuthtimes2 = azimuth * 2.;
1865 float elevationtimes2 = elevation * 2.;
1866 float sina = sin(azimuth);
1867 float sinb = sin(elevation);
1868
1869 float cosa = cos(azimuth);
1870 float cosb = cos(elevation);
1871
1872 float cosbsq = cosb * cosb;
1873 float sinbsq = sinb * sinb;
1874 float sinelevationtimes2 = sin(elevationtimes2);
1875
1876 if(rho >= 1) {
1877 float intrho = 1 / pow(rho, 1.5);
1878 sinint = (rsqrt2 * (sin(0.78539816339745))) * intrho; // pow(rho, (float)1.5);
1879 cosint = (rsqrt2 * (cos(0.78539816339745))) * intrho;} // pow(rho, (float)1.5);}
1880 else {
1881 sinint = rsqrt2 * (sin(0.78539816339745 * rho));
1882 cosint = rsqrt2 * (cos(0.78539816339745 * rho));
1883 };
1884
1885 float levelsinint = level * sinint;
1886
1887 CALC_FMH_COEFS
1888
1889 float W_slope = CALCSLOPE(unit->m_W_amp, W_amp);
1890 float X_slope = CALCSLOPE(unit->m_X_amp, X_amp);
1891 float Y_slope = CALCSLOPE(unit->m_Y_amp, Y_amp);
1892 float Z_slope = CALCSLOPE(unit->m_Z_amp, Z_amp);
1893 float R_slope = CALCSLOPE(unit->m_R_amp, R_amp);
1894 float S_slope = CALCSLOPE(unit->m_S_amp, S_amp);
1895 float T_slope = CALCSLOPE(unit->m_T_amp, T_amp);
1896 float U_slope = CALCSLOPE(unit->m_U_amp, U_amp);
1897 float V_slope = CALCSLOPE(unit->m_V_amp, V_amp);
1898
1899 for(int i = 0; i < inNumSamples; i++){
1900 z = in[i];
1901 if(wComp > 0){
1902 wScale = (W_amp * (1 - (0.293 * ((X_amp * X_amp) + (Y_amp * Y_amp) + (Z_amp * Z_amp) + (R_amp * R_amp) + (S_amp * S_amp) +
1903 (T_amp * T_amp) + (U_amp * U_amp) + (V_amp * V_amp)))));
1904 } else {
1905 wScale = 0.707 * W_amp;
1906 }
1907 // vary w according to x, y and z
1908 Wout[i] = z * wScale;
1909 // vary w according to x, y, z, r and weighted s, t, u, v
1910 Wout[i] = z * (W_amp * (1 - (0.293 * ((X_amp * X_amp) + (Y_amp * Y_amp) + (Z_amp * Z_amp) + (R_amp * R_amp) + (S_amp * S_amp) +
1911 (T_amp * T_amp) + (U_amp * U_amp) + (V_amp * V_amp)))));
1912 Xout[i] = z * X_amp;
1913 Yout[i] = z * Y_amp;
1914 Zout[i] = z * Z_amp;
1915 Rout[i] = z * R_amp;
1916 Sout[i] = z * S_amp;
1917 Tout[i] = z * T_amp;
1918 Uout[i] = z * U_amp;
1919 Vout[i] = z * V_amp;
1920
1921 W_amp += W_slope;
1922 X_amp += X_slope;
1923 Y_amp += Y_slope;
1924 Z_amp += Z_slope;
1925 R_amp += R_slope;
1926 S_amp += S_slope;
1927 T_amp += T_slope;
1928 U_amp += U_slope;
1929 V_amp += V_slope;
1930
1931 }
1932 } else {
1933 for(int i = 0; i < inNumSamples; i++)
1934 {
1935 z = in[i];
1936 Wout[i] = z * (W_amp * (1 - (0.293 * ((X_amp * X_amp) + (Y_amp * Y_amp) + (Z_amp * Z_amp) + (R_amp * R_amp) + (S_amp * S_amp) +
1937 (T_amp * T_amp) + (U_amp * U_amp) + (V_amp * V_amp)))));
1938 Xout[i] = z * X_amp;
1939 Yout[i] = z * Y_amp;
1940 Zout[i] = z * Z_amp;
1941 Rout[i] = z * R_amp;
1942 Sout[i] = z * S_amp;
1943 Tout[i] = z * T_amp;
1944 Uout[i] = z * U_amp;
1945 Vout[i] = z * V_amp;
1946 }
1947 }
1948 }
1949
1950
1951 ////////////////////////////////////////////////////////////////////////////////////////////////////////
1952
BFDecode1_Ctor(BFDecode1 * unit)1953 void BFDecode1_Ctor(BFDecode1 *unit)
1954 {
1955 SETCALC(BFDecode1_next);
1956
1957 float azimuth = unit->m_azimuth = IN0(4);
1958 float elevation = unit->m_elevation = IN0(5);
1959
1960 float cosa = cos(azimuth);
1961 float sina = sin(azimuth);
1962 float sinb = sin(elevation);
1963 float cosb = cos(elevation);
1964 float wComp = IN0(7);
1965 if(wComp > 0.0) unit->m_W_amp = rsqrt2; else unit->m_W_amp = 1.;
1966 unit->m_X_amp = cosa * cosb;
1967 unit->m_Y_amp = sina * cosb;
1968 unit->m_Z_amp = sinb;
1969
1970 BFDecode1_next(unit, 1);
1971
1972 }
1973
BFDecode1_next(BFDecode1 * unit,int inNumSamples)1974 void BFDecode1_next(BFDecode1 *unit, int inNumSamples)
1975 {
1976 float *Win0 = IN(0);
1977 float *Xin0 = IN(1);
1978 float *Yin0 = IN(2);
1979 float *Zin0 = IN(3);
1980 float *out = OUT(0);
1981 float W_amp = unit->m_W_amp;
1982 float X_amp = unit->m_X_amp;
1983 float Y_amp = unit->m_Y_amp;
1984 float Z_amp = unit->m_Z_amp;
1985
1986 if((unit->m_azimuth != IN0(4)) || (unit->m_elevation != IN0(5))){
1987 unit->m_azimuth = IN0(4);
1988 unit->m_elevation = IN0(5);
1989 float cosa = cos(unit->m_azimuth);
1990 float sina = sin(unit->m_azimuth);
1991 float sinb = sin(unit->m_elevation);
1992 float cosb = cos(unit->m_elevation);
1993
1994 unit->m_X_amp = cosa * cosb;
1995 unit->m_Y_amp = sina * cosb;
1996 unit->m_Z_amp = sinb;
1997
1998 float X_ampslope = CALCSLOPE(unit->m_X_amp, X_amp);
1999 float Y_ampslope = CALCSLOPE(unit->m_Y_amp, Y_amp);
2000 float Z_ampslope = CALCSLOPE(unit->m_Z_amp, Z_amp);
2001
2002 for(int i = 0; i < inNumSamples; i++)
2003 {
2004 out[i] = (Win0[i] * W_amp) +
2005 (Xin0[i] * X_amp) +
2006 (Yin0[i] * Y_amp) +
2007 (Zin0[i] * Z_amp);
2008 X_amp += X_ampslope;
2009 Y_amp += Y_ampslope;
2010 Z_amp += Z_ampslope;
2011 }
2012 } else {
2013 for(int i = 0; i < inNumSamples; i++)
2014 {
2015 out[i] = (Win0[i] * W_amp) +
2016 (Xin0[i] * X_amp) +
2017 (Yin0[i] * Y_amp) +
2018 (Zin0[i] * Z_amp);
2019 }
2020 }
2021 }
2022
2023
2024 #define CALC_FMH_SPEAKER_COEFS \
2025 unit->m_X_amp = cosa * cosb; \
2026 unit->m_Y_amp = sina * cosb; \
2027 unit->m_Z_amp = sinb; \
2028 unit->m_R_amp = 1.5 * sinbsq - 0.5; \
2029 unit->m_S_amp = cosa * sinelevationtimes2; \
2030 unit->m_T_amp = sina * sinelevationtimes2; \
2031 unit->m_U_amp = cos(azimuthtimes2) * cosbsq; \
2032 unit->m_V_amp = sin(azimuthtimes2) * cosbsq; \
2033
FMHDecode1_Ctor(FMHDecode1 * unit)2034 void FMHDecode1_Ctor(FMHDecode1 *unit)
2035 {
2036 SETCALC(FMHDecode1_next);
2037
2038 float azimuth = unit->m_azimuth = IN0(9);
2039 float elevation = unit->m_elevation = IN0(10);
2040
2041 float azimuthtimes2 = azimuth * 2.;
2042 float elevationtimes2 = elevation * 2.;
2043 float sina = sin(azimuth);
2044 float sinb = sin(elevation);
2045
2046 float cosa = cos(azimuth);
2047 float cosb = cos(elevation);
2048
2049 float cosbsq = cosb * cosb;
2050 float sinbsq = sinb * sinb;
2051 float sinelevationtimes2 = sin(elevationtimes2);
2052
2053 CALC_FMH_SPEAKER_COEFS
2054
2055 FMHDecode1_next(unit, 1);
2056
2057 }
2058
FMHDecode1_next(FMHDecode1 * unit,int inNumSamples)2059 void FMHDecode1_next(FMHDecode1 *unit, int inNumSamples)
2060 {
2061 float *Win0 = IN(0);
2062 float *Xin0 = IN(1);
2063 float *Yin0 = IN(2);
2064 float *Zin0 = IN(3);
2065 float *Rin0 = IN(4);
2066 float *Sin0 = IN(5);
2067 float *Tin0 = IN(6);
2068 float *Uin0 = IN(7);
2069 float *Vin0 = IN(8);
2070 float *out = OUT(0);
2071
2072 float X_amp = unit->m_X_amp;
2073 float Y_amp = unit->m_Y_amp;
2074 float Z_amp = unit->m_Z_amp;
2075 float R_amp = unit->m_R_amp;
2076 float S_amp = unit->m_S_amp;
2077 float T_amp = unit->m_T_amp;
2078 float U_amp = unit->m_U_amp;
2079 float V_amp = unit->m_V_amp;
2080
2081 if((unit->m_azimuth != IN0(9)) || (unit->m_elevation != IN0(10))){
2082 float azimuth = unit->m_azimuth = IN0(9);
2083 float elevation = unit->m_elevation = IN0(10);
2084
2085 float azimuthtimes2 = azimuth * 2.;
2086 float elevationtimes2 = elevation * 2.;
2087 float sina = sin(azimuth);
2088 float sinb = sin(elevation);
2089
2090 float cosa = cos(azimuth);
2091 float cosb = cos(elevation);
2092
2093 float cosbsq = cosb * cosb;
2094 float sinbsq = sinb * sinb;
2095 float sinelevationtimes2 = sin(elevationtimes2);
2096
2097 CALC_FMH_SPEAKER_COEFS
2098
2099 float X_slope = CALCSLOPE(X_amp, unit->m_X_amp);
2100 float Y_slope = CALCSLOPE(Y_amp, unit->m_Y_amp);
2101 float Z_slope = CALCSLOPE(Z_amp, unit->m_Z_amp);
2102 float R_slope = CALCSLOPE(R_amp, unit->m_R_amp);
2103 float S_slope = CALCSLOPE(S_amp, unit->m_S_amp);
2104 float T_slope = CALCSLOPE(T_amp, unit->m_T_amp);
2105 float U_slope = CALCSLOPE(U_amp, unit->m_U_amp);
2106 float V_slope = CALCSLOPE(V_amp, unit->m_V_amp);
2107
2108 for(int i = 0; i < inNumSamples; i++)
2109 {
2110 out[i] = Win0[i] +
2111 (Xin0[i] * X_amp) +
2112 (Yin0[i] * Y_amp) +
2113 (Zin0[i] * Z_amp) +
2114 (Rin0[i] * R_amp) +
2115 (Sin0[i] * S_amp) +
2116 (Tin0[i] * T_amp) +
2117 (Uin0[i] * U_amp) +
2118 (Vin0[i] * V_amp);
2119 X_amp += X_slope;
2120 Y_amp += Y_slope;
2121 Z_amp += Z_slope;
2122 R_amp += R_slope;
2123 S_amp += S_slope;
2124 T_amp += T_slope;
2125 U_amp += U_slope;
2126 V_amp += V_slope;
2127 }
2128 } else {
2129 for(int i = 0; i < inNumSamples; i++)
2130 {
2131 out[i] = Win0[i] +
2132 (Xin0[i] * X_amp) +
2133 (Yin0[i] * Y_amp) +
2134 (Zin0[i] * Z_amp) +
2135 (Rin0[i] * R_amp) +
2136 (Sin0[i] * S_amp) +
2137 (Tin0[i] * T_amp) +
2138 (Uin0[i] * U_amp) +
2139 (Vin0[i] * V_amp);
2140 }
2141 }
2142 }
2143
BFFreeVerb_next(BFFreeVerb * unit,int inNumSamples)2144 void BFFreeVerb_next(BFFreeVerb *unit, int inNumSamples){
2145 int i, j;
2146 float* in_W = IN(0);
2147 float* in_X = IN(1);
2148 float* in_Y = IN(2);
2149 float* in_Z = IN(3);
2150 float* out_W = OUT(0);
2151 float* out_X = OUT(1);
2152 float* out_Y = OUT(2);
2153 float* out_Z = OUT(3);
2154 if(unit->first){
2155 Print("Creating memory\n");
2156 int floatSize = sizeof(float);
2157 for(i = 0; i < 4; i++){
2158 unit->m_dline0[i] = (float*)RTAlloc(unit->mWorld, floatSize * 225);
2159 unit->m_dline1[i] = (float*)RTAlloc(unit->mWorld, floatSize * 341);
2160 unit->m_dline2[i] = (float*)RTAlloc(unit->mWorld, floatSize * 441);
2161 unit->m_dline3[i] = (float*)RTAlloc(unit->mWorld, floatSize * 556);
2162 unit->m_dline4[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1617);
2163 unit->m_dline5[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1557);
2164 unit->m_dline6[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1491);
2165 unit->m_dline7[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1422);
2166 unit->m_dline8[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1277);
2167 unit->m_dline9[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1116);
2168 unit->m_dline10[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1188);
2169 unit->m_dline11[i] = (float*)RTAlloc(unit->mWorld, floatSize * 1356);
2170 unit->m_iota[i] = (float*)RTAlloc(unit->mWorld, floatSize * 12);
2171 unit->m_r0[i] = (float*)RTAlloc(unit->mWorld, floatSize * 20);
2172 unit->m_r1[i] = (float*)RTAlloc(unit->mWorld, floatSize * 4);
2173 }
2174 Print("Zeroing out data\n");
2175 for(i = 0; i < 4; i++){
2176 for(j = 0; j < 255; j++) unit->m_dline0[i][j] = 0.f;
2177 for(j = 0; j < 341; j++) unit->m_dline1[i][j] = 0.f;
2178 for(j = 0; j < 441; j++) unit->m_dline2[i][j] = 0.f;
2179 for(j = 0; j < 556; j++) unit->m_dline3[i][j] = 0.f;
2180 for(j = 0; j < 1617; j++) unit->m_dline4[i][j] = 0.f;
2181 for(j = 0; j < 1557; j++) unit->m_dline5[i][j] = 0.f;
2182 for(j = 0; j < 1491; j++) unit->m_dline6[i][j] = 0.f;
2183 for(j = 0; j < 1422; j++) unit->m_dline7[i][j] = 0.f;
2184 for(j = 0; j < 1277; j++) unit->m_dline8[i][j] = 0.f;
2185 for(j = 0; j < 1116; j++) unit->m_dline9[i][j] = 0.f;
2186 for(j = 0; j < 1188; j++) unit->m_dline10[i][j] = 0.f;
2187 for(j = 0; j < 1356; j++) unit->m_dline11[i][j] = 0.f;
2188 for(j = 0; j < 12; j++) unit->m_iota[i][j] = 0.f;
2189 for(j = 0; j < 20; j++) unit->m_r0[i][i] = 0.f;
2190 for(j = 0; j < 4; j++) unit->m_r1[i][j] = 0.f;
2191 }
2192 Print("Zeroing out data - done!\n");
2193 unit->first = false;
2194 }
2195
2196 for(i = 0; i < inNumSamples; i++){
2197 out_W[i] = 0.f;
2198 out_X[i] = 0.f;
2199 out_Y[i] = 0.f;
2200 out_Z[i] = 0.f;
2201 }
2202
2203 }
2204
2205 /*
2206 float* m_dline0[4];
2207 float* m_dline1[4];
2208 float* m_dline2[4];
2209 float* m_dline3[4];
2210 float* m_dline4[4];
2211 float* m_dline5[4];
2212 float* m_dline6[4];
2213 float* m_dline7[4];
2214 float* m_dline8[4];
2215 float* m_dline9[4];
2216 float* m_dline10[4];
2217 float* m_dline11[4];
2218 float* m_iota[4];
2219 float* m_r0[4];
2220 float* m_r1[4];
2221 */
BFFreeVerb_Ctor(BFFreeVerb * unit)2222 void BFFreeVerb_Ctor(BFFreeVerb *unit){
2223 SETCALC(BFFreeVerb_next);
2224 unit->first = true;
2225 OUT0(0) = 0.f;
2226 OUT0(1) = 0.f;
2227 OUT0(2) = 0.f;
2228 OUT0(3) = 0.f;
2229 }
2230
BFFreeVerb_Dtor(BFFreeVerb * unit)2231 void BFFreeVerb_Dtor(BFFreeVerb *unit){
2232 for(int i = 0; i < 4; i++){
2233 RTFree(unit->mWorld, unit->m_dline0[i]);
2234 RTFree(unit->mWorld, unit->m_dline1[i]);
2235 RTFree(unit->mWorld, unit->m_dline2[i]);
2236 RTFree(unit->mWorld, unit->m_dline3[i]);
2237 RTFree(unit->mWorld, unit->m_dline4[i]);
2238 RTFree(unit->mWorld, unit->m_dline5[i]);
2239 RTFree(unit->mWorld, unit->m_dline6[i]);
2240 RTFree(unit->mWorld, unit->m_dline7[i]);
2241 RTFree(unit->mWorld, unit->m_dline8[i]);
2242 RTFree(unit->mWorld, unit->m_dline9[i]);
2243 RTFree(unit->mWorld, unit->m_dline10[i]);
2244 RTFree(unit->mWorld, unit->m_dline11[i]);
2245 RTFree(unit->mWorld, unit->m_iota[i]);
2246 RTFree(unit->mWorld, unit->m_r0[i]);
2247 RTFree(unit->mWorld, unit->m_r1[i]);
2248 }
2249 }
2250
2251 ////////////////////////////////////////////////////////////////////////////////////////////////////////
2252
PluginLoad(JoshAmbi)2253 PluginLoad(JoshAmbi)
2254 {
2255 ft = inTable;
2256
2257 DefineSimpleCantAliasUnit(BFEncode1);
2258 DefineSimpleCantAliasUnit(BFEncode2);
2259 DefineSimpleCantAliasUnit(BFEncodeSter);
2260 DefineSimpleCantAliasUnit(FMHEncode0);
2261 DefineSimpleCantAliasUnit(FMHEncode1);
2262 DefineSimpleCantAliasUnit(FMHEncode2);
2263 DefineSimpleCantAliasUnit(BFDecode1);
2264 DefineSimpleCantAliasUnit(FMHDecode1);
2265 DefineSimpleUnit(BFManipulate);
2266 DefineSimpleCantAliasUnit(B2Ster);
2267 DefineSimpleUnit(A2B);
2268 DefineSimpleUnit(B2A);
2269 DefineSimpleCantAliasUnit(UHJ2B);
2270 DefineSimpleCantAliasUnit(B2UHJ);
2271 // DefineDtorCantAliasUnit(BFFreeVerb);
2272
2273
2274 }
2275
2276
2277