10 #include "TTClassWrapperMax.h"
11 #include "ext_hashtab.h"
21 static t_hashtab* wrappedMaxClasses = NULL;
24 t_object* wrappedClass_new(t_symbol* name,
long argc, t_atom* argv)
26 WrappedClass* wrappedMaxClass = NULL;
30 long attrstart = attr_args_offset(argc, argv);
34 hashtab_lookup(wrappedMaxClasses, name, (t_object**)&wrappedMaxClass);
38 if (wrappedMaxClass) {
39 if (wrappedMaxClass->validityCheck)
40 err = wrappedMaxClass->validityCheck(wrappedMaxClass->validityCheckArgument);
50 x->wrappedClassDefinition = wrappedMaxClass;
51 x->maxNumChannels = 2;
52 if (attrstart && argv)
53 x->maxNumChannels = atom_getlong(argv);
57 if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(
TT(
"numChannelsUseFixedRatioInputsToOutputs"), v)) {
63 x->numInputs = x->maxNumChannels * inputs;
64 x->numOutputs = x->maxNumChannels * outputs;
66 else if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(
TT(
"fixedNumChannels"), v)) {
70 x->numInputs = numChannels;
71 x->numOutputs = numChannels;
73 else if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(
TT(
"fixedNumOutputChannels"), v)) {
77 x->numInputs = x->maxNumChannels;
78 x->numOutputs = numChannels;
81 x->numInputs = x->maxNumChannels;
82 x->numOutputs = x->maxNumChannels;
85 if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(
TT(
"additionalSignalInputSetsAttribute"), v)) {
86 x->numControlSignals = v.
size();
87 x->controlSignalNames =
new TTSymbol[x->numControlSignals];
88 for (
TTUInt16 i=0; i<x->numControlSignals; i++) {
90 x->controlSignalNames[i] = v[i];
94 x->wrappedObject =
new TTAudioObject(wrappedMaxClass->ttblueClassName, x->maxNumChannels);
95 x->audioIn =
new TTAudio(x->numInputs);
96 x->audioOut =
new TTAudio(x->numOutputs);
97 attr_args_process(x,argc,argv);
98 object_obex_store((
void *)x, _sym_dumpout, (
object *)outlet_new(x,NULL));
101 dsp_setup((t_pxobject *)x, x->numInputs);
105 if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(
TT(
"controlOutletFromNotification"), v)) {
110 notificationName = v[1];
115 x->controlOutlet = outlet_new((t_pxobject*)x, NULL);
117 x->controlCallback =
new TTObject(
"callback");
118 x->controlCallback->set(
"function",
TTPtr(&wrappedClass_receiveNotificationForOutlet));
119 x->controlCallback->set(
"baton",
TTPtr(x));
125 x->wrappedObject->registerObserverForNotifications(*x->controlCallback);
129 for (
short i=0; i < x->numOutputs; i++)
130 outlet_new((t_pxobject *)x,
"signal");
133 x->obj.z_misc = Z_NO_INPLACE;
141 dsp_free((t_pxobject *)x);
142 delete x->wrappedObject;
145 delete[] x->controlSignalNames;
152 t_symbol* s = gensym((
char*)
string.c_str());
154 outlet_anything(self->controlOutlet, s, 0, NULL);
158 t_max_err wrappedClass_attrGet(
TTPtr self, t_object* attr,
long* argc, t_atom** argv)
160 t_symbol* attrName = (t_symbol*)object_method(attr, _sym_getname);
167 err = hashtab_lookup(x->wrappedClassDefinition->maxNamesToTTNames, attrName, (t_object**)&rawpointer);
173 x->wrappedObject->get(ttAttrName, v);
177 *argv = (t_atom *)sysmem_newptr(
sizeof(t_atom) * v.
size());
183 atom_setfloat(*argv+i, value);
188 atom_setsym(*argv+i, gensym((
char*)value.
c_str()));
193 atom_setlong(*argv+i, value);
200 t_max_err wrappedClass_attrSet(
TTPtr self, t_object* attr,
long argc, t_atom* argv)
205 t_symbol* attrName = (t_symbol*)object_method(attr, _sym_getname);
211 err = hashtab_lookup(x->wrappedClassDefinition->maxNamesToTTNames, attrName, (t_object**)&ptr);
218 for (i=0; i<argc; i++) {
219 if (atom_gettype(argv+i) == A_LONG)
220 v[i] = (
TTInt32)atom_getlong(argv+i);
221 else if (atom_gettype(argv+i) == A_FLOAT)
222 v[i] = atom_getfloat(argv+i);
223 else if (atom_gettype(argv+i) == A_SYM)
224 v[i] =
TT(atom_getsym(argv+i)->s_name);
226 object_error((t_object*)x,
"bad type for attribute setter");
228 x->wrappedObject->set(ttAttrName, v);
231 return MAX_ERR_GENERIC;
235 void wrappedClass_anything(
TTPtr self, t_symbol* s,
long argc, t_atom* argv)
243 err = hashtab_lookup(x->wrappedClassDefinition->maxNamesToTTNames, s, (t_object**)&ttName);
245 object_post((t_object*)x,
"no method found for %s", s->s_name);
251 for (
long i=0; i<argc; i++) {
252 if (atom_gettype(argv+i) == A_LONG)
253 v_in[i] = (
TTInt32)atom_getlong(argv+i);
254 else if (atom_gettype(argv+i) == A_FLOAT)
255 v_in[i] = atom_getfloat(argv+i);
256 else if (atom_gettype(argv+i) == A_SYM)
257 v_in[i] =
TT(atom_getsym(argv+i)->s_name);
259 object_error((t_object*)x,
"bad type for message arg");
262 x->wrappedObject->send(ttName, v_in, v_out);
266 long ac = v_out.
size();
269 t_atom* av = (t_atom*)malloc(
sizeof(t_atom) * ac);
271 for (
long i=0; i<ac; i++) {
275 atom_setsym(av+i, gensym((
char*)ttSym.
c_str()));
280 atom_setfloat(av+i, f);
285 atom_setfloat(av+i, l);
288 object_obex_dumpout(
self, s, ac, av);
296 void wrappedClass_assist(
WrappedInstancePtr self,
void *b,
long msg,
long arg,
char *dst)
300 strcpy(dst,
"signal input, control messages");
302 if (arg > self->numInputs-self->numControlSignals-1)
304 snprintf(dst, 256,
"control signal for \"%s\"", self->controlSignalNames[arg - self->numInputs+1].c_str());
306 strcpy(dst,
"signal input");
310 if (arg < self->numOutputs)
311 strcpy(dst,
"signal output");
313 strcpy(dst,
"dumpout");
318 void wrappedClass_perform64(
WrappedInstancePtr self, t_object* dsp64,
double **ins,
long numins,
double **outs,
long numouts,
long sampleframes,
long flags,
void *userparam)
323 self->numChannels = numouts;
325 for (i=0; i <
self->numControlSignals; i++) {
326 int signal_index =
self->numInputs -
self->numControlSignals + i;
328 if (self->signals_connected[signal_index])
329 self->wrappedObject->set(self->controlSignalNames[i], *ins[signal_index]);
332 self->audioIn->setNumChannels(self->numInputs-self->numControlSignals);
333 self->audioOut->setNumChannels(self->numOutputs);
334 self->audioOut->allocWithVectorSize(sampleframes);
336 for (i=0; i <
self->numInputs-
self->numControlSignals; i++)
337 self->audioIn->setVector(i, self->vs, ins[i]);
339 self->wrappedObject->process(self->audioIn, self->audioOut);
341 for (i=0; i <
self->numOutputs; i++)
342 self->audioOut->getVectorCopy(i, self->vs, outs[i]);
347 void wrappedClass_dsp64(
WrappedInstancePtr self, t_object* dsp64,
short *count,
double samplerate,
long maxvectorsize,
long flags)
349 for (
int i=0; i < (
self->numInputs +
self->numOutputs); i++)
350 self->signals_connected[i] = count[i];
353 self->wrappedObject->set(
TT(
"sampleRate"), samplerate);
355 self->vs = maxvectorsize;
357 self->audioIn->setVectorSizeWithInt(self->vs);
358 self->audioOut->setVectorSizeWithInt(self->vs);
360 object_method(dsp64, gensym(
"dsp_add64"),
self, wrappedClass_perform64, 0, NULL);
364 TTErr wrapTTClassAsMaxClass(
TTSymbol ttblueClassName,
const char* maxClassName, WrappedClassPtr* c)
366 return wrapTTClassAsMaxClass(ttblueClassName, maxClassName, c, (WrappedClassOptionsPtr)NULL);
369 TTErr wrapTTClassAsMaxClass(
TTSymbol ttblueClassName,
const char* maxClassName, WrappedClassPtr* c, WrappedClassOptionsPtr options)
373 WrappedClass* wrappedMaxClass = NULL;
375 TTCString nameCString = NULL;
376 t_symbol* nameMaxSymbol = NULL;
379 common_symbols_init();
382 if (!wrappedMaxClasses)
383 wrappedMaxClasses = hashtab_new(0);
385 wrappedMaxClass =
new WrappedClass;
386 wrappedMaxClass->maxClassName = gensym((
char*)maxClassName);
387 wrappedMaxClass->maxClass = class_new( (
char*)maxClassName,
388 (method)wrappedClass_new,
389 (method)wrappedClass_free,
390 sizeof(WrappedInstance),
394 wrappedMaxClass->ttblueClassName = ttblueClassName;
395 wrappedMaxClass->validityCheck = NULL;
396 wrappedMaxClass->validityCheckArgument = NULL;
397 wrappedMaxClass->options = options;
398 wrappedMaxClass->maxNamesToTTNames = hashtab_new(0);
401 error(
"Jamoma ClassWrapper failed to load %s", ttblueClassName.
c_str());
409 nameSize = strlen(name.
c_str());
410 nameCString =
new char[nameSize+1];
411 strncpy_zero(nameCString, name.
c_str(), nameSize+1);
413 nameMaxSymbol = gensym(nameCString);
414 hashtab_store(wrappedMaxClass->maxNamesToTTNames, nameMaxSymbol, (t_object*)name.
rawpointer());
415 class_addmethod(wrappedMaxClass->maxClass, (method)wrappedClass_anything, nameCString, A_GIMME, 0);
424 t_symbol* maxType = _sym_long;
428 nameSize = strlen(name.
c_str());
429 nameCString =
new char[nameSize+1];
430 strncpy_zero(nameCString, name.
c_str(), nameSize+1);
431 nameMaxSymbol = gensym(nameCString);
433 if (name ==
TT(
"maxNumChannels"))
435 if (name ==
TT(
"bypass")) {
436 if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(
TT(
"generator"), v))
440 o.instance()->findAttribute(name, &attr);
443 maxType = _sym_float32;
445 maxType = _sym_float64;
447 maxType = _sym_symbol;
449 hashtab_store(wrappedMaxClass->maxNamesToTTNames, nameMaxSymbol, (t_object*)name.
rawpointer());
450 class_addattr(wrappedMaxClass->maxClass, attr_offset_new(nameCString, maxType, 0, (method)wrappedClass_attrGet, (method)wrappedClass_attrSet, 0));
454 CLASS_ATTR_STYLE(wrappedMaxClass->maxClass, (
char*)name.
c_str(), 0, (
char*)
"onoff");
455 if (name ==
TT(
"fontFace"))
456 CLASS_ATTR_STYLE(wrappedMaxClass->maxClass, (
char*)
"fontFace", 0, (
char*)
"font");
462 class_addmethod(wrappedMaxClass->maxClass, (method)wrappedClass_dsp64,
"dsp64", A_CANT, 0L);
463 class_addmethod(wrappedMaxClass->maxClass, (method)object_obex_dumpout,
"dumpout", A_CANT, 0);
464 class_addmethod(wrappedMaxClass->maxClass, (method)wrappedClass_assist,
"assist", A_CANT, 0L);
465 class_addmethod(wrappedMaxClass->maxClass, (method)stdinletinfo,
"inletinfo", A_CANT, 0);
467 class_dspinit(wrappedMaxClass->maxClass);
468 class_register(_sym_box, wrappedMaxClass->maxClass);
470 *c = wrappedMaxClass;
472 hashtab_store(wrappedMaxClasses, wrappedMaxClass->maxClassName, (t_object*)wrappedMaxClass);
479 TTErr err = wrapTTClassAsMaxClass(ttblueClassName, maxClassName, c);
482 (*c)->validityCheck = validityCheck;
483 (*c)->validityCheckArgument = (*c)->maxClass;
490 TTErr err = wrapTTClassAsMaxClass(ttblueClassName, maxClassName, c, options);
493 (*c)->validityCheck = validityCheck;
494 (*c)->validityCheckArgument = (*c)->maxClass;
502 TTErr err = wrapTTClassAsMaxClass(ttblueClassName, maxClassName, c);
505 (*c)->validityCheck = validityCheck;
506 (*c)->validityCheckArgument = validityCheckArgument;
513 TTErr err = wrapTTClassAsMaxClass(ttblueClassName, maxClassName, c, options);
516 (*c)->validityCheck = validityCheck;
517 (*c)->validityCheckArgument = validityCheckArgument;
529 for (
int i=0; i<ac; i++)
534 TTErr TTAtomsFromValue(
const TTValue& v,
long* ac, t_atom** av)
542 *av =
new t_atom[size];
545 for (
int i=0; i<size; i++) {
546 atom_setfloat((*av)+i, v[i]);
552 #include "jit.common.h"
575 t_jit_matrix_info jitterMatrixInfo;
577 long jitterMatrixLock = (long)jit_object_method(aJitterMatrix, _sym_lock, 1);
578 long jitterDimensionCount;
581 jit_object_method(aJitterMatrix, _sym_getinfo, &jitterMatrixInfo);
582 jit_object_method(aJitterMatrix, _sym_getdata, &jitterMatrixData);
587 if (jitterMatrixInfo.type == _sym_char)
588 aMatrix.
set(kTTSym_type, kTTSym_uint8);
589 else if (jitterMatrixInfo.type == _sym_long)
590 aMatrix.
set(kTTSym_type, kTTSym_int32);
591 else if (jitterMatrixInfo.type == _sym_float32)
592 aMatrix.
set(kTTSym_type, kTTSym_float32);
593 else if (jitterMatrixInfo.type == _sym_float64)
594 aMatrix.
set(kTTSym_type, kTTSym_float64);
596 aMatrix.
set(kTTSym_elementCount, (
int)jitterMatrixInfo.planecount);
598 jitterDimensionCount = jitterMatrixInfo.dimcount;
599 dimensions.
resize(jitterDimensionCount);
601 for (
int d=0; d < jitterDimensionCount; d++) {
604 dimensions[0] = (int)jitterMatrixInfo.dim[d];
605 else if (d==0 && jitterDimensionCount>1)
606 dimensions[1] = (int)jitterMatrixInfo.dim[d];
608 dimensions[d] = (
int)jitterMatrixInfo.dim[d];
611 aMatrix.
set(kTTSym_dimensions, dimensions);
613 return jitterMatrixLock;
620 t_jit_matrix_info jitterMatrixInfo;
626 jit_object_method(aJitterMatrix, _sym_getinfo, &jitterMatrixInfo);
627 jit_object_method(aJitterMatrix, _sym_getdata, &jitterMatrixData);
629 dimcount = jitterMatrixInfo.dimcount;
632 memcpy(data, jitterMatrixData, jitterMatrixInfo.dimstride[0] * jitterMatrixInfo.dim[0]);
634 else if (dimcount == 2) {
635 for (
int i=0; i<jitterMatrixInfo.dim[1]; i++) {
637 jitterMatrixData+(i*jitterMatrixInfo.dimstride[1]),
638 jitterMatrixInfo.dimstride[0] * jitterMatrixInfo.dim[0]);
654 t_jit_matrix_info jitterMatrixInfo;
660 jit_object_method(aJitterMatrix, _sym_getinfo, &jitterMatrixInfo);
661 jit_object_method(aJitterMatrix, _sym_getdata, &jitterMatrixData);
663 dimcount = jitterMatrixInfo.dimcount;
668 memcpy(jitterMatrixData, data, jitterMatrixInfo.dimstride[0] * jitterMatrixInfo.dim[0]);
670 else if (dimcount == 2) {
671 for (
int i=0; i<jitterMatrixInfo.dim[1]; i++) {
672 memcpy(jitterMatrixData+(i*jitterMatrixInfo.dimstride[1]),
674 jitterMatrixInfo.dimstride[0] * jitterMatrixInfo.dim[0]);
bool TTBoolean
Boolean flag, same as Boolean on the Mac.
std::uint16_t TTUInt16
16 bit unsigned integer
TTByte * getLockedPointer()
Return a pointer to the matrix data, and lock the matrix so that others cannot access the data...
void releaseLockedPointer()
Release a locked pointer obtained using getLockedPointer().
TTDataType type
The data type of the attribute value.
TTFOUNDATION_EXPORT TTEnvironment * ttEnvironment
The environment object has one instance, which is global in scope.
Create and use Jamoma object instances.
size_type size() const noexcept
Return the number of elements.
Bad DataType for the context.
TTUInt32 getComponentStride() const
Return number of bytes from one the beginning one matrix component to the next.
This class represents a single attribute, as used by the TTObjectBase class.
Wrap audio objects for convenience.
TTErr(TTObjectBase::* TTMethod)(const TTSymbol methodName, const TTValue &anInputValue, TTValue &anOutputValue)
A type that can be used to store a pointer to a message for an object.
TTErr setAttributeValue(const TTSymbol name, TTValue &value)
Set an attribute value for an object.
double TTFloat64
64 bit floating point number
#define TT
This macro is defined as a shortcut for doing a lookup in the symbol table.
void append(const T &anElementValueToAppend)
Insert a single TTElement at the end.
WrappedInstance * WrappedInstancePtr
Pointer to a wrapped instance of our object.
void * TTPtr
A generic pointer.
This class is used to create a backward communication channel to notify a client that something chang...
TTPtr rawpointer() const
Get the value of the raw pointer into the symbol table.
TTErr(* TTValidityCheckFunction)(const TTPtr data)
A type that can be used to store a pointer to a validity checking function.
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...
Boolean (1/0) or (true/false) flag.
const char * c_str() const
Return a pointer to the internal string as a C-string.
std::int32_t TTInt32
32 bit signed integer
TTByte * TTBytePtr
Data is a pointer to some bytes.
void TTDSP_EXPORT TTDSPInit(const char *pathToBinaries=NULL)
Initialise the Jamoma DSP library, as well as Jamoma Foundation foundation if needed.
Wrap TTMatrixBase instances.
void clear()
Clear all values from the vector, leaving with size of 0.
Set this flag if the method you are binding to this message is prototyped with a single TTValue& argu...
Something went wrong, but what exactly is not known. Typically used for context-specific problems...
TTErr
Jamoma Error Codes Enumeration of error codes that might be returned by any of the TTBlue functions a...
std::uint32_t TTUInt32
32 bit unsigned integer
void referenceExternalData(TTPtr aDataPointer)
You must proceed to set the various attributes, dimensions, etc.
TTErr notify(const TTValue &anInputValue, TTValue &anUnusedOutputValue)
Message called because we are registered as an observer to some other object, and then calls our exte...
The TTString class is used to represent a string.
void resize(size_type n)
Change the number of elements.
[doxygenAppendixC_copyExample]
Wrap TTAudioSignal instances for convenience.