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;
}
