KwidgetProcessor_Recorder.cpp

Go to the documentation of this file.

#include "KwidgetProcessor_Recorder.h"
namespace krotos
{
    KwidgetProcessor_Recorder::KwidgetProcessor_Recorder(Kwidget& owner)
        : KwidgetProcessor(owner), Thread("Recorder Operations Thread")
    {
        // create a new temp directory for this recorder
        auto uniqueId = m_uniqueId.toString();
        m_tempDir = AssetManager::newTempDirectory(uniqueId);
 
        // start the background thread
        m_backgroundThread.startThread();
 
        m_kwidgetRecorder = dynamic_cast<Kwidget_Recorder*>(&getOwner());
    }
 
    KwidgetProcessor_Recorder::~KwidgetProcessor_Recorder()
    {
        // delete this recorders temp dir on recorder destruction
        if (m_tempDir.isDirectory())
        {
            if (!m_tempDir.deleteRecursively())
            {
                jassertfalse; // could not delete this recorders temp directory
            }
        }
    }
 
    void KwidgetProcessor_Recorder::prepare(double sampleRate, int samplesPerBlock)
    {
        m_sampleRate = sampleRate;
        m_lastSamplesPerBlock = samplesPerBlock;
 
        // currently writing file - located in this recorders temp dir till writing is completed
        m_writingFile = File::addTrailingSeparator(m_tempDir.getFullPathName()) + m_kwidgetRecorder->getKwidgetID() +
                        "_writing.wav";
 
        // finished recording - located in this recorders temp dir until another performance is captured
        m_latestFileName = File::addTrailingSeparator(m_tempDir.getFullPathName()) + m_kwidgetRecorder->getKwidgetID() +
                           "_latest.wav";
 
        updateReleaseTime();
        
        // if recording request has been made, call startRecording
        if (m_recordingPending)
        {
            m_recordingPending = false;
            startRecording();
        }
    }
 
    void KwidgetProcessor_Recorder::startRecording()
    {
        // For safety, if the stop thread is running, don't attempt to start recording - shouldn't happen
        if (isThreadRunning())
        {
            jassertfalse; // Tried to start recording while stop thread is still running
            return;
        }
 
        // clear pointer to m_activeWriter and reset threadedWriter
        resetWriter();
        
        // if prepare has been called and we are not currently recording..
        if (m_sampleRate > 0 && m_recording == false)
        {
            updateReleaseTime();
 
            // create outputStream to write to the destination File
            m_writingFile.deleteFile();
 
            if (auto fileStream = std::unique_ptr<FileOutputStream>(m_writingFile.createOutputStream()))
            {
                WavAudioFormat wavFormat;
                // Create WAV writer Object that writes to our output steam
                if (auto writer =
                            wavFormat.createWriterFor(fileStream.get(), m_sampleRate, NUM_BUFFER_CHANNELS, 24, {}, 0))
                {
                    fileStream.release(); // passes responsibility for deleting the stream to the writer object that is
                                          // now using it
 
                    // Now we'll create one of these helper objects which will act as a FIFO buffer, and will
                    // write the data to disk on our background thread
                    m_threadedWriter.reset(
                            new AudioFormatWriter::ThreadedWriter(writer, m_backgroundThread, NUM_BUFFER_SAMPLES));
                    // Now swap over our active writer pointer so that the processBlock will start using it
                    const ScopedLock sl(m_writerLock);
                    m_activeWriter = m_threadedWriter.get();
                    m_recording = true;
                }
            }
        }
        else // if prepare has not yet been called...
        {
            // when recalling state it is possible for startRecording to be called prior to prepare
            // therefor queue a recording request with this flag to be actioned by prepare
            m_recordingPending = true;
        }
    }
 
    bool KwidgetProcessor_Recorder::bufferIsSilent(AudioSampleBuffer& inputBuffer)
    {
        auto maxRmsLevel = minus_infinity_dB;
        for (int i = 0; i < inputBuffer.getNumChannels(); i++)
        {
            auto rmsLevel = Decibels::gainToDecibels(inputBuffer.getRMSLevel(i, 0, inputBuffer.getNumSamples()),
                                                     minus_infinity_dB);
            maxRmsLevel = rmsLevel > maxRmsLevel ? rmsLevel : maxRmsLevel;
        }
        return maxRmsLevel == minus_infinity_dB;
    }
 
    void KwidgetProcessor_Recorder::stop()
    {
        m_recording = false;
        if (m_activeWriter != nullptr)
        {
            // clear pointer to m_activeWriter and reset threadedWriter
            resetWriter();
            
            // copy the writing file over to the temp file. so that only the temp file is dragged.
            File latestRecording(m_latestFileName);
            m_writingFile.copyFileTo(latestRecording);
 
            if (m_writingFile.exists() == true)
            {
                if (!m_writingFile.deleteFile())
                {
                    jassertfalse; // writing file not being deleted
                }
            }
 
            m_kwidgetRecorder->addFilename(m_latestFileName);
            m_kwidgetRecorder->setActive(false);
            m_kwidgetRecorder->setDraggable(true);
        }
    }
 
    void KwidgetProcessor_Recorder::stopRecording()
    {
        m_stopRecordingRequest = false; // Stop thread is about to be called so we can cancel any pending request
        startThread();
    }
 
    void KwidgetProcessor_Recorder::process(AudioBuffer<float>& inputBuffer)
    {
        if (!m_recording) // If recording is not enabled, then there is nothing to do here
        {
            return;
        }
 
        // there are situations where prepare is not called when there is a block size or sr change
        // therefor we re-calculate the inactive frames before stopping (KST-2245)
        // NOTE: this logic only recalculates for block size changes currently, not sr changes
        const int currentSamplesPerBlock = inputBuffer.getNumSamples();
        if (currentSamplesPerBlock != m_lastSamplesPerBlock && currentSamplesPerBlock > 0)
        {
            m_inactiveFramesBeforeStop = jmax<int>(1, m_postRollSamples / currentSamplesPerBlock);
            m_lastSamplesPerBlock = currentSamplesPerBlock; // keep track of the last block size
        }
 
        if (m_stopRecordingRequest)
        {
            if (m_tailFramesCounter)
            {
                m_tailFramesCounter--;
            }
        }
        else
        {
            m_tailFramesCounter = m_inactiveFramesBeforeStop; // Reset tail timeout
        }
 
        // The most accurate place to calculate when to stop the recorder is here in the precess method,
        // however, because it is time consuming, the process of stopping the recorder is launched
        // from here on its own thread
        // As a failsafe, we always test to see if we need to stop, and whether stopping is already in progress
        // If we are in the body of the process method, we know that the m_recording flag is true
        if ((m_tailFramesCounter == 0) && bufferIsSilent(inputBuffer)) // Have conditions for stopping been met ?
        {
            // If the stop thread is already running then we don't need to do anything
            // If the thread finishes and has not stopped the recording for whatever reason
            // execution will return here and the thread will be restarted
            if (!isThreadRunning())
            {
                stopRecording(); // Otherwise start the thread which will stop the recording
            }
        }
        else
        {
            // Recording is active, this is where we actually write to the stream
            const ScopedLock sl(m_writerLock);
            m_activeWriter.load()->write(inputBuffer.getArrayOfReadPointers(), inputBuffer.getNumSamples());
        }
    }
 
    void KwidgetProcessor_Recorder::noteOn(int midiNoteNumber, float velocity, int)
    {
        ignoreUnused(velocity);
 
        // Clear pending stop recording requests
        m_stopRecordingRequest = false;
 
        if (m_recording)
        {
            // Reset tail counter to extend recording time
            m_tailFramesCounter = m_inactiveFramesBeforeStop;
        }
        else
        {
            // Start the recorder
            startRecording();
            m_kwidgetRecorder->setActive(true);
            m_kwidgetRecorder->setDraggable(false);
        }
    }
 
    void KwidgetProcessor_Recorder::noteOff(float velocity)
    {
        ignoreUnused(velocity);
        if (m_recording)
        {
            m_stopRecordingRequest = true;
        }
    }
 
    void KwidgetProcessor_Recorder::resetWriter()
    {
        // First clear the pointer to the activeWriter to stop the process from using it
        const ScopedLock sl(m_writerLock);
        m_activeWriter = nullptr;
        // Now we can delete the writer object. It's done in this order because the deletion could
        // take a little time while remaining data gets flushed to disk, so it's best to avoid blocking
        // the audio callback while this happens.
        m_threadedWriter.reset();
    }
 
    void KwidgetProcessor_Recorder::run()
    {
        stop();
    }
 
    void KwidgetProcessor_Recorder::updateReleaseTime()
    {
        // setting the time in seconds of a recording release after silence is detected
        using KAP = KwidgetAudioProcessor;
 
        const auto recorderReleaseTimeValue = KAP::settingsFile.getSetting(KAP::recorderReleaseTime);
 
        // 1.5 second fallback time
        const float releaseTime =
                recorderReleaseTimeValue.isVoid() ? 1.5f : static_cast<float>(recorderReleaseTimeValue);
 
        m_postRollSamples = releaseTime * static_cast<float>(m_sampleRate);
 
        m_inactiveFramesBeforeStop = jmax<int>(1, m_postRollSamples / m_lastSamplesPerBlock);
    }
} // namespace krotos