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);
   169                 WriteNextStateStop();
   173             void Init(jack_nframes_t buffer_size, jack_nframes_t sample_rate)
   176                 dll->Init(buffer_size, sample_rate);
   177                 WriteNextStateStop();
   181             void IncFrame(jack_time_t callback_usecs)
   184                 dll->IncFrame(callback_usecs);
   185                 WriteNextStateStop();
   189             jack_nframes_t Time2Frames(jack_time_t time)
   191                 UInt16 next_index = GetCurrentIndex();
   196                     cur_index = next_index;
   197                     res = ReadCurrentState()->Time2Frames(time);
   198                     next_index = GetCurrentIndex();
   199                 } 
while (cur_index != next_index); 
   204             jack_time_t Frames2Time(jack_nframes_t frames)
   206                 UInt16 next_index = GetCurrentIndex();
   211                     cur_index = next_index;
   212                     res = ReadCurrentState()->Frames2Time(frames);
   213                     next_index = GetCurrentIndex();
   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;
 
A class to handle two states (switching from one to the other) in a lock-free manner.