blob: d3cc77449877dc52ceda1a56323070b3ce1c7727 (
about) (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
//-----------------------------------------------------
// name: "Phaser Mono"
//
// Code generated with Faust 0.9.67 (http://faust.grame.fr)
//-----------------------------------------------------
/* link with */
#ifndef FAUSTPOWER
#define FAUSTPOWER
#define faustpower4(x) ((x)*(x)*(x)*(x))
#define faustpower3(x) ((x)*(x)*(x))
#define faustpower2(x) ((x)*(x))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif
//----------------------------------------------------------------------------
// FAUST generated signal processor
//----------------------------------------------------------------------------
#ifndef FAUSTFLOAT
#define FAUSTFLOAT float
#endif
#ifndef FAUSTCLASS
#define FAUSTCLASS mydsp
#endif
class Dsp {
private:
int iVec0[2];
int iConst0;
float fConst1;
float fConst2;
FAUSTFLOAT speed; //default: 0.5f; range: 0..10
float fConst3;
float fRec5[2];
float fRec6[2];
float fConst4;
float fConst5;
float fRec4[3];
float fConst6;
float fRec3[3];
float fConst7;
float fRec2[3];
float fConst8;
float fRec1[3];
float fRec0[2];
public:
static void classInit(int samplingFreq) {
}
virtual void instanceInit(int samplingFreq) {
int fSamplingFreq = samplingFreq;
for (int i=0; i<2; i++) iVec0[i] = 0;
iConst0 = min(192000, max(1, fSamplingFreq));
fConst1 = 0.9366460212365959; //expf((0 - (3141.592653589793f / float(iConst0))));
fConst2 = faustpower2(fConst1);
speed = 0.5f;
fConst3 = (6.283185307179586f / float(iConst0));
for (int i=0; i<2; i++) fRec5[i] = 0;
for (int i=0; i<2; i++) fRec6[i] = 0;
fConst4 = (2.0f / float(iConst0));
fConst5 = (0 - (2 * fConst1));
for (int i=0; i<3; i++) fRec4[i] = 0;
fConst6 = (4.0f / float(iConst0));
for (int i=0; i<3; i++) fRec3[i] = 0;
fConst7 = (8.0f / float(iConst0));
for (int i=0; i<3; i++) fRec2[i] = 0;
fConst8 = (16.0f / float(iConst0));
for (int i=0; i<3; i++) fRec1[i] = 0;
for (int i=0; i<2; i++) fRec0[i] = 0;
}
virtual void init(int samplingFreq) {
classInit(samplingFreq);
instanceInit(samplingFreq);
}
// convert fixed point to float
// * invert bits if sign bit is set (0x08000000, or (1<<27))
// * cast int to float
// * divide by constant to shift decimal point
// * multiply by -1 if sign bit was set
float ConvertFracToFloat(int32_t frac) {
bool neg = (((1<<27) & frac) != 0);
float res = (float)(neg ? frac : ~frac);
res = res / (float(1<<29));
return (neg ? (-1 * res) : res);
}
virtual void compute (int count,
const int32_t** input,
int32_t* output,
int32_t speed) {
float fSlow0 = 100;
float fSlow1 = 0.01f * fSlow0;
float fSlow2 = (fConst3 * 10*ConvertFracToFloat(speed));
float fSlow3 = cosf(fSlow2);
float fSlow4 = sinf(fSlow2);
float fSlow5 = (0 - fSlow4);
float fSlow6 = (1 - (0.01f * fSlow0));
const int32_t* input0 = *input;
int32_t* output0 = output;
for (int i=0; i<count; i++) {
iVec0[0] = 1;
float fTemp0 = ConvertFracToFloat(input0[i]);
fRec5[0] = ((fSlow4 * fRec6[1]) + (fSlow3 * fRec5[1]));
fRec6[0] = ((1 + ((fSlow3 * fRec6[1]) + (fSlow5 * fRec5[1]))) - iVec0[1]);
float fTemp1 = (628.3185307179587f + (2199.1148575128555f * (1 - fRec5[0])));
float fTemp2 = (fRec4[1] * cosf((fConst4 * fTemp1)));
fRec4[0] = (0 - (((fConst5 * fTemp2) + (fConst2 * fRec4[2])) - ((fSlow1 * fTemp0) + (0.5f * fRec0[1]))));
float fTemp3 = (fRec3[1] * cosf((fConst6 * fTemp1)));
fRec3[0] = ((fConst5 * (fTemp2 - fTemp3)) + (fRec4[2] + (fConst2 * (fRec4[0] - fRec3[2]))));
float fTemp4 = (fRec2[1] * cosf((fConst7 * fTemp1)));
fRec2[0] = ((fConst5 * (fTemp3 - fTemp4)) + (fRec3[2] + (fConst2 * (fRec3[0] - fRec2[2]))));
float fTemp5 = (fRec1[1] * cosf((fConst8 * fTemp1)));
fRec1[0] = ((fConst5 * (fTemp4 - fTemp5)) + (fRec2[2] + (fConst2 * (fRec2[0] - fRec1[2]))));
fRec0[0] = ((fConst2 * fRec1[0]) + ((fConst5 * fTemp5) + fRec1[2]));
output0[i] = ConvertFloatToFrac((fSlow6 * fTemp0) - fRec0[0]) <<7;
// post processing
fRec0[1] = fRec0[0];
fRec1[2] = fRec1[1]; fRec1[1] = fRec1[0];
fRec2[2] = fRec2[1]; fRec2[1] = fRec2[0];
fRec3[2] = fRec3[1]; fRec3[1] = fRec3[0];
fRec4[2] = fRec4[1]; fRec4[1] = fRec4[0];
fRec6[1] = fRec6[0];
fRec5[1] = fRec5[0];
iVec0[1] = iVec0[0];
}
}
};
|
