// new PFieldSet sending command.
Instrument *
RTcmix::cmd(const char *name, const PFieldSet &pfSet)
{
int nFields = pfSet.size();
Arg *arglist = new Arg[nFields];
Arg retArg;
// Copy PField pointers into arglist
for (int field = 0; field < nFields; ++field) {
arglist[field] = createPFieldHandle(&pfSet[field]);
}
(void) dispatch(name, arglist, nFields, &retArg);
delete [] arglist;
// Extract and return instrument pointer.
Handle rethandle = (Handle) retArg;
if (rethandle->type == InstrumentPtrType)
return (Instrument *) rethandle->ptr;
else
return NULL;
}
Handle
create_handle(const Arg args[], const int nargs)
{
PField *pField = create_pfield(args, nargs);
Handle handle = NULL;
if (pField != NULL) {
handle = createPFieldHandle(pField);
}
return handle;
}
Handle
create_pfbus_handle(const Arg args[], const int nargs)
{
// BGG mm -- see note aboove
PField *pField = create_pfbus_pfield(args, nargs);
Handle handle = NULL;
if (pField != NULL) {
handle = createPFieldHandle(pField);
}
return handle;
}
Handle
#ifdef MAXMSP
create_pfbus_handle(const Arg args[], const int nargs)
{
PField *pField = create_pfbus_pfield(args, nargs);
#else
create_handle(const Arg args[], const int nargs)
{
PField *pField = create_pfield(args, nargs);
#endif
Handle handle = NULL;
if (pField != NULL) {
handle = createPFieldHandle(pField);
}
return handle;
}
// ----------------------------------------------------------- makeconverter ---
Handle
makeconverter(const Arg args[], const int nargs)
{
if (!args[0].isType(HandleType)) {
die("makeconverter", "First argument must be a valid pfield handle.");
return NULL;
}
PField *pfield = (PField *) args[0];
if (!args[1].isType(StringType)) {
die("makeconverter", "Second argument must be a string giving "
"converter type, e.g. \"ampdb\", \"cpsoct\".");
return NULL;
}
ConverterPField *converter = NULL;
if (args[1] == "ampdb")
converter = new ConverterPField(pfield, ConverterPField::ampdb);
else if (args[1] == "cpsoct")
converter = new ConverterPField(pfield, ConverterPField::cpsoct);
else if (args[1] == "octcps")
converter = new ConverterPField(pfield, ConverterPField::octcps);
else if (args[1] == "octpch")
converter = new ConverterPField(pfield, ConverterPField::octpch);
else if (args[1] == "cpspch")
converter = new ConverterPField(pfield, ConverterPField::cpspch);
else if (args[1] == "pchoct")
converter = new ConverterPField(pfield, ConverterPField::pchoct);
else if (args[1] == "pchcps")
converter = new ConverterPField(pfield, ConverterPField::pchcps);
else if (args[1] == "midipch")
converter = new ConverterPField(pfield, ConverterPField::midipch);
else if (args[1] == "pchmidi")
converter = new ConverterPField(pfield, ConverterPField::pchmidi);
else if (args[1] == "octmidi")
converter = new ConverterPField(pfield, ConverterPField::octmidi);
else if (args[1] == "boost")
converter = new ConverterPField(pfield, ConverterPField::boost);
if (converter == NULL) {
die("makeconverter", "Invalid converter type \"%s\".", (const char *) args[1]);
return NULL;
}
return createPFieldHandle(converter);
}
Handle
makeLFO(const Arg args[], const int nargs)
{
if (nargs < 3)
return _makeLFO_usage();
TablePField *tablePField = (TablePField *) ((PField *) args[0]);
if (tablePField == NULL || tablePField->values() < 2) { // not a TablePField
if (args[0].isType(StringType)) {
const int len = kLFOWavetableSize;
double *wavetable = new double [len];
if (wavetable_from_string(args[0], wavetable, len, "makeLFO") != 0) {
delete[] wavetable;
return NULL;
}
tablePField = new TablePField(wavetable, len);
}
else
return _makeLFO_usage();
}
InterpType interp = kInterp1stOrder;
int index = 1;
if (args[index].isType(StringType)) {
if (args[index] == "nointerp")
interp = kTruncate;
else if (args[index] == "interp")
interp = kInterp1stOrder;
else {
die("makeLFO", "Invalid string option \"%s\".",
(const char *) args[index]);
return NULL;
}
index++;
}
PField *freqpf = (PField *) args[index];
if (freqpf == NULL) {
if (args[index].isType(DoubleType))
freqpf = new ConstPField((double) args[index]);
else
return _makeLFO_usage();
}
index++;
if (index >= nargs)
return _makeLFO_usage();
PField *amppf = NULL;
PField *minpf = NULL;
PField *maxpf = NULL;
if (nargs - index > 1) { // min, max instead of amp
minpf = (PField *) args[index];
if (minpf == NULL) {
if (args[index].isType(DoubleType))
minpf = new ConstPField((double) args[index]);
else
return _makeLFO_usage();
}
index++;
if (index >= nargs)
return _makeLFO_usage();
maxpf = (PField *) args[index];
if (maxpf == NULL) {
if (args[index].isType(DoubleType))
maxpf = new ConstPField((double) args[index]);
else
return _makeLFO_usage();
}
}
else {
amppf = (PField *) args[index];
if (amppf == NULL) {
if (args[index].isType(DoubleType))
amppf = new ConstPField((double) args[index]);
else
return _makeLFO_usage();
}
}
PField *lfo = NULL;
if (interp == kInterp1stOrder)
lfo = new LFOPField(resetval, tablePField, freqpf);
else // (interp == kTruncate)
lfo = new LFOPField(resetval, tablePField, freqpf, LFOPField::Truncate);
if (amppf != NULL)
lfo = new MultPField(lfo, amppf);
else
lfo = new RangePField(lfo, minpf, maxpf, RangePField::BipolarSource);
return createPFieldHandle(lfo);
}
Handle
makerandom(const Arg args[], const int nargs)
{
if (nargs < 4)
return _makerandom_usage();
int type;
if (args[0].isType(StringType)) {
if (args[0] == "even" || args[0] == "linear")
type = kLinearRandom;
else if (args[0] == "low")
type = kLowLinearRandom;
else if (args[0] == "high")
type = kHighLinearRandom;
else if (args[0] == "triangle")
type = kTriangleRandom;
else if (args[0] == "gaussian")
type = kGaussianRandom;
else if (args[0] == "cauchy")
type = kCauchyRandom;
else if (args[0] == "prob")
type = kProbRandom;
else
return _makerandom_usage();
}
else
return _makerandom_usage();
int index = 1;
PField *freqpf = (PField *) args[index];
if (freqpf == NULL) {
if (args[index].isType(DoubleType))
freqpf = new ConstPField((double) args[index]);
else
return _makerandom_usage();
}
index++;
PField *minpf = (PField *) args[index];
if (minpf == NULL) {
if (args[index].isType(DoubleType))
minpf = new ConstPField((double) args[index]);
else
return _makerandom_usage();
}
double min = minpf->doubleValue(0);
index++;
if (index >= nargs)
return _makerandom_usage();
PField *maxpf = (PField *) args[index];
if (maxpf == NULL) {
if (args[index].isType(DoubleType))
maxpf = new ConstPField((double) args[index]);
else
return _makerandom_usage();
}
double max = maxpf->doubleValue(0);
index++;
PField *midpf = NULL;
if (type == kProbRandom) {
if (index >= nargs)
return _makerandom_usage();
midpf = (PField *) args[index];
if (midpf == NULL) {
if (args[index].isType(DoubleType))
midpf = new ConstPField((double) args[index]);
else
return _makerandom_usage();
}
index++;
if (index >= nargs)
return _makerandom_usage();
}
double mid = midpf ? midpf->doubleValue(0) : 0.0;
PField *tightpf = NULL;
if (type == kProbRandom) {
tightpf = (PField *) args[index];
if (tightpf == NULL) {
if (args[index].isType(DoubleType))
tightpf = new ConstPField((double) args[index]);
else
return _makerandom_usage();
}
index++;
}
double tight = tightpf ? tightpf->doubleValue(0) : 0.0;
int seed = 0;
if (nargs - index > 0) // explicit seed
seed = (int) args[index];
if (seed == 0) {
struct timeval tv;
gettimeofday(&tv, NULL);
seed = (int) tv.tv_usec;
}
// check initial values
if (min > max) {
die("makerandom", "<min> must be less than or equal to <max>.");
return NULL;
}
if (tight < 0.0) {
die("makerandom", "<tight> must be zero or greater.");
return NULL;
}
Random *gen = NULL;
switch (type) {
case kLinearRandom:
gen = new LinearRandom(min, max, seed);
break;
case kLowLinearRandom:
gen = new LowLinearRandom(min, max, seed);
break;
case kHighLinearRandom:
gen = new HighLinearRandom(min, max, seed);
break;
case kTriangleRandom:
gen = new TriangleRandom(min, max, seed);
break;
case kGaussianRandom:
gen = new GaussianRandom(min, max, seed);
break;
case kCauchyRandom:
gen = new CauchyRandom(min, max, seed);
break;
case kProbRandom:
gen = new ProbRandom(min, max, mid, tight, seed);
break;
default: // can't get here if type inited correctly above
break;
}
PField *rand = new RandomPField(resetval, gen, freqpf, minpf, maxpf, midpf, tightpf);
return createPFieldHandle(rand);
}
