JamomaError RampLib::createUnit(const TTSymbol* unitName, RampUnit **unit, RampUnitCallback callback, void* baton)
{
TTValue v;
v.setSize(2);
v.set(0, TTPtr(callback));
v.set(1, TTPtr(baton));
// These should be alphabetized
if (unitName == TT("async"))
TTObjectInstantiate(TT("AsyncRamp"), (TTObjectPtr*)unit, v);
//*unit = (RampUnit*) new AsyncRamp(callback, baton);
else if (unitName == TT("none"))
TTObjectInstantiate(TT("NoneRamp"), (TTObjectPtr*)unit, v);
// *unit = (RampUnit*) new NoneRamp(callback, baton);
else if (unitName == TT("queue"))
TTObjectInstantiate(TT("QueueRamp"), (TTObjectPtr*)unit, v);
// *unit = (RampUnit*) new QueueRamp(callback, baton);
else if (unitName == TT("scheduler"))
TTObjectInstantiate(TT("SchedulerRamp"), (TTObjectPtr*)unit, v);
// *unit = (RampUnit*) new SchedulerRamp(callback, baton);
else {
// Invalid function specified default to linear
error("Jamoma RampLib: Invalid RampUnit ( %s ) specified", (char*)unitName);
TTObjectInstantiate(TT("NoneRamp"), (TTObjectPtr*)unit, v);
// *unit = (RampUnit*) new NoneRamp(callback, baton);
}
return JAMOMA_ERR_NONE;
}
TTErr TTScoreTimeProcessCreate(TTTimeProcessPtr *timeProcess, const std::string timeProcessClass, TTTimeEventPtr startEvent, TTTimeEventPtr endEvent, TTTimeContainerPtr timeContainer)
{
TTValue args;
*timeProcess = NULL;
if (timeContainer) {
TTValue out;
TTErr err;
args = TTSymbol(timeProcessClass);
args.append(TTObjectBasePtr(startEvent));
args.append(TTObjectBasePtr(endEvent));
err = timeContainer->sendMessage(TTSymbol("TimeProcessCreate"), args, out);
if (!err)
*timeProcess = TTTimeProcessPtr(TTObjectBasePtr(out[0]));
return err;
}
else {
args = TTObjectBasePtr(startEvent);
args.append(TTObjectBasePtr(endEvent));
return TTObjectBaseInstantiate(timeProcessClass.c_str(), TTObjectBaseHandle(timeProcess), args);
}
}
t_unpack* UnpackNew(t_symbol *msg, long argc, t_atom* argv)
{
t_unpack* self;
TTValue sr(sys_getsr());
long attrstart = attr_args_offset(argc, argv); // support normal arguments
short i;
TTValue v;
TTErr err;
self = (t_unpack*)object_alloc(sUnpackClass);
if (self) {
self->maxNumChannels = 2; // An initial argument to this object will set the maximum number of channels
if (attrstart && argv)
self->maxNumChannels = atom_getlong(argv);
ttEnvironment->setAttributeValue(kTTSym_sampleRate, sr);
v.resize(2);
v[0] = "thru";
v[1] = 1; // arg is the number of inlets
err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v);
//self->audioGraphObject->getUnitGenerator()->setAttributeValue(TT("linearGain"), 1.0);
attr_args_process(self, argc, argv);
object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL)); // dumpout
dsp_setup((t_pxobject*)self, 1);
for (i=0; i < self->maxNumChannels; i++)
outlet_new((t_pxobject*)self, "signal");
self->qelem = qelem_new(self, (method)UnpackQFn);
self->obj.z_misc = Z_NO_INPLACE | Z_PUT_LAST;
}
return self;
}
InfoPtr InfoNew(t_symbol* msg, long argc, t_atom* argv)
{
InfoPtr self;
TTValue v;
TTErr err;
self = InfoPtr(object_alloc(sInfoClass));
if (self) {
object_obex_store((TTPtr)self, _sym_dumpout, (t_object*)outlet_new(self, NULL));
self->outletNumChannels = outlet_new((t_pxobject*)self, 0);
self->outletVectorSize = outlet_new((t_pxobject*)self, 0);
self->outletSampleRate = outlet_new((t_pxobject*)self, 0);
self->outletSmartSignal = outlet_new((t_pxobject*)self, "audio.connect");
self->qelem = qelem_new(self, (method)InfoQfn);
v.resize(2);
v[0] = "thru";
v[1] = 1; // we set it up with 1 inlet, and later modify to 2 inlets if the connection is made
err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v);
if (!self->audioGraphObject->getUnitGenerator().valid()) {
object_error(SELF, "cannot load Jamoma DSP object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
UnpackPtr UnpackNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
UnpackPtr self;
TTValue v;
TTErr err;
self = UnpackPtr(object_alloc(sUnpackClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (ObjectPtr)outlet_new(self, NULL)); // dumpout
self->graphOutlets[0] = outlet_new(self, NULL);
v.setSize(2);
v.set(0, TT("graph.output"));
v.set(1, TTUInt32(1));
err = TTObjectInstantiate(TT("graph.object"), (TTObjectPtr*)&self->graphObject, v);
if (!self->graphObject->mKernel) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
err = TTObjectInstantiate(TT("Callback"), (TTObjectPtr*)&self->callback, kTTValNONE);
self->callback->setAttributeValue(TT("Function"), TTPtr(&UnpackGraphCallback));
self->callback->setAttributeValue(TT("Baton"), TTPtr(self));
// dynamically add a message to the callback object so that it can handle the 'dictionaryReceived' notification
self->callback->registerMessage(TT("dictionaryReceived"), (TTMethod)&TTCallback::notify, kTTMessagePassValue);
// tell the graph object that we want to watch it
self->graphObject->mKernel->registerObserverForNotifications(*self->callback);
attr_args_process(self, argc, argv);
}
return self;
}
PlugOutPtr PlugOutNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
PlugOutPtr self = PlugOutPtr(object_alloc(sPlugOutClass));
TTValue v;
TTErr err;
if (self) {
v.setSize(2);
v.set(0, TT("plugtastic.output"));
v.set(1, 2);
err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v);
v = TTPtr(self->audioGraphObject);
object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL));
self->audioGraphOutlet = outlet_new(self, "audio.connect");
self->qelem = qelem_new(self, (method)PlugOutQFn);
object_obex_lookup(self, GENSYM("#P"), &self->patcher);
self->pluginName = object_attr_getsym(self->patcher, _sym_name);
self->pluginVersion = GENSYM("1.0");
self->pluginVersionHex = GENSYM("0x00010000");
self->pluginManufacturer = GENSYM("Plugtastic");
self->pluginManufacturerCode = GENSYM("74Ob");
self->pluginID = GENSYM("ftmp");
attr_args_process(self, argc, argv);
}
return self;
}
void CMYUnit::convertFromNeutral(const TTValue& input, TTValue& output)
{
output.setSize(3);
output.set(0, 255 * (1 - input.getFloat64(0)));
output.set(1, 255 * (1 - input.getFloat64(1)));
output.set(2, 255 * (1 - input.getFloat64(2)));
}
t_max_err wrappedClass_attrSet(WrappedInstancePtr self, t_object* attr, long argc, t_atom* argv)
{
if (argc && argv) {
t_symbol* attrName = (t_symbol*)object_method(attr, _sym_getname);
TTValue v;
long i;
t_max_err err;
TTPtr ptr;
err = hashtab_lookup(self->wrappedClassDefinition->maxNamesToTTNames, attrName, (t_object**)&ptr);
if (err)
return err;
TTSymbol ttAttrName(ptr);
v.resize(argc);
for (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 attribute setter");
}
self->graphObject->mKernel.set(ttAttrName, v);
return MAX_ERR_NONE;
}
return MAX_ERR_GENERIC;
}
OpPtr OpNew(SymbolPtr msg, AtomCount argc, AtomPtr argv)
{
OpPtr self;
TTValue v;
TTErr err;
self = OpPtr(object_alloc(sOpClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (ObjectPtr)outlet_new(self, NULL)); // dumpout
self->outlet = outlet_new(self, "audio.connect");
self->inlet = proxy_new(self, 1, &self->inletnum);
v.setSize(2);
v.set(0, TT("operator"));
v.set(1, TTUInt32(1)); // we set it up with 1 inlet, and later modify to 2 inlets if the connection is made
err = TTObjectInstantiate(TT("audio.object"), (TTObjectPtr*)&self->audioGraphObject, v);
if (!self->audioGraphObject->getUnitGenerator()) {
object_error(SELF, "cannot load Jamoma DSP object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
void PackAnything(PackPtr self, t_symbol* s, long ac, t_atom* ap)
{
TTValue v;
v.resize(ac+1);
if (ac > 0) {
self->graphDictionary->setSchema(TT("array"));
v[0] = TT(s->s_name);
for (int i=0; i<ac; i++) {
switch (atom_gettype(ap+i)) {
case A_LONG:
v[i+1] = (int)atom_getlong(ap+i);
break;
case A_FLOAT:
v[i+1] = atom_getfloat(ap+i);
break;
case A_SYM:
v[i+1] = TT(atom_getsym(ap+i)->s_name);
break;
default:
break;
}
}
}
else {
self->graphDictionary->setSchema(TT("symbol"));
v[0] = TT(s->s_name);
}
self->graphDictionary->setValue(v);
((TTGraphInput*)self->graphObject->mKernel.instance())->push(*self->graphDictionary);
}
PackPtr PackNew(t_symbol* msg, long argc, t_atom* argv)
{
PackPtr self;
TTValue v;
TTErr err;
self = PackPtr(object_alloc(sPackClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (t_object*)outlet_new(self, NULL));
self->graphOutlets[0] = outlet_new(self, "graph.connect");
v.resize(2);
v[0] = "graph.input";
v[1] = 1;
err = TTObjectBaseInstantiate(TT("graph.object"), (TTObjectBasePtr*)&self->graphObject, v);
((TTGraphInput*)self->graphObject->mKernel.instance())->setOwner(self->graphObject);
if (!self->graphObject->mKernel.valid()) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
self->graphDictionary = new TTDictionary;
self->graphDictionary->setSchema(TT("none"));
self->graphDictionary->append(TT("outlet"), 0);
attr_args_process(self, argc, argv);
self->qelem = qelem_new(self, (method)PackQFn);
// PackStartTracking(self);
defer_low(self, (method)PackStartTracking, NULL, 0, NULL);
}
return self;
}
MaxErr OpGetOperand(OpPtr self, ObjectPtr attr, AtomCount* argc, AtomPtr* argv)
{
TTValue v;
self->audioGraphObject->getUnitGenerator()->getAttributeValue(TT("operand"), v);
*argc = v.getSize();
if (!(*argv)) // otherwise use memory passed in
*argv = (t_atom *)sysmem_newptr(sizeof(t_atom) * v.getSize());
for (int i=0; i<v.getSize(); i++) {
if(v.getType(i) == kTypeFloat32 || v.getType(i) == kTypeFloat64){
TTFloat64 value;
v.get(i, value);
atom_setfloat(*argv+i, value);
}
else if(v.getType(i) == kTypeSymbol){
TTSymbol value;
v.get(i, value);
atom_setsym(*argv+i, gensym((char*)value.c_str()));
}
else{ // assume int
TTInt32 value;
v.get(i, value);
atom_setlong(*argv+i, value);
}
}
return MAX_ERR_NONE;
}
void data_list(TTPtr self, t_symbol *msg, long argc, const t_atom *argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTObject o;
if (!x->internals->isEmpty()) {
// send to each data
if (x->arrayIndex == 0) {
TTValue keys;
x->internals->getKeys(keys);
for (TTUInt32 i = 0; i < keys.size(); i++) {
x->cursor = keys[i];
o = selectedObject;
jamoma_data_command(o, msg, argc, argv);
}
// watch an instance by default
x->cursor = keys[0];
}
else {
o = selectedObject;
jamoma_data_command(o, msg, argc, argv);
}
}
else
object_error((t_object*)x, "list : the array is empty");
}
TTErr TTSampleMatrix::load(const TTValue& input, TTValue& unusedOutput)
{
/* * *
Beware this method is still in progress
It will eventually work with the TTSoundfileLoader class
* * */
TTValue inputWithPointerPrepended = input;
TTObjectBase* objectBasePtrToSampleMatrix = (TTObjectBase*)(TTPtr(this));
inputWithPointerPrepended.prepend(objectBasePtrToSampleMatrix);
try {
// first instantiate the SoundfileLoader object
TTAudioObject fileToLoad("soundfile.loader");
if (fileToLoad.valid())
// then pass along the updated TTValue to its load() method
return fileToLoad.send("load", inputWithPointerPrepended);
else
return kTTErrInstantiateFailed;
}
catch (...) {
return kTTErrInstantiateFailed;
}
}
TTErr
DemoAppDataReturnValueCallback(const TTValue& baton, const TTValue& value)
{
DemoApp* demoApp = (DemoApp*)TTPtr(baton[0]);
TTObject anObject = baton[1];
// Reteive which data has been updated
if (anObject.instance() == demoApp->mDataDemoParameter.instance()) {
// print the returned value
TTLogMessage("/myParameter has been updated to %s \n", value.toString().data());
return kTTErrNone;
}
if (anObject.instance() == demoApp->mDataDemoMessage.instance()) {
// print the returned value
TTLogMessage("/myMessage has been updated to %s \n", value.toString().data());
return kTTErrNone;
}
if (anObject.instance() == demoApp->mDataDemoReturn.instance()) {
// print the returned value
TTLogMessage("/myReturn has been updated to %s \n", value.toString().data());
return kTTErrNone;
}
return kTTErrGeneric;
}
AppendPtr AppendNew(t_symbol* msg, long argc, t_atom* argv)
{
AppendPtr self;
TTValue v;
TTErr err;
self = AppendPtr(object_alloc(sAppendClass));
if (self) {
object_obex_store((void*)self, _sym_dumpout, (t_object*)outlet_new(self, NULL)); // dumpout
self->graphOutlets[0] = outlet_new(self, "graph.connect");
v.resize(2);
v[0] = "dictionary.append";
v[1] = 1;
err = TTObjectBaseInstantiate(TT("graph.object"), (TTObjectBasePtr*)&self->graphObject, v);
if (!self->graphObject->mKernel.valid()) {
object_error(SELF, "cannot load Jamoma object");
return NULL;
}
attr_args_process(self, argc, argv);
}
return self;
}
int main(int argc, const char * argv[])
{
std::cout << "BEGIN testing for Jamoma DSP...\n";
TTDSPInit();
TTValue classNames;
// if the follow group tag is present within the thisTTClassTags definition, the class will be tested
TTValue testClassesWithTheseTags(TT("dspLibrary"));
TTObject::GetRegisteredClassNamesForTags(classNames, testClassesWithTheseTags);
for (int i=0; i<classNames.size(); i++) {
TTSymbol name = classNames[i];
TTObject obj(name);
try {
TTObject obj(name);
std::cout << "TESTING " << name.string() << std::endl;
obj.send("test");
}
catch (...) {
TTLogMessage("UnitTest Failure to instantiate object of class %s! \n", name.c_str());
continue;
}
}
std::cout << "END testing of Jamoma DSP!\n";
return 0;
}
void CMYUnit::convertToNeutral(const TTValue& input, TTValue& output)
{
output.setSize(3);
output.set(0, (255 - input.getFloat64(0)) * inv255);
output.set(1, (255 - input.getFloat64(1)) * inv255);
output.set(2, (255 - input.getFloat64(2)) * inv255);
}
void RGB8Unit::convertFromNeutral(const TTValue& input, TTValue& output)
{
output.setSize(3);
output.set(0, input.getFloat64(0)*255);
output.set(1, input.getFloat64(1)*255);
output.set(2, input.getFloat64(2)*255);
}
void HSVUnit::convertToNeutral(const TTValue& input, TTValue& output)
{
double h = input.getFloat64(0)/360.;
double s = input.getFloat64(1)/100.;
double v = input.getFloat64(2)/100.;
double r, g, b;
//double h1, a[7], q, f;
if ( s == 0 )
{
r = v;
g = v;
b = v;
}
else
{
double var_h = h * 6;
double var_i = floor( var_h );
double var_1 = v * ( 1 - s );
double var_2 = v * ( 1 - s * ( var_h - var_i ) );
double var_3 = v * ( 1 - s * ( 1 - ( var_h - var_i ) ) );
if ( var_i == 0 ) { r = v ; g = var_3 ; b = var_1; }
else if ( var_i == 1 ) { r = var_2 ; g = v ; b = var_1; }
else if ( var_i == 2 ) { r = var_1 ; g = v ; b = var_3; }
else if ( var_i == 3 ) { r = var_1 ; g = var_2 ; b = v; }
else if ( var_i == 4 ) { r = var_3 ; g = var_1 ; b = v; }
else { r = v ; g = var_1 ; b = var_2; }
}
output.setSize(3);
output.set(0, r);
output.set(1, g);
output.set(2, b);
}
void WrappedInputClass_new(TTPtr self, AtomCount argc, AtomPtr argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
TTString sInstance;
TTValue v;
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
// Get input instance symbol
if (attrstart && argv) {
jamoma_ttvalue_from_Atom(v, _sym_nothing, attrstart, argv);
v.toString();
sInstance = TTString(v[0]);
EXTRA->instance = TTSymbol(sInstance.data());
}
else
EXTRA->instance = kTTSymEmpty;
// Create Input Object and one outlet
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr));
#ifdef JCOM_IN_TILDE
jamoma_input_create_audio((ObjectPtr)x, &x->wrappedObject);
dsp_setup((t_pxobject *)x, 1);
x->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST;
outlet_new((t_pxobject *)x, "signal");
// Prepare memory to store internal datas
x->internals = new TTHash();
// Prepare extra data for envelope tracking
EXTRA->clock = NULL;
EXTRA->pollInterval = 0; // not active by default
EXTRA->meter = 0.;
EXTRA->peak = 0.;
#else
jamoma_input_create((ObjectPtr)x, &x->wrappedObject);
x->outlets[0] = outlet_new(x, 0L);
#endif
// handle attribute args
attr_args_process(x, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
defer_low((ObjectPtr)x, (method)in_subscribe, NULL, 0, NULL);
}
void RampLib::getUnitNames(TTValue& unitNames)
{
unitNames.clear();
unitNames.append(TT("async"));
unitNames.append(TT("none"));
unitNames.append(TT("queue"));
unitNames.append(TT("scheduler"));
}
void WrappedOutputClass_new(TTPtr self, long argc, t_atom* argv)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
TTString sInstance;
TTValue v;
// Prepare extra data
x->extra = (t_extra*)malloc(sizeof(t_extra));
// Get input instance symbol
if (attrstart && argv) {
jamoma_ttvalue_from_Atom(v, _sym_nothing, attrstart, argv);
v.toString();
sInstance = TTString(v[0]);
EXTRA->instance = TTSymbol(sInstance.data());
}
else
EXTRA->instance = kTTSymEmpty;
// Create Input Object and one outlet
x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr));
#ifdef J_OUT_TILDE
jamoma_output_create_audio((t_object*)x, x->wrappedObject);
dsp_setup((t_pxobject *)x, 1);
x->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST;
outlet_new((t_pxobject *)x, "signal");
#endif
#ifdef J_OUT_MULTI
jamoma_output_create_audio((t_object*)x, x->wrappedObject);
x->outlets[0] = outlet_new(x, 0L);
#endif
#ifndef J_OUT_TILDE
#ifndef J_OUT_MULTI
jamoma_output_create((t_object*)x, x->wrappedObject);
x->outlets[0] = outlet_new((t_object*)x, 0L);
#endif
#endif
// handle attribute args
attr_args_process(x, argc, argv);
// The following must be deferred because we have to interrogate our box,
// and our box is not yet valid until we have finished instantiating the object.
// Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
// out_subscribe(x);
// defer_low((t_object*)x, (method)out_subscribe, NULL, 0, NULL);
}
TTErr TTValueFromAtoms(TTValue& v, long ac, t_atom* av)
{
v.clear();
// For now we assume floats for speed (e.g. in the performance sensitive j.unit object)
for (int i=0; i<ac; i++)
v.append((TTFloat64)atom_getfloat(av+i));
return kTTErrNone;
}
// C Callback from any Graph Source objects we are observing
void UnpackGraphCallback(UnpackPtr self, TTValue& arg)
{
TTDictionaryPtr aDictionary = NULL;
TTValue v;
long ac;
t_atom* ap;
TTBoolean firstItemASymbol = NO;
TTSymbol firstItem;
//arg.get(0, (TTPtr*)(&aDictionary));
aDictionary = (TTDictionaryPtr)(TTPtr)arg[0];
aDictionary->getValue(v);
ac = v.size();
if (ac) {
ap = new t_atom[ac];
for (int i=0; i<ac; i++) {
if (v[i].type() == kTypeInt8 ||
v[i].type() == kTypeUInt8 ||
v[i].type() == kTypeInt16 ||
v[i].type() == kTypeUInt16 ||
v[i].type() == kTypeInt32 ||
v[i].type() == kTypeUInt32 ||
v[i].type() == kTypeInt64 ||
v[i].type() == kTypeUInt64)
{
TTInt32 ival;
ival = v[i];
atom_setlong(ap+i, ival);
}
else if (v[i].type() == kTypeFloat32 || v[i].type() == kTypeFloat64)
{
atom_setfloat(ap+i, v[i]);
}
else if (v[i].type() == kTypeSymbol)
{
TTSymbol s;
s = v[i];
atom_setsym(ap+i, gensym((char*)s.c_str()));
if (i==0) {
firstItemASymbol = YES;
firstItem = s;
}
}
}
if (firstItemASymbol)
outlet_anything(self->graphOutlets[0], gensym((char*)firstItem.c_str()), ac-1, ap+1);
else if (ac == 1)
outlet_float(self->graphOutlets[0], atom_getfloat(ap));
else
outlet_anything(self->graphOutlets[0], _sym_list, ac, ap);
delete ap;
}
}
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);
}
ObjectPtr wrappedClass_new(SymbolPtr name, AtomCount argc, AtomPtr argv)
{
WrappedClass* wrappedMaxClass = NULL;
WrappedInstancePtr self = NULL;
TTValue v;
TTErr err = kTTErrNone;
TTUInt8 numInputs = 1;
TTUInt8 numOutputs = 1;
long attrstart = attr_args_offset(argc, argv); // support normal arguments
// Find the WrappedClass
hashtab_lookup(wrappedMaxClasses, name, (ObjectPtr*)&wrappedMaxClass);
// If the WrappedClass has a validity check defined, then call the validity check function.
// If it returns an error, then we won't instantiate the object.
if (wrappedMaxClass) {
if (wrappedMaxClass->validityCheck)
err = wrappedMaxClass->validityCheck(wrappedMaxClass->validityCheckArgument);
else
err = kTTErrNone;
}
else
err = kTTErrGeneric;
if (!err)
self = (WrappedInstancePtr)object_alloc(wrappedMaxClass->maxClass);
if (self){
if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(TT("argumentDefinesNumInlets"), v)) {
long argumentOffsetToDefineTheNumberOfInlets = v;
if ((attrstart-argumentOffsetToDefineTheNumberOfInlets > 0) && argv+argumentOffsetToDefineTheNumberOfInlets)
numInputs = atom_getlong(argv+argumentOffsetToDefineTheNumberOfInlets);
}
for (TTUInt16 i=numInputs-1; i>0; i--)
self->inlets[i-1] = proxy_new(self, i, NULL);
object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL)); // dumpout
if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(TT("argumentDefinesNumOutlets"), v)) {
long argumentOffsetToDefineTheNumberOfOutlets = v;
if ((attrstart-argumentOffsetToDefineTheNumberOfOutlets > 0) && argv+argumentOffsetToDefineTheNumberOfOutlets)
numOutputs = atom_getlong(argv+argumentOffsetToDefineTheNumberOfOutlets);
}
for (TTInt16 i=numOutputs-1; i>=0; i--)
self->audioGraphOutlets[i] = outlet_new(self, "audio.connect");
self->wrappedClassDefinition = wrappedMaxClass;
v.setSize(3);
v.set(0, wrappedMaxClass->ttClassName);
v.set(1, numInputs);
v.set(2, numOutputs);
err = TTObjectInstantiate(TT("audio.object"), (TTObjectPtr*)&self->audioGraphObject, v);
attr_args_process(self, argc, argv);
}
return ObjectPtr(self);
}
void
DemoApp::SetupScore()
{
TTValue args, out;
TTObject xmlHandler("XmlHandler");
TTLogMessage("\n*** Initialisation of Score environnement ***\n");
/////////////////////////////////////////////////////////////////////
// Init the Score library (passing the folder path where all the dylibs are)
TTScoreInit("/usr/local/jamoma");
TTLogMessage("\n*** Reading of an interactive scenario file ***\n");
/////////////////////////////////////////////////////////////////////
// Create an empty Scenario
mScenario = TTObject("Scenario");
// Read DemoScenario1.score file to fill mScenario
xmlHandler.set("object", mScenario);
xmlHandler.send("Read", "../DemoScenario.score", out);
TTLogMessage("\n*** Prepare scenario observation ***\n");
/////////////////////////////////////////////////////////////////////
// Create a callback for the "EventStatusChanged" notification sent by each event
mEventStatusChangedCallback = TTObject("callback");
mEventStatusChangedCallback.set("baton", TTPtr(this));
mEventStatusChangedCallback.set("function", TTPtr(&DemoAppEventStatusChangedCallback));
mEventStatusChangedCallback.set("notification", TTSymbol("EventStatusChanged"));
// Get all events of the scenario and attach a callback to them
TTValue timeEvents;
mScenario.get("timeEvents", timeEvents);
for (TTElementIter it = timeEvents.begin() ; it != timeEvents.end() ; it++) {
TTObject event = TTElement(*it);
event.registerObserverForNotifications(mEventStatusChangedCallback);
}
TTLogMessage("\n*** Start scenario execution ***\n");
/////////////////////////////////////////////////////////////////////
// Set the execution speed of the scenario
mScenario.set("speed", 2.);
// Start the scenario
mScenario.send("Start");
// Poll Scenario information
mPollingThread = new TTThread(TTThreadCallbackType(DemoAppScenarioPollingThread), this);
}
void TTExpression::parse(TTValue& toParse)
{
// parse address
if (toParse.size() > 0) {
if (toParse[0].type() == kTypeSymbol) {
mAddress = toParse[0];
// parse operator
if (toParse.size() > 1) {
if (toParse[1].type() == kTypeSymbol) {
mOperator = toParse[1];
// we need to use word instead of sign because < and > symbol make trouble for XmlFormat parsing
if (mOperator == TTSymbol("=="))
mOperator = TTSymbol("equal");
else if (mOperator == TTSymbol("!="))
mOperator = TTSymbol("different");
else if (mOperator == TTSymbol(">"))
mOperator = TTSymbol("greaterThan");
else if (mOperator == TTSymbol(">="))
mOperator = TTSymbol("greaterThanOrEqual");
else if (mOperator == TTSymbol("<"))
mOperator = TTSymbol("lowerThan");
else if (mOperator == TTSymbol("<="))
mOperator = TTSymbol("lowerThanOrEqual");
// parse value
if (toParse.size() > 2) {
mValue.copyFrom(toParse, 2);
// convert to TTFloat64 for comparison purpose (see in evaluate method)
if (mValue.size())
{
if (mValue[0].type() != kTypeSymbol)
{
for (TTElementIter it = mValue.begin(); it != mValue.end(); it++)
*it = TTFloat64(TTElement(*it));
}
}
}
}
}
}
}
}
NSPStatus
Namespace::namespaceParameterCreate(std::string address, int instanceNumber, void* object, void (*returnValueCallback) (TTPtr, TTValue&)
, void (*returnAddressCallback)(TTPtr, TTValue&))
{
// Create a TTData
TTDataPtr data = NULL;
TTCallbackPtr p_returnValueCallback, p_returnAddressCallback;
TTValuePtr p_returnValueBaton, p_returnAddressBaton;
// prepare arguments : see TTData.h to know which args are needed
TTValue args;
args.clear();
p_returnValueCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&p_returnValueCallback), kTTValNONE);
p_returnValueBaton = new TTValue(TTPtr(object));
p_returnValueCallback->setAttributeValue(kTTSym_baton, TTPtr(p_returnValueBaton));
p_returnValueCallback->setAttributeValue(kTTSym_function, TTPtr(returnValueCallback));
args.append(p_returnValueCallback);
p_returnAddressCallback = NULL;
TTObjectInstantiate(TTSymbol("callback"), TTObjectHandle(&p_returnAddressCallback), kTTValNONE);
p_returnAddressBaton = new TTValue(TTPtr(object));
p_returnAddressCallback->setAttributeValue(kTTSym_baton, TTPtr(p_returnAddressBaton));
p_returnAddressCallback->setAttributeValue(kTTSym_function, TTPtr(p_returnAddressCallback));
args.append(p_returnAddressCallback);
// Register a TTObject into the NSPDirectory
TTNodePtr returnedNode;
TTBoolean newInstanceCreated;
for (int i = 0; i < instanceNumber; i++) {
data = NULL;
returnedNode = NULL;
newInstanceCreated = NULL;
// create an instance of TTData
TTObjectInstantiate(TTSymbol("Data"), TTObjectHandle(&data), args);
std::string absAddress = AppName + address;
// add instance number
if (i != 0) {
absAddress += ".";
stringstream st;
st << i;
absAddress += st.str();
}
// add the parameter data in the namespace directory
NSPDirectory->TTNodeCreate(TT(absAddress), (TTObjectPtr)data, NULL, &returnedNode, &newInstanceCreated);
// note : our myRegistrationObserver is informed if declared
}
return NSP_NO_ERROR;
}
