aboutsummaryrefslogtreecommitdiff
path: root/externals/grill/flext/tutorial/signal1/main.cpp
blob: 14818e6f53b152274407492a2f9452ec37c037a9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
// signal1~ - a flext tutorial external written by Frank Barknecht
// 
// This is a commented port of the pan~ example from the PD-Externals-Howto to
// illustrate the usage of flext. You can get the original code at
// http://iem.kug.ac.at/pd/externals-HOWTO/

#include <flext.h>
#include <math.h>
 
#if !defined(FLEXT_VERSION) || (FLEXT_VERSION < 300)
#error You need at least flext version 0.3.0
#endif


// A flext dsp external ("tilde object") inherits from the class flext_dsp 
class signal1: 
	public flext_dsp
{
	// Each external that is written in C++ needs to use #defines 
	// from flbase.h
	// 
	// The define
	// 
	// FLEXT_HEADER(NEW_CLASS, PARENT_CLASS)
	// 
	// should be somewhere in your dsp file.
	// A good place is here:
	
	FLEXT_HEADER(signal1, flext_dsp)

	public:
		signal1():
			f_pan(0) // initialize f_pan
		{
			// The constructor of your class is responsible for
			// setting up inlets and outlets and for registering
			// inlet-methods:
			
			AddInSignal(2);         // 2 audio ins
			AddInFloat();           // 1 float in
			AddOutSignal();         // 1 audio out [ == AddOutSignal(1) ]
			
			SetupInOut();           // set up inlets and outlets. 
			                        // Must be called once!

			// Now we need to bind the handler function to our
			// panning inlet, which is inlet 2 (counting all inlets
			// from 0).  We want the function "setPan" to get
			// called on incoming float messages:

			FLEXT_ADDMETHOD(2,setPan);
			
			// We're done constructing:
			post("-- pan~ with flext ---");
			
		} // end of constructor
		
	
	protected:
		// here we declare the virtual DSP function
		virtual void m_signal(int n, float *const *in, float *const *out);
	private:	
		float f_pan;  // holds our panning factor
		
		// Before we can use "setPan" as a handler, we must register this
		// function as a callback to PD or Max. This is done using the
		// FLEXT_CALLBACK* macros. There are several of them.
		//
		// FLEXT_CALLBACK_F is a shortcut, that registers a function
		// expecting one float arg (thus ending in "_F"). There are
		// other shortcuts that register other types of functions. Look
		// into flext.h. No semicolon at the end of line!!!
		FLEXT_CALLBACK_F(setPan)

		// Now setPan can get declared and defined here.
		void setPan(float f) 
		{ 
			// set our private panning factor "f_pan" to the inlet
			// value float "f" in the intervall [0,1]
			f_pan = (f<0) ? 0.0f : (f>1) ? 1.0f : f ;	
			
			// if you want to debug if this worked, comment out the
			// following line: 
			//post("Set panning to %.2f, maybe clipped from %.2f", f_pan,f);
		} // end setPan
}; // end of class declaration for signal1


// Before we can run our signal1-class in PD, the object has to be registered as a
// PD object. Otherwise it would be a simple C++-class, and what good would
// that be for?  Registering is made easy with the FLEXT_NEW_* macros defined
// in flext.h. For tilde objects without arguments call:

FLEXT_NEW_DSP("signal1~ signal1~", signal1)
// T.Grill: there are two names for the object: signal1~ as main name and pan~ as its alias

// Now we define our DSP function. It gets this arguments:
// 
// int n: length of signal vector. Loop over this for your signal processing.
// float *const *in, float *const *out: 
//          These are arrays of the signals in the objects signal inlets rsp.
//          oulets. We come to that later inside the function.

void signal1::m_signal(int n, float *const *in, float *const *out)
{
	
	const float *ins1    =  in[0];
	const float *ins2    =  in[1];
	// As said above "in" holds a list of the signal vectors in all inlets.
	// After these two lines, ins1 holds the signal vector ofthe first
	// inlet, index 0, and ins2 holds the signal vector of the second
	// inlet, with index 1.
	
	float *outs          = out[0];
	// Now outs holds the signal vector at the one signal outlet we have.
	
	// We are now ready for the main signal loop
	while (n--)
	{
		
		// The "++" after the pointers outs, ins1 and ins2 walks us
		// through the signal vector with each n, of course. Before
		// each step we change the signal value in the outlet *outs
		// according to our panning factor "f_pan" and according to the
		// signals at the two signal inlets, *ins1 and *ins2 
		
		*outs++  = (*ins1++) * (1-f_pan) + (*ins2++) * f_pan;
	}
}  // end m_signal