tuner.cpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2016-2017 Karolin Stange, Christoph Wick, and Haye Hinrichsen
 *
 * This file is part of JustIntonation.
 *
 * JustIntonation is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * JustIntonation is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along 
 * with JustIntonation. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//                  Tuner: Module for adaptive tuning
//=============================================================================

#include "tuner.h"
#include <math.h>

//-----------------------------------------------------------------------------
//                                Constructor
//-----------------------------------------------------------------------------

Tuner::Tuner() : ThreadBase()
    , mTunerAlgorithm()
    , mGlobalTargetPitchInCents(0)
    , mTuningMode (1)
    , mStaticReferenceKey(0)
    , mWolfsIntervalShift(0)
    , mTuningEnabled(true)
    , mLastMessage("")
    , mIntervalSizes(12,0)
    , mIntervalWeights(12,1)
    , mKeyDataVector()
    , pElapsedTimer(nullptr)
    , mStaticTuningModeEnabled(false)
    , mPitchAutoCorrectionParameter(0.5)
    , mDelayParameter(0)
    , mMemoryOffFactor(0)
    , mWaitingTimeMsec(0)

{
    setThreadName("Tuner");
    setModuleName("Tuner");
    setMemoryLength(3);
}


//-----------------------------------------------------------------------------
//                                  Init
//-----------------------------------------------------------------------------

bool Tuner::init()
{
    ThreadBase::init();
    setTimerInterval(updateIntervalMsec);   // Initialize envelope timer
    mKeyDataVector.resize(128);
    for (int n=0; n<128; n++)               // Reset all keys
    {
        mKeyDataVector[n].clear();
        mKeyDataVector[n].key = n;
    }
    emitPitchCorrections();                 // Emit zero pitch corrections
    signalAveragePitchDrift(0);             // Pitch drift zero
    return true;
}


//-----------------------------------------------------------------------------
//                       Public slot: Start the tuner
//-----------------------------------------------------------------------------

bool Tuner::start()
{
    if (not ThreadBase::start()) return false;
    signalReadyForReceivingParameters(); // Ask the GUI to set the tuning parameters
    return true;
}


//-----------------------------------------------------------------------------
//                      Public slot: Set frequency of A4
//-----------------------------------------------------------------------------

void Tuner::setFrequencyOfA4 (double f)
{
    if (f<=0) return;
    double cents = 1200 * log(f/440.0) / log(2.0);
    // Do not accept pitch changes of more than two semitones
    if (cents > 200 or cents < -200)
    {
        LOGWARNING << "Unreasonable global pitch =" << cents;
        return;
    }
    LOGMESSAGE << "Setting global ptich to" << cents;
    mGlobalTargetPitchInCents = cents;
}


//-----------------------------------------------------------------------------
//                      Public slot: Set tuning mode
//-----------------------------------------------------------------------------

void Tuner::setTuningMode (int mode, int wolfsShift)
{
    mTuningMode = mode;
    mWolfsIntervalShift = wolfsShift;

    // If the tuning mode changes all sounding keys are declared
    // as being newly pressed. This ensures renewed tuning of those keys
    for (int i=0; i<128; ++i) if (mKeyDataVector[i].intensity>0)
        mKeyDataVector[i].newlyPressed=true;
    switch(mode)
    {
    case 0:
        LOGMESSAGE << "Tuning mode: ET: Equal temperament";
        break;
    case 1:
        LOGMESSAGE << "Tuning mode: JI: Dynamically tuned optimized just intonation";
        break;
    case 2:
        LOGMESSAGE << "Tuning mode: UT: Custom unequal temperament given by table";
        break;
    default:
        LOGERROR << "Undefined value for tuning mode";
    }
    LOGSTATUS << "Wolfs interval shift =" << mWolfsIntervalShift;
}


//-----------------------------------------------------------------------------
//                     Enable or disable tuning process
//-----------------------------------------------------------------------------

void Tuner::enableTuning (bool enable)
{
    LOGMESSAGE << (enable ? "enable" : "disable") << " tunging algorithm";
    mTuningEnabled = enable;
    for (int i=0; i<128; ++i) if (mKeyDataVector[i].intensity>0)
        mKeyDataVector[i].newlyPressed=true;
}


//-----------------------------------------------------------------------------
//        Public slot: Set parameter for pitch progression compensation
//-----------------------------------------------------------------------------

void Tuner::setPitchProgressionCompensationParameter (double lambda)
{
    if (lambda<0 or lambda>1)
    {
        LOGWARNING << "Unreasonable correction parameter =" << lambda;
        LOGWARNING << "Value should be between 0 and 1.";
        return;
    }
    LOGMESSAGE << "Setting pitch progression parameter lambda =" << lambda;
    mPitchAutoCorrectionParameter = lambda;
}



//-----------------------------------------------------------------------------
//                       Public slot: Set delay parameter
//-----------------------------------------------------------------------------

void Tuner::setDelayParameter (double delay)
{
    if (delay<0 or delay>10)
    {
        LOGWARNING << "Unreasonable delay parameter =" << delay;
        LOGWARNING << "Value should be between 0 and 10.";
        return;
    }
    LOGMESSAGE << "Setting delay parameter: delay=" << delay;
    mDelayParameter = delay;
}


//-----------------------------------------------------------------------------
//                       Public slot: Set memory parameter
//-----------------------------------------------------------------------------

void Tuner::setMemoryLength (double seconds)
{
    if (seconds<0 or seconds>10)
    {
        LOGWARNING << "Unreasonable memory duration parameter =" << seconds;
        LOGWARNING << "Value should be between 0 and 10.";
        return;
    }
    LOGMESSAGE << "Setting memory duration parameter: delay=" << seconds;
    mMemoryOffFactor = exp(-0.005*updateIntervalMsec/seconds);
}


//-----------------------------------------------------------------------------
//                   Main input slot: Receive Midi event
//-----------------------------------------------------------------------------

void Tuner::receiveMidiEvent(QMidiMessage event)
{
    if (not isActive()) return;

    // get key number and intensity from the Midi message
    int key = event.byte1() & 0x7F;
    double intensity = static_cast<double>(event.byte2())/127.0;

    switch (event.byte0() & 0xF0)
    {
    case 0x90: // Press key: Note on
        if (intensity>0)
        {
            // Reset data of the newly pressed key
            mKeyDataVector[key].pressed = true;
            mKeyDataVector[key].newlyPressed = true;
            mKeyDataVector[key].emitted = false;
            mKeyDataVector[key].intensity = intensity;
            mKeyDataVector[key].memory = 0;
            mKeyDataVector[key].timeStamp = getNow();
            // Reset time variable to enforce immediate tuning
            mWaitingTimeMsec=0;
        }
        else mKeyDataVector[key].pressed = false;
        break;

    case 0x80: // Release key: Note off
        mKeyDataVector[key].pressed = false;
        break;

    case 0xB0: // Control command:
        {
            switch(event.byte1())
            {
            case 67: // Pressing the left pedal will turn off tuning
                enableTuning(event.byte2()==0);
                break;

            case 123: // Command to switch all notes off
                for (int k=0; k<128; ++k) mKeyDataVector[k].pressed = false;
                break;
            default:
                break;
            }
        }
        break;
    default:
        break;
    }
}


//-----------------------------------------------------------------------------
//                           Slot: Set interval size
//-----------------------------------------------------------------------------

void Tuner::setIntervalSize (int semitones, double cents)
{
    if (semitones<1 or semitones>12)
    { LOGERROR << "Set cents: Number of halftones" << semitones << "must be between 1 and 12"; }
    else if (cents < -50 or cents > 50)
    { LOGERROR << "Set cents: Value" << cents << "out of allowed range (-50..50)"; }
    else mIntervalSizes[semitones%12] = cents;
}


//-----------------------------------------------------------------------------
//                           Slot: Set interval weight
//-----------------------------------------------------------------------------

void Tuner::setIntervalWeight (int semitones, double weight)
{
    if (semitones < 1 or semitones > 12)
    { LOGERROR << "Set weights: Number of halftones" << semitones << "must be between 1 and 12"; }
    else if (weight < 0 or weight > 1)
    { LOGERROR << "Set weights: Value" << weight << "out of allowed range (0..1)"; }
    else mIntervalWeights[semitones%12] = (weight==0 ? 0.000000001 : weight);
}


//-----------------------------------------------------------------------------
//                Emit the newly calculated pitch corrections
//-----------------------------------------------------------------------------

void Tuner::emitPitchCorrections()
{
    const double centQuantization = 0.05;
    QMap<int,double> changes;
    qint64 now = getNow();
    for (KeyData &keydata : mKeyDataVector) if (keydata.intensity > 0)
    {
        // Handle delayed tuning if necessary
        bool tune = now - keydata.timeStamp >= 1000 * mDelayParameter;
        double pitch = mGlobalTargetPitchInCents + (tune ? keydata.pitch : 0);

        if (not keydata.emitted or
            fabs(pitch-keydata.previousPitch) > centQuantization)
            changes[keydata.key] =  keydata.previousPitch = pitch;
        keydata.emitted = true;
    }
    if (changes.size()>0)
    {
        emit signalTuningCorrections(changes);

        // Report the emitted signal:
        QString message = "|  ";
        int firstkey=0; double lastpitch=0;
        for (KeyData &key : mKeyDataVector)  if (key.pressed)
        {
            firstkey=key.key; lastpitch=key.pitch; break;
        }
        for (KeyData &key : mKeyDataVector)  if (key.pressed and key.key > firstkey)
        {
            message += QString::number(((int)(10*(key.pitch-lastpitch)))/10.0) + "  |  ";
            lastpitch = key.pitch;
        }
        if (message != mLastMessage)
        {
            emit signalIntervalString(message);
            mLastMessage = message;
        }
        if (getVerbosity() >= 4) if (message.size() > 0) { LOGSTATUS << message; }
        LOGSTATUS << "INTERVALS:" << message;
    }
}


//-----------------------------------------------------------------------------
//            Get current elapsed tuner runtime in milliseconds
//-----------------------------------------------------------------------------


qint64 Tuner::getNow()
{
    if (pElapsedTimer) return pElapsedTimer->elapsed();
    else return 0;
}


//-----------------------------------------------------------------------------
//              Public slot: Enable or disable static tuning mode
//-----------------------------------------------------------------------------

void Tuner::setStaticTuningMode (bool enable, int reference)
{
    LOGMESSAGE << "Setting static tuning =" << enable
               << "with reference key" << reference;
    mStaticTuningModeEnabled = enable;
    mStaticReferenceKey = reference%128;
}


//-----------------------------------------------------------------------------
//                 Set the essential parameters of the envelope
//-----------------------------------------------------------------------------

void Tuner::setEnvelopeParameters (double secondsBass,
                            double secondsTreble,
                            double secondsRelease)
{
    LOGMESSAGE << "Envelope: Bass =" << secondsBass << " Treble ="
               << secondsTreble << " Release =" << secondsRelease;
    auto factor = [this] (double seconds) {
        return (seconds==0 ? 0 :  exp(-0.001*updateIntervalMsec/seconds)); };
    for (int key=0; key<128; key++)
    {
        double sedondsSustain = secondsBass +
                (108.0-key)/88.0*(secondsTreble-secondsBass);
        mKeyDataVector[key].sustainDampingFactor = factor(sedondsSustain);
        mKeyDataVector[key].releaseDampingFactor = factor(secondsRelease);
    }
}



//-----------------------------------------------------------------------------
//                   Initialization of the starting thread
//-----------------------------------------------------------------------------

void Tuner::initiallyCalledWorker()
{
    pElapsedTimer = new QElapsedTimer;
    QTimer::singleShot(1,this,&Tuner::tune);
}


//-----------------------------------------------------------------------------
//                     Cleanup of the terminating thread
//-----------------------------------------------------------------------------

void Tuner::finallyCalledWorker()
{
    if (pElapsedTimer) delete pElapsedTimer;
    pElapsedTimer = nullptr;
}

//-----------------------------------------------------------------------------
//                   Update procedure triggered by the timer
//-----------------------------------------------------------------------------

void Tuner::periodicallyCalledWorker()
{
    // Update the key data to emulate the envelope and memory
    for (KeyData &key : mKeyDataVector) if (key.memory > 0 or key.intensity > 0)
    {
        if (key.pressed)
        {
            key.memory += (1-memoryOnFactor)*(key.intensity-key.memory);
            key.intensity *= key.sustainDampingFactor;

            // If volume decreases below cutoff turn the key off
            if (key.intensity < cutoffIntensity or
                 getNow()-key.timeStamp > 1000*noteTimeoutSeconds)
                    key.pressed = false;
        }
        else // if the key has been released
        {
            key.memory += (1-mMemoryOffFactor)*(key.intensity-key.memory);
            key.intensity *= key.releaseDampingFactor;
            if (key.intensity < cutoffIntensity) key.intensity = 0;
            if (key.memory < cutoffMemory)       key.memory = 0;
        }
    }

    // Pitch drift compensation mechanism
    handlePitchDrift();
}


//-----------------------------------------------------------------------------
//                             Tune the pitches
//-----------------------------------------------------------------------------

void Tuner::tune()
{
    if (isInterruptionRequested()) return;
    if ((--mWaitingTimeMsec) > 0)  // wait until mWaitingTimeMsec == 0
        { QTimer::singleShot(1,this,&Tuner::tune); return; }

    if (not mTuningEnabled or mTuningMode==0)
        for (auto &key : mKeyDataVector) key.pitch = 0;
    else if (mStaticTuningModeEnabled)
        mTunerAlgorithm.tuneStatically (mKeyDataVector,mIntervalSizes,
                                        mStaticReferenceKey,mWolfsIntervalShift);
    else
    {
        double tension = mTunerAlgorithm.tuneDynamically (mKeyDataVector,
                         mIntervalSizes,mIntervalWeights,mTuningMode==1);
        emit signalTension(exp(-0.01*std::abs(tension)));
    }
    emitPitchCorrections();

    mWaitingTimeMsec = tuningIntervalMsec; // Trigger next tuning event
    QTimer::singleShot(1,this,&Tuner::tune);
}


//-----------------------------------------------------------------------------
//                             Handle pitch drift
//-----------------------------------------------------------------------------

void Tuner::handlePitchDrift()
{
    if (not mTuningEnabled or mStaticTuningModeEnabled)
    {
        signalAveragePitchDrift(0);
        return;
    }
    // Determine arithmetic mean of pitch weighted by intensity
    double avsum = 0, norm = 0;
    for (KeyData &key : mKeyDataVector) if (key.intensity > 0)
        { avsum += key.pitch * key.intensity; norm += key.intensity; }
    if (norm > 0)
    {
        double averagePitch = avsum/norm;
        if (not mStaticTuningModeEnabled)
        {
            const double dP = - averagePitch * pow(mPitchAutoCorrectionParameter,2.5);
            for (KeyData &key : mKeyDataVector) key.pitch += dP;
            averagePitch += dP;
        }
        if (std::abs(averagePitch) < 1E-6) averagePitch=0;
        signalAveragePitchDrift(averagePitch);
    }
}


//-----------------------------------------------------------------------------
//                 Reset pitch progression to a given value
//-----------------------------------------------------------------------------

void Tuner::resetPitchProgression()
{
    LOGMESSAGE << "Resetting global pitch correction";
    double av=0,sum=0;
    for (KeyData &e : mKeyDataVector)
    {
        sum += e.intensity;
        av += e.intensity * e.pitch;
    }
    for (KeyData &e : mKeyDataVector)
    {
        if (e.intensity > 0 and sum > 0) e.pitch -= av/sum;
        else e.pitch=0;
    }
    signalAveragePitchDrift(0);
    emitPitchCorrections();
}