customviews.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Custom Views File:  customviews.h
//
// -----------------------------------------------------------------------------
#pragma once
#include "vstgui/vstgui.h"
#include "vstgui/vstgui_uidescription.h" // for IController

#include "../PluginKernel/pluginstructures.h"

namespace VSTGUI {

// --- with an update cycle of ~50mSec, we need at least 2205 samples; this should be more than enough
const int DATA_QUEUE_LEN = 4096;

class WaveView : public CControl, public ICustomView
{
public:
    WaveView(const CRect& size, IControlListener* listener, int32_t tag);
    ~WaveView();

    virtual void updateView() override;

    virtual void pushDataValue(double data) override;

    void addWaveDataPoint(float fSample);

    void clearBuffer();

    void showXAxis(bool _paintXAxis) { paintXAxis = _paintXAxis; }

    void draw(CDrawContext* pContext) override;

    // --- for CControl pure abstract functions
    CLASS_METHODS(WaveView, CControl)

protected:
    // --- turn on/off zerodB line
    bool paintXAxis = true; 

    // --- circular buffer and index values
    double* circularBuffer = nullptr;   
    int writeIndex = 0;     
    int readIndex = 0;      
    int circularBufferLength = 0;
    CRect currentRect;      

private:
    // --- lock-free queue for incoming data, sized to DATA_QUEUE_LEN in length
    moodycamel::ReaderWriterQueue<double, DATA_QUEUE_LEN>* dataQueue = nullptr; 

};

#define HAVE_FFTW 1

#ifdef HAVE_FFTW
// --- FFTW (REQUIRED)
#include "fftw3.h"

enum class spectrumViewWindowType {kRectWindow, kHannWindow, kBlackmanHarrisWindow};

// --- change this for higher accuracy; needs to be power of 2
const int FFT_LEN = 512;

// --- SpectrumView
/*
*/
class SpectrumView : public CControl, public ICustomView
{
public:
    SpectrumView(const CRect& size, IControlListener* listener, int32_t tag);
    ~SpectrumView();

    virtual void updateView() override;

    virtual void pushDataValue(double data) override;

    void showFilledFFT(bool _filledFFT) { filledFFT = _filledFFT; }

    void setWindow(spectrumViewWindowType _window);

    void draw(CDrawContext* pContext) override;

    // --- for CControl pure abstract functions
    CLASS_METHODS(SpectrumView, CControl)

protected:
    // --- for windowing; this doesn't need to be saved in current
    //     implementation but you may need it for homework/upgrading the object
    spectrumViewWindowType window = spectrumViewWindowType::kRectWindow; 

    // --- setup FFTW
    fftw_complex* data = nullptr;           
    fftw_complex* fft_result = nullptr;     
    fftw_complex* ifft_result = nullptr;    
    fftw_plan plan_forward;                 
    fftw_plan plan_backward;                

    // --- for FFT data input
    int fftInputCounter = 0;                

    bool addFFTInputData(double inputSample);

    // --- a double buffer pair of magnitude arrays
    double fftMagnitudeArray_A[FFT_LEN] = {0.0}; 
    double fftMagnitudeArray_B[FFT_LEN] = {0.0}; 

    // --- buffer for the assigned window
    double fftWindow[FFT_LEN] = {1.0}; 

    // --- pointer to mag buffer that drawing thread uses; note that
    //     this pointer is never shared with any other function
    double* currentFFTMagBuffer = nullptr; 

    // --- NOTE: move these to another file for use by other objects!!
    // --- helper for FFT magnitude
    inline double getMagnitude(double re, double im)
    {
        return sqrt((re*re)+(im*im));
    }

    inline double normalizeBufferGetFMax(double* buffer, unsigned int bufferSize, int* ptrMaxIndex)
    {
        double max = 0;
        double maxRetValue = 0;
        *ptrMaxIndex = 0;

        for(int j=0; j<bufferSize; j++)
        {
            if((fabs(buffer[j])) > max)
            {
                max = fabs(buffer[j]);
                *ptrMaxIndex = j;
            }
        }

        if(max > 0)
        {
            for(int j=0; j<bufferSize; j++)
            {
                buffer[j] = buffer[j]/max;
                if(j == *ptrMaxIndex)
                    maxRetValue = buffer[j];
            }
        }

        return maxRetValue;
    }

    inline double interpArrayValue(double* array, int arraySize, double fractionalIndex)
    {
        // --- extract [index_x] values
        int x1 = (int)fractionalIndex;
        int x2 = x1 + 1;

        // --- check invalid conditions
        if(x1 >= arraySize)
            return 0.0;
        if(x2 >= arraySize)
            return array[x1];
        if(x2 - x1 == 0)    // 0 slope: should not ever happen
            return array[x1];

        // --- calculate decimal position of x
        double dx = (fractionalIndex - x1)/(x2 - x1);

        // --- use weighted sum method of interpolating
        return dx*array[x2] + (1-dx)*array[x1];
    }

protected:
    // --- filled/unfilled FFT
    bool filledFFT = true; 

private:
    // --- lock-free queue for incoming data, sized to FFT_LEN in length
    moodycamel::ReaderWriterQueue<double,FFT_LEN>* dataQueue = nullptr; 

    // --- a pair of lock-free queues to store empty and full magnitude buffers
    //     these are setup as double buffers but you can easily extend them
    //     to quad (4) and octal (8) if you want
    moodycamel::ReaderWriterQueue<double*,2>* fftMagBuffersReady = nullptr; 
    moodycamel::ReaderWriterQueue<double*,2>* fftMagBuffersEmpty = nullptr; 
};
#endif // defined FFTW


// --- custom view example
const unsigned int MESSAGE_SHOW_CONTROL = 0;
const unsigned int MESSAGE_HIDE_CONTROL = 1;
const unsigned int MESSAGE_SET_CONTROL_ALPHA = 1;

// --- example of a custom view message; here we control the visual appearance of a control
struct CustomViewMessage
{
    CustomViewMessage() {}
    CustomViewMessage(const CustomViewMessage& initMessage)
    {
        visible = initMessage.visible;
        showAlternateGraphic = initMessage.showAlternateGraphic;
        controlAlpha = initMessage.controlAlpha;
    }

    CustomViewMessage& operator =(const CustomViewMessage& viewMessage)
    {
        visible = viewMessage.visible;
        showAlternateGraphic = viewMessage.showAlternateGraphic;
        controlAlpha = viewMessage.controlAlpha;
        return *this;
    }

    unsigned int message = MESSAGE_HIDE_CONTROL;    
    bool visible = true;                            
    bool showAlternateGraphic = false;              
    double controlAlpha = 1.0;                      
};

class CustomKnobView : public CAnimKnob, public ICustomView
{
public:
    CustomKnobView(const CRect& size, IControlListener* listener, int32_t tag, int32_t subPixmaps,
            CCoord heightOfOneImage, CBitmap* background, const CPoint &offset,
            bool bSwitchKnob = false);

    virtual void updateView() override;

    virtual void sendMessage(void* data) override;

protected:
    virtual ~CustomKnobView(void);

private:
    // --- lock-free queue for incoming data, sized to 32 in length
    moodycamel::ReaderWriterQueue<CustomViewMessage, 32>* dataQueue = nullptr; 
};


class KnobLinkController : public IController
{
public:
    KnobLinkController(IController* _parentController)
    {
        // --- save the parent listener
        parentController = _parentController;

        // --- INITIALIZE LINK STATE
        linkControls = false;
    }
    ~KnobLinkController()
    {
        linkedKnobs.clear();
    }

    bool isLinkedControl(CControl* control)
    {
        return std::find(linkedKnobs.begin(), linkedKnobs.end(), control) != linkedKnobs.end();
    }

    virtual CView* verifyView(CView* view, const UIAttributes& attributes, const IUIDescription* description) override
    {
        CAnimKnob* knob = dynamic_cast<CAnimKnob*>(view);
        CTextButton* button = dynamic_cast<CTextButton*>(view);

        // --- save button, push back knob onto list
        if (button)
        {
            linkControl = button;
            if (button->getValueNormalized() != 0)
                linkControls = true;
            else
                linkControls = false;
        }
        else if (knob)
            linkedKnobs.push_back(knob);

        return view;
    }

    virtual void valueChanged(CControl* control) override
    {
        // --- set the link flag
        if (control == linkControl)
        {
            if (control->getValueNormalized() != 0)
                linkControls = true;
            else
                linkControls = false;

            return parentController->valueChanged(control);
        }

        // --- check flag
        if (!linkControls)
            return parentController->valueChanged(control);

        // --- we are linking
        //
        // --- make sure this is not a rogue control
        if (isLinkedControl(control))
        {
            // --- iterate list
            for (std::vector<CAnimKnob*>::iterator it = linkedKnobs.begin(); it != linkedKnobs.end(); ++it)
            {
                // --- set the control value for all knobs except the one generating this message
                CControl* ctrl = *it;

                if (ctrl && control != ctrl)
                {
                    // --- set the control visually
                    ctrl->setValueNormalized(control->getValueNormalized());

                    // --- do the value change at parent level, to set on plugin
                    parentController->valueChanged(ctrl);
                }
            }
        }
        // --- do the value change at parent level, to set on plugin
        parentController->valueChanged(control);
    }

    virtual CView* createView(const UIAttributes& attributes, const IUIDescription* description) override { return parentController->createView(attributes, description); }

    virtual void controlBeginEdit(CControl* pControl)override { parentController->controlBeginEdit(pControl); }

    virtual void controlEndEdit(CControl* pControl)override { parentController->controlEndEdit(pControl); }

    virtual void controlTagWillChange(CControl* pControl) override
    {
        pControl->setListener(parentController);
        parentController->controlTagWillChange(pControl);
        pControl->setListener(this);
    }

    virtual void controlTagDidChange(CControl* pControl) override
    {
        pControl->setListener(parentController);
        parentController->controlTagDidChange(pControl);
        pControl->setListener(this);
    }

protected:
    // --- the parent controller; we can issue IController commands to it!
    IController* parentController = nullptr; 

    // --- a CTextButton is the switcher (linkControl)
    CTextButton* linkControl = nullptr; 

    // --- when linked, all of these controls move when one of them moves,
    //     regardless of their control tags
    typedef std::vector<CAnimKnob*> KnobList; 
    KnobList linkedKnobs;

    // --- flag for linking knobs
    bool linkControls = false;      
};



}