---

gapefunctionunit.cpp

// gapefunctionunit.cpp
// Dave Chisholm dkc@ccrma.stanford.edu 11/21/00

#include "gapefunctionunit.h"
#include "gapewaveformpalette.h"
#include "WvIn.h"
#include "qstring.h"
#include "AifWvIn.h"
#include "SndWvIn.h"
#include "RawWvIn.h"
#include "WavWvIn.h"


GapeFunctionUnit::GapeFunctionUnit(GapeController* c, int nChannels)
: GapeUnit(c, nChannels),
sampleData(NULL),
initialized(false),
currentTime(0.0) {
    //if (c != NULL) {
        setFreq(GAPE_FUNCTION_UNIT_DEFAULT_FREQ);
        setGain(GAPE_FUNCTION_UNIT_DEFAULT_GAIN);
        setMute(false);
    //}
    //GapeConsts::reportError("GFu Cons\n");
}


GapeFunctionUnit::~GapeFunctionUnit() {
    delete[] sampleData;
    sampleData = NULL;
}

//This function may seem a bit terse. We have a fixed number of samples representing our waveform, and we must
//use a scalar (timeScalar) to "translate" between the requested frequency and the frequency our buffer of data
//would normally have (ie sample rate / dataLength). This timescalar, as well as the varibles which track our
//current "time" must be updated every time our frequency control is changed.
void GapeFunctionUnit::receiveTick(const GapeFloat* values, int numValues) {
    if (!initialized) {
        fillBuffer();
        period = (double) GapeConsts::sampleRate / frequency;
        timeScalar = ((double) dataLength) / period;
        oldFrequency = frequency;
        initialized = true;
    }

    if (muted) {
        emit emitTick(values,numValues);
        return;
    }
//if (updateMutex.locked()) GapeConsts::reportError("locked GFU\n");
//else GapeConsts::reportError("UNlocked GFU\n");
    //updateMutex.lock();
    if (frequency != oldFrequency) {//check if our freq has changed, and if so, recalculate our period information
        updateMutex.lock();
        double newFrequency = frequency;
        updateMutex.unlock();
        period = (double) GapeConsts::sampleRate / newFrequency;
        timeScalar = ((double) dataLength) / period;
        currentTime = currentTime * (oldFrequency / newFrequency);
        oldFrequency = newFrequency;
    }


    //Our current position in the waveform is between two samples (possibly right on one). We determine the sample before
    //our position, as well as the fraction past it we are. We then use that fraction to linearly interpolate between
    //the two samples in question.
    double scaledTime = currentTime * timeScalar;
    int index = (int) scaledTime;
    double indexRemainder = scaledTime - (double)index;
    double difference;
    if (index + 1 < dataLength) {
        difference = difference = sampleData[index+1] - sampleData[index];
    } else {
        difference = sampleData[0] - sampleData[index];
    }
    GapeFloat currentValue = sampleData[index] + indexRemainder*difference;

    //updateMutex.unlock();


    currentTime = currentTime + 1.0;
    if (currentTime >= period) {
        currentTime = currentTime - period;
    }

    GapeFloat sample[GAPE_MAX_NUM_CHANNELS] = {0.0};//aggregate initialization initializes all data to 0
    if (numValues > GAPE_MAX_NUM_CHANNELS) {
        numValues = GAPE_MAX_NUM_CHANNELS;
    }


    if (numValues == 0 || values == NULL) {//ie we are generating the waveform
        numValues = numChannels;
        for (int i = 0; i < numChannels; i++) {
            sample[i] = (currentValue * gain);
        }

    } else {//ie we are acting as a filter
        int i;
        for (i = 0;i < numValues;i++) {
            sample[i] = values[i];
        }
        for (i = 0; i < numValues; i++) {
            sample[i] += (currentValue * gain);
        }
        if (numValues < numChannels) {
            numValues = numChannels;
        }
    }
    emit emitTick(sample,numValues);

}


void GapeFunctionUnit::normalize() {
    GapeFloat max = 0.0;
    double scalar;
    int i;

    for (i = 0;i < dataLength; i++) {
        if (sampleData[i] > max) {
            max = sampleData[i];
        }
    }

    for (i = 0;i < dataLength; i++) {
        sampleData[i] *= 1.0 / max;
    }
}


void GapeSineUnit::fillBuffer() {
    int i;

    sampleData = new GapeFloat[GAPE_FN_BUFFER_LENGTH];
    for(i = 0; i < GAPE_FN_BUFFER_LENGTH; ++i) {
        sampleData[i] = sin(i * 2 * PI / (double) GAPE_FN_BUFFER_LENGTH);
    }
    dataLength = GAPE_FN_BUFFER_LENGTH;
    normalize();
}


void GapeTriangleUnit::fillBuffer() {
    int i, j, maxHarmonic;
    maxHarmonic = GAPE_FUNCTION_UNIT_MAX_HARMONICS;
    bool positive = true;  // every other term is positive.
    sampleData = new GapeFloat[GAPE_FN_BUFFER_LENGTH];

    for(i = 0; i < GAPE_FN_BUFFER_LENGTH; ++i) {
        sampleData[i] = 0;
        for(j = 1; j < maxHarmonic; j += 2) {
            sampleData[i] += ((positive) ? 1 : -1) * sin(j * i * 2 * PI /
                (double) GAPE_FN_BUFFER_LENGTH) /
                ((double) j * j);
            positive = !positive;
        }
    }
    dataLength = GAPE_FN_BUFFER_LENGTH;
    normalize();
}


void GapeSawtoothUnit::fillBuffer() {
    int i, j, maxHarmonic;
    maxHarmonic = GAPE_FUNCTION_UNIT_MAX_HARMONICS;
    sampleData = new GapeFloat[GAPE_FN_BUFFER_LENGTH];

    for(i = 0; i < GAPE_FN_BUFFER_LENGTH; ++i) {
        sampleData[i] = 0;
        for(j = 1; j < maxHarmonic; ++j) {
            sampleData[i] +=  sin(j * i * 2 * PI / (double) GAPE_FN_BUFFER_LENGTH) / (double) j;
        }
    }
    dataLength = GAPE_FN_BUFFER_LENGTH;
    normalize();
}


void GapeSquareUnit::fillBuffer() {
    int i, j, maxHarmonic;
    maxHarmonic = GAPE_FUNCTION_UNIT_MAX_HARMONICS;
    sampleData = new GapeFloat[GAPE_FN_BUFFER_LENGTH];

    for(i = 0; i < GAPE_FN_BUFFER_LENGTH; ++i) {
        sampleData[i] = 0;
        for(j = 1; j < maxHarmonic; j+=2) {
            sampleData[i] +=  sin(j * i * 2 * PI / (double) GAPE_FN_BUFFER_LENGTH) / (double) j;
        }
    }
    dataLength = GAPE_FN_BUFFER_LENGTH;
    normalize();
}


void GapeHalfwaveUnit::fillBuffer() {
    int i;
    sampleData = new GapeFloat[GAPE_FN_BUFFER_LENGTH];

    for(i = 0; i < GAPE_FN_BUFFER_LENGTH / 2; ++i) {
        sampleData[i] = sin(i * 2 * PI / (double) GAPE_FN_BUFFER_LENGTH);
    }
    for(i = GAPE_FN_BUFFER_LENGTH / 2; i < GAPE_FN_BUFFER_LENGTH; ++i) {
        sampleData[i] = 0;
    }
    dataLength = GAPE_FN_BUFFER_LENGTH;
    normalize();
}


GapeDrawnWaveformUnit::GapeDrawnWaveformUnit(QWidget* parent)
: GapeFunctionUnit(new GapeWaveformPalette(parent,"Drawn Waveform")),
xData(NULL) {
    fillBuffer();
    period = (double) GapeConsts::sampleRate / frequency;
    timeScalar = ((double) dataLength) / period;
    oldFrequency = frequency;
    initialized = true;
    xData = new double[dataLength];
    for (int i = 0; i < dataLength; i++) {
        xData[i] = (double) i / (double) dataLength;
    }
    GapeWaveformPalette* c = (GapeWaveformPalette*) controllers[0];
    connect(c, SIGNAL(emitPoint(double, double)), this, SLOT(setPoint(double, double)));
    c->setRawData(xData, sampleData, dataLength);
}



//void GapeDrawnWaveformUnit::setFreq(double newFreq) {
//  GapeUnit::setFreq(newFreq / GapeConsts::sampleRate);
//}


void GapeDrawnWaveformUnit::setPoint(double x, double y) {
    int index = (int) (x * ((double) dataLength));
    sampleData[index] = y;
}


void GapeDrawnWaveformUnit::fillBuffer() {
    int i;
    sampleData = new GapeFloat[GAPE_DRAWN_WAVEFORM_BUFFER_LENGTH];

    for(i = 0; i < GAPE_DRAWN_WAVEFORM_BUFFER_LENGTH; i++) {
        sampleData[i] = 0;
    }
    dataLength = GAPE_DRAWN_WAVEFORM_BUFFER_LENGTH;
}




GapeFileSampleUnit::GapeFileSampleUnit (QWidget* parent, const QString& file)
: GapeFunctionUnit(new GapeSimpleController(parent,"SampleLoadedFromFile")),
dataReader(NULL),
validFile(false) {
    filename = new QString(file.latin1());
    fillBuffer();
    period = (double) GapeConsts::sampleRate / frequency;
    timeScalar = ((double) dataLength) / period;
    oldFrequency = frequency;
    initialized = true;
    ((GapeSimpleController*) controllers[0])->setFreqRange(1.0, GAPE_SIMPLE_CONTROLLER_FREQ_MAX, GAPE_SIMPLE_CONTROLLER_FREQ_STEP);
    controllers[0]->setFreq(1.0);
}


GapeFileSampleUnit::~GapeFileSampleUnit () {delete filename;}

void GapeFileSampleUnit::fillBuffer() {
    char buffer[512];
    validFile = true;

    //we must use a bufer for our file name b/c stk doesn't use the const keyword...
    strncpy(buffer, filename->latin1(), 512);

    try {
        if (filename->find(".aif",-5,false) >= 0) {//we have an aiff format file
            dataReader = new AifWvIn(buffer,"oneshot");
        } else if (filename->find(".raw",-4,false) >= 0) {//we have a raw sound file
            dataReader = new RawWvIn(buffer,"oneshot");
        } else if (filename->find(".wav",-4,false) >= 0) {//we have a wav format sound file
            dataReader = new WavWvIn(buffer,"oneshot");
        } else if (filename->find(".snd",-4,false) >= 0) {//we have an snd format sound file
            dataReader = new SndWvIn(buffer,"oneshot");
        } else {
            //validFile = false;
            QString errorMessage("Vague filename for GapeFileSampleUnit (should end in .raw/wav/snd/aif/aiff) - ");
            errorMessage.append(*filename);
            errorMessage.append("\n Opening as raw file \n");
            GapeConsts::reportError(errorMessage.latin1());
            dataReader = new WavWvIn(buffer,"oneshot");
        }
    } catch(StkError& e) {
        validFile = false;
        QString errorMessage("Error opening file - ");
        errorMessage.append(*filename);
        GapeConsts::reportError(errorMessage.latin1());
    }
    setNumChannels(1);

    if (dataReader->getSize() > GAPE_FILE_SAMPLE_UNIT_MAX_SIZE) {
        validFile = false;
        QString errorMessage("File: ");
        errorMessage.append(*filename);
        errorMessage.append("too large for GapeFileSampleUnit \n");
        GapeConsts::reportError(errorMessage.latin1());
    }

    if (!validFile) return;

    //I have no idea why this is needed but STK seems to be acting unexspectedly
    dataReader->setRate(1.5);

    //dataReader->setRate(dataReader->getRate() * SRATE/GapeConsts::sampleRate);

    dataLength = dataReader->getSize();// * GapeConsts::sampleRate/SRATE;
    sampleData = new GapeFloat[dataLength];

    for (int i = 0; i < dataLength; i++) {
        if (dataReader->isFinished()) break;
        for (int j = 0; j < numChannels; j++) {
            sampleData[i] = dataReader->tick();
        }
    }

    delete dataReader;
}


void GapeFileSampleUnit::receiveTick(const GapeFloat* values, int numValues) {
    if (validFile) {
        GapeFunctionUnit::receiveTick(values, numValues);
    } else {
        emit emitTick(values, numValues);
    }
}

---