audiorecorderadapter.cpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2015 Haye Hinrichsen, Christoph Wick
 *
 * This file is part of Entropy Piano Tuner.
 *
 * Entropy Piano Tuner 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.
 *
 * Entropy Piano Tuner 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
 * Entropy Piano Tuner. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//                         Adapter for audio input
//=============================================================================

// Test sine waves with: play -n synth sin 440 vol 0.1
// monitor system input with xoscope

#include "audiorecorderadapter.h"

#include "../../messages/messagerecorderenergychanged.h"
#include "../../messages/messagemodechanged.h"
#include "../../messages/messagehandler.h"
#include "../../math/mathtools.h"
#include "../../system/log.h"

//-----------------------------------------------------------------------------
//                            Various constants
//-----------------------------------------------------------------------------

const int    AudioRecorderAdapter::BUFFER_SIZE_IN_SECONDS = 2;

const int    AudioRecorderAdapter::UPDATE_IN_MILLISECONDS = 50;

const double AudioRecorderAdapter::ATTACKRATE = 0.97;

const double AudioRecorderAdapter::DECAYRATE  = 0.7;

const double AudioRecorderAdapter::LEVEL_RETRIGGER = 0.3;

const double AudioRecorderAdapter::LEVEL_TRIGGER = 0.48;

const double  AudioRecorderAdapter::LEVEL_CUTOFF = 0.9;

const double AudioRecorderAdapter::DB_OFF = 2;


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

AudioRecorderAdapter::AudioRecorderAdapter() :
      mMuted(false),            // input device is not muted
      mGain(1),                 // Gain factor amplifying the PCM signal
      mCounter(0),              // Counter counting incoming PCM values
      mCounterThreshold(0),     // Counter threshold for a single packet
      mPacketM1(0),             // First intensity moment of a single packet
      mPacketM2(0),             // Second intensity moment of a single packet
      mSlidingLevel(0),         // Sliding VU level of the signal
      mStopLevel(0.1),          // Level at which recording stops
      mRecording(false),        // Flag for recording
      mRestartable(true),       // Flag if recorder is restartable (retrigger)
      mWaiting(false),          // Wait for analysis to be completed
      mStandby(false),          // Flag for standby mode
      mPacketCounter(0),        // Counter for the number of packages
      mIntensityHistogram(),    // Histogram of intensities for level control
      mCurrentPacket(0),        // Local audio buffer
      mStroboscope(this)
{
      setSamplingRate(44100);   // Set default sampling rate
}


//---------------------------------------------l--------------------------------
//                        Reset input level control
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::resetInputLevelControl()
{
    setDeviceInputGain(1);
    mGain = 1;
    mIntensityHistogram.clear();
    mPacketCounter = 0;
}


//-----------------------------------------------------------------------------
//                           Mutes the input device
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::setMuted (bool muted)
{
    mMuted = muted;
}


//-----------------------------------------------------------------------------
//                           Set sampling rate
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::setSamplingRate(int rate)
{
    AudioBase::setSamplingRate(rate);
    mCurrentPacket.resize(rate * BUFFER_SIZE_IN_SECONDS);
    mCounterThreshold =   rate * UPDATE_IN_MILLISECONDS / 1000;
}


//-----------------------------------------------------------------------------
//                      Read all data from the buffer
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::readAll(PacketType &packet)
{
    std::lock_guard<std::mutex> lock(mCurrentPacketMutex);   // lock the function
    packet = mCurrentPacket.getOrderedData();               // copy the content
    mCurrentPacket.clear();                                 // clear audio buffer
}


//-----------------------------------------------------------------------------
//          Convert signal intensity to a VU level and vice versa
//-----------------------------------------------------------------------------


double AudioRecorderAdapter::convertIntensityToLevel (double intensity)
{ return pow(intensity*mGain*mGain,0.25); }



double AudioRecorderAdapter::convertLevelToIntensity (double level)
{ return pow(level,4.0)/mGain/mGain; }


//-----------------------------------------------------------------------------
//                Push raw PCM data from the implementation
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::pushRawData(const PacketType &data)
{
    if (data.size()==0) return;

    // Forward packet to the stroboscope
    mStroboscope.pushRawData (data);

    std::lock_guard<std::mutex> lock(mCurrentPacketMutex);

    // loop over all PCM values of the incoming data vector
    for (auto &pcmvalue : data)
    {
        mCurrentPacket.push_back(pcmvalue);
        mPacketM1 += pcmvalue;
        mPacketM2 += pcmvalue*pcmvalue;

        if (++mCounter > mCounterThreshold) // if packet is complete
        {
            // Compute the intensity (variance) of the packet and reset counter
            double intensity = (mPacketM2-mPacketM1*mPacketM1/mCounter)/mCounter;
            mPacketM1 = mPacketM2 = mCounter = 0;

            // Convert intensity to the corresponding VU level
            double level = MathTools::restrictToInterval(convertIntensityToLevel(intensity),0,1);

            // Compute a sliding level with fast attack and slow deay
            if (level > mSlidingLevel)
                  mSlidingLevel += (level-mSlidingLevel)*ATTACKRATE;
            else  mSlidingLevel -= (mSlidingLevel-level)*DECAYRATE;

            // If muted then the shown level is zero
            double shownLevel = (mMuted ? 0 : mSlidingLevel);

            // Send shown (muted) level to the GUI VU meter
            MessageHandler::send<MessageRecorderEnergyChanged>(MessageRecorderEnergyChanged::LevelType::LEVEL_INPUT, shownLevel);

            // Switch recording process on and off according to the shown (muted) level
            controlRecordingState (shownLevel);

            // Control the input level shown at the VU meter automaticall
            if (not mMuted) automaticControl (intensity,level);
        }
    }
}


//-----------------------------------------------------------------------------
//           Automatic noise estimation and threshold control
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::automaticControl (double intensity, double level)
{
    if (intensity == 0) return;

    // Limit the maximal raw pcm intensity.
    // A sine wave with maximal amplitude +/- 1 has the integrated intensity 1/2.
    // Therefore, we reduce the hardware input level whenever this value
    // is surpassed. This down-regulation is irreversible.
    if (intensity > 0.45) setDeviceInputGain(getDeviceInputGain() * 0.9);

    // The level (passed as parameter) is a power law funtion of the intensity
    // scaled with the parameter mGain. The parameter mGain controls the overall
    // input amplification. It can move in both directions.

    // if level exceeds predefined cutoff turn gain down
    if (level > LEVEL_CUTOFF) mGain *= 0.9;

    // compute intensity histogram in decibel
    double dB = 4.34294 * log(intensity);
    mIntensityHistogram[MathTools::roundToInteger(dB)]++;

    // after 10 packets if the histogram has enough entries
    if ((++mPacketCounter)%10==0 and mIntensityHistogram.size()>5)
    {
        // determine left and right boundary in a soft way
        double norm=0, MIN=0, MAX=0;
        for (auto &e : mIntensityHistogram)
        {
            norm += e.second;
            MIN += pow(fabs(static_cast<double>(e.first)),10) * e.second;
            MAX += exp(e.first) * e.second;
        }
        if (norm==0) return;
        double dBoff = -pow(MIN/norm,1.0/10) + DB_OFF;
        double dBmax = log(MAX/norm);

        // slowly adjust the gain according to the upper edge
        double gain_target = exp(-dBmax/4.34294/2.0);
        mGain += 0.02*(gain_target-mGain);

        // slowly adjust the noise cutoff according to the lower edge
        double newStopLevel = convertIntensityToLevel(exp (dBoff/4.34294));
        if (newStopLevel < LEVEL_RETRIGGER  and fabs(newStopLevel-mStopLevel)>0.01)
        {
            // notify that stop level changed (reposition off level in mainwindow)
            mStopLevel += 0.1*(newStopLevel-mStopLevel);
            MessageHandler::send<MessageRecorderEnergyChanged>(
                        MessageRecorderEnergyChanged::LevelType::LEVEL_OFF, mStopLevel);
        }

        // After 10 packages decrease the whole histogram by a factor.
        // This ensures that new data gradually overwrites older data.
        if (mPacketCounter >= 10) for (auto &e: mIntensityHistogram) e.second /= 1.018;
    }
}


//-----------------------------------------------------------------------------
//              Control the beginning and the end of recording
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::controlRecordingState (double level)
{
    // check for recording end
    // ------------------------------------------------------------------------

    if (mRecording and level < mStopLevel)
    {
        mRecording   = false;
        mRestartable = true;
        MessageHandler::send(Message::MSG_RECORDING_ENDED);
        LogI("Recording stopped");
    }

    // check for recording start (only if not in standby mode)
    // ------------------------------------------------------------------------

    if (mStandby or mWaiting) return;

    // If the level falls below LEVEL_RETRIGGER, the status of
    // the adapter is declared as restartable:
    if (not mRestartable and mSlidingLevel < LEVEL_RETRIGGER) mRestartable = true;

    // If the adapter is restartable or crosses the trigger recording starts
    if (level>LEVEL_TRIGGER and mRestartable)
    {
        if (mRecording) LogI("Recording retriggered")
        else            LogI("Recording started");
        mRecording   = true;
        mRestartable = false;
        mWaiting = true;
        MessageHandler::send(Message::MSG_RECORDING_STARTED);
    }
}


//-----------------------------------------------------------------------------
//               Cut away silence at the beginning of the buffer
//-----------------------------------------------------------------------------


void AudioRecorderAdapter::cutSilence (PacketType &packet)
{
    // determine the maximum amplitude in the packet
    double maxamplitude = 0;
    for (auto &y : packet) if (fabs(y)>maxamplitude) maxamplitude = fabs(y);
    double trigger = std::min(0.2,maxamplitude*maxamplitude/100);

    int w = getSamplingRate() / 40;           // section width of 0.025 sec
    int sections = packet.size() / w;         // number of sections
    if (sections < 2) return;                 // required: at least two sections
    size_t entries_to_delete = 0;             // number of sections to be deleted
    for (int sec = 0; sec < sections; ++sec)  // scan sectors
    {
        double energy = 0;
        for (int i = sec*w; i < (sec+1)*w; ++i) energy += packet[i] * packet[i];
        if (energy / w < trigger) entries_to_delete += w;
        else break;
    }
    // Remove the first silent sectors:
    EptAssert(entries_to_delete <= packet.size(),"inconsistent numbers of elements");
    if (entries_to_delete > 0)
        packet.erase(packet.begin(), packet.begin() + entries_to_delete);
}