WaveformViewer.cpp

Go to the documentation of this file.

#include "WaveformViewer.h"
#include "KrotosBinaryData.h"
 
namespace krotos
{
    WaveformViewer::WaveformViewer(Colour waveformColour) : m_waveformColour(waveformColour)
    {
        m_formatManager = std::make_unique<AudioFormatManager>();
        m_formatManager->registerBasicFormats();
 
        const int downsampleFactor = 1;
        m_thumbnailCache = std::make_unique<AudioThumbnailCache>(2);
        m_thumbnail = std::make_unique<AudioThumbnail>(downsampleFactor, *m_formatManager, *m_thumbnailCache);
 
        m_titleLabel.setJustificationType(Justification::centredTop);
        m_titleLabel.setFont(12);
        addAndMakeVisible(m_titleLabel);
 
        // Load the backdrop image resource
        int dataSizeBytes = 0;
        auto resource =
                KrotosBinaryData::getNamedResource(m_layout.waveformAreaBackdropImageName.toUTF8(), dataSizeBytes);
        m_waveformAreaBackdropImage = Drawable::createFromImageData(resource, dataSizeBytes);
 
        resource = KrotosBinaryData::getNamedResource(m_layout.addIconImageName.toUTF8(), dataSizeBytes);
        m_addIconImage = Drawable::createFromImageData(resource, dataSizeBytes);
 
        // The backdrop could be added here using addAndMakeVisible(), but would be
        // drawn after the paint() method is called, obscuring the audio thumbnail.
        // For that reason it is drawn in from the paint() method instead
    }
 
    void WaveformViewer::addListener(Listener* l) { m_listeners.add(l); }
 
    void WaveformViewer::removeListener(Listener* l) { m_listeners.remove(l); }
 
    void WaveformViewer::paint(Graphics& g)
    {
        if (!isEnabled())
            return;
 
        float opacity = m_mouseHover ? m_layout.dropTextOpacityHover : m_layout.dropTextOpacityDefault;
 
        // Draw in the backdrop image
        m_waveformAreaBackdropImage->drawWithin(g, getLocalBounds().toFloat(), RectanglePlacement::centred, 1.f);
 
        // Is there a thumbnail to draw ?
        if (m_thumbnail != nullptr && m_thumbnail->getNumSamplesFinished() > 0)
        {
            // Draw background grid
            if (m_drawGrid)
            {
                DrawingHelper::drawBackgroundGridNoBackground(g, 10, getLocalBounds());
            }
 
            auto zoomRange = getHorizontalRange();
            double audioFileDuration = m_thumbnail->getTotalLength();
            double startTimeSeconds = zoomRange.getStart() * audioFileDuration;
            double endTimeSeconds = zoomRange.getEnd() * audioFileDuration;
            float verticalZoom = 1.0f;
            g.setColour(m_waveformColour);
            m_thumbnail->drawChannels(g, getLocalBounds(), startTimeSeconds, endTimeSeconds, verticalZoom);
 
            // Show file name if enabled
            if (m_showFileName)
            {
                g.setColour(Colours::white);
                g.setFont(12);
                g.drawText(m_fileName, 2, 2, 250, 12, Justification::left);
            }
        }
        else // Draw "drop a file" text
        {
            // Set droptext colour
            const Colour gentleRed(165, 79, 64);
            m_dropText.containsIgnoreCase("fail") ? g.setColour(gentleRed)
                                                  : g.setColour(Colours::white.withAlpha(opacity));
 
            // Set droptext font
            g.setFont(m_layout.dropTextFont.withHorizontalScale(m_layout.dropTextHorizontalScaleFactor));
 
            // Draw droptext
            g.drawFittedText(m_dropText, m_layout.dropTextArea, Justification::centredLeft, 2);
 
            // Draw +Icon
            m_addIconImage->drawWithin(g, m_layout.plusButtonArea.toFloat(), RectanglePlacement::centred, opacity);
        }
 
        if (m_draggedItemIsHovering)
        {
            const Colour hoverGreen(186, 205, 127);
            g.setColour(hoverGreen.withAlpha(0.15f));
            g.fillAll();
        }
    }
 
    void WaveformViewer::resized() { m_titleLabel.setBounds(0, 5, getWidth(), 20); }
 
    void WaveformViewer::updateWaveformView(const AudioBuffer<float>& newAudio)
    {
        if (newAudio.getNumSamples())
        {
            updateWaveformThumbnail(newAudio);
        }
        else
        {
            DBG("the test sample file did not open");
        }
    }
 
    void WaveformViewer::updateWaveformViewInterpolateBuffers(float gainSliderValue, const AudioBuffer<float>& buffer1,
                                                              const AudioBuffer<float>& buffer2, float samplePosition)
    {
        int len = static_cast<int>(m_fixedSampleRate);
        AudioBuffer<float> monoAudioBuffer{1, len};
 
        float gain1 = gainSliderValue;
        float gain2 = -1.0f * gainSliderValue + 1.0f;
 
        for (int sampleNum = 0; sampleNum < len; ++sampleNum)
        {
            float sample1 = buffer1.getSample(0, int(samplePosition));
            float sample2 = buffer2.getSample(0, int(samplePosition));
            samplePosition += 1.0f;
 
            if (samplePosition >= m_fixedSampleRate)
                samplePosition = 0.0f;
 
            monoAudioBuffer.setSample(0, sampleNum, gain2 * sample1 + gain1 * sample2);
        }
 
        updateWaveformThumbnail(monoAudioBuffer);
        repaint();
    }
 
    void WaveformViewer::clear()
    {
        m_thumbnailCache->clear();
        m_thumbnail->clear();
 
        m_fileName.clear();
 
        repaint();
    }
 
    void WaveformViewer::waveformZoomed(const AudioBuffer<float>& audioBuffer, int startSample, int numsamples) const
    {
        m_thumbnail->reset(int(m_wavReader->numChannels), m_wavReader->sampleRate, audioBuffer.getNumSamples());
        m_thumbnail->addBlock(0, audioBuffer, startSample, numsamples);
    }
 
    void WaveformViewer::setWaveformColour(Colour waveformColour) { m_waveformColour = waveformColour; }
 
    void WaveformViewer::setTitle(const String& title) { m_titleLabel.setText(title, dontSendNotification); }
 
    void WaveformViewer::setDropText(const String& newText) { m_dropText = newText; }
 
    void WaveformViewer::setDrawGrid(bool drawGrid) { m_drawGrid = drawGrid; }
 
    void WaveformViewer::setShowFileName(bool showFileName) { m_showFileName = showFileName; }
 
    void WaveformViewer::setShowBorderOnDragHover(bool showBorder) { m_dragBorderShouldShow = showBorder; }
 
    void WaveformViewer::setUseExtendedFilePaths(bool val) { m_useExtendedFilePaths = val; }
 
    void WaveformViewer::setLimitToSingleDroppedItem(bool val) { m_limitToSingleDroppedItem = val; }
 
    bool WaveformViewer::matchesExpression(const String& /*expression*/, const String& /*stringToTest*/)
    {
        /* SANTODO reinstate
        try
        {
            std::regex reg(expression.toStdString());
 
            return std::regex_search(stringToTest.toStdString(), reg);
        }
        catch (std::regex_error e)
        {
            DBG(e.what());
 
            return false;
        }*/
 
        return true;
    }
 
    void WaveformViewer::setRegexFileFilter(const String& newExpression) { m_regexFileFilter = newExpression; }
 
    bool WaveformViewer::soundFileTypeIsValid(std::string /*fileName*/)
    {
        /* SANTODO: reinstate
        std::regex acceptedExtensions(".wav|.aif|.aiff|.ogg|.flac", std::regex_constants::icase);
        return std::regex_search(fileName.begin(), fileName.end(), acceptedExtensions);*/
 
        return true;
    }
 
    Array<File> WaveformViewer::getExtendedFilePaths(const StringArray& files)
    {
        Array<File> referencedFiles;
 
        if ((m_limitToSingleDroppedItem && files.size() != 1) || files.size() < 1)
            return referencedFiles;
 
        for (auto f : files)
        {
            File file{f};
 
            if (file.isDirectory())
                referencedFiles.addArray(
                        file.findChildFiles(File::findFiles, true, "*.wav;*.aif;*.aiff;*.flac;*.ogg;*.kaf"));
            else if (soundFileTypeIsValid(f.toStdString()))
                referencedFiles.add(file);
        }
 
        if (m_regexFileFilter == "" || referencedFiles.size() <= 1)
            return referencedFiles;
 
        Array<File> filteredFiles;
 
        for (auto& fl : referencedFiles)
            if (matchesExpression(m_regexFileFilter, fl.getFileName()))
                filteredFiles.add(fl);
 
        return filteredFiles;
    }
 
    void WaveformViewer::setHoverState(bool newState) { m_mouseHover = newState; }
 
    bool WaveformViewer::isInterestedInFileDrag(const StringArray& files)
    {
        if (m_useExtendedFilePaths)
        {
            Array<File> referencedFiles = getExtendedFilePaths(files);
            m_numDraggedFilesHovering = referencedFiles.size();
 
            return m_numDraggedFilesHovering > 0;
        }
 
        if (files.size() != 1)
            return false;
 
        return soundFileTypeIsValid(files[0].toStdString());
    }
 
    void WaveformViewer::fileDragEnter(const StringArray& files, int /*x*/, int /*y*/)
    {
        // if the waveform viewer is disabled do nothing
        if (!isEnabled())
        {
            return;
        }
 
        if (isInterestedInFileDrag(files))
        {
            m_draggedItemIsHovering = true;
            repaint();
        }
    }
 
    void WaveformViewer::fileDragExit(const StringArray& /*files*/)
    {
        if (m_draggedItemIsHovering)
        {
            m_draggedItemIsHovering = false;
            repaint();
        }
    }
 
    void WaveformViewer::updateWaveformThumbnail(const AudioBuffer<float>& audioBuffer)
    {
        m_thumbnail->reset(audioBuffer.getNumChannels(), m_fixedSampleRate, audioBuffer.getNumSamples());
 
        m_thumbnail->addBlock(0, audioBuffer, 0, audioBuffer.getNumSamples());
    }
 
    void WaveformViewer::mixStereoBufferToMono(const AudioBuffer<float>& stereo, AudioBuffer<float>& mono) const
    {
        mono.setSize(1, int(m_wavReader->lengthInSamples));
        mono.copyFrom(0, 0, stereo, 0, 0, int(m_wavReader->lengthInSamples));
        mono.addFrom(0, 0, stereo, 1, 0, int(m_wavReader->lengthInSamples));
        mono.applyGain(0, int(m_wavReader->lengthInSamples), 0.5f);
    }
} // namespace krotos