void *euclid_new(t_symbol *s, long argc, t_atom *argv)
{
t_euclid *x = NULL;
long i;
// object instantiation, NEW STYLE
if (x = (t_euclid *)object_alloc(euclid_class)) {
object_post((t_object *)x, "a new %s object was instantiated: 0x%X", s->s_name, x);
object_post((t_object *)x, "it has %ld arguments", argc);
x = (t_euclid *)object_alloc(euclid_class);
x->m_outlet1 = listout((t_euclid *)x);
for (i = 0; i < argc; i++) {
if ((argv + i)->a_type == A_LONG) {
object_post((t_object *)x, "arg %ld: long (%ld)", i, atom_getlong(argv+i));
} else if ((argv + i)->a_type == A_FLOAT) {
object_post((t_object *)x, "arg %ld: float (%f)", i, atom_getfloat(argv+i));
} else if ((argv + i)->a_type == A_SYM) {
object_post((t_object *)x, "arg %ld: symbol (%s)", i, atom_getsym(argv+i)->s_name);
} else {
object_error((t_object *)x, "forbidden argument");
}
}
}
// default values
x->l_M = 12;
x->l_N = 5;
x->l_rotate = 0;
return (x);
}
/**@public @memberof t_OMax_learn
* @brief Bind the learner with FO and Data Sequence */
bool OMax_learn_bind(t_OMax_learn *x)
{
///@remarks Do this binding only once
if (x->obound == FALSE)
{
///@details Check if FO name points to an existing @link t_OMax_oracle OMax.oracle @endlink object. If so, binds t_OMax_learn::oname with the actual FO structure (t_OMax_oracle::oracle member).
if ((x->oname->s_thing) && (ob_sym(x->oname->s_thing) == gensym("OMax.oracle")))
{
x->builder.set_oracle((((t_OMax_oracle*)(x->oname->s_thing))->oracle));
object_post((t_object *)x,"Learner bound to Oracle %s", x->oname->s_name);
}
else
{
object_error((t_object *)x,"No oracle %s declared", x->oname->s_name);
}
/// Do the same for Data Sequence with member t_OMax_learn::dataname and the related @link t_OMax_data OMax.data @endlink object.
if ((x->dataname->s_thing) && (ob_sym(x->dataname->s_thing) == gensym("OMax.data")))
{
x->builder.set_data((((t_OMax_data*)(x->dataname->s_thing))->data));
x->obound = TRUE;
x->datatype = ((t_OMax_data*)(x->dataname->s_thing))->datatype;
if (x->datatype == SPECTRAL)
x->nbcoeffs = ((t_OMax_data*)(x->dataname->s_thing))->nbcoeffs;
((t_OMax_data*)(x->dataname->s_thing))->noDelete = FALSE;
object_post((t_object *)x,"Learner bound to Data of Oracle %s", x->oname->s_name);
}
else
{
object_error((t_object *)x,"No data for oracle %s declared", x->oname->s_name);
}
}
// If binding is ok, then don't do it next time.
return x->obound;
}
TTErr makeInternals_viewer(TTPtr self, TTAddress address, TTSymbol name, t_symbol *callbackMethod, TTObject& returnedViewer, TTBoolean deferlow)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, baton;
TTAddress adrs;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedViewer = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_viewer : \"%s\" internal already exists", name.c_str());
return kTTErrNone;
}
returnedViewer = TTObject(kTTSym_Viewer);
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnedViewer.set(kTTSym_baton, baton);
returnedViewer.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
// edit address
adrs = address.appendAddress(TTAddress(name));
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedViewer);
// set address attribute (after registration as the value can be updated in the same time)
returnedViewer.set(kTTSym_address, adrs);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" viewer to bind on : %s", name.c_str(), adrs.c_str());
return kTTErrNone;
}
TTErr makeInternals_explorer(TTPtr self, TTSymbol name, t_symbol *callbackMethod, TTObject& returnedExplorer, TTBoolean deferlow)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, args, baton;
TTObject returnValueCallback;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedExplorer = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_explorer : \"%s\" internal already exists", name.c_str());
return kTTErrNone;
}
// prepare arguments
returnValueCallback = TTObject("callback");
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnValueCallback.set(kTTSym_baton, baton);
returnValueCallback.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
args.append(returnValueCallback);
args.append((TTPtr)jamoma_explorer_default_filter_bank());
returnedExplorer = TTObject(kTTSym_Explorer, args);
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedExplorer);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" explorer", name.c_str());
return kTTErrNone;
}
TTErr makeInternals_sender(TTPtr self, TTAddress address, TTSymbol name, TTObject& returnedSender, TTBoolean appendNameAsAttribute)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v;
TTAddress adrs;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedSender = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_sender : \"%s\" internal already exists", name.c_str());
return kTTErrNone;
}
returnedSender = TTObject(kTTSym_Sender);
// edit address
if (appendNameAsAttribute)
adrs = address.appendAttribute(name);
else
adrs = address.appendAddress(TTAddress(name.c_str()));
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedSender);
// set address attribute
returnedSender.set(kTTSym_address, adrs);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" sender to bind on : %s", name.c_str(), adrs.c_str());
return kTTErrNone;
}
/*
t_symbol {
char *s_name;
t_object *s_thing;
}
*/
void *simplemax_new(t_symbol *s, long argc, t_atom *argv)
{
t_simplemax *x = NULL;
long i;
// object instantiation, OLD STYLE
// if (x = (t_simplemax *)newobject(simplemax_class)) {
// ;
// }
// object instantiation, NEW STYLE
if (x = (t_simplemax *)object_alloc(simplemax_class)) {
object_post((t_object *)x, "a new %s object was instantiated: 0x%X", s->s_name, x);
object_post((t_object *)x, "it has %ld arguments", argc);
for (i = 0; i < argc; i++) {
if ((argv + i)->a_type == A_LONG) {
object_post((t_object *)x, "arg %ld: long (%ld)", i, atom_getlong(argv+i));
} else if ((argv + i)->a_type == A_FLOAT) {
object_post((t_object *)x, "arg %ld: float (%f)", i, atom_getfloat(argv+i));
} else if ((argv + i)->a_type == A_SYM) {
object_post((t_object *)x, "arg %ld: symbol (%s)", i, atom_getsym(argv+i)->s_name);
} else {
object_error((t_object *)x, "forbidden argument");
}
}
}
return (x);
}
/****************************************************************
* Post the object string buffers
*/
void strstr_post(t_strstr *x)
{
object_post((t_object *)x, "Mode: %i", x->mode);
object_post((t_object *)x, "Float precision: %i", x->fprecision);
object_post((t_object *)x, "Alloc: Left: %i - Right: %i",
DSTR_ALLOC(x->i_dstr1), DSTR_ALLOC(x->i_dstr2));
object_post((t_object *)x, "Left: %s", DSTR_CSTR(x->i_dstr1));
object_post((t_object *)x, "Right: %s", DSTR_CSTR(x->i_dstr2));
}
void *simpleNeuron_new(t_symbol *s, long argc, t_atom *argv)
{
t_simpleNeuron *x = NULL;
long i;
// object instantiation
if (x = (t_simpleNeuron *)object_alloc(simpleNeuron_class)) {
object_post((t_object *)x, "a new %s object was instantiated: 0x%X", s->s_name, x);
object_post((t_object *)x, "it has %ld arguments", argc);
x = (t_simpleNeuron *)object_alloc(simpleNeuron_class);
x->m_outlet1 = bangout((t_simpleNeuron *)x);
x->m_clock1 = clock_new((t_simpleNeuron *)x, (method)delayedReset);
x->m_clock2 = clock_new((t_simpleNeuron *)x, (method)leak);
x->m_clock3 = clock_new((t_simpleNeuron *)x, (method)delayedBang);
for (i = 0; i < argc; i++) {
if ((argv + i)->a_type == A_LONG) {
object_post((t_object *)x, "arg %ld: long (%ld)", i, atom_getlong(argv+i));
} else if ((argv + i)->a_type == A_FLOAT) {
object_post((t_object *)x, "arg %ld: float (%f)", i, atom_getfloat(argv+i));
} else if ((argv + i)->a_type == A_SYM) {
object_post((t_object *)x, "arg %ld: symbol (%s)", i, atom_getsym(argv+i)->s_name);
} else {
object_error((t_object *)x, "forbidden argument");
}
}
}
// default settings
x->d_V = 0;
x->d_Vth = 5;
x->d_C = 1;
x->d_R = 100;
// Fitzhugh
x->d_W = 0;
x->d_Wth = 1.5;
x->d_Wr = 1.3;
x->d_a = -0.7; // http://www.scholarpedia.org/article/FitzHugh-Nagumo_model
x->d_b = 0.8;
x->d_tao = 12.5;
x->d_stepSize = 0.3; // this needs to be
x->l_bangFlag = 0;
x->l_mode = 0;
x->l_ref = 0;
x->d_absRef = 100;
x->d_leakPer = 100;
x->d_bangD = 10;
return (x);
}
MaxErr PlugOutNotify(PlugOutPtr self, SymbolPtr s, SymbolPtr msg, ObjectPtr sender, TTPtr data)
{
if (sender == self->patcherview) {
if (msg == _sym_attr_modified) {
SymbolPtr name = (SymbolPtr)object_method((ObjectPtr)data, _sym_getname);
if (name == _sym_dirty) {
qelem_set(self->qelem);
}
}
else if (msg == _sym_free)
self->patcherview = NULL;
}
else {
if (msg == _sym_free) {
ObjectPtr sourceBox;
ObjectPtr sourceObject;
long sourceOutlet;
ObjectPtr destBox;
ObjectPtr destObject;
long destInlet;
if (self->patcherview)
goto out; // if there is no patcherview, then we are freeing the whole thing and can skip this
#ifdef DEBUG_NOTIFICATIONS
object_post(SELF, "patch line deleted");
#endif // DEBUG_NOTIFICATIONS
// get boxes and inlets
sourceBox = jpatchline_get_box1(sender);
if (!sourceBox)
goto out;
sourceObject = jbox_get_object(sourceBox);
sourceOutlet = jpatchline_get_outletnum(sender);
destBox = jpatchline_get_box2(sender);
if (!destBox)
goto out;
destObject = jbox_get_object(destBox);
destInlet = jpatchline_get_inletnum(sender);
// if both boxes are audio graph objects
if ( zgetfn(sourceObject, GENSYM("audio.object")) && zgetfn(destObject, GENSYM("audio.object")) ) {
#ifdef DEBUG_NOTIFICATIONS
object_post(SELF, "deleting audio graph patchline!");
#endif // DEBUG_NOTIFICATIONS
object_method(destObject, GENSYM("audio.drop"), destInlet, sourceObject, sourceOutlet);
}
out:
;
}
}
return MAX_ERR_NONE;
}
MaxErr UnpackNotify(UnpackPtr self, SymbolPtr s, SymbolPtr msg, ObjectPtr sender, TTPtr data)
{
if (sender == self->patcherview) {
if (msg == _sym_attr_modified) {
SymbolPtr name = (SymbolPtr)object_method((ObjectPtr)data, _sym_getname);
if (name == _sym_dirty) {
qelem_set(self->qelem);
}
}
else if (msg == _sym_free)
self->patcherview = NULL;
}
else {
if (msg == _sym_free) {
ObjectPtr sourceBox;
ObjectPtr sourceObject;
long sourceOutlet;
ObjectPtr destBox;
ObjectPtr destObject;
long destInlet;
#ifdef DEBUG_NOTIFICATIONS
object_post(SELF, "patch line deleted");
#endif // DEBUG_NOTIFICATIONS
// get boxes and inlets
sourceBox = jpatchline_get_box1(sender);
if (!sourceBox)
goto out;
sourceObject = jbox_get_object(sourceBox);
sourceOutlet = jpatchline_get_outletnum(sender);
destBox = jpatchline_get_box2(sender);
if (!destBox)
goto out;
destObject = jbox_get_object(destBox);
destInlet = jpatchline_get_inletnum(sender);
// if both boxes are audio graph objects
if ( zgetfn(sourceObject, gensym("audio.object")) && zgetfn(destObject, gensym("audio.object")) ) {
#ifdef DEBUG_NOTIFICATIONS
object_post(SELF, "deleting audio graph patchline!");
#endif // DEBUG_NOTIFICATIONS
object_method(destObject, gensym("audio.drop"), destInlet, sourceObject, sourceOutlet);
UnpackReset(self, self->vectorSize); // attempt for http://redmine.jamoma.org/issues/1248
}
out:
;
}
}
return MAX_ERR_NONE;
}
t_max_err PackNotify(PackPtr self, t_symbol* s, t_symbol* msg, t_object* sender, TTPtr data)
{
if (sender == self->patcherview) {
if (msg == _sym_attr_modified) {
t_symbol* name = (t_symbol*)object_method((t_object*)data, _sym_getname);
if (name == _sym_dirty) {
qelem_set(self->qelem);
}
}
else if (msg == _sym_free)
self->patcherview = NULL;
}
else {
if (msg == _sym_free) {
t_object* sourceBox;
t_object* sourceObject;
long sourceOutlet;
t_object* destBox;
t_object* destObject;
long destInlet;
#ifdef DEBUG_NOTIFICATIONS
object_post(SELF, "patch line deleted");
#endif // DEBUG_NOTIFICATIONS
// get boxes and inlets
sourceBox = jpatchline_get_box1(sender);
if (!sourceBox)
goto out;
sourceObject = jbox_get_object(sourceBox);
sourceOutlet = jpatchline_get_outletnum(sender);
destBox = jpatchline_get_box2(sender);
if (!destBox)
goto out;
destObject = jbox_get_object(destBox);
destInlet = jpatchline_get_inletnum(sender);
// if both boxes are graph objects
if ( zgetfn(sourceObject, gensym("graph.object")) && zgetfn(destObject, gensym("graph.object")) ) {
#ifdef DEBUG_NOTIFICATIONS
object_post(SELF, "deleting graph patchline!");
#endif // DEBUG_NOTIFICATIONS
object_method(destObject, gensym("graph.drop"), destInlet, sourceObject, sourceOutlet);
}
out:
;
}
}
return MAX_ERR_NONE;
}
t_jit_err jit_openlase_trace_matrix_calc(t_jit_openlase_trace *x, void *inputs, void *outputs)
{
t_jit_err err=JIT_ERR_NONE;
long in_savelock;
t_jit_matrix_info in_minfo;
char *in_bp;
long dimcount;
void *in_matrix;
int width, height;
unsigned bytesperrow;
in_matrix = jit_object_method(inputs,_jit_sym_getindex,0);
if (x&&in_matrix) {
in_savelock = (long) jit_object_method(in_matrix,_jit_sym_lock,1);
jit_object_method(in_matrix,_jit_sym_getinfo,&in_minfo);
jit_object_method(in_matrix,_jit_sym_getdata,&in_bp);
if (!in_bp) { err=JIT_ERR_INVALID_INPUT; x->planecount = 0; goto out;}
//get dimensions/planecount
dimcount = in_minfo.dimcount;
if (dimcount != 2) {
object_post((t_object *)x, "requires matrix dimension equals to 2");
err=JIT_ERR_INVALID_INPUT; goto out;
}
width = in_minfo.dim[0];
height = in_minfo.dim[1];
bytesperrow = in_minfo.dimstride[1];
// check matrix type
if (in_minfo.type != _jit_sym_char) {
object_post((t_object *)x, "requires matrix type is char");
err=JIT_ERR_INVALID_INPUT; goto out;
}
if (in_minfo.planecount != 1) {
object_post((t_object *)x, "requires matrix has just one plane");
err=JIT_ERR_INVALID_INPUT; goto out;
}
openlase_initialize(x, width, height);
openlase_trace(x, width, height, (uint8_t*)in_bp, bytesperrow);
} else {
return JIT_ERR_INVALID_PTR;
}
out:
jit_object_method(in_matrix,_jit_sym_lock,in_savelock);
return err;
}
void oudpsend_printcontents (t_oudpsend *x) {
char *m, buf[100], *p;
int n, i;
m = x->slipibuf;
n = x->icount;
object_post((t_object *)x, "oudpsend_printcontents: buffer %p, size %ld", m, (long) n);
if (n % 4 != 0) {
object_post((t_object *)x, "Hey, the size isn't a multiple of 4!");
} else {
for (i = 0; i < n; i += 4) {
p = buf;
p += sprintf(p, " %x", m[i]);
if (isprint(m[i])) {
p += sprintf(p, " (%c)", m[i]);
} else {
p += sprintf(p, " ()");
}
p += sprintf(p, " %x", m[i+1]);
if (isprint(m[i+1])) {
p += sprintf(p, " (%c)", m[i+1]);
} else {
p += sprintf(p, " ()");
}
p += sprintf(p, " %x", m[i+2]);
if (isprint(m[i+2])) {
p += sprintf(p, " (%c)", m[i+2]);
} else {
p += sprintf(p, " ()");
}
p += sprintf(p, " %x", m[i+3]);
if (isprint(m[i+3])) {
p += sprintf(p, " (%c)", m[i+3]);
} else {
p += sprintf(p, " ()");
}
*p = '\0';
object_post((t_object *)x, buf);
}
}
}
void iterator_bang(t_iterator *x)
{
t_object *jp;
t_object *jb;
t_object *mybox;
t_object *o;
t_rect jr;
t_symbol *scriptingname;
t_max_err err;
// get the object's parent patcher
err = object_obex_lookup(x, gensym("#P"), (t_object **)&jp);
if (err != MAX_ERR_NONE)
return;
// get the object's wrapping box
err = object_obex_lookup(x, gensym("#B"), (t_object **)&mybox);
if (err != MAX_ERR_NONE)
return;
jb = jpatcher_get_firstobject(jp); // get the first BOX in the object list
while(jb) {
jbox_get_patching_rect(jb, &jr); // x, y, width, height (double)
object_post((t_object *)x, "found an object at %ld %ld, w %ld, h %ld", (long)jr.x, (long)jr.y, (long)jr.width, (long)jr.height);
scriptingname = jbox_get_varname(jb); // scripting name
if (scriptingname && scriptingname != gensym(""))
object_post((t_object *)x, " it is named %s...", scriptingname->s_name);
o = jbox_get_object(jb); // get the box's object (b_firstin in Max4)
post(" it's a(n) %s object...", object_classname(o)->s_name);
if (jpatcher_is_patcher(o)) {
post(" which is some kind of a patcher. we could recurse here...");
}
if (jb == mybox)
post(" ...and it's me!");
jb = jbox_get_nextobject(jb); // iterate
}
// jbox_get_patcher(abox); // get a box's patcher
// maybe upwards? jpatcher_get_parentpatcher(<#t_object * p#>)
}
TTErr makeInternals_data(TTPtr self, TTAddress address, TTSymbol name, t_symbol *callbackMethod, TTPtr context, TTSymbol service, TTObject& returnedData, TTBoolean deferlow)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue baton, v, out;
TTAddress dataAddress, dataRelativeAddress;
TTNodePtr dataNode;
returnedData = TTObject(kTTSym_Data, service);
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnedData.set(kTTSym_baton, baton);
returnedData.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
// absolute registration
dataAddress = address.appendAddress(TTAddress(name));
v = TTValue(dataAddress, returnedData, context);
out = MaxApplication.send("ObjectRegister", v);
// retreive relative effective address
dataAddress = out[0];
dataNode = TTNodePtr((TTPtr)out[1]);
dataNode->getAddress(dataRelativeAddress, address);
// absolute registration case : set the address in second position (see in unregister method)
v = TTValue(returnedData, dataAddress);
x->internals->append(dataRelativeAddress, v);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" %s at : %s", dataRelativeAddress.c_str(), service.c_str(), dataAddress.c_str());
return kTTErrNone;
}
void *SDIFlistpoke_new(t_symbol *dummy, short argc, t_atom *argv) {
SDIFlistpoke *x;
// post("SDIFlistpoke_new: %s, %ld args", s->s_name, (long) argc);
x = object_alloc(SDIFlistpoke_class);
if(!x){
return NULL;
}
x->t_errorreporting = 0;
x->t_buffer = 0;
// x->t_out = bangout(x);
if (argc >= 1) {
// First argument is name of SDIF-buffer
if (argv[0].a_type != A_SYM) {
object_post((t_object *)x, "¥ SDIF-tuples: argument must be name of an SDIF-buffer");
} else {
// post("* You want SDIF-buffer %s", argv[0].a_w.w_sym->s_name);
x->t_bufferSym = argv[0].a_w.w_sym;
}
}
x->t_mainMatrix = 1;
x->t_time = 0.0;
x->t_num_columns = 1;
return (x);
}
// Method for list input (converts a list of bits into a long)
void bits_list(t_bits *x, t_symbol *msg, short argc, t_atom *argv)
{
int i, j; // counters
long val = 0; // Our bit-constructed number
long temp;
Atom templist[3]; // used in matrixctrl mode
if(x->mode==ps_bits2ints){ // *** BIT-LIST TO INTEGER(LIST) MODE ***
for(i=(argc - 1); i>=0; i--){
temp = argv[i].a_w.w_long;
val |= temp<<(argc-(i+1)); // bit shift, then or it with the val
}
outlet_int(x->my_outlet[0], val); // spit it out
}
else if(x->mode==ps_matrixctrl2ints){ // *** MATRIX-CTRL TO INTEGER-LIST MODE ***
object_post((t_object *)x, "tap.bits: This mode is not yet implemented");
}
else if(x->mode==ps_ints2matrixctrl){ // *** INTEGER-LIST TO MATRIX-CTRL MODE ***
for(j=0; j<argc; j++){
atom_setlong(templist+1, j); // Store the row in the output list
temp = argv[j].a_w.w_long; // Get the value in the input list (for the moment we assume it is an int - should also handle floats)
for(i=0; i < x->matrix_width; i++){
atom_setlong(templist+0, i); // Store the column in the output list
atom_setlong(templist+2, 1 & temp); // Store the switch value in the output list
temp = temp>>1; // Bit shift to the next one
outlet_list(x->my_outlet[0], 0L, 3, templist); // output the result
}
}
}
else // use the Jitter attribute dumpout outlet to report an error
/* The initialization routine *************************************************/
int C74_EXPORT main()
{
/* Initialize the class */
bed_class = class_new("bed",
(method)bed_new,
(method)bed_free,
(long)sizeof(t_bed), 0, A_GIMME, 0);
/* Bind the object-specific methods */
class_addmethod(bed_class, (method)bed_info, "info", 0);
class_addmethod(bed_class, (method)bed_dblclick, "dblclick", A_CANT, 0);
class_addmethod(bed_class, (method)bed_bufname, "name", A_SYM, 0);
class_addmethod(bed_class, (method)bed_normalize, "normalize", A_GIMME, 0);
class_addmethod(bed_class, (method)bed_fadein, "fadein", A_FLOAT, 0);
class_addmethod(bed_class, (method)bed_fadeout, "fadeout", A_FLOAT, 0);
class_addmethod(bed_class, (method)bed_cut, "cut", A_FLOAT, A_FLOAT, 0);
class_addmethod(bed_class, (method)bed_paste, "paste", A_SYM, 0);
class_addmethod(bed_class, (method)bed_reverse, "reverse", 0);
class_addmethod(bed_class, (method)bed_ring_modulation, "ring", A_FLOAT, 0);
class_addmethod(bed_class, (method)bed_shuffle_n_segments, "shuffle_n", A_LONG, 0);
class_addmethod(bed_class, (method)bed_undo, "undo", 0);
/* Register the class with Max */
class_register(CLASS_BOX, bed_class);
/* Print message to Max window */
object_post(NULL, "bed • External was loaded");
/* Return with no error */
return 0;
}
static void SDIFlistpoke_numcolumns(SDIFlistpoke *x, long n) {
if (n <= 0) {
object_post((t_object *)x, "¥ SDIF-listpoke: numcolumns: number must be non-negative");
} else {
x->t_num_columns = n;
}
}
/**
* Print the port names to the Max console
*/
void printPorts() {
object_post((t_object *)this, "MIDI input Port count: %u", numInPorts);
for( portmap::iterator iter=inPortMap.begin(); iter!=inPortMap.end(); iter++ ) {
t_symbol *portName = (*iter).first;
object_post((t_object *)this, "input %u: %s", (*iter).second, *portName);
}
object_post((t_object *)this, " ");
object_post((t_object *)this, "MIDI output port count: %u", numOutPorts);
for( portmap::iterator iter=outPortMap.begin(); iter!=outPortMap.end(); iter++ ) {
t_symbol* portName = (*iter).first;
object_post((t_object *)this, "output %u: %s", (*iter).second, *portName);
}
}
void openlase_initialize(t_jit_openlase_trace *x, int width, int height)
{
if (x->initialized) {
return;
}
//object_post((t_object *)x, "openlase_initialize enter");
if(olInit(FRAMES_BUF, 300000) < 0) {
object_post((t_object *)x, "failed to initialize OpenLase");
return;
}
float overscan = x->overscan;
float aspect = x->aspect;
float snap_pix = x->snap_pix;
//float framerate = 30;
x->tparams.mode = OL_TRACE_THRESHOLD;
x->tparams.sigma = 0;
x->tparams.threshold2 = 50;
//x->tparams.mode = OL_TRACE_CANNY;
x->tparams.sigma = 1;
if (aspect == 0)
aspect = (float)width / height;
// if (framerate == 0)
// framerate = (float)pFormatCtx->streams[videoStream]->r_frame_rate.num / (float)pFormatCtx->streams[videoStream]->r_frame_rate.den;
float iaspect = 1/aspect;
if (aspect > 1) {
olSetScissor(-1, -iaspect, 1, iaspect);
olScale(1, iaspect);
} else {
olSetScissor(-aspect, -1, aspect, 1);
olScale(aspect, 1);
}
olScale(1+overscan, 1+overscan);
olTranslate(-1.0f, 1.0f);
olScale(2.0f/width, -2.0f/height);
int maxd = width > height ? width : height;
x->params.snap = (snap_pix*2.0)/(float)maxd;
//float frametime = 1.0f/framerate;
olSetRenderParams(&x->params);
x->tparams.width = width,
x->tparams.height = height,
olTraceInit(&x->trace_ctx, &x->tparams);
//object_post((t_object *)x, "openlase initialized");
x->initialized = true;
}
void breakgen_setfreq(t_breakgen *x, double f)
{
if (f > 0.0) {
x->freq = f;
}
object_post((t_object *)x, "Frequency set to %f", x->freq);
}
void breakgen_setconstsig(t_breakgen *x, double f)
{
if (f > 0.0) {
x->constval = f;
}
object_post((t_object *)x, "Constant signal value set to %f", x->constval);
}
TTErr makeInternals_receiver(TTPtr self, TTAddress address, TTSymbol name, t_symbol *callbackMethod, TTObject& returnedReceiver, TTBoolean deferlow, TTBoolean appendNameAsAttribute)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTValue v, args, baton;
TTObject returnValueCallback, empty;
TTAddress adrs;
// check the internals do not exist yet
if (!x->internals->lookup(name, v)) {
returnedReceiver = v[0];
JamomaDebug object_post((t_object*)x, "makeInternals_receiver : \"%s\" internal already exists", name.c_str());
returnedReceiver.send("Get");
return kTTErrNone;
}
// prepare arguments
// we don't want the address back
args.append(empty);
returnValueCallback = TTObject("callback");
baton = TTValue(TTPtr(x), TTPtr(callbackMethod), deferlow);
returnValueCallback.set(kTTSym_baton, baton);
returnValueCallback.set(kTTSym_function, TTPtr(&jamoma_callback_return_value));
args.append(returnValueCallback);
returnedReceiver = TTObject(kTTSym_Receiver, args);
// edit address
if (appendNameAsAttribute)
adrs = address.appendAttribute(name);
else
adrs = address.appendAddress(TTAddress(name.c_str()));
// default registration case : store object only (see in unregister method)
x->internals->append(name, returnedReceiver);
// set address attribute (after registration as the value can be updated in the same time)
returnedReceiver.set(kTTSym_address, adrs);
JamomaDebug object_post((t_object*)x, "makes internal \"%s\" receiver to bind on : %s", name.c_str(), adrs.c_str());
return kTTErrNone;
}
void wrappedClass_anything(WrappedInstancePtr self, t_symbol* s, long argc, t_atom* argv)
{
TTValue v;
TTSymbol ttName;
t_max_err err;
err = hashtab_lookup(self->wrappedClassDefinition->maxNamesToTTNames, s, (t_object**)&ttName);
if (err) {
object_post(SELF, "no method found for %s", s->s_name);
return;
}
if (argc && argv) {
TTValue v;
v.resize(argc);
for (long i=0; i<argc; i++) {
if (atom_gettype(argv+i) == A_LONG)
v[i] = (TTInt32)atom_getlong(argv+i);
else if (atom_gettype(argv+i) == A_FLOAT)
v[i] = atom_getfloat(argv+i);
else if (atom_gettype(argv+i) == A_SYM)
v[i] = TT(atom_getsym(argv+i)->s_name);
else
object_error(SELF, "bad type for message arg");
}
self->graphObject->mKernel.send(ttName, v, v); // FIXME: TEMPORARY HACK WHILE WE TRANSITION FROM 1-ARG MESSAGES to 2-ARG MESSAGES
// process the returned value for the dumpout outlet
{
long ac = v.size();
if (ac) {
t_atom* av = (t_atom*)malloc(sizeof(t_atom) * ac);
for (long i=0; i<ac; i++) {
if (v[i].type() == kTypeSymbol) {
TTSymbol ttSym = v[i];
atom_setsym(av+i, gensym((char*)ttSym.c_str()));
}
else if (v[i].type() == kTypeFloat32 || v[i].type() == kTypeFloat64) {
TTFloat64 f = v[i];
atom_setfloat(av+i, f);
}
else {
TTInt32 l = v[i];
atom_setfloat(av+i, l);
}
}
object_obex_dumpout(self, s, ac, av);
free(av);
}
}
}
else
self->graphObject->mKernel.send(ttName);
}
void breakgen_setsr(t_breakgen *x, double f)
{
if (f > 0.0) {
x->sr = f;
free(x->osc);
x->osc = new_oscil(x->sr);
}
object_post((t_object *)x, "Sampling rate set to %f", x->freq);
}
void dummy_anything(t_dummy *x, t_symbol *s, long ac, t_atom *av)
{
if (s == gensym("xyzzy")) {
object_post((t_object *)x, "A hollow voice says 'Plugh'");
} else {
atom_setsym(&x->val, s);
dummy_bang(x);
}
}
void printit_assist (printit *x, void *box, long msg, long arg, char *dstString) {
if (msg==ASSIST_INLET) {
sprintf(dstString, "Anything to print");
} else if (msg==ASSIST_OUTLET) {
sprintf(dstString, "No outlet");
} else {
object_post((t_object *)x, "¥ printit_assist: unrecognized message %ld", msg);
}
}
void *deinterleave_new(
t_symbol *s,
int ac,
t_atom *av)
{
t_deinterleave *x;
//post("Running deinterleave_new");
x = (t_deinterleave *)object_alloc(deinterleave_class);
if(!x){
return NULL;
}
/*
* Deal with arguments.
*/
if (ac == 0)
{
// If no args, then 2 outputs.
x->num_outputs = 2;
}
else if (ac == 1)
{
// If 1 arg, then its value is number of outputs.
x->num_outputs = av[0].a_w.w_long;
}
else
{
// if 2 or more args, then number of args= number of outputs.
x->num_outputs = ac;
}
// Allow 2 to MAX_OUTLETS outputs.
if (x->num_outputs > MAX_OUTLETS) {
object_post((t_object *)x, "deinterleave: can't have more than %ld outlets (compile-time constant MAX_OUTLETS)", MAX_OUTLETS);
x->num_outputs = MAX_OUTLETS;
}
if (x->num_outputs < 2)
x->num_outputs = 2;
// Make outputs (in right to left order) and allocate space to hold output lists
for (int i = x->num_outputs-1; i >= 0; --i) {
x->t_out[i] = listout(x);
x->t_list_out[i] = (t_atom *) getbytes(DEFAULT_MAX_OUTARGS * sizeof(t_atom));
}
// Set output size 0
x->t_outsize = 0;
return(x);
}
static int resolveBufferAndMatrixType(SDIFranges *x, t_symbol *matrixTypeSym, char *matrixType) {
int i;
if (x->t_bufferSym == 0) {
object_post((t_object *)x, "SDIFranges: no SDIF buffer name specified");
return 0;
}
LookupMyBuffer(x);
if (x->t_buffer == 0) {
object_post((t_object *)x, "¥ SDIFranges: \"%s\" is not an SDIF buffer.", x->t_bufferSym->s_name);
return 0;
}
if (matrixTypeSym->s_name[0] == '\0') {
// Use "main matrix": the one whose type is the same as the frame type
SDIFmem_Frame f;
if((f = SDIFbuf_GetFirstFrame(x->t_buf)) == NULL) {
object_post((t_object *)x, NAME ": SDIF-buffer %s is empty", x->t_bufferSym->s_name);
return 0;
} else {
SDIF_Copy4Bytes(matrixType, f->header.frameType);
}
} else {
// Look at user-supplied matrix type
for (i = 1; i < 4; ++i) {
if (matrixTypeSym->s_name[i] == '\0') {
error(NAME ": error: maxcolumns' matrix type argument \"%s\" is less than 4 characters.",
matrixTypeSym->s_name);
return 0;
}
}
SDIF_Copy4Bytes(matrixType, matrixTypeSym->s_name);
if (matrixTypeSym->s_name[4] != '\0') {
post("¥ " NAME ": warning: truncating maxcolumns' matrix type argument to \"%c%c%c%c\".",
matrixType[0], matrixType[1], matrixType[2], matrixType[3]);
}
}
return 1;
}
