__asm__ __volatile__ (

"cpuid":

"=a" (CPUInfo[0]),

"=b" (CPUInfo[1]),

"=c" (CPUInfo[2]),

"=d" (CPUInfo[3]) :

"a" (InfoType)

);

mThreadCount(0),mFilterSize(0),mWindowSize(0),mBlockSize(0),mWorkerDataCount(0),mBlocksPerBuffer(20),

mScratchBufferSize(0),mSubBufferSize(0),mThreaded(false),

mBenching(false),mBufferCount(0)

{

{

if(mBigBuffer)

FreeBuffersWorkers();

mFilterSize=(mEffectEqualization->mM-1)&(~15); // 4000 !!! Filter MUST BE QUAD WORD ALIGNED !!!!

mWindowSize=mEffectEqualization->windowSize;

wxASSERT(mFilterSize < mWindowSize);

mBlockSize=mWindowSize-mFilterSize; // 12,384

auto threadCount = wxThread::GetCPUCount();

mThreaded = (nThreads > 0 && threadCount > 0);

if(mThreaded)

{

mThreadCount = threadCount;

mWorkerDataCount=mThreadCount+2; // 2 extra slots (maybe double later)

} else {

mWorkerDataCount=1;

mThreadCount=0;

}

#ifdef __AVX_ENABLED

mBufferCount=sMathPath&MATH_FUNCTION_AVX?8:4;

#else

mBufferCount=4;

#endif

// we're skewing the data by one block to allow for 1/4 block intersections.

// this will remove the disparity in data at the intersections of the runs

// The nice magic allocation

// megabyte - 3 windows - 4 overlapping buffers - filter

// 2^20 = 1,048,576 - 3 * 2^14 (16,384) - ((4 * 20) - 3) * 12,384 - 4000

// 1,048,576 - 49,152 - 953,568 - 4000 = 41,856 (leftover)

mScratchBufferSize=mWindowSize*3*sizeof(float)*mBufferCount; // 3 window size blocks of instruction size

mSubBufferSize=mBlockSize*(mBufferCount*(mBlocksPerBuffer-1)); // we are going to do a full block overlap

mBigBuffer.reset( (float *)malloc_simd(sizeof(float) * (mSubBufferSize + mFilterSize + mScratchBufferSize) * mWorkerDataCount) ); // we run over by filtersize

// fill the bufferInfo

mBufferInfo.reinit(mWorkerDataCount);

for(int i=0;i<mWorkerDataCount;i++) {

mBufferInfo[i].mFftWindowSize=mWindowSize;

mBufferInfo[i].mFftFilterSize=mFilterSize;

mBufferInfo[i].mBufferLength=mBlockSize*mBlocksPerBuffer;

mBufferInfo[i].mContiguousBufferSize=mSubBufferSize;

mBufferInfo[i].mScratchBuffer=&mBigBuffer[(mSubBufferSize+mScratchBufferSize)*i+mSubBufferSize];

for(int j=0;j<mBufferCount;j++)

mBufferInfo[i].mBufferDest[j]=mBufferInfo[i].mBufferSouce[j]=&mBigBuffer[j*(mBufferInfo[i].mBufferLength-mBlockSize)+(mSubBufferSize+mScratchBufferSize)*i];

}

if(mThreadCount) {

// start the workers

mDataMutex.IsOk();

mEQWorkers.reinit(mThreadCount);

for(int i=0;i<mThreadCount;i++) {

mEQWorkers[i].SetData( mBufferInfo.get(), mWorkerDataCount, &mDataMutex, this);

mEQWorkers[i].Create();

mEQWorkers[i].Run();

}

}

return true;

{

if(mThreaded) {

for(int i=0;i<mThreadCount;i++) { // tell all the workers to exit

mEQWorkers[i].ExitLoop();

}

for(int i=0;i<mThreadCount;i++) {

mEQWorkers[i].Wait();

}

mEQWorkers.reset(); // kill the workers ( go directly to jail)

mThreadCount=0;

mWorkerDataCount=0;

}

mBufferInfo.reset();

mBigBuffer.reset();

return true;

{

// deal with tables here

flags&=~(MATH_FUNCTION_BITREVERSE_TABLE|MATH_FUNCTION_SIN_COS_TABLE); // clear out the table flags

switch (flags)

{

case MATH_FUNCTION_SSE:

return ProcessOne4x(count, track, start, len);

break;

case MATH_FUNCTION_SSE|MATH_FUNCTION_THREADED:

return ProcessOne1x4xThreaded(count, track, start, len);

break;

case MATH_FUNCTION_THREADED:

case MATH_FUNCTION_THREADED|MATH_FUNCTION_SEGMENTED_CODE:

return ProcessOne1x4xThreaded(count, track, start, len, 1);

break;

case MATH_FUNCTION_SEGMENTED_CODE:

return ProcessOne1x(count, track, start, len);

break;

default:

return !mEffectEqualization->ProcessOne(count, track, start, len);

break;

}

return false;

{

mEffectEqualization=effectEqualization;

mEffectEqualization->CopyInputTracks(); // Set up mOutputTracks.

bool bBreakLoop = false;

TableUsage(sMathPath);

if(sMathPath) // !!! Filter MUST BE QUAD WORD ALIGNED !!!!

mEffectEqualization->mM=(mEffectEqualization->mM&(~15))+1;

AllocateBuffersWorkers(sMathPath&MATH_FUNCTION_THREADED);

auto cleanup = finally( [&] { FreeBuffersWorkers(); } );

int count = 0;

for( auto track :

mEffectEqualization->mOutputTracks->Selected< WaveTrack >() ) {

double trackStart = track->GetStartTime();

double trackEnd = track->GetEndTime();

double t0 = mEffectEqualization->mT0 < trackStart? trackStart: mEffectEqualization->mT0;

double t1 = mEffectEqualization->mT1 > trackEnd? trackEnd: mEffectEqualization->mT1;

if (t1 > t0) {

auto start = track->TimeToLongSamples(t0);

auto end = track->TimeToLongSamples(t1);

auto len = end - start;

bBreakLoop=RunFunctionSelect(sMathPath, count, track, start, len);

if( bBreakLoop )

break;

}

count++;

}

mEffectEqualization->ReplaceProcessedTracks(!bBreakLoop);

return !bBreakLoop;

{

mEffectEqualization->CopyInputTracks(); // Set up mOutputTracks.

bool bBreakLoop = false;

TableUsage(sMathPath);

if(sMathPath) // !!! Filter MUST BE QUAD WORD ALIGNED !!!!

mEffectEqualization->mM=(mEffectEqualization->mM&(~15))+1;

AllocateBuffersWorkers(sMathPath&MATH_FUNCTION_THREADED);

auto cleanup = finally( [&] { FreeBuffersWorkers(); } );

// Reset map

// PRL: These two maps aren't really used

std::vector<const Track*> SecondIMap;

std::vector<Track*> SecondOMap;

SecondIMap.clear();

SecondOMap.clear();

auto pSecondOutputTracks = TrackList::Create( nullptr );

auto &SecondOutputTracks = *pSecondOutputTracks;

for (auto aTrack :

mEffectEqualization->inputTracks()->Any< const WaveTrack >()) {

// Include selected tracks, plus sync-lock selected tracks for Track::All.

if (aTrack->GetSelected() ||

(// mEffectEqualization->mOutputTracksType == TrackKind::All &&

aTrack->IsSyncLockSelected()))

{

auto o = mEffectEqualization->mFactory->DuplicateWaveTrack( *aTrack );

SecondIMap.push_back(aTrack);

SecondIMap.push_back(o.get());

SecondOutputTracks.Add( o );

}

}

for(int i = 0; i < 2; i++) {

i?sMathPath=sMathPath:sMathPath=0;

int count = 0;

for( auto track :

( i ? mEffectEqualization->mOutputTracks.get()

: &SecondOutputTracks ) -> Selected< WaveTrack >() ) {

double trackStart = track->GetStartTime();

double trackEnd = track->GetEndTime();

double t0 = mEffectEqualization->mT0 < trackStart? trackStart: mEffectEqualization->mT0;

double t1 = mEffectEqualization->mT1 > trackEnd? trackEnd: mEffectEqualization->mT1;

if (t1 > t0) {

auto start = track->TimeToLongSamples(t0);

auto end = track->TimeToLongSamples(t1);

auto len = end - start;

bBreakLoop=RunFunctionSelect(sMathPath, count, track, start, len);

if( bBreakLoop )

break;

}

count++;

}

}

auto iter2 = (SecondOutputTracks.Selected< const WaveTrack >()).first;

auto track2 = *iter2;

for ( auto track :

mEffectEqualization->mOutputTracks->Selected< WaveTrack >() ) {

double trackStart = track->GetStartTime();

double trackEnd = track->GetEndTime();

double t0 = mEffectEqualization->mT0 < trackStart? trackStart: mEffectEqualization->mT0;

double t1 = mEffectEqualization->mT1 > trackEnd? trackEnd: mEffectEqualization->mT1;

if (t1 > t0) {

auto start = track->TimeToLongSamples(t0);

auto end = track->TimeToLongSamples(t1);

auto len = end - start;

DeltaTrack(track, track2, start, len);

}

track2 = * ++iter2;

}

mEffectEqualization->ReplaceProcessedTracks(!bBreakLoop);

return bBreakLoop; // return !bBreakLoop ?

WaveTrack * t, const WaveTrack * t2, sampleCount start, sampleCount len)

{

auto trackBlockSize = t->GetMaxBlockSize();

Floats buffer1{ trackBlockSize };

Floats buffer2{ trackBlockSize };

auto output = t->EmptyCopy();

t->ConvertToSampleFormat( floatSample );

auto originalLen = len;

auto currentSample = start;

while(len > 0) {

auto curretLength = limitSampleBufferSize(trackBlockSize, len);

t->Get((samplePtr)buffer1.get(), floatSample, currentSample, curretLength);

t2->Get((samplePtr)buffer2.get(), floatSample, currentSample, curretLength);

for(decltype(curretLength) i=0;i<curretLength;i++)

buffer1[i]-=buffer2[i];

output->Append((samplePtr)buffer1.get(), floatSample, curretLength);

currentSample+=curretLength;

len-=curretLength;

}

output->Flush();

len=originalLen;

ProcessTail(t, output.get(), start, len);

return true;

{

mEffectEqualization=effectEqualization;

mEffectEqualization->CopyInputTracks(); // Set up mOutputTracks.

bool bBreakLoop = false;

TableUsage(sMathPath);

if(sMathPath) // !!! Filter MUST BE QUAD WORD ALIGNED !!!!

mEffectEqualization->mM=(mEffectEqualization->mM&(~15))+1;

AllocateBuffersWorkers(MATH_FUNCTION_THREADED);

auto cleanup = finally( [&] { FreeBuffersWorkers(); } );

long times[] = { 0,0,0,0,0 };

wxStopWatch timer;

mBenching = true;

for(int i = 0; i < 5 && !bBreakLoop; i++) {

int localMathPath;

switch(i) {

case 0: localMathPath=MATH_FUNCTION_SSE|MATH_FUNCTION_THREADED;

if(!sMathCaps.SSE)

localMathPath=-1;

break;

case 1: localMathPath=MATH_FUNCTION_SSE;

if(!sMathCaps.SSE)

localMathPath=-1;

break;

case 2: localMathPath=MATH_FUNCTION_SEGMENTED_CODE;

break;

case 3: localMathPath=MATH_FUNCTION_THREADED|MATH_FUNCTION_SEGMENTED_CODE;

break;

case 4: localMathPath=0;

break;

default: localMathPath=-1;

}

if(localMathPath >= 0) {

timer.Start();

int count = 0;

for (auto track :

mEffectEqualization->mOutputTracks->Selected< WaveTrack >() ) {

double trackStart = track->GetStartTime();

double trackEnd = track->GetEndTime();

double t0 = mEffectEqualization->mT0 < trackStart? trackStart: mEffectEqualization->mT0;

double t1 = mEffectEqualization->mT1 > trackEnd? trackEnd: mEffectEqualization->mT1;

if (t1 > t0) {

auto start = track->TimeToLongSamples(t0);

auto end = track->TimeToLongSamples(t1);

auto len = end - start;

bBreakLoop=RunFunctionSelect( localMathPath, count, track, start, len);

if( bBreakLoop )

break;

}

count++;

}

times[i]=timer.Time();

}

}

mBenching=false;

bBreakLoop=false;

mEffectEqualization->ReplaceProcessedTracks(bBreakLoop);

wxTimeSpan tsSSEThreaded(0, 0, 0, times[0]);

wxTimeSpan tsSSE(0, 0, 0, times[1]);

wxTimeSpan tsDefaultEnhanced(0, 0, 0, times[2]);

wxTimeSpan tsDefaultThreaded(0, 0, 0, times[3]);

wxTimeSpan tsDefault(0, 0, 0, times[4]);

mEffectEqualization->MessageBox(

XO(

"Benchmark times:\nOriginal: %s\nDefault Segmented: %s\nDefault Threaded: %s\nSSE: %s\nSSE Threaded: %s\n")

.Format(

tsDefault.Format(wxT("%M:%S.%l")),

tsDefaultEnhanced.Format(wxT("%M:%S.%l")),

tsDefaultThreaded.Format(wxT("%M:%S.%l")),

tsSSE.Format(wxT("%M:%S.%l")),

tsSSEThreaded.Format(wxT("%M:%S.%l")) ) );

return bBreakLoop; // return !bBreakLoop ?

{

// double offsetT0 = t->LongSamplesToTime(offset);

double lenT = t->LongSamplesToTime(len);

// 'start' is the sample offset in 't', the passed in track

// 'startT' is the equivalent time value

// 'output' starts at zero

double startT = t->LongSamplesToTime(start);

//output has one waveclip for the total length, even though

//t might have whitespace separating multiple clips

//we want to maintain the original clip structure, so

//only paste the intersections of the NEW clip.

//Find the bits of clips that need replacing

std::vector<std::pair<double, double> > clipStartEndTimes;

std::vector<std::pair<double, double> > clipRealStartEndTimes; //the above may be truncated due to a clip being partially selected

for (const auto &clip: t->GetClips())

{

double clipStartT;

double clipEndT;

clipStartT = clip->GetStartTime();

clipEndT = clip->GetEndTime();

if( clipEndT <= startT )

continue; // clip is not within selection

if( clipStartT >= startT + lenT )

continue; // clip is not within selection

//save the actual clip start/end so that we can rejoin them after we paste.

clipRealStartEndTimes.push_back(std::pair<double,double>(clipStartT,clipEndT));

if( clipStartT < startT ) // does selection cover the whole clip?

clipStartT = startT; // don't copy all the NEW clip

if( clipEndT > startT + lenT ) // does selection cover the whole clip?

clipEndT = startT + lenT; // don't copy all the NEW clip

//save them

clipStartEndTimes.push_back(std::pair<double,double>(clipStartT,clipEndT));

}

//now go thru and replace the old clips with NEW

for(unsigned int i=0;i<clipStartEndTimes.size();i++)

{

//remove the old audio and get the NEW

t->Clear(clipStartEndTimes[i].first,clipStartEndTimes[i].second);

// output->Copy(clipStartEndTimes[i].first-startT+offsetT0,clipStartEndTimes[i].second-startT+offsetT0, &toClipOutput);

auto toClipOutput = output->Copy(clipStartEndTimes[i].first-startT, clipStartEndTimes[i].second-startT);

//put the processed audio in

t->Paste(clipStartEndTimes[i].first, toClipOutput.get());

//if the clip was only partially selected, the Paste will have created a split line. Join is needed to take care of this

//This is not true when the selection is fully contained within one clip (second half of conditional)

if( (clipRealStartEndTimes[i].first != clipStartEndTimes[i].first ||

clipRealStartEndTimes[i].second != clipStartEndTimes[i].second) &&

!(clipRealStartEndTimes[i].first <= startT &&

clipRealStartEndTimes[i].second >= startT+lenT) )

t->Join(clipRealStartEndTimes[i].first,clipRealStartEndTimes[i].second);

}

return true;

{

BufferInfo bufferInfo;

bufferInfo.mContiguousBufferSize=bufferLength;

bufferInfo.mBufferSouce[0]=sourceBuffer;

bufferInfo.mBufferDest[0]=destBuffer;

bufferInfo.mScratchBuffer=&sourceBuffer[mSubBufferSize];

return ProcessBuffer1x(&bufferInfo);

{

int bufferCount=bufferInfo->mContiguousBufferSize?1:4;

for(int bufferIndex=0;bufferIndex<bufferCount;bufferIndex++)

{

auto bufferLength=bufferInfo->mBufferLength;

if(bufferInfo->mContiguousBufferSize)

bufferLength=bufferInfo->mContiguousBufferSize;

auto blockCount=bufferLength/mBlockSize;

auto lastBlockSize=bufferLength%mBlockSize;

if(lastBlockSize)

blockCount++;

float *workBuffer=bufferInfo->mScratchBuffer; // all scratch buffers are at the end

float *scratchBuffer=&workBuffer[mWindowSize*2]; // all scratch buffers are at the end

float *sourceBuffer=bufferInfo->mBufferSouce[bufferIndex];

float *destBuffer=bufferInfo->mBufferDest[bufferIndex];

for(size_t runx=0;runx<blockCount;runx++)

{

float *currentBuffer=&workBuffer[mWindowSize*(runx&1)];

for(int i=0;i<mBlockSize;i++)

currentBuffer[i]=sourceBuffer[i];

sourceBuffer+=mBlockSize;

float *currentFilter=&currentBuffer[mBlockSize];

for(int i=0;i<mFilterSize;i++)

currentFilter[i]=0;

Filter1x(mWindowSize, currentBuffer, scratchBuffer);

float *writeEnd=currentBuffer+mBlockSize;

if(runx==blockCount)

writeEnd=currentBuffer+(lastBlockSize+mFilterSize);

if(runx) {

float *lastOverrun=&workBuffer[mWindowSize*((runx+1)&1)+mBlockSize];

for(int j=0;j<mFilterSize;j++)

*destBuffer++= *currentBuffer++ + *lastOverrun++;

} else

currentBuffer+=mFilterSize>>1; // this will skip the first filterSize on the first run

while(currentBuffer<writeEnd)

*destBuffer++ = *currentBuffer++;

}

}

return true;

sampleCount start, sampleCount len)

{

//sampleCount blockCount=len/mBlockSize;

auto trackBlockSize = t->GetMaxBlockSize();

auto output = t->EmptyCopy();

t->ConvertToSampleFormat( floatSample );

mEffectEqualization->TrackProgress(count, 0.0);

int subBufferSize=mBufferCount==8?(mSubBufferSize>>1):mSubBufferSize; // half the buffers if avx is active

auto bigRuns=len/(subBufferSize-mBlockSize);

int trackBlocksPerBig=subBufferSize/trackBlockSize;

int trackLeftovers=subBufferSize-trackBlocksPerBig*trackBlockSize;

size_t singleProcessLength;

if(bigRuns == 0)

singleProcessLength = len.as_size_t();

else

singleProcessLength =

((mFilterSize>>1)*bigRuns + len%(bigRuns*(subBufferSize-mBlockSize)))

.as_size_t();

auto currentSample=start;

bool bBreakLoop = false;

for(int bigRun=0;bigRun<bigRuns;bigRun++)

{

// fill the buffer

for(int i=0;i<trackBlocksPerBig;i++) {

t->Get((samplePtr)&mBigBuffer[i*trackBlockSize], floatSample, currentSample, trackBlockSize);

currentSample+=trackBlockSize;

}

if(trackLeftovers) {

t->Get((samplePtr)&mBigBuffer[trackBlocksPerBig*trackBlockSize], floatSample, currentSample, trackLeftovers);

currentSample+=trackLeftovers;

}

currentSample-=mBlockSize+(mFilterSize>>1);

ProcessBuffer1x(mBufferInfo.get());

bBreakLoop=mEffectEqualization->TrackProgress(count, (double)(bigRun)/bigRuns.as_double());

if( bBreakLoop )

break;

output->Append((samplePtr)&mBigBuffer[(bigRun?mBlockSize:0)+(mFilterSize>>1)], floatSample, subBufferSize-((bigRun?mBlockSize:0)+(mFilterSize>>1)));

}

if(singleProcessLength && !bBreakLoop) {

t->Get((samplePtr)mBigBuffer.get(), floatSample, currentSample, singleProcessLength+mBlockSize+(mFilterSize>>1));

ProcessBuffer(mBigBuffer.get(), mBigBuffer.get(), singleProcessLength+mBlockSize+(mFilterSize>>1));

output->Append((samplePtr)&mBigBuffer[bigRuns > 0 ? mBlockSize : 0], floatSample, singleProcessLength+mBlockSize+(mFilterSize>>1));

}

output->Flush();

if(!bBreakLoop)

ProcessTail(t, output.get(), start, len);

return bBreakLoop;

float *buffer, float *scratchBuffer)

{

int i;

float real, imag;

// Apply FFT

RealFFTf1x(buffer, mEffectEqualization->hFFT.get());

// Apply filter

// DC component is purely real

float filterFuncR, filterFuncI;

filterFuncR = mEffectEqualization->mFilterFuncR[0];

scratchBuffer[0] = buffer[0] * filterFuncR;

auto halfLength = (len / 2);

bool useBitReverseTable=sMathPath&1;

for(i = 1; i < halfLength; i++)

{

if(useBitReverseTable) {

real=buffer[mEffectEqualization->hFFT->BitReversed[i] ];

imag=buffer[mEffectEqualization->hFFT->BitReversed[i]+1];

} else {

int bitReversed=SmallRB(i,mEffectEqualization->hFFT->pow2Bits);

real=buffer[bitReversed];

imag=buffer[bitReversed+1];

}

filterFuncR=mEffectEqualization->mFilterFuncR[i];

filterFuncI=mEffectEqualization->mFilterFuncI[i];

scratchBuffer[2*i ] = real*filterFuncR - imag*filterFuncI;

scratchBuffer[2*i+1] = real*filterFuncI + imag*filterFuncR;

}

// Fs/2 component is purely real

filterFuncR=mEffectEqualization->mFilterFuncR[halfLength];

scratchBuffer[1] = buffer[1] * filterFuncR;

// Inverse FFT and normalization

InverseRealFFTf1x(scratchBuffer, mEffectEqualization->hFFT.get());

ReorderToTime1x(mEffectEqualization->hFFT.get(), scratchBuffer, buffer);

{

// length must be a factor of window size for 4x processing.

if(bufferInfo->mBufferLength%mBlockSize)

return false;

auto blockCount=bufferInfo->mBufferLength/mBlockSize;

__m128 *readBlocks[4]; // some temps so we dont destroy the vars in the struct

__m128 *writeBlocks[4];

for(int i=0;i<4;i++) {

readBlocks[i]=(__m128 *)bufferInfo->mBufferSouce[i];

writeBlocks[i]=(__m128 *)bufferInfo->mBufferDest[i];

}

__m128 *swizzledBuffer128=(__m128 *)bufferInfo->mScratchBuffer;

__m128 *scratchBuffer=&swizzledBuffer128[mWindowSize*2];

for(size_t run4x=0;run4x<blockCount;run4x++)

{

// swizzle the data to the swizzle buffer

__m128 *currentSwizzledBlock=&swizzledBuffer128[mWindowSize*(run4x&1)];

for(int i=0,j=0;j<mBlockSize;i++,j+=4) {

__m128 tmp0 = _mm_shuffle_ps(readBlocks[0][i], readBlocks[1][i], _MM_SHUFFLE(1,0,1,0));

__m128 tmp1 = _mm_shuffle_ps(readBlocks[0][i], readBlocks[1][i], _MM_SHUFFLE(3,2,3,2));

__m128 tmp2 = _mm_shuffle_ps(readBlocks[2][i], readBlocks[3][i], _MM_SHUFFLE(1,0,1,0));

__m128 tmp3 = _mm_shuffle_ps(readBlocks[2][i], readBlocks[3][i], _MM_SHUFFLE(3,2,3,2));

currentSwizzledBlock[j] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(2,0,2,0));

currentSwizzledBlock[j+1] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(3,1,3,1));

currentSwizzledBlock[j+2] = _mm_shuffle_ps(tmp1, tmp3, _MM_SHUFFLE(2,0,2,0));

currentSwizzledBlock[j+3] = _mm_shuffle_ps(tmp1, tmp3, _MM_SHUFFLE(3,1,3,1));

}

__m128 *thisOverrun128=&currentSwizzledBlock[mBlockSize];

for(int i=0;i<mFilterSize;i++)

thisOverrun128[i]=_mm_set1_ps(0.0);

Filter4x(mWindowSize, (float *)currentSwizzledBlock, (float *)scratchBuffer);

int writeStart=0, writeToStart=0; // note readStart is where the read data is written

int writeEnd=mBlockSize;

if(run4x) {

// maybe later swizzle add and write in one

__m128 *lastOverrun128=&swizzledBuffer128[mWindowSize*((run4x+1)&1)+mBlockSize];

// add and swizzle data + filter

for(int i=0,j=0;j<mFilterSize;i++,j+=4) {

__m128 tmps0 = _mm_add_ps(currentSwizzledBlock[j], lastOverrun128[j]);

__m128 tmps1 = _mm_add_ps(currentSwizzledBlock[j+1], lastOverrun128[j+1]);

__m128 tmps2 = _mm_add_ps(currentSwizzledBlock[j+2], lastOverrun128[j+2]);

__m128 tmps3 = _mm_add_ps(currentSwizzledBlock[j+3], lastOverrun128[j+3]);

__m128 tmp0 = _mm_shuffle_ps(tmps1, tmps0, _MM_SHUFFLE(0,1,0,1));

__m128 tmp1 = _mm_shuffle_ps(tmps1, tmps0, _MM_SHUFFLE(2,3,2,3));

__m128 tmp2 = _mm_shuffle_ps(tmps3, tmps2, _MM_SHUFFLE(0,1,0,1));

__m128 tmp3 = _mm_shuffle_ps(tmps3, tmps2, _MM_SHUFFLE(2,3,2,3));

writeBlocks[0][i] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(1,3,1,3));

writeBlocks[1][i] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(0,2,0,2));

writeBlocks[2][i] = _mm_shuffle_ps(tmp1, tmp3, _MM_SHUFFLE(1,3,1,3));

writeBlocks[3][i] = _mm_shuffle_ps(tmp1, tmp3, _MM_SHUFFLE(0,2,0,2));

}

writeStart=mFilterSize;

writeToStart=mFilterSize>>2;

// swizzle it back.

for(int i=writeToStart,j=writeStart;j<writeEnd;i++,j+=4) {

__m128 tmp0 = _mm_shuffle_ps(currentSwizzledBlock[j+1], currentSwizzledBlock[j], _MM_SHUFFLE(0,1,0,1));

__m128 tmp1 = _mm_shuffle_ps(currentSwizzledBlock[j+1], currentSwizzledBlock[j], _MM_SHUFFLE(2,3,2,3));

__m128 tmp2 = _mm_shuffle_ps(currentSwizzledBlock[j+3], currentSwizzledBlock[j+2], _MM_SHUFFLE(0,1,0,1));

__m128 tmp3 = _mm_shuffle_ps(currentSwizzledBlock[j+3], currentSwizzledBlock[j+2], _MM_SHUFFLE(2,3,2,3));

writeBlocks[0][i] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(1,3,1,3));

writeBlocks[1][i] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(0,2,0,2));

writeBlocks[2][i] = _mm_shuffle_ps(tmp1, tmp3, _MM_SHUFFLE(1,3,1,3));

writeBlocks[3][i] = _mm_shuffle_ps(tmp1, tmp3, _MM_SHUFFLE(0,2,0,2));

}

} else {

// swizzle it back. We overlap one block so we only write the first block on the first run

writeStart=0;

writeToStart=0;

for(int i=writeToStart,j=writeStart;j<writeEnd;i++,j+=4) {

__m128 tmp0 = _mm_shuffle_ps(currentSwizzledBlock[j+1], currentSwizzledBlock[j], _MM_SHUFFLE(0,1,0,1));

__m128 tmp2 = _mm_shuffle_ps(currentSwizzledBlock[j+3], currentSwizzledBlock[j+2], _MM_SHUFFLE(0,1,0,1));

writeBlocks[0][i] = _mm_shuffle_ps(tmp0, tmp2, _MM_SHUFFLE(1,3,1,3));

}

}

for(int i=0;i<4;i++) { // shift each block

readBlocks[i]+=mBlockSize>>2; // these are 128b pointers, each window is 1/4 blockSize for those

writeBlocks[i]+=mBlockSize>>2;

}

}

return true;

sampleCount start, sampleCount len)

{

int subBufferSize=mBufferCount==8?(mSubBufferSize>>1):mSubBufferSize; // half the buffers if avx is active

if(len<subBufferSize) // it's not worth 4x processing do a regular process

return ProcessOne1x(count, t, start, len);

auto trackBlockSize = t->GetMaxBlockSize();

auto output = t->EmptyCopy();

t->ConvertToSampleFormat( floatSample );

mEffectEqualization->TrackProgress(count, 0.0);

auto bigRuns = len/(subBufferSize-mBlockSize);

int trackBlocksPerBig=subBufferSize/trackBlockSize;

int trackLeftovers=subBufferSize-trackBlocksPerBig*trackBlockSize;

size_t singleProcessLength =

((mFilterSize>>1)*bigRuns + len%(bigRuns*(subBufferSize-mBlockSize)))

.as_size_t();

auto currentSample=start;

bool bBreakLoop = false;

for(int bigRun=0;bigRun<bigRuns;bigRun++)

{

// fill the buffer

for(int i=0;i<trackBlocksPerBig;i++) {

t->Get((samplePtr)&mBigBuffer[i*trackBlockSize], floatSample, currentSample, trackBlockSize);

currentSample+=trackBlockSize;

}

if(trackLeftovers) {

t->Get((samplePtr)&mBigBuffer[trackBlocksPerBig*trackBlockSize], floatSample, currentSample, trackLeftovers);

currentSample+=trackLeftovers;

}

currentSample-=mBlockSize+(mFilterSize>>1);

ProcessBuffer4x(mBufferInfo.get());

bBreakLoop=mEffectEqualization->TrackProgress(count, (double)(bigRun)/bigRuns.as_double());

if( bBreakLoop )

break;

output->Append((samplePtr)&mBigBuffer[(bigRun?mBlockSize:0)+(mFilterSize>>1)], floatSample, subBufferSize-((bigRun?mBlockSize:0)+(mFilterSize>>1)));

}

if(singleProcessLength && !bBreakLoop) {

t->Get((samplePtr)mBigBuffer.get(), floatSample, currentSample, singleProcessLength+mBlockSize+(mFilterSize>>1));

ProcessBuffer(mBigBuffer.get(), mBigBuffer.get(), singleProcessLength+mBlockSize+(mFilterSize>>1));

output->Append((samplePtr)&mBigBuffer[bigRuns > 0 ? mBlockSize : 0], floatSample, singleProcessLength+mBlockSize+(mFilterSize>>1));

}

output->Flush();

if(!bBreakLoop)

ProcessTail(t, output.get(), start, len);

return bBreakLoop;

sampleCount start, sampleCount len, int processingType)

{

int subBufferSize=mBufferCount==8?(mSubBufferSize>>1):mSubBufferSize; // half the buffers if avx is active

sampleCount blockCount=len/mBlockSize;

if(blockCount<16) // it's not worth 4x processing do a regular process

return ProcessOne4x(count, t, start, len);

if(mThreadCount<=0 || blockCount<256) // dont do it without cores or big data

return ProcessOne4x(count, t, start, len);

for(int i=0;i<mThreadCount;i++)

mEQWorkers[i].mProcessingType=processingType;

auto output = t->EmptyCopy();

t->ConvertToSampleFormat( floatSample );

auto trackBlockSize = t->GetMaxBlockSize();

mEffectEqualization->TrackProgress(count, 0.0);

auto bigRuns = len/(subBufferSize-mBlockSize);

int trackBlocksPerBig=subBufferSize/trackBlockSize;

int trackLeftovers=subBufferSize-trackBlocksPerBig*trackBlockSize;

size_t singleProcessLength =

((mFilterSize>>1)*bigRuns + len%(bigRuns*(subBufferSize-mBlockSize)))

.as_size_t();

auto currentSample=start;

int bigBlocksRead=mWorkerDataCount, bigBlocksWritten=0;

// fill the first workerDataCount buffers we checked above and there is at least this data

auto maxPreFill = bigRuns < mWorkerDataCount ? bigRuns : mWorkerDataCount;

for(int i=0;i<maxPreFill;i++)

{

// fill the buffer

for(int j=0;j<trackBlocksPerBig;j++) {

t->Get((samplePtr)&mBufferInfo[i].mBufferSouce[0][j*trackBlockSize], floatSample, currentSample, trackBlockSize);

currentSample+=trackBlockSize;

}

if(trackLeftovers) {

t->Get((samplePtr)&mBufferInfo[i].mBufferSouce[0][trackBlocksPerBig*trackBlockSize], floatSample, currentSample, trackLeftovers);

currentSample+=trackLeftovers;

}

currentSample-=mBlockSize+(mFilterSize>>1);

mBufferInfo[i].mBufferStatus=BufferReady; // free for grabbin

}

int currentIndex=0;

bool bBreakLoop = false;

while(bigBlocksWritten<bigRuns && !bBreakLoop) {

bBreakLoop=mEffectEqualization->TrackProgress(count, (double)(bigBlocksWritten)/bigRuns.as_double());

if( bBreakLoop )

break;

wxMutexLocker locker( mDataMutex ); // Get in line for data

// process as many blocks as we can

while((mBufferInfo[currentIndex].mBufferStatus==BufferDone) && (bigBlocksWritten<bigRuns)) { // data is ours

output->Append((samplePtr)&mBufferInfo[currentIndex].mBufferDest[0][(bigBlocksWritten?mBlockSize:0)+(mFilterSize>>1)], floatSample, subBufferSize-((bigBlocksWritten?mBlockSize:0)+(mFilterSize>>1)));

bigBlocksWritten++;

if(bigBlocksRead<bigRuns) {

// fill the buffer

for(int j=0;j<trackBlocksPerBig;j++) {

t->Get((samplePtr)&mBufferInfo[currentIndex].mBufferSouce[0][j*trackBlockSize], floatSample, currentSample, trackBlockSize);

currentSample+=trackBlockSize;

}

if(trackLeftovers) {

t->Get((samplePtr)&mBufferInfo[currentIndex].mBufferSouce[0][trackBlocksPerBig*trackBlockSize], floatSample, currentSample, trackLeftovers);

currentSample+=trackLeftovers;

}

currentSample-=mBlockSize+(mFilterSize>>1);

mBufferInfo[currentIndex].mBufferStatus=BufferReady; // free for grabbin

bigBlocksRead++;

} else mBufferInfo[currentIndex].mBufferStatus=BufferEmpty; // this is completely unnecessary

currentIndex=(currentIndex+1)%mWorkerDataCount;

}

}

if(singleProcessLength && !bBreakLoop) {

t->Get((samplePtr)mBigBuffer.get(), floatSample, currentSample, singleProcessLength+mBlockSize+(mFilterSize>>1));

ProcessBuffer(mBigBuffer.get(), mBigBuffer.get(), singleProcessLength+mBlockSize+(mFilterSize>>1));

output->Append((samplePtr)&mBigBuffer[mBlockSize], floatSample, singleProcessLength+mBlockSize+(mFilterSize>>1));

}

output->Flush();

if(!bBreakLoop)

ProcessTail(t, output.get(), start, len);

return bBreakLoop;

float *buffer, float *scratchBuffer)

{

int i;

__m128 real128, imag128;

// Apply FFT

RealFFTf4x(buffer, mEffectEqualization->hFFT.get());

// Apply filter

// DC component is purely real

__m128 *localFFTBuffer=(__m128 *)scratchBuffer;

__m128 *localBuffer=(__m128 *)buffer;

__m128 filterFuncR, filterFuncI;

filterFuncR = _mm_set1_ps(mEffectEqualization->mFilterFuncR[0]);

localFFTBuffer[0] = _mm_mul_ps(localBuffer[0], filterFuncR);

auto halfLength = (len / 2);

bool useBitReverseTable = sMathPath & 1;

for(i = 1; i < halfLength; i++)