8 #include "alAuxEffectSlot.h"
11 static inline ALfloat
point32(const ALfloat
*restrict vals
, ALuint
UNUSED(frac
))
13 static inline ALfloat
lerp32(const ALfloat
*restrict vals
, ALuint frac
)
14 { return lerp(vals
[0], vals
[1], frac
* (1.0f
/FRACTIONONE
)); }
15 static inline ALfloat
fir4_32(const ALfloat
*restrict vals
, ALuint frac
)
16 { return resample_fir4(vals
[-1], vals
[0], vals
[1], vals
[2], frac
); }
19 const ALfloat
*Resample_copy32_C(const InterpState
* UNUSED(state
),
20 const ALfloat
*restrict src
, ALuint
UNUSED(frac
), ALint
UNUSED(increment
),
21 ALfloat
*restrict dst
, ALsizei numsamples
)
23 #if defined(HAVE_SSE) || defined(HAVE_NEON)
24 /* Avoid copying the source data if it's aligned like the destination. */
25 if((((intptr_t)src
)&15) == (((intptr_t)dst
)&15))
28 memcpy(dst
, src
, numsamples
*sizeof(ALfloat
));
32 #define DECL_TEMPLATE(Sampler) \
33 const ALfloat *Resample_##Sampler##_C(const InterpState* UNUSED(state), \
34 const ALfloat *restrict src, ALuint frac, ALint increment, \
35 ALfloat *restrict dst, ALsizei numsamples) \
38 for(i = 0;i < numsamples;i++) \
40 dst[i] = Sampler(src, frac); \
43 src += frac>>FRACTIONBITS; \
44 frac &= FRACTIONMASK; \
49 DECL_TEMPLATE(point32
)
51 DECL_TEMPLATE(fir4_32
)
55 const ALfloat
*Resample_bsinc32_C(const InterpState
*state
, const ALfloat
*restrict src
,
56 ALuint frac
, ALint increment
, ALfloat
*restrict dst
,
59 const ALfloat
*fil
, *scd
, *phd
, *spd
;
60 const ALfloat sf
= state
->bsinc
.sf
;
61 const ALsizei m
= state
->bsinc
.m
;
65 src
+= state
->bsinc
.l
;
66 for(i
= 0;i
< dstlen
;i
++)
68 // Calculate the phase index and factor.
69 #define FRAC_PHASE_BITDIFF (FRACTIONBITS-BSINC_PHASE_BITS)
70 pi
= frac
>> FRAC_PHASE_BITDIFF
;
71 pf
= (frac
& ((1<<FRAC_PHASE_BITDIFF
)-1)) * (1.0f
/(1<<FRAC_PHASE_BITDIFF
));
72 #undef FRAC_PHASE_BITDIFF
74 fil
= ASSUME_ALIGNED(state
->bsinc
.coeffs
[pi
].filter
, 16);
75 scd
= ASSUME_ALIGNED(state
->bsinc
.coeffs
[pi
].scDelta
, 16);
76 phd
= ASSUME_ALIGNED(state
->bsinc
.coeffs
[pi
].phDelta
, 16);
77 spd
= ASSUME_ALIGNED(state
->bsinc
.coeffs
[pi
].spDelta
, 16);
79 // Apply the scale and phase interpolated filter.
81 for(j_f
= 0;j_f
< m
;j_f
++)
82 r
+= (fil
[j_f
] + sf
*scd
[j_f
] + pf
*(phd
[j_f
] + sf
*spd
[j_f
])) *
87 src
+= frac
>>FRACTIONBITS
;
94 void ALfilterState_processC(ALfilterState
*filter
, ALfloat
*restrict dst
, const ALfloat
*restrict src
, ALsizei numsamples
)
99 dst
[0] = filter
->b0
* src
[0] +
100 filter
->b1
* filter
->x
[0] +
101 filter
->b2
* filter
->x
[1] -
102 filter
->a1
* filter
->y
[0] -
103 filter
->a2
* filter
->y
[1];
104 dst
[1] = filter
->b0
* src
[1] +
105 filter
->b1
* src
[0] +
106 filter
->b2
* filter
->x
[0] -
107 filter
->a1
* dst
[0] -
108 filter
->a2
* filter
->y
[0];
109 for(i
= 2;i
< numsamples
;i
++)
110 dst
[i
] = filter
->b0
* src
[i
] +
111 filter
->b1
* src
[i
-1] +
112 filter
->b2
* src
[i
-2] -
113 filter
->a1
* dst
[i
-1] -
114 filter
->a2
* dst
[i
-2];
115 filter
->x
[0] = src
[i
-1];
116 filter
->x
[1] = src
[i
-2];
117 filter
->y
[0] = dst
[i
-1];
118 filter
->y
[1] = dst
[i
-2];
120 else if(numsamples
== 1)
122 dst
[0] = filter
->b0
* src
[0] +
123 filter
->b1
* filter
->x
[0] +
124 filter
->b2
* filter
->x
[1] -
125 filter
->a1
* filter
->y
[0] -
126 filter
->a2
* filter
->y
[1];
127 filter
->x
[1] = filter
->x
[0];
128 filter
->x
[0] = src
[0];
129 filter
->y
[1] = filter
->y
[0];
130 filter
->y
[0] = dst
[0];
135 static inline void ApplyCoeffsStep(ALsizei Offset
, ALfloat (*restrict Values
)[2],
136 const ALsizei IrSize
,
137 ALfloat (*restrict Coeffs
)[2],
138 const ALfloat (*restrict CoeffStep
)[2],
139 ALfloat left
, ALfloat right
)
142 for(c
= 0;c
< IrSize
;c
++)
144 const ALsizei off
= (Offset
+c
)&HRIR_MASK
;
145 Values
[off
][0] += Coeffs
[c
][0] * left
;
146 Values
[off
][1] += Coeffs
[c
][1] * right
;
147 Coeffs
[c
][0] += CoeffStep
[c
][0];
148 Coeffs
[c
][1] += CoeffStep
[c
][1];
152 static inline void ApplyCoeffs(ALsizei Offset
, ALfloat (*restrict Values
)[2],
153 const ALsizei IrSize
,
154 ALfloat (*restrict Coeffs
)[2],
155 ALfloat left
, ALfloat right
)
158 for(c
= 0;c
< IrSize
;c
++)
160 const ALsizei off
= (Offset
+c
)&HRIR_MASK
;
161 Values
[off
][0] += Coeffs
[c
][0] * left
;
162 Values
[off
][1] += Coeffs
[c
][1] * right
;
166 #define MixHrtf MixHrtf_C
167 #define MixDirectHrtf MixDirectHrtf_C
168 #include "mixer_inc.c"
172 void Mix_C(const ALfloat
*data
, ALsizei OutChans
, ALfloat (*restrict OutBuffer
)[BUFFERSIZE
],
173 ALfloat
*CurrentGains
, const ALfloat
*TargetGains
, ALsizei Counter
, ALsizei OutPos
,
176 ALfloat gain
, delta
, step
;
179 delta
= (Counter
> 0) ? 1.0f
/(ALfloat
)Counter
: 0.0f
;
181 for(c
= 0;c
< OutChans
;c
++)
184 gain
= CurrentGains
[c
];
185 step
= (TargetGains
[c
] - gain
) * delta
;
186 if(fabsf(step
) > FLT_EPSILON
)
188 ALsizei minsize
= mini(BufferSize
, Counter
);
189 for(;pos
< minsize
;pos
++)
191 OutBuffer
[c
][OutPos
+pos
] += data
[pos
]*gain
;
195 gain
= TargetGains
[c
];
196 CurrentGains
[c
] = gain
;
199 if(!(fabsf(gain
) > GAIN_SILENCE_THRESHOLD
))
201 for(;pos
< BufferSize
;pos
++)
202 OutBuffer
[c
][OutPos
+pos
] += data
[pos
]*gain
;
206 /* Basically the inverse of the above. Rather than one input going to multiple
207 * outputs (each with its own gain), it's multiple inputs (each with its own
208 * gain) going to one output. This applies one row (vs one column) of a matrix
209 * transform. And as the matrices are more or less static once set up, no
210 * stepping is necessary.
212 void MixRow_C(ALfloat
*OutBuffer
, const ALfloat
*Gains
, const ALfloat (*restrict data
)[BUFFERSIZE
], ALsizei InChans
, ALsizei InPos
, ALsizei BufferSize
)
216 for(c
= 0;c
< InChans
;c
++)
218 ALfloat gain
= Gains
[c
];
219 if(!(fabsf(gain
) > GAIN_SILENCE_THRESHOLD
))
222 for(i
= 0;i
< BufferSize
;i
++)
223 OutBuffer
[i
] += data
[c
][InPos
+i
] * gain
;