20 #ifndef __JackFilters__ 21 #define __JackFilters__ 24 #include <TargetConditionals.h> 28 #ifndef MY_TARGET_OS_IPHONE 29 #include "JackAtomicState.h" 37 #ifndef TARGET_OS_IPHONE 45 jack_time_t fTable[MAX_SIZE];
49 for (
int i = 0; i < MAX_SIZE; i++) {
54 void AddValue(jack_time_t val)
56 memcpy(&fTable[1], &fTable[0],
sizeof(jack_time_t) * (MAX_SIZE - 1));
63 for (
int i = 0; i < MAX_SIZE; i++) {
66 return mean / MAX_SIZE;
69 } POST_PACKED_STRUCTURE;
77 jack_nframes_t fFrames;
78 jack_time_t fCurrentWakeup;
79 jack_time_t fCurrentCallback;
80 jack_time_t fNextWakeUp;
81 float fSecondOrderIntegrator;
82 jack_nframes_t fBufferSize;
83 jack_nframes_t fSampleRate;
84 jack_time_t fPeriodUsecs;
85 float fFilterCoefficient;
95 Init(buffer_size, sample_rate);
98 void Init(jack_nframes_t buffer_size, jack_nframes_t sample_rate)
102 fCurrentCallback = 0;
104 fFilterCoefficient = 0.01f;
105 fSecondOrderIntegrator = 0.0f;
106 fBufferSize = buffer_size;
107 fSampleRate = sample_rate;
108 fPeriodUsecs = jack_time_t(1000000.f / fSampleRate * fBufferSize);
111 void Init(jack_time_t callback_usecs)
115 fSecondOrderIntegrator = 0.0f;
116 fCurrentCallback = callback_usecs;
117 fNextWakeUp = callback_usecs + fPeriodUsecs;
120 void IncFrame(jack_time_t callback_usecs)
122 float delta = (int64_t)callback_usecs - (int64_t)fNextWakeUp;
123 fCurrentWakeup = fNextWakeUp;
124 fCurrentCallback = callback_usecs;
125 fFrames += fBufferSize;
126 fSecondOrderIntegrator += 0.5f * fFilterCoefficient * delta;
127 fNextWakeUp = fCurrentWakeup + fPeriodUsecs + (int64_t) floorf((fFilterCoefficient * (delta + fSecondOrderIntegrator)));
130 jack_nframes_t Time2Frames(jack_time_t time)
132 long delta = (long) rint(((
double) ((
long long)(time - fCurrentWakeup)) / ((
long long)(fNextWakeUp - fCurrentWakeup))) * fBufferSize);
133 return (delta < 0) ? ((fFrames > 0) ? fFrames : 1) : (fFrames + delta);
136 jack_time_t Frames2Time(jack_nframes_t frames)
138 long delta = (long) rint(((
double) ((
long long)(frames - fFrames)) * ((
long long)(fNextWakeUp - fCurrentWakeup))) / fBufferSize);
139 return (delta < 0) ? ((fCurrentWakeup > 0) ? fCurrentWakeup : 1) : (fCurrentWakeup + delta);
142 jack_nframes_t CurFrame()
147 jack_time_t CurTime()
149 return fCurrentWakeup;
152 } POST_PACKED_STRUCTURE;
161 fState[0].Init(buffer_size, sample_rate);
162 fState[1].Init(buffer_size, sample_rate);
165 void Init(jack_time_t callback_usecs)
168 dll->Init(callback_usecs);
173 void Init(jack_nframes_t buffer_size, jack_nframes_t sample_rate)
176 dll->Init(buffer_size, sample_rate);
181 void IncFrame(jack_time_t callback_usecs)
184 dll->IncFrame(callback_usecs);
189 jack_nframes_t Time2Frames(jack_time_t time)
196 cur_index = next_index;
199 }
while (cur_index != next_index);
204 jack_time_t Frames2Time(jack_nframes_t frames)
211 cur_index = next_index;
214 }
while (cur_index != next_index);
218 } POST_PACKED_STRUCTURE;
228 double resample_mean;
229 double static_resample_factor;
231 double* offset_array;
232 double* window_array;
233 int offset_differential_index;
235 double offset_integral;
238 double catch_factor2;
243 double hann(
double x)
245 return 0.5 * (1.0 - cos(2 * M_PI * x));
250 resample_mean = resample_factor;
251 static_resample_factor = resample_factor;
252 offset_array =
new double[fir_size];
253 window_array =
new double[fir_size];
254 offset_differential_index = 0;
255 offset_integral = 0.0;
256 smooth_size = fir_size;
258 for (
int i = 0; i < fir_size; i++) {
259 offset_array[i] = 0.0;
260 window_array[i] = hann(
double(i) / (
double(fir_size) - 1.0));
264 catch_factor = 100000;
265 catch_factor2 = 10000;
267 controlquant = 10000.0;
272 delete[] offset_array;
273 delete[] window_array;
276 void Init(
double resample_factor)
278 resample_mean = resample_factor;
279 static_resample_factor = resample_factor;
320 double GetRatio(
int error)
322 double smooth_offset = error;
325 offset_integral += smooth_offset;
330 return static_resample_factor - smooth_offset/catch_factor - offset_integral/catch_factor/catch_factor2;
339 offset_integral = - (resample_mean - static_resample_factor) * catch_factor * catch_factor2;
341 for (i = 0; i < smooth_size; i++) {
342 offset_array[i] = 0.0;
JackDelayLockedLoop * ReadCurrentState()
Returns the current state : only valid in the RT reader thread.
void WriteNextStateStop()
Stop write operation : make the next state ready to be used by the RT thread.
JackDelayLockedLoop * WriteNextStateStart()
Start write operation : setup and returns the next state to update, check for recursive write calls.
UInt16 GetCurrentIndex()
Returns the current state index.
JackDelayLockedLoop * TrySwitchState()
Tries to switch to the next state and returns the new current state (either the same as before if cas...
A class to handle two states (switching from one to the other) in a lock-free manner.