VCO.h

Go to the documentation of this file.

/*
  dsp/VCO.h
 
        Copyright 2004, 2010 Tim Goetze <tim@quitte.de>
 
        oscillators for triangle/sawtooth/square waves, and a combination
        for detuning and hard sync.
 
        NB: these oscillators are *not* bandlimited. oversample if needed.
 
 */
/*
        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; if not, write to the Free Software
        Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
        02111-1307, USA or point your web browser to http://www.gnu.org.
*/
 
 
#ifndef _DSP_VCO_H_
#define _DSP_VCO_H_
 
namespace DSP {
        
/* variable triangle to sawtooth generator. you can use two of these to
 * generate a square, but we prefer the integrated solution below.
 */
class TriSaw
{
        public:
                /* doubles for maximum stability */
                double phase, inc;
                
                double tri, tri1, tri2;
                
        public:
                TriSaw()
                        { 
                                phase = 0;
                                tri = .5;
                        }
 
                inline void set_f (double f, double fs)
                        {
                                set_inc (f / fs);
                        }
 
                inline void set_inc (double i)
                        {
                                inc = i;
                        }
 
                /* 0: triangle, 1: saw */
                inline void set_saw (double t)
                        {
                                tri = .5 + .5 * t;
                                tri1 = 2. / tri;
                                tri2 = 2. / (1 - tri);
                        }
 
                /* advance and return 1 sample.
                 * many conditionals, but quicker than a solution based on fmod()
                 */
                inline float get()
                        {
                                phase += inc;
 
                                /* the good thing is that tri is always > .5, which implies
                                 * that this first conditional is true more often than not. */
                                if (phase <= tri)
                                        return -1 + phase * tri1;
                                if (phase < 1)
                                        return 1 - (phase - tri) * tri2;
                                
                                phase -= 1;
                                return -1 + phase * tri1;
                        }
};
 
/* variable triangle to sawtooth to square generator */
class TriSawSquare
{
        public:
                /* doubles for maximum stability, using floats here increases
                 * cycle need on my athlon */
                double phase, inc;
                double * sync;
 
                float sync_phase;
 
                /* using doubles here increases cycle need significantly */
                float square_i;
                float tri, tri1, tri2;
                float st1, st2;
 
        public:
                TriSawSquare()
                        { 
                                reset();
                        }
 
                void reset()
                        {
                                phase = 0;
                                sync = &phase;
                                sync_phase = 0;
                                set_saw_square (.5, .5);
                        }
 
                inline void set_f (double f, double fs)
                        {
                                set_inc (f / fs);
                        }
 
                inline void set_inc (double i)
                        {
                                inc = i;
                        }
 
                inline void set_sync (TriSawSquare & tss, float p)
                        {
                                sync = &tss.phase;
                                sync_phase = p;
                        }
 
                /* t = 0: tri     - 1: saw, 
                 * s = 0: tri/saw - 1: square 
                 */
                inline void set_saw_square (float t, float s)
                        {
                                tri = .5 + .5 * t;
                                square_i = 1 - s;
 
                                float si2 = 2 * square_i;
                                float one_m_t = 1 - tri;
 
                                tri1 = si2 / tri;
                                tri2 = si2 / one_m_t;
 
                                st1 = s * one_m_t;
                                st2 = s * tri;
                        }
 
                /* advance and return 1 sample. 
                 * many branching instructions but on this intel chip faster than
                 * a version using floor() to keep the phase within [0..1].
                 */
                inline float get()
                        {
                                phase += inc;
 
                                if (phase <= tri)
                                        first_half:
                                        /* raw version:
                                        return (1 - square) * (-1 + phase * 2 / tri) - square * (1 - tri);
                                         */
                                        return -square_i + phase * tri1 - st1;
 
                                if (phase < 1)
                                        /* raw version:
                                        return (1 - square) * (1 - (phase - tri) * 2 / (1 - tri)) + square * tri;
                                         */
                                        return square_i - (phase - tri) * tri2 + st2;
                                
                                phase -= 1;
                                *sync = phase + sync_phase;
                                goto first_half;
                        }
};
 
class VCO2
{
        public:
                TriSawSquare vco[2];
                float blend, i_blend;
 
        public:
                VCO2()
                        {
                                set_blend (.5);
                        }
                
                void reset()
                        {
                                set_blend (.5);
                                vco[0].reset();
                                vco[1].reset();
                        }
 
                void set_f (double f, double fs, double detune)
                        {
                                vco[0].set_f (f, fs);
                                vco[1].set_f (f * pow (2, detune / 12.), fs);
                        }
 
                inline void set_blend (float b)
                        {
                                blend = b;
                                i_blend = 1 - fabs (b);
                        }
                                
                inline void set_sync (float sync)
                        {
                                vco[0].set_sync (sync ? vco[1] : vco[0], sync);
                        }
 
                inline float get()
                        {
                                return vco[0].get() * blend + vco[1].get() * i_blend;
                        }
};
 
} /* namespace DSP */
 
#endif /* _DSP_VCO_H_ */