Jamoma API  0.6.0.a19
Max/source/j.model/j.model_signal.cpp
Go to the documentation of this file.
1 /** @file
2  *
3  * @ingroup implementationMaxExternals
4  *
5  * @brief j.model / j.view - signal features
6  *
7  * @details
8  *
9  * @authors Théo de la Hogue, Trond Lossius
10  *
11  * @copyright Copyright © 2010 Théo de la Hogue @n
12  * This code is licensed under the terms of the "New BSD License" @n
13  * http://creativecommons.org/licenses/BSD/
14  */
15 
16 
17 #include "j.model.h"
18 
19 void model_signal_amenities(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
20 {
22 
23  // don't do nothing while internals are processed or the internals table is not availalble
24  if (x->iterateInternals || x->internals == NULL)
25  return;
26 
27  TTAddress modelAdrs, relativeAddress;
28  TTObject aData, aSender;
29  TTBoolean dataInput, dataOutput, audioInput, audioOutput;
30  TTValue v;
31 
32  // get model:address
33  EXTRA->modelInfo->get(kTTSym_address, v);
34  modelAdrs = v[0];
35 
36  // look into the patcher to know if there are data or audio input and output
37  jamoma_patcher_get_input_output(x->patcherPtr, dataInput, dataOutput, audioInput, audioOutput);
38 
39  if (model_test_amenities(self, TTSymbol("data"))) {
40 
41  // create internal datas depending on what have been found
42  if (dataInput || dataOutput) {
43 
44  // make internal parameter at data/active address
45  if (x->internals->lookup(TTSymbol("data/active"), v)) {
46 
47  makeInternals_data(x, modelAdrs, TTSymbol("data/active"), gensym("return_data_active"), x->patcherPtr, kTTSym_parameter, aData);
48  aData.set(kTTSym_type, kTTSym_boolean);
49  aData.set(kTTSym_tags, kTTSym_generic);
50  aData.set(kTTSym_description, TTSymbol("this parameter turns on model's data processing"));
51  aData.set(kTTSym_valueDefault, YES);
52  }
53 
54  // make an internal sender to access to all in|out instance mute attribute
55  if (x->internals->lookup(TTSymbol("data/*.*:mute"), v))
56  makeInternals_sender(self, modelAdrs, TTSymbol("data/*.*:mute"), aSender);
57  }
58 
59  if (dataInput && dataOutput) {
60 
61  // make internal parameter at data/bypass address
62  if (x->internals->lookup(TTSymbol("data/bypass"), v)) {
63 
64  makeInternals_data(x, modelAdrs, TTSymbol("data/bypass"), gensym("return_data_bypass"), x->patcherPtr, kTTSym_parameter, aData);
65  aData.set(kTTSym_type, kTTSym_boolean);
66  aData.set(kTTSym_tags, kTTSym_generic);
67  aData.set(kTTSym_description, TTSymbol("When active, this parameter bypasses the model's data processing algorithm, letting incoming signal pass through unaffected"));
68  aData.set(kTTSym_valueDefault, NO);
69  }
70 
71  // make an internal sender to access to all in instance bypass attribute
72  if (x->internals->lookup(TTSymbol("data/in.*:bypass"), v))
73  makeInternals_sender(self, modelAdrs, TTSymbol("data/in.*:bypass"), aSender);
74  }
75  }
76 
77  if (model_test_amenities(self, TTSymbol("audio"))) {
78 
79  // create internal audio datas depending on what have been found
80  if (audioInput || audioOutput) {
81 
82  // make internal parameter at audio/mute address
83  if (x->internals->lookup(TTSymbol("audio/mute"), v)) {
84 
85  makeInternals_data(x, modelAdrs, TTSymbol("audio/mute"), gensym("return_audio_mute"), x->patcherPtr, kTTSym_parameter, aData);
86  aData.set(kTTSym_type, kTTSym_boolean);
87  aData.set(kTTSym_tags, kTTSym_generic);
88  aData.set(kTTSym_description, TTSymbol("When active, this parameter turns off model's audio processing"));
89  aData.set(kTTSym_valueDefault, NO);
90  }
91 
92  // make an internal sender to access to all in|out instance mute attribute
93  if (x->internals->lookup(TTSymbol("audio/*.*:mute"), v))
94  makeInternals_sender(self, modelAdrs, TTSymbol("audio/*.*:mute"), aSender);
95  }
96 
97  if (audioInput && audioOutput) {
98 
99  // make internal parameter at audio/bypass address
100  if (x->internals->lookup(TTSymbol("audio/bypass"), v)) {
101 
102  makeInternals_data(x, modelAdrs, TTSymbol("audio/bypass"), gensym("return_audio_bypass"), x->patcherPtr, kTTSym_parameter, aData);
103  aData.set(kTTSym_type, kTTSym_boolean);
104  aData.set(kTTSym_tags, kTTSym_generic);
105  aData.set(kTTSym_description, TTSymbol("When active, this parameter bypasses the model's audio processing algorithm, letting incoming signal pass through unaffected"));
106  aData.set(kTTSym_valueDefault, NO);
107  }
108 
109  // make an internal sender to access to all in instance bypass attribute
110  if (x->internals->lookup(TTSymbol("audio/in.*:bypass"), v))
111  makeInternals_sender(self, modelAdrs, TTSymbol("audio/in.*:bypass"), aSender);
112 
113  // make internal parameter at data/mix address
114  if (x->internals->lookup(TTSymbol("audio/mix"), v)) {
115 
116  makeInternals_data(x, modelAdrs, TTSymbol("audio/mix"), gensym("return_audio_mix"), x->patcherPtr, kTTSym_parameter, aData);
117  aData.set(kTTSym_type, kTTSym_decimal);
118  aData.set(kTTSym_tags, kTTSym_generic);
119  v = TTValue(0., 100.);
120  aData.set(kTTSym_rangeBounds, v);
121  aData.set(kTTSym_rangeClipmode, kTTSym_both);
122  v = TTValue(100.);
123  aData.set(kTTSym_valueDefault, v); // Assume 100%, so that processed signal is passed through
124  aData.set(kTTSym_rampDrive, TTSymbol("max"));
125  aData.set(kTTSym_rampFunction, TTSymbol("linear"));
126  aData.set(kTTSym_description, TTSymbol("Controls the wet/dry mix in percent"));
127  }
128 
129  // make an internal sender to access to all out instance mix attribute
130  if (x->internals->lookup(TTSymbol("audio/out.*:mix"), v))
131  makeInternals_sender(self, modelAdrs, TTSymbol("audio/out.*:mix"), aSender);
132  }
133 
134  if (audioOutput) {
135 
136  // make internal parameter at audio/gain address
137  if (x->internals->lookup(TTSymbol("audio/gain"), v)) {
138 
139  makeInternals_data(x, modelAdrs, TTSymbol("audio/gain"), gensym("return_audio_gain"), x->patcherPtr, kTTSym_parameter, aData);
140  aData.set(kTTSym_type, kTTSym_decimal);
141  aData.set(kTTSym_tags, kTTSym_generic);
142  v = TTValue(0., 127.);
143  aData.set(kTTSym_rangeBounds, v);
144  aData.set(kTTSym_rangeClipmode, kTTSym_both);
145  v = TTValue(100.);
146  aData.set(kTTSym_valueDefault, v);
147  aData.set(kTTSym_rampDrive, TTSymbol("max"));
148  aData.set(kTTSym_rampFunction, TTSymbol("linear"));
149  aData.set(kTTSym_description, TTSymbol("Set gain of model's outputs (as MIDI value by default)."));
150  }
151 
152  // make an internal sender to access to all out instance gain attribute
153  if (x->internals->lookup(TTSymbol("audio/out.*:gain"), v))
154  makeInternals_sender(self, modelAdrs, TTSymbol("audio/out.*:gain"), aSender);
155  }
156  }
157 }
158 
159 void model_signal_return_data_active(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
160 {
162  TTObject aSender;
163  TTValue v, out;
164 
165  if (!x->internals->lookup(TTSymbol("data/*.*:mute"), v)) {
166 
167  aSender = v[0];
168 
169  v = TTBoolean(atom_getlong(argv) == 0);
170 
171  aSender.send(kTTSym_Send, v, out);
172  }
173 }
174 
175 void model_signal_return_data_bypass(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
176 {
178  TTObject aSender;
179  TTValue v, out;
180 
181  if (!x->internals->lookup(TTSymbol("data/in.*:bypass"), v)) {
182 
183  aSender = v[0];
184 
185  jamoma_ttvalue_from_Atom(v, msg, argc, argv);
186 
187  aSender.send(kTTSym_Send, v, out);
188  }
189 }
190 
191 void model_signal_return_audio_mute(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
192 {
194  TTObject aSender;
195  TTValue v, out;
196 
197  if (!x->internals->lookup(TTSymbol("audio/*.*:mute"), v)) {
198 
199  aSender = v[0];
200 
201  jamoma_ttvalue_from_Atom(v, msg, argc, argv);
202 
203  aSender.send(kTTSym_Send, v, out);
204  }
205 }
206 
207 void model_signal_return_audio_bypass(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
208 {
210  TTObject aSender;
211  TTValue v, out;
212 
213  if (!x->internals->lookup(TTSymbol("audio/in.*:bypass"), v)) {
214 
215  aSender = v[0];
216 
217  jamoma_ttvalue_from_Atom(v, msg, argc, argv);
218 
219  aSender.send(kTTSym_Send, v, out);
220  }
221 }
222 
223 void model_signal_return_audio_mix(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
224 {
226  TTObject aSender;
227  TTValue v, out;
228 
229  if (!x->internals->lookup(TTSymbol("audio/out.*:mix"), v)) {
230 
231  aSender = v[0];
232 
233  jamoma_ttvalue_from_Atom(v, msg, argc, argv);
234 
235  aSender.send(kTTSym_Send, v, out);
236  }
237 }
238 
239 void model_signal_return_audio_gain(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
240 {
242  TTObject aSender;
243  TTValue v, out;
244 
245  if (!x->internals->lookup(TTSymbol("audio/out.*:gain"), v)) {
246 
247  aSender = v[0];
248 
249  jamoma_ttvalue_from_Atom(v, msg, argc, argv);
250 
251  aSender.send(kTTSym_Send, v, out);
252  }
253 }
bool TTBoolean
Boolean flag, same as Boolean on the Mac.
Definition: TTBase.h:167
TTErr send(const TTSymbol aName)
Send a message to this object with no arguments.
Definition: TTObject.cpp:135
void model_signal_return_data_active(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
TTErr lookup(const TTSymbol key, TTValue &value)
Find the value for the given key.
Definition: TTHash.cpp:76
void model_signal_return_audio_bypass(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
The TTAddress class is used to represent a string and efficiently pass and compare that string...
Definition: TTAddress.h:29
Create and use Jamoma object instances.
Definition: TTObject.h:29
t_object * patcherPtr
the patcher in which the external is (ignoring subpatcher)
TTHashPtr internals
An hash table to store any internal TTObjectBases (like TTData, TTViewer, ...)
void JAMOMA_EXPORT jamoma_patcher_get_input_output(t_object *patcher, TTBoolean &dataInput, TTBoolean &dataOutput, TTBoolean &audioInput, TTBoolean &audioOutput)
Look into the given patcher to know if there are data or audio inputs and outputs.
void model_signal_amenities(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
void * TTPtr
A generic pointer.
Definition: TTBase.h:248
void model_signal_return_audio_mute(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
TTErr set(const TTSymbol aName, T aValue)
Set an attribute value for an object.
The TTSymbol class is used to represent a string and efficiently pass and compare that string...
Definition: TTSymbol.h:26
TTBoolean iterateInternals
The flag is true when an iteration is done on the internals.
void model_signal_return_data_bypass(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
TTBoolean model_test_amenities(TTPtr self, TTSymbol name)
void model_signal_return_audio_gain(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
void JAMOMA_EXPORT jamoma_ttvalue_from_Atom(TTValue &v, t_symbol *msg, long argc, const t_atom *argv)
Make a TTValue from Atom array.
j.model / j.view - The main control center of Jamoma model and view patcher
Data Structure for this object.
WrappedModularInstance * WrappedModularInstancePtr
Pointer to a wrapped instance of our object.
[doxygenAppendixC_copyExample]
Definition: TTValue.h:34
void model_signal_return_audio_mix(TTPtr self, t_symbol *msg, long argc, t_atom *argv)