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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/*
* HOWTO write an External for Pure data
* (c) 2001-2006 IOhannes m zmölnig zmoelnig[AT]iem.at
*
* this is the source-code for the fourth example in the HOWTO
* it creates a simple dsp-object:
* 2 input signals are mixed into 1 output signal
* the mixing-factor can be set via the 3rd inlet
*
* for legal issues please see the file LICENSE.txt
*/
/**
* include the interface to Pd
*/
#include "m_pd.h"
/**
* define a new "class"
*/
static t_class *pan_tilde_class;
/**
* this is the dataspace of our new object
* the first element is the mandatory "t_object"
* f_pan denotes the mixing-factor
* "f" is a dummy and is used to be able to send floats AS signals.
*/
typedef struct _pan_tilde {
t_object x_obj;
t_sample f_pan;
t_sample f;
t_inlet *x_in2;
t_inlet *x_in3;
t_outlet*x_out;
} t_pan_tilde;
/**
* this is the core of the object
* this perform-routine is called for each signal block
* the name of this function is arbitrary and is registered to Pd in the
* pan_tilde_dsp() function, each time the DSP is turned on
*
* the argument to this function is just a pointer within an array
* we have to know for ourselves how many elements inthis array are
* reserved for us (hint: we declare the number of used elements in the
* pan_tilde_dsp() at registration
*
* since all elements are of type "t_int" we have to cast them to whatever
* we think is apropriate; "apropriate" is how we registered this function
* in pan_tilde_dsp()
*/
t_int *pan_tilde_perform(t_int *w)
{
/* the first element is a pointer to the dataspace of this object */
t_pan_tilde *x = (t_pan_tilde *)(w[1]);
/* here is a pointer to the t_sample arrays that hold the 2 input signals */
t_sample *in1 = (t_sample *)(w[2]);
t_sample *in2 = (t_sample *)(w[3]);
/* here comes the signalblock that will hold the output signal */
t_sample *out = (t_sample *)(w[4]);
/* all signalblocks are of the same length */
int n = (int)(w[5]);
/* get (and clip) the mixing-factor */
t_sample f_pan = (x->f_pan<0)?0.0:(x->f_pan>1)?1.0:x->f_pan;
/* just a counter */
int i;
/* this is the main routine:
* mix the 2 input signals into the output signal
*/
for(i=0; i<n; i++)
{
out[i]=in1[i]*(1-f_pan)+in2[i]*f_pan;
}
/* return a pointer to the dataspace for the next dsp-object */
return (w+6);
}
/**
* register a special perform-routine at the dsp-engine
* this function gets called whenever the DSP is turned ON
* the name of this function is registered in pan_tilde_setup()
*/
void pan_tilde_dsp(t_pan_tilde *x, t_signal **sp)
{
/* add pan_tilde_perform() to the DSP-tree;
* the pan_tilde_perform() will expect "5" arguments (packed into an
* t_int-array), which are:
* the objects data-space, 3 signal vectors (which happen to be
* 2 input signals and 1 output signal) and the length of the
* signal vectors (all vectors are of the same length)
*/
dsp_add(pan_tilde_perform, 5, x,
sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[0]->s_n);
}
/**
* this is the "destructor" of the class;
* it allows us to free dynamically allocated ressources
*/
void pan_tilde_free(t_pan_tilde *x)
{
/* free any ressources associated with the given inlet */
inlet_free(x->x_in2);
inlet_free(x->x_in3);
/* free any ressources associated with the given outlet */
outlet_free(x->x_out);
}
/**
* this is the "constructor" of the class
* the argument is the initial mixing-factor
*/
void *pan_tilde_new(t_floatarg f)
{
t_pan_tilde *x = (t_pan_tilde *)pd_new(pan_tilde_class);
/* save the mixing factor in our dataspace */
x->f_pan = f;
/* create a new signal-inlet */
x->x_in2 = inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
/* create a new passive inlet for the mixing-factor */
x->x_in3 = floatinlet_new (&x->x_obj, &x->f_pan);
/* create a new signal-outlet */
x->x_out = outlet_new(&x->x_obj, &s_signal);
return (void *)x;
}
/**
* define the function-space of the class
* within a single-object external the name of this function is very special
*/
void pan_tilde_setup(void) {
pan_tilde_class = class_new(gensym("pan~"),
(t_newmethod)pan_tilde_new,
(t_method)pan_tilde_free,
sizeof(t_pan_tilde),
CLASS_DEFAULT,
A_DEFFLOAT, 0);
/* whenever the audio-engine is turned on, the "pan_tilde_dsp()"
* function will get called
*/
class_addmethod(pan_tilde_class,
(t_method)pan_tilde_dsp, gensym("dsp"), 0);
/* if no signal is connected to the first inlet, we can as well
* connect a number box to it and use it as "signal"
*/
CLASS_MAINSIGNALIN(pan_tilde_class, t_pan_tilde, f);
}
|
