VibratingString.h

Go to the documentation of this file.

/*
 * VibratingString.h - model of a vibrating string lifted from pluckedSynth
 *
 * Copyright (c) 2006-2007 Danny McRae <khjklujn/at/yahoo/com>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program 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 2 of the License, or (at your option) any later version.
 *
 * This program 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 this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_VIBRATING_STRING_H
#define LMMS_VIBRATING_STRING_H
 
#include <memory>
#include <cstdlib>
 
#include "LmmsTypes.h"
#include "lmms_math.h"
 
namespace lmms
{
 
 
class VibratingString
{
public:
        VibratingString() = default;
        VibratingString(float pitch, float pick, float pickup, const float* impulse, int len,
                sample_rate_t sampleRate, int oversample, float randomize, float stringLoss, float detune, bool state);
        ~VibratingString() = default;
 
        VibratingString(const VibratingString&) = delete;
        VibratingString& operator=(const VibratingString&) = delete;
        VibratingString(VibratingString&&) noexcept = delete;
        VibratingString& operator=(VibratingString&&) noexcept = default;
 
        sample_t nextSample()
        {
                for (int i = 0; i < m_oversample; ++i)
                {
                        // Output at pickup position
                        m_outsamp[i] = fromBridgeAccess(m_fromBridge.get(), m_pickupLoc);
                        m_outsamp[i] += toBridgeAccess(m_toBridge.get(), m_pickupLoc);
 
                        // Sample traveling into "bridge"
                        sample_t ym0 = toBridgeAccess(m_toBridge.get(), 1);
                        // Sample to "nut"
                        sample_t ypM = fromBridgeAccess(m_fromBridge.get(), m_fromBridge->length - 2);
 
                        // String state update
 
                        // Decrement pointer and then update
                        fromBridgeUpdate(m_fromBridge.get(), -bridgeReflection(ym0));
                        // Update and then increment pointer
                        toBridgeUpdate(m_toBridge.get(), -ypM);
                }
 
                return m_outsamp[m_choice];
        }
 
private:
        struct DelayLine
        {
                std::unique_ptr<sample_t[]> data;
                int length;
                sample_t* pointer;
                sample_t* end;
        };
 
        std::unique_ptr<DelayLine> m_fromBridge;
        std::unique_ptr<DelayLine> m_toBridge;
        int m_pickupLoc;
        int m_oversample;
        float m_randomize;
        float m_stringLoss;
 
        std::unique_ptr<float[]> m_impulse;
        int m_choice;
        float m_state;
 
        std::unique_ptr<sample_t[]> m_outsamp;
 
        std::unique_ptr<DelayLine> initDelayLine(int len);
        void resample(const float* src, f_cnt_t srcFrames, f_cnt_t dstFrames);

        void setDelayLine(DelayLine* dl, int pick, const float* values, int len, float scale, bool state)
        {
                const auto randAmt = m_randomize / 2.f - m_randomize;
                if (!state)
                {
                        for (int i = 0; i < pick; ++i)
                        {
                                dl->data[i] = scale * values[dl->length - i - 1] + fastRandInc(randAmt);
                        }
                        for (int i = pick; i < dl->length; ++i)
                        {
                                dl->data[i] = scale * values[i - pick] + fastRandInc(randAmt);
                        }
                }
                else
                {
                        if (len + pick > dl->length)
                        {
                                for (int i = pick; i < dl->length; ++i)
                                {
                                        dl->data[i] = scale * values[i - pick] + fastRandInc(randAmt);
                                }
                        }
                        else
                        {
                                for (int i = 0; i < len; ++i)
                                {
                                        dl->data[i+pick] = scale * values[i] + fastRandInc(randAmt);
                                }
                        }
                }
        }

        void toBridgeUpdate(DelayLine* dl, sample_t insamp)
        {
                sample_t* ptr = dl->pointer;
                *ptr = insamp * m_stringLoss;
                ++ptr;
                if (ptr > dl->end)
                {
                        ptr = dl->data.get();
                }
                dl->pointer = ptr;
        }

        void fromBridgeUpdate(DelayLine* dl, sample_t insamp)
        {
                sample_t* ptr = dl->pointer;
                --ptr;
                if (ptr < dl->data.get())
                {
                        ptr = dl->end;
                }
                *ptr = insamp * m_stringLoss;
                dl->pointer = ptr;
        }

        static sample_t dlAccess(DelayLine* dl, int position)
        {
                sample_t* outpos = dl->pointer + position;
                while (outpos < dl->data.get())
                {
                        outpos += dl->length;
                }
                while (outpos > dl->end)
                {
                        outpos -= dl->length;
                }
                return *outpos;
        }
 
        /*
         * Right-going delay line:
         * -->---->---->---
         * x=0
         * (pointer)
         * Left-going delay line:
         * --<----<----<---
         * x=0
         * (pointer)
         */

        static sample_t fromBridgeAccess(DelayLine* dl, int position)
        {
                return dlAccess(dl, position);
        }

        static sample_t toBridgeAccess(DelayLine* dl, int position)
        {
                return dlAccess(dl, position);
        }
 
        sample_t bridgeReflection(sample_t insamp)
        {
                m_state = (m_state + insamp) * 0.5;
                return m_state;
        }
};
 
 
} // namespace lmms
 
#endif // LMMS_VIBRATING_STRING_H