Method ProcessOne1x4xThreaded

src/effects/Equalization48x.cpp:888–971

}

bool EffectEqualization48x::ProcessOne1x4xThreaded(int count, WaveTrack * t,
                                                 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) // don't 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) {