int C74_EXPORT main(void) { long attrflags = 0; t_class *c; t_object *attr; TTDSPInit(); common_symbols_init(); c = class_new("j.zerox~", (method)zerox_new, (method)zerox_free, sizeof(t_zerox), (method)0L, A_GIMME, 0); class_addmethod(c, (method)zerox_dsp, "dsp", A_CANT, 0L); class_addmethod(c, (method)zerox_dsp64, "dsp64", A_CANT, 0); class_addmethod(c, (method)zerox_assist, "assist", A_CANT, 0L); class_addmethod(c, (method)jamoma_fileusage, "fileusage", A_CANT, 0); attr = attr_offset_new("size", _sym_long, attrflags, (method)0L, (method)attr_set_size, calcoffset(t_zerox, attr_size)); class_addattr(c, attr); class_dspinit(c); class_register(CLASS_BOX, c); s_zerox_class = c; return 0; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { t_class *c; TTDSPInit(); common_symbols_init(); c = class_new("jcom.op~",(method)op_new, (method)op_free, sizeof(t_op), (method)0L, A_GIMME, 0); class_addmethod(c, (method)op_dsp, "dsp", A_CANT, 0); class_addmethod(c, (method)op_dsp64, "dsp64", A_CANT, 0); class_addmethod(c, (method)op_assist, "assist", A_CANT, 0); class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT, 0); CLASS_ATTR_SYM(c, "operator", 0, t_op, attrOperator); CLASS_ATTR_ACCESSORS(c, "operator", NULL, op_setOperator); CLASS_ATTR_ENUM(c, "operator", 0, "+ - * / % > >= == != <= < abs acos asin atan ceil cos cosh exp floor log log10 sin sinh sqrt tan tanh"); CLASS_ATTR_FLOAT(c, "operand", 0, t_op, attrOperand); CLASS_ATTR_ACCESSORS(c, "operand", NULL, op_setOperand); class_dspinit(c); // Setup object's class to work with MSP class_register(CLASS_BOX, c); s_op_class = c; return 0; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { long attrflags = 0; t_class *c; t_object *attr; TTDSPInit(); common_symbols_init(); c = class_new("jcom.balance~",(method)balance_new, (method)balance_free, (short)sizeof(t_balance), (method)0L, A_GIMME, 0); class_addmethod(c, (method)balance_clear, "clear", 0L); class_addmethod(c, (method)balance_dsp, "dsp", A_CANT, 0L); class_addmethod(c, (method)balance_assist, "assist", A_CANT, 0L); attr = attr_offset_new("bypass", _sym_long, attrflags, (method)0L,(method)balance_setBypass, calcoffset(t_balance, attrBypass)); class_addattr(c, attr); attr = attr_offset_new("frequency", _sym_float32, attrflags, (method)0L,(method)balance_setFrequency, calcoffset(t_balance, attrFrequency)); class_addattr(c, attr); class_dspinit(c); // Setup object's class to work with MSP class_register(CLASS_BOX, c); balance_class = c; return 0; }
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; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { t_class *c; TTDSPInit(); common_symbols_init(); c = class_new("jcom.gain~", (method)gain_new, (method)gain_free, sizeof(t_gain), (method)0L, A_GIMME, 0); // Make methods accessible for our class: class_addmethod(c, (method)gain_dsp, "dsp", A_CANT, 0L); class_addmethod(c, (method)gain_dsp64, "dsp64", A_CANT, 0); class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT,0); class_addmethod(c, (method)gain_assist, "assist", A_CANT, 0L); CLASS_ATTR_CHAR(c, "bypass", 0, t_gain, attrBypass); CLASS_ATTR_ACCESSORS(c, "bypass", NULL, attr_set_bypass); CLASS_ATTR_FLOAT(c, "mix", 0, t_gain, attrBypass); CLASS_ATTR_ACCESSORS(c, "mix", NULL, attr_set_mix); CLASS_ATTR_FLOAT(c, "gain", 0, t_gain, attrBypass); CLASS_ATTR_ACCESSORS(c, "gain", NULL, attr_set_gain); // Setup our class to work with MSP class_dspinit(c); // Finalize our class class_register(CLASS_BOX, c); s_gain_class = c; return 0; }
extern "C" TT_EXTENSION_EXPORT TTErr loadTTExtension(void) { TTDSPInit(); TTfft::registerClass(); return kTTErrNone; }
extern "C" TT_EXTENSION_EXPORT TTErr TTLoadJamomaExtension_FFTLib(void) { TTDSPInit(); TTfft::registerClass(); return kTTErrNone; }
/** Register classes for all of the SpatLib rendering techniques (aka units). @return #TTErr error code if the method fails to execute, else #kTTErrNone. */ extern "C" TT_EXTENSION_EXPORT TTErr TTLoadJamomaExtension_SpatLib(void) { TTDSPInit(); TTSpat::registerClass(); TTSpatDBAP::registerClass(); TTSpatSnap::registerClass(); return kTTErrNone; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { s_jamoma_class = class_new("j~", (method)jamoma_new, (method)wrappedClass_free, sizeof(WrappedInstance), (method)0L, A_GIMME, 0); class_register(CLASS_BOX, s_jamoma_class); common_symbols_init(); TTDSPInit(); return 0; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { // First, we have to register our custom subclass with the TTBlue framework. TTDSPInit(); TTOverdriveExtended::registerClass(); // Then we are able to wrap it as a Max class. return wrapTTClassAsMaxClass(TT(thisTTClassName), "jcom.overdrive~", NULL); }
extern "C" TT_EXTENSION_EXPORT TTErr loadTTExtension(void) { TTDSPInit(); TTOperator::registerClass(); TTMatrix::registerClass(); TTMatrixMixer::registerClass(); return kTTErrNone; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { WrappedClassPtr w; TTDSPInit(); TTLoadJamomaExtension_EffectsLib(); TTLoadJamomaExtension_FilterLib(); return wrapTTClassAsMaxClass(TT("limiter"), "tap.limi~", &w); }
extern "C" TT_EXTENSION_EXPORT TTErr TTLoadJamomaExtension_FilterLib(void) { TTDSPInit(); TTFilter::registerClass(); TTAllpass::registerClass(); TTAllpass1::registerClass(); TTAllpass1a::registerClass(); TTAllpass1aCascade2::registerClass(); TTAllpass1b::registerClass(); TTAllpass1c::registerClass(); TTAllpass2a::registerClass(); TTAllpass2b::registerClass(); TTAllpass2c::registerClass(); TTAllpass4a::registerClass(); TTHalfband3::registerClass(); TTHalfband5::registerClass(); TTHalfband9::registerClass(); TTHalfbandLinear33::registerClass(); TTHilbert9::registerClass(); TTHilbertLinear33::registerClass(); TTMirror5::registerClass(); TTMirrorBandpass10::registerClass(); // TTAverage::registerClass(); TTBandpassButterworth2::registerClass(); TTBandRejectButterworth2::registerClass(); TTDCBlock::registerClass(); TTHighMidLowShelf::registerClass(); TTHighpassButterworth1::registerClass(); TTHighpassButterworth2::registerClass(); TTHighpassButterworth3::registerClass(); TTHighpassButterworth4::registerClass(); TTHighpassLinkwitzRiley2::registerClass(); TTHighpassLinkwitzRiley4::registerClass(); TTLowpassButterworth1::registerClass(); TTLowpassButterworth2::registerClass(); TTLowpassButterworth3::registerClass(); TTLowpassButterworth4::registerClass(); TTLowpassLinkwitzRiley2::registerClass(); TTLowpassLinkwitzRiley4::registerClass(); TTLowpassOnePole::registerClass(); TTLowpassTwoPole::registerClass(); TTLowpassFourPole::registerClass(); TTOnePole::registerClass(); TTSvf::registerClass(); return kTTErrNone; }
extern "C" TT_EXTENSION_EXPORT TTErr TTLoadJamomaExtension_MidiLib(void) { TTDSPInit(); TTMidiFilter::registerClass(); TTMidiFormat::registerClass(); TTMidiInput::registerClass(); TTMidiOutput::registerClass(); return kTTErrNone; }
// Class Definition void ttclip_tilde_setup(void) { TTDSPInit(); ttclip_class = class_new(gensym("ttclip~"), (t_newmethod)ttclip_new, (t_method)ttclip_free, sizeof(t_ttclip), 0, A_GIMME, 0); CLASS_MAINSIGNALIN(ttclip_class, t_ttclip, f); class_addmethod(ttclip_class, (t_method)ttclip_dsp, gensym("dsp"), A_NULL); class_addmethod(ttclip_class, (t_method)ttclip_setlowbound, gensym("lowbound"), A_FLOAT, 0); class_addmethod(ttclip_class, (t_method)ttclip_sethighbound, gensym("highbound"), A_FLOAT, 0); class_sethelpsymbol(ttclip_class, gensym("help-ttclip~.pd")); }
int C74_EXPORT main(void) { WrappedClassOptionsPtr options = new WrappedClassOptions; TTValue value; TTDSPInit(); value.clear(); value.append(TT("drive")); options->append(TT("additionalSignalInputSetsAttribute"), value); return wrapTTClassAsMaxClass(TT("overdrive"), "j.overdrive~", NULL, options); }
/** Register the classes of this extension. @return #TTErr error code if the method fails to execute, else #kTTErrNone. */ extern "C" TT_EXTENSION_EXPORT TTErr TTLoadJamomaExtension_GeneratorLib(void) { TTDSPInit(); TTAdsr::registerClass(); TTCount::registerClass(); TTNoise::registerClass(); TTPhasor::registerClass(); TTRamp::registerClass(); TTWavetable::registerClass(); return kTTErrNone; }
int C74_EXPORT main(void) { WrappedClassOptionsPtr options = new WrappedClassOptions; WrappedClassPtr c = NULL; TTValue v(2); TTDSPInit(); options->append(TT("fixedNumOutputChannels"), v); wrapTTClassAsMaxClass(TT("panorama"), "j.panorama~", &c, options); CLASS_ATTR_ENUM(c->maxClass, "mode", 0, "calculate lookup"); CLASS_ATTR_ENUM(c->maxClass, "shape", 0, "equalPower linear squareRoot"); return 0; }
extern "C" TT_EXTENSION_EXPORT TTErr loadTTExtension(void) { TTDSPInit(); BartlettWindow::registerClass(); BlackmanWindow::registerClass(); HammingWindow::registerClass(); HanningWindow::registerClass(); KaiserWindow::registerClass(); RectangularWindow::registerClass(); TrapezoidWindow::registerClass(); WelchWindow::registerClass(); WindowFunction::registerClass(); return kTTErrNone; }
int TTCLASSWRAPPERMAX_EXPORT main(void) { WrappedClassOptionsPtr options = new WrappedClassOptions; TTValue value; TTDSPInit(); value.clear(); value.append(TT("srRatio")); value.append(TT("bitdepth")); // TODO: experimental: // options->append(TT("additionalSignalInputSetsAttribute"), value); return wrapTTClassAsMaxClass(TT("degrade"), "jcom.degrade~", NULL, options); }
extern "C" TT_EXTENSION_EXPORT TTErr TTLoadJamomaExtension_EffectsLib(void) { TTDSPInit(); TTBalance::registerClass(); TTDegrade::registerClass(); TTGain::registerClass(); TTLimiter::registerClass(); TTMutesolo::registerClass(); TTOverdrive::registerClass(); TTPanorama::registerClass(); TTThru::registerClass(); TTWaveshaper::registerClass(); return kTTErrNone; }
int C74_EXPORT main(void) { t_class *c = class_new("allpass1~.model", (method)allpassmod_new, (method)allpassmod_free, sizeof(t_allpassmod), (method)0L, A_GIMME, 0); TTDSPInit(); class_addmethod(c, (method)allpassmod_dsp64, "dsp64", A_CANT, 0); class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT,0); class_addmethod(c, (method)allpassmod_assist, "assist", A_CANT, 0L); // standalone support: class_addmethod(c, (method)jamoma_fileusage, "fileusage", A_CANT, 0); class_dspinit(c); class_register(CLASS_BOX, c); s_allpassmod_class = c; return 0; }
extern "C" int C74_EXPORT main(void) { t_class *c; c = class_new("tap.zerox~",(method)zerox_new, (method)zerox_free, sizeof(t_zerox), (method)0L, A_GIMME, 0); TTDSPInit(); TTLoadJamomaExtension_AnalysisLib(); common_symbols_init(); class_addmethod(c, (method)zerox_dsp64, "dsp64", A_CANT, 0); class_addmethod(c, (method)zerox_assist, "assist", A_CANT, 0L); class_addmethod(c, (method)stdinletinfo, "inletinfo", A_CANT, 0); CLASS_ATTR_LONG(c, "size", 0, t_zerox, attr_size); CLASS_ATTR_ACCESSORS(c, "size", NULL, attr_set_size); class_dspinit(c); // Setup object's class to work with MSP class_register(_sym_box, c); zerox_class = c; return 0; }
int TTCLASSWRAPPERMAX_EXPORT main(void) // main recieves a copy of the Max function macros table { ClassPtr c; TTDSPInit(); common_symbols_init(); // Define our class c = class_new("jcom.fft~", (method)FFTNew, (method)FFTFree, sizeof(FFT), (method)NULL, A_GIMME, 0); // Make methods accessible for our class: class_addmethod(c, (method)FFTDsp, "dsp", A_CANT, 0L); class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT,0); // Setup our class to work with MSP class_dspinit(c); // Finalize our class class_register(_sym_box, c); sFFTClass = c; return 0; }
BlueSaturation::BlueSaturation(audioMasterCallback audioMaster) : AudioEffectX(audioMaster, kNumPresets, kNumParameters), mNumChannels(2), mOverdrive(NULL), mInput(NULL), mOutput(NULL) { TTDSPInit(); setNumInputs(2); // stereo in setNumOutputs(2); // stereo out setUniqueID('TTOv'); // identify canProcessReplacing(); // supports replacing output canDoubleReplacing(); // supports double precision processing TTObjectInstantiate(TT("overdrive"), &mOverdrive, mNumChannels); TTObjectInstantiate(kTTSym_audiosignal, &mInput, mNumChannels); TTObjectInstantiate(kTTSym_audiosignal, &mOutput, mNumChannels); mParameterList = new BlueParameter[kNumParameters]; strncpy(mParameterList[kParameterDrive].name, "drive", 256); mParameterList[kParameterDrive].scaling = 9.0; mParameterList[kParameterDrive].offset = 1.0; strncpy(mParameterList[kParameterPreamp].name, "preamp", 256); mParameterList[kParameterPreamp].scaling = 96.0; mParameterList[kParameterPreamp].offset = -78.0; strncpy(mParameterList[kParameterMode].name, "mode", 256); mParameterList[kParameterMode].scaling = 2.0; // just round this one mParameterList[kParameterMode].offset = 0.5; strncpy(mParameterList[kParameterBlockDC].name, "dcblocker", 256); mParameterList[kParameterBlockDC].scaling = 1.0; // just round this one mParameterList[kParameterBlockDC].offset = 0.5; vst_strncpy(programName, "Default", kVstMaxProgNameLen); // default program name }
int C74_EXPORT main(void) // main recieves a copy of the Max function macros table { t_class *c; TTDSPInit(); common_symbols_init(); // Define our class c = class_new("j.xfade~", (method)fade_new, (method)fade_free, sizeof(t_fade), (method)0L, A_GIMME, 0); // Make methods accessible for our class: class_addmethod(c, (method)fade_float, "float", A_FLOAT,0L); class_addmethod(c, (method)fade_dsp, "dsp", A_CANT, 0L); class_addmethod(c, (method)fade_dsp64, "dsp64", A_CANT, 0); class_addmethod(c, (method)object_obex_dumpout, "dumpout", A_CANT, 0); class_addmethod(c, (method)fade_assist, "assist", A_CANT, 0L); class_addmethod(c, (method)jamoma_fileusage, "fileusage", A_CANT, 0); // Add attributes to our class: CLASS_ATTR_LONG(c, "shape", 0, t_fade, attr_shape); CLASS_ATTR_ACCESSORS(c, "shape", NULL, attr_set_shape); CLASS_ATTR_ENUMINDEX(c, "shape", 0, "EqualPower Linear SquareRoot"); CLASS_ATTR_LONG(c, "mode", 0, t_fade, attr_mode); CLASS_ATTR_ACCESSORS(c, "mode", NULL, attr_set_mode); CLASS_ATTR_ENUMINDEX(c, "mode", 0, "LookupTable Calculate"); CLASS_ATTR_FLOAT(c, "position", 0, t_fade, attr_position); CLASS_ATTR_ACCESSORS(c, "position", NULL, attr_set_position); // Setup our class to work with MSP class_dspinit(c); // Finalize our class class_register(CLASS_BOX, c); s_fade_class = c; return 0; }
int C74_EXPORT main(void) { TTDSPInit(); return wrapTTClassAsMaxClass(TT("clipper"), "j.clip~", NULL); }
int TTCLASSWRAPPERMAX_EXPORT main(void) { TTDSPInit(); return wrapTTClassAsMaxClass(TT("clipper"), "j.clip~", NULL); }
int TTCLASSWRAPPERMAX_EXPORT main(void) { TTDSPInit(); return wrapTTClassAsMaxClass(TT("array"), "jcom.array~", NULL); }
TTErr wrapTTClassAsPdClass(TTSymbol ttblueClassName, const char* pdClassName, WrappedClassPtr* c, WrappedClassOptionsPtr options) { TTObject o(ttblueClassName, 1); // Create a temporary instance of the class so that we can query it. TTValue v; WrappedClass* wrappedPdClass = NULL; TTSymbol name; TTCString nameCString = NULL; t_symbol* namePdSymbol = NULL; TTUInt32 nameSize = 0; TTDSPInit(); wrappedPdClass = new WrappedClass; wrappedPdClass->pdClassName = gensym((char*)pdClassName); wrappedPdClass->pdClass = eclass_new( (char*)pdClassName, (method)wrappedClass_new, (method)wrappedClass_free, sizeof(WrappedInstance), CLASS_NOINLET, A_GIMME, 0); wrappedPdClass->ttblueClassName = ttblueClassName; wrappedPdClass->validityCheck = NULL; wrappedPdClass->validityCheckArgument = NULL; wrappedPdClass->options = options; if (!o.valid()) { error("Jamoma ClassWrapper failed to load %s", ttblueClassName.c_str()); return kTTErrAllocFailed; } o.messages(v); for (TTUInt16 i=0; i<v.size(); i++) { name = v[i]; //nameSize = name->getString().length(); // TODO -- this crash on Windows... nameSize = strlen(name.c_str()); nameCString = new char[nameSize+1]; strncpy(nameCString, name.c_str(), nameSize+1); namePdSymbol = gensym(nameCString); wrappedPdClass->pdNamesToTTNames[namePdSymbol->s_name] = (t_object*)name.rawpointer(); eclass_addmethod((t_eclass*)wrappedPdClass->pdClass, (method)wrappedClass_anything, nameCString, A_GIMME, 0); delete[] nameCString; nameCString = NULL; } o.attributes(v); for (TTUInt16 i=0; i<v.size(); i++) { TTAttributePtr attr = NULL; name = v[i]; //nameSize = name->getString().length(); // TODO -- this crash on Windows... nameSize = strlen(name.c_str()); nameCString = new char[nameSize+1]; strncpy(nameCString, name.c_str(), nameSize+1); namePdSymbol = gensym(nameCString); if (name == TT("maxNumChannels")) continue; // don't expose these attributes to Pd users if (name == TT("bypass")) { if (wrappedPdClass->options && !wrappedPdClass->options->lookup(TT("generator"), v)) continue; // generators don't have inputs, and so don't really provide a bypass } o.instance()->findAttribute(name, &attr); wrappedPdClass->pdNamesToTTNames[namePdSymbol->s_name] = (t_object*)name.rawpointer(); if (attr->type == kTypeFloat32) CLASS_ATTR_FLOAT(wrappedPdClass->pdClass,nameCString,0,t_eclass,c_attr); else if (attr->type == kTypeFloat64) CLASS_ATTR_DOUBLE(wrappedPdClass->pdClass,nameCString,0,t_eclass,c_attr); else if (attr->type == kTypeSymbol || attr->type == kTypeString) CLASS_ATTR_SYMBOL(wrappedPdClass->pdClass,nameCString,0,t_eclass,c_attr); else CLASS_ATTR_LONG(wrappedPdClass->pdClass,nameCString,0,t_eclass,c_attr); //class_addattr(wrappedPdClass->pdClass, attr_offset_new(nameCString, pdType, 0, (method)wrappedClass_attrGet, (method)wrappedClass_attrSet, 0)); /* // Add display styles for the Max 5 inspector if (attr->type == kTypeBoolean) CLASS_ATTR_STYLE(wrappedPdClass->pdClass, (char*)name.c_str(), 0, (char*)"onoff"); if (name == TT("fontFace")) CLASS_ATTR_STYLE(wrappedPdClass->pdClass, (char*)"fontFace", 0, (char*)"font"); */ delete[] nameCString; nameCString = NULL; } eclass_addmethod(wrappedPdClass->pdClass, (method)wrappedClass_dsp64, "dsp64", A_CANT, 0L); eclass_addmethod(wrappedPdClass->pdClass, (method)object_obex_dumpout, "dumpout", A_CANT, 0); eclass_addmethod(wrappedPdClass->pdClass, (method)wrappedClass_assist, "assist", A_CANT, 0L); // eclass_addmethod(wrappedPdClass->pdClass, (method)stdinletinfo, "inletinfo", A_CANT, 0); eclass_dspinit(wrappedPdClass->pdClass); eclass_register(CLASS_BOX, wrappedPdClass->pdClass); if (c) *c = wrappedPdClass; wrappedPdClasses[wrappedPdClass->pdClassName->s_name] = (t_object*)wrappedPdClass; return kTTErrNone; }