---

gapeaccumulator.cpp

#include "gapeaccumulator.h"
#include <limits.h>

GapeAccumulator::GapeAccumulator(int numSamples)
: GapeUnit(NULL),
resizeSize(numSamples),
//resizeNeeded(false) {
tickCounter(INT_MAX) {
    if (numSamples <= 0) {
        numSamples = 1;
        GapeConsts::reportError("Invalid number of samples in GapeAccumulator constructor, gapeaccumulator.cpp line 33\n");
    }
    d_numSamples = numSamples;
    d_writeIndex = 0;
    d_samples = new GapeFloat[d_numSamples];
}

GapeAccumulator::~GapeAccumulator() { delete[] d_samples; }


void GapeAccumulator::receiveTick( const GapeFloat* values, int numValues ) {
    // handled by next case, but faster.
    if(numValues == 0) return;


    //more terse code for thread safety and to keep critcal section small...
    if (tickCounter >= GapeConsts::updateMutexPeriod) {
        bool needResize = false;
        int newSize;
        d_mutex.lock();
        if (resizeSize != d_numSamples) {
            needResize = true;
            newSize = resizeSize;
        }
        d_mutex.unlock();
        if (needResize) {
            adjustBuffers(newSize);
        }
        tickCounter = 0;
    }

    const GapeFloat*  readptr = values;
    int   numunaccumulated   = numValues;
    int   numtocopy;

    while(true) {
        // if we have space to write all values to d_samples,
        // just do so and break.
        if(numunaccumulated < spaceRemaining() ) {
            memcpy(d_samples + d_writeIndex, readptr,
            numunaccumulated * sizeof(GapeFloat));
            d_writeIndex     += numunaccumulated;
            break;
        } else {
            numtocopy = spaceRemaining();
            memcpy(d_samples + d_writeIndex, readptr,
            numtocopy * sizeof(GapeFloat));
            readptr += numtocopy;
            d_writeIndex = 0;
            numunaccumulated -= numtocopy;
            emit emitTick(d_samples, d_numSamples);
        }
    }
    tickCounter++;
}



void GapeAccumulator::adjustBuffers(int newSize) {
    if (newSize <= 0) {
            newSize = 1;
            GapeConsts::reportError("Invalid number of samples in GapeAccumulator adjustBuffers, gapeaccumulator.cpp line 79\n");
    }

    int numTimesSmaller = d_writeIndex / newSize; // truncated.

    // if new size is smaller, send out newSize buffers
    // as many times as it takes to get the existing
    // samples within the new range.
    int numEmitted = 0;
    for(int i = 0; i < numTimesSmaller; ++i) {
     emit emitTick(d_samples + (i * newSize), newSize);
     numEmitted += newSize;
    }

    GapeFloat* temp = new GapeFloat[newSize];
    d_writeIndex -= numEmitted;

    memcpy(temp, d_samples + numEmitted,
    d_writeIndex * sizeof(GapeFloat));

    delete[] d_samples;
    d_samples = temp;
    d_numSamples = newSize;
}



//this function and the whole flag structure here is for threading issues. mutex.lock() would
//have been more desirable but it's too slow to use every sample and this works just as well.
void GapeAccumulator::resizeAccumulator( int newSize ) {
    if (newSize <= 0) {
        newSize = 1;
        GapeConsts::reportError("Invalid number of samples in GapeAccumulator resize, gapeaccumulator.cpp line 79\n");
    }
    d_mutex.lock();
    resizeSize = newSize;
    d_mutex.unlock();
}

---