[PD-cvs] externals/sc4pd/source Decay.cpp,NONE,1.1 Impulse.cpp,NONE,1.1 Integrator.cpp,NONE,1.1 main.cpp,1.11,1.12 support.hpp,1.4,1.5

Sun Aug 1 22:51:13 CEST 2004

Update of /cvsroot/pure-data/externals/sc4pd/source
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv26709/source

Modified Files:
	main.cpp support.hpp 
Added Files:
	Decay.cpp Impulse.cpp Integrator.cpp 
Log Message:
some more ugens

Index: main.cpp
===================================================================
RCS file: /cvsroot/pure-data/externals/sc4pd/source/main.cpp,v
retrieving revision 1.11
retrieving revision 1.12
diff -C2 -d -r1.11 -r1.12
*** main.cpp	1 Aug 2004 19:00:30 -0000	1.11
--- main.cpp	1 Aug 2004 20:51:11 -0000	1.12
***************
*** 63,67 ****
  	 "          ring2(~), ring3(~), ring4(~), difsqr(~), sumsqr(~), "
  	 "sqrdif(~),\n"
! 	 "          sqrsum(~), absdif(~), LFSaw(~), LFPulse(~)");

      //initialize objects
--- 63,69 ----
  	 "          ring2(~), ring3(~), ring4(~), difsqr(~), sumsqr(~), "
  	 "sqrdif(~),\n"
! 	 "          sqrsum(~), absdif(~), LFSaw(~), LFPulse(~), Impulse(~),\n"
! 	 "          Integrator(~), Decay~\n"
! 	 );

      //initialize objects
***************
*** 190,193 ****
--- 192,203 ----
      FLEXT_DSP_SETUP(LFPulse_ar);
      FLEXT_SETUP(LFPulse_kr);
+ 
+     FLEXT_DSP_SETUP(Impulse_ar);
+     FLEXT_SETUP(Impulse_kr);
+ 
+     FLEXT_DSP_SETUP(Integrator_ar);
+     FLEXT_SETUP(Integrator_kr);
+ 
+     FLEXT_DSP_SETUP(Decay_ar); 
  }

--- NEW FILE: Decay.cpp ---
/* sc4pd 
   Decay~, Decay

   Copyright (c) 2004 Tim Blechmann.                                       

   This code is derived from:
	SuperCollider real time audio synthesis system
    Copyright (c) 2002 James McCartney. All rights reserved.
	http://www.audiosynth.com

   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.

   Based on:
     PureData by Miller Puckette and others.
         http://www.crca.ucsd.edu/~msp/software.html
     FLEXT by Thomas Grill
         http://www.parasitaere-kapazitaeten.net/ext
     SuperCollider by James McCartney
         http://www.audiosynth.com

   Coded while listening to: AMM: AMMMusic 1966

*/

#include <flext.h>
#include "SC_PlugIn.h"
#include "support.hpp"

#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 406)
#error You need at least FLEXT version 0.4.6
#endif

/* ------------------------ Decay~ -----------------------------*/

class Decay_ar
    :public flext_dsp
{
    FLEXT_HEADER(Decay_ar,flext_dsp);

public:
    Decay_ar(int argc,t_atom * argv);

protected:
    virtual void m_signal(int n, t_sample *const *in, t_sample *const *out);
    virtual void m_dsp(int n, t_sample *const *in, t_sample *const *out);
    void m_set(float f);

private:
    FLEXT_CALLBACK_F(m_set);
    float m_b1;                       //leak
    float m_y1;                       //z-1
    float decayTime;
};

FLEXT_LIB_DSP_V("Decay~",Decay_ar);

Decay_ar::Decay_ar(int argc,t_atom * argv)
{
    FLEXT_ADDMETHOD_(0,"decayTime",m_set);

    AtomList Args(argc,argv);

    m_b1 = sc_getfloatarg(Args,0);

    AddOutSignal();

    m_y1 = 0.f;
}

void Decay_ar::m_signal(int n, t_sample *const *in, 
				t_sample *const *out)
{
    t_sample *nout = *out;
    t_sample *nin = *in;

    float b1 = m_b1;
    float y1 = m_y1;

    if (b1 == m_b1) 
    {
	if (b1 == 1.f) 
	{
	    for (int i = 0; i!= n;++i)
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + y1;
	    }

	} 
	else if (b1 == 0.f) 
	{
	    for (int i = 0; i!= n;++i)
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0;
	    }
	} 
	else 
	{
	    for (int i = 0; i!= n;++i)
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + b1 * y1;
	    }
	}
    } 
    else 
    {
	float b1_slope = CALCSLOPE(m_b1, b1);
	if (b1 >= 0.f && m_b1 >= 0) 
	{
	    for (int i = 0; i!= n;++i) 
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + b1 * (y1 - y0);
		b1 += b1_slope;
	    }
	} 
	else if (b1 <= 0.f && m_b1 <= 0) 
	{
	    for (int i = 0; i!= n;++i) 
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + b1 * (y1 + y0);
		b1 += b1_slope;
	    }
	} 
	else 
	{
	    for (int i = 0; i!= n;++i) 
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = (1.f - fabs(b1)) * y0 + b1 * y1;
		b1 += b1_slope;
	    }
	}
    }
    m_y1 = zapgremlins(y1);
}

void Decay_ar::m_set(float f)
{
    decayTime = f;
    m_b1= 0.f ? 0.f : exp(log001 / (decayTime * Samplerate()));
}

void Decay_ar::m_dsp(int n, t_sample *const *in, t_sample *const *out)
{
    m_b1= 0.f ? 0.f : exp(log001 / (decayTime * Samplerate()));
}

/* todo: does it make sense to implement a message-based Decay? 
   Probably not... */

/* ------------------------ Decay ------------------------------*/

// class Decay_kr
//     :public flext_base
// {
//     FLEXT_HEADER(Decay_kr,flext_base);

// public:
//     Decay_kr(int argc,t_atom * argv);

// protected:
//     void m_set(float f);
//     void m_perform(float f);

// private:
//     float m_b1;                       //leak
//     float m_y1;                       //z-1

//     FLEXT_CALLBACK_F(m_set);
//     FLEXT_CALLBACK_F(m_perform);
// };

// FLEXT_LIB_V("Decay",Decay_kr);

// Decay_kr::Decay_kr(int argc,t_atom * argv)
// {
//     AtomList Args(argc,argv);

//     m_b1 = sc_getfloatarg(Args,0);
//     m_y1 = 0.f;

//     AddInFloat();
//     AddOutFloat();

//     FLEXT_ADDMETHOD(0,m_perform);
//     FLEXT_ADDMETHOD_(0,"leak",m_set);
// }

// void Decay_kr::m_perform(float f)
// {
//     m_y1 = f + m_y1 * m_b1;
//     ToOutFloat(0,m_y1);
// }

// void Decay_kr::m_set(float f)
// {
//     m_b1=f;
// }

Index: support.hpp
===================================================================
RCS file: /cvsroot/pure-data/externals/sc4pd/source/support.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -C2 -d -r1.4 -r1.5
*** support.hpp	1 Aug 2004 19:00:30 -0000	1.4
--- support.hpp	1 Aug 2004 20:51:11 -0000	1.5
***************
*** 94,95 ****
--- 94,103 ----

  #define SIGFUN(FUN) &thisType::FUN
+ 
+ 
+ /* this macro has to be redefined to work with flext */
+ 
+ // calculate a slope for control rate interpolation to audio rate.
+ //#define CALCSLOPE(next,prev) ((next - prev) * unit->mRate->mSlopeFactor)
+ #undef CALCSLOPE
+ #define CALCSLOPE(next,prev) ((next - prev) * 1/Blocksize())

--- NEW FILE: Integrator.cpp ---
/* sc4pd 
   Integrator~, Integrator

   Copyright (c) 2004 Tim Blechmann.                                       

   This code is derived from:
	SuperCollider real time audio synthesis system
    Copyright (c) 2002 James McCartney. All rights reserved.
	http://www.audiosynth.com

   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.

   Based on:
     PureData by Miller Puckette and others.
         http://www.crca.ucsd.edu/~msp/software.html
     FLEXT by Thomas Grill
         http://www.parasitaere-kapazitaeten.net/ext
     SuperCollider by James McCartney
         http://www.audiosynth.com

   Coded while listening to: AMM: AMMMusic 1966

*/

#include <flext.h>
#include "SC_PlugIn.h"
#include "support.hpp"

#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 406)
#error You need at least FLEXT version 0.4.6
#endif

/* ------------------------ Integrator~ -----------------------------*/

class Integrator_ar
    :public flext_dsp
{
    FLEXT_HEADER(Integrator_ar,flext_dsp);

public:
    Integrator_ar(int argc,t_atom * argv);

protected:
    virtual void m_signal(int n, t_sample *const *in, t_sample *const *out);
    void m_set(float f);

private:
    FLEXT_CALLBACK_F(m_set);
    float m_b1;                       //leak
    float m_y1;                       //z-1
};

FLEXT_LIB_DSP_V("Integrator~",Integrator_ar);

Integrator_ar::Integrator_ar(int argc,t_atom * argv)
{
    FLEXT_ADDMETHOD_(0,"leak",m_set);

    AtomList Args(argc,argv);

    m_b1 = sc_getfloatarg(Args,0);

    AddOutSignal();

    m_y1 = 0.f;
}

void Integrator_ar::m_signal(int n, t_sample *const *in, 
				t_sample *const *out)
{
    t_sample *nout = *out;
    t_sample *nin = *in;

    float b1 = m_b1;
    float y1 = m_y1;

    if (b1 == m_b1) 
    {
	if (b1 == 1.f) 
	{
	    for (int i = 0; i!= n;++i)
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + y1;
	    }

	} 
	else if (b1 == 0.f) 
	{
	    for (int i = 0; i!= n;++i)
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0;
	    }
	} 
	else 
	{
	    for (int i = 0; i!= n;++i)
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + b1 * y1;
	    }
	}
    } 
    else 
    {
	float b1_slope = CALCSLOPE(m_b1, b1);
	if (b1 >= 0.f && m_b1 >= 0) 
	{
	    for (int i = 0; i!= n;++i) 
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + b1 * (y1 - y0);
		b1 += b1_slope;
	    }
	} 
	else if (b1 <= 0.f && m_b1 <= 0) 
	{
	    for (int i = 0; i!= n;++i) 
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = y0 + b1 * (y1 + y0);
		b1 += b1_slope;
	    }
	} 
	else 
	{
	    for (int i = 0; i!= n;++i) 
	    {
		float y0 = (*(nin)++); 
		(*(nout)++) = y1 = (1.f - fabs(b1)) * y0 + b1 * y1;
		b1 += b1_slope;
	    }
	}
    }
    m_y1 = zapgremlins(y1);
}

void Integrator_ar::m_set(float f)
{
    m_b1=f;
}

/* ------------------------ Integrator ------------------------------*/

class Integrator_kr
    :public flext_base
{
    FLEXT_HEADER(Integrator_kr,flext_base);

public:
    Integrator_kr(int argc,t_atom * argv);

protected:
    void m_set(float f);
    void m_perform(float f);

private:
    float m_b1;                       //leak
    float m_y1;                       //z-1

    FLEXT_CALLBACK_F(m_set);
    FLEXT_CALLBACK_F(m_perform);
};

FLEXT_LIB_V("Integrator",Integrator_kr);

Integrator_kr::Integrator_kr(int argc,t_atom * argv)
{
    AtomList Args(argc,argv);

    m_b1 = sc_getfloatarg(Args,0);
    m_y1 = 0.f;

    AddInFloat();
    AddOutFloat();

    FLEXT_ADDMETHOD(0,m_perform);
    FLEXT_ADDMETHOD_(0,"leak",m_set);
}

void Integrator_kr::m_perform(float f)
{
    m_y1 = f + m_y1 * m_b1;
    ToOutFloat(0,m_y1);
}

void Integrator_kr::m_set(float f)
{
    m_b1=f;
}

--- NEW FILE: Impulse.cpp ---
/* sc4pd 
   Impulse, Impulse~

   Copyright (c) 2004 Tim Blechmann.

   This code is derived from:
	SuperCollider real time audio synthesis system
    Copyright (c) 2002 James McCartney. All rights reserved.
	http://www.audiosynth.com

   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.

   Based on:
     PureData by Miller Puckette and others.
         http://www.crca.ucsd.edu/~msp/software.html
     FLEXT by Thomas Grill
         http://www.parasitaere-kapazitaeten.net/ext
     SuperCollider by James McCartney
         http://www.audiosynth.com

   Coded while listening to: AMM: AMMMusic 1966

*/

#include <flext.h>
#include "SC_PlugIn.h"
#include "support.hpp"

#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 406)
#error You need at least FLEXT version 0.4.6
#endif

/* todo: implement phase offset as in sc3
/* ------------------------ Impulse~ -------------------------------*/

class Impulse_ar:
    public flext_dsp
{
    FLEXT_HEADER(Impulse_ar,flext_dsp);

public:
    Impulse_ar(int argc, t_atom *argv);

protected:
    virtual void m_signal(int n, t_sample *const *in, t_sample *const *out)
    {
	m_signal_fun(n,in,out);
    }
    virtual void m_dsp(int n, t_sample *const *in, t_sample *const *out);

    void m_set(float f)
    {
	m_freq=f;
    }

    void m_ar()
    {
	SETSIGFUN(m_signal_fun,SIGFUN(m_signal_ar));
    }

    void m_kr()
    {
	SETSIGFUN(m_signal_fun,SIGFUN(m_signal_kr));
    }

private:
    double mPhase, mPhaseOffset;
    float mFreqMul;
    float m_freq;      //for kr arguments

    DEFSIGCALL (m_signal_fun);
    DEFSIGFUN (m_signal_ar);
    DEFSIGFUN (m_signal_kr);

    FLEXT_CALLBACK_F(m_set);
    FLEXT_CALLBACK(m_ar);
    FLEXT_CALLBACK(m_kr);
};

FLEXT_LIB_DSP_V("Impulse~",Impulse_ar);

Impulse_ar::Impulse_ar(int argc, t_atom *argv)
{
    FLEXT_ADDMETHOD_(0,"freq",m_set);
    FLEXT_ADDMETHOD_(0,"ar",m_ar);
    FLEXT_ADDMETHOD_(0,"kr",m_kr);

    //parse arguments
    AtomList Args(argc,argv);

    m_freq = sc_getfloatarg(Args,0);

    if(sc_ar(Args))
	SETSIGFUN(m_signal_fun,SIGFUN(m_signal_ar));
    else // if not given, use control rate
	SETSIGFUN(m_signal_fun,SIGFUN(m_signal_kr)); 

    AddOutSignal();
}    

void Impulse_ar::m_dsp(int n, t_sample *const *in, t_sample *const *out)
{
    mFreqMul = 1 / Samplerate();

}

void Impulse_ar::m_signal_ar(int n, t_sample *const *in, 
	 		   t_sample *const *out)
{
    t_sample *freq = *in;
    t_sample *xout = *out;

    float freqmul = mFreqMul;
    double phase = mPhase;

    for (int i = 0; i!= n;++i)
    {
	float z;
	if (phase >= 1.f) 
	{
	    phase -= 1.f;
	    z = 1.f;
	} 
	else 
	{
	    z = 0.f;
	}
	phase += (*(freq)++) * freqmul;
	(*(xout)++) = z;
    }

    mPhase=phase;
}

void Impulse_ar::m_signal_kr(int n, t_sample *const *in, 
			   t_sample *const *out)
{
    t_sample *xout = *out;

    float freq = m_freq * mFreqMul;
    float freqmul = mFreqMul;
    double phase = mPhase;

    for (int i = 0; i!= n;++i)
    {
	float z;
	if (phase >= 1.f) 
	{
	    phase -= 1.f;
	    z = 1.f;
	} 
	else 
	{
	    z = 0.f;
	}
	phase += freq;
	(*(xout)++) = z;
    }

    mPhase=phase;
}

/* ------------------------ Impulse ---------------------------------*/

/* todo: remove obsolete messages */

class Impulse_kr:
    public flext_base
{
    FLEXT_HEADER(Impulse_kr,flext_base);

public:
    Impulse_kr(int argc, t_atom *argv);

protected:
    void m_perform(void*);

    void m_set(float f)
    {
	m_freq_set = f;
	m_freq = f * mFreqMul;
    }

    void m_set_kr(float f)
    {
	if (f != 0)
	{
	    dt = f * 0.001;
 	    mFreqMul = dt;
	    m_freq = m_freq_set * mFreqMul;
	    m_timer.Reset();
	    m_timer.Periodic(dt);
	}
    }

private:

    double mPhase, mPhaseOffset;
    float mFreqMul;
    float m_freq;      //for kr arguments

    float dt;
    float m_freq_set;

    Timer m_timer;

    FLEXT_CALLBACK_F(m_set_kr);
    FLEXT_CALLBACK_F(m_set);
    FLEXT_CALLBACK_T(m_perform);
};

FLEXT_LIB_V("Impulse",Impulse_kr);

Impulse_kr::Impulse_kr(int argc, t_atom *argv)
{
    FLEXT_ADDMETHOD(0,m_set);
    FLEXT_ADDMETHOD_(0,"kr",m_set_kr);

    FLEXT_ADDTIMER(m_timer,m_perform);

    AddOutFloat();

    //parse arguments
    AtomList Args(argc,argv);

    m_freq_set = sc_getfloatarg(Args,0);

    dt = sc_getfloatarg(Args,1) * 0.001;

    if (dt == 0)
	dt = 0.02;  // 20 ms as default control rate as in line
    mFreqMul = dt; 

    m_freq = m_freq_set * mFreqMul;

    m_timer.Periodic(dt);

}

void Impulse_kr::m_perform(void*)
{
    float z;
    if (mPhase >= 1.f) 
    {
	mPhase -= 1.f;
	z = 1.f;
    } 
    else 
    {
	z = 0.f;
    }

    mPhase += m_freq;
    ToOutFloat(0,z);
}