void legion_outputErrorMatrix(t_legion *x){
void *m;
t_jit_matrix_info info;
char *bp, *p;
int row, col, i;
jit_matrix_info_default(&info);
info.type = _jit_sym_float64;
info.planecount = 1;
info.dim[0] = x->t_numRows;
info.dim[1] = x->t_numColumns;
t_symbol *name = jit_symbol_unique();
m = jit_object_new(_jit_sym_jit_matrix, &info);
//m = jit_object_method(m, _jit_sym_register, name);
m = jit_object_register(m, name);
//jit_object_method(m, gensym("setinfo"), &info);
info.dimstride[0] = sizeof(double);
info.dimstride[1] = info.dimstride[0] * info.dim[0];
post("%d %d", info.dimstride[0], info.dimstride[1]);
jit_object_method(m, _jit_sym_getdata, &bp);
for(row = 0; row < x->t_numRows; row++){
for(col = 0; col < x->t_numColumns; col++){
i = (row * x->t_numRows) + col;
p = bp + (i / info.dim[0]) * info.dimstride[1] + (i % info.dim[0]) * info.dimstride[0];
*((double *)p) = x->t_rosom[row][col].error;
post("%d [%d, %d] %f %p", i, row, col, x->t_rosom[row][col].error, p);
}
}
t_atom a;
SETSYM(&a, name);
outlet_anything(x->t_out, _jit_sym_jit_matrix, 1, &a);
}
void clifford_print(t_chaos *x)
{
t_atom list[7];
int i;
SETSYM(list, gensym("Clifford"));
for(i = 1; i < 7; i++)
{
SETFLOAT(list+i, x->f_parameterInit[i-1]);
}
outlet_list(x->out4 , 0L, 7, list);
}
void mira_print(t_chaos *x)
{
t_atom list[4];
int i;
SETSYM(list, gensym("Mira"));
for(i = 1; i < 4; i++)
{
SETFLOAT(list+i, x->f_parameterInit[i-1]);
}
outlet_list(x->out4 , 0L, 4, list);
}
/*------------------------------------ inputCallback ---*/
static void
inputCallback(STANDARD_HID_ARGS_INPUTEVENTHANDLER)
{
#pragma unused(elementCookie,longValue,longValueSize)
PhidgRefConPtr data = reinterpret_cast<PhidgRefConPtr>(refCon);
PrivatePtr privateData = reinterpret_cast<PrivatePtr>(data->fPrivateStorage);
if (privateData->fDigitalInputTriggerEnabled)
{
Atom reportList[DIGITAL_REPORT_SIZE];
// Extract the output bit vector and concatenate with the raw bits
SETSYM(reportList, data->fDeviceType);
SETSYM(reportList + 1, data->fThisDevice->fSerialNumber);
SETSYM(reportList + 2, lDiSymbol);
SETLONG(reportList + 3, value);
for (UInt32 ii = 0; ii <= MAX_INDEX; ++ii)
SETLONG(reportList + ii + 4, (value & (1 << ii)) ? 1 : 0);
genericListOutput(data->fOutlet, DIGITAL_REPORT_SIZE, reportList);
}
} /* inputCallback */
void duffing_print(t_chaos *x)
{
t_atom list[8];
int i;
SETSYM(list, gensym("Duffing"));
for(i = 1; i < 8; i++)
{
SETFLOAT(list+i, x->f_parameterInit[i-1]);
}
outlet_list(x->out4 , 0L, 8, list);
}
// Method for Posting Hardware Version
static void teabox_getversion(t_teabox *x)
{
short version_major, version_minor;
char version_string[64];
t_symbol *version_symbol;
t_atom version_atom;
version_major = (int)((x->hw_version * 4095.0) + 0.49) >> 8;
version_minor = (int)((x->hw_version * 4095.0) + 0.49) & 255;
//post("Teabox Firmware Version: %i.%i", version_major, version_minor);
sprintf(version_string, "%i.%i", version_major, version_minor);
version_symbol = gensym(version_string);
SETSYM(&version_atom, version_symbol);
outlet_anything(x->outlet, gensym("version"), 1, &version_atom);
}
void LCD_doreadpict(Lcd *x) /*read in a 'PICT' selected by the user*/
{
Point wher;
SFReply reply;
SFTypeList myFileTypes;
short numFileTypes;
OSErr err;
QDProcsPtr savedProcs;
long longCount,myEOF,filePos;
short vol,refNum;
long length;
Atom a;
short i;
GrafPort *thePort;
Symbol *file;
EnterCallback();
wher.h = 20;
wher.v = 20;
numFileTypes = 1; /*display 'PICT's*/
myFileTypes[0] = 'PICT';
if (!x->fn[0])
{
SFGetFile(wher,"\p",0L,numFileTypes,myFileTypes,0L,&reply);
vol=reply.vRefNum;
if (reply.good)
{
for (i=0;i<=reply.fName[0];i++)
x->fn[i]=reply.fName[i];
PtoCstr((Byte *)x->fn);
file=gensym(x->fn);
SETSYM(&a,file);
outlet_anything (x->file_outlet,ps_pictname,1,&a);
CtoPstr(x->fn);
}
}
void EermMaxOutputToken(EermMax *m, int i)
{
int k,j;
Atom av[2];
int ac = 2;
char OutputString[MAX_LABEL_SIZE];
//Symbol* symtoken, symnode;
MMemEntry;
MTraceCall("eermMax:\tOutputToken..");
MAssertVoid(m != NULL, "invalid eerm ptr");
// Todo : Check that the following string usage is correct.
//MTrace2("OutputToken:\tToken[%d] : Simplex = %s", i, EermMaxSimplexLabel(m, m->e->tokens[i]->s->index));
for (j = 0; j < m->e->Nn; j++)
{
strcpy(OutputString, EermMaxTokenLabel(m,i));
strcat(OutputString, "/");
strcat(OutputString, EermMaxNodeLabel(m, m->e->nodes[j]->index));
SETSYM(av, gensym(OutputString));
k = SimplexNodeFind(m->e->tokens[i]->s, m->e->nodes[j]);
MAssert((k < m->e->tokens[i]->Nn), "invalid index");
if (k != -1)
{
SETFLOAT(av+1, m->e->tokens[i]->coord[k]);
}
else
{
SETFLOAT(av+1, 0.0f);
}
outlet_list(m->out, 0L, ac, av);
}
/*
for (j = 0; j < m->e->tokens[i]->Nn; j++)
{
MTrace1("OutputToken:\tCoord=%f",
m->e->tokens[i]->coord[j]);
MTrace1("OutputToken:\tVCoord=%f",
m->e->tokens[i]->vcoord[j]);
strcpy(OutputString, EermMaxTokenLabel(m,i));
strcat(OutputString, "/");
strcat(OutputString, EermMaxNodeLabel(m, m->e->tokens[i]->s->nodes[j]->index) );
SETSYM(av, gensym(OutputString));
SETFLOAT(av+1, m->e->tokens[i]->coord[j]);
outlet_list(m->out, 0L, ac, av);
}
*/
MTraceCall("eermMax:\tOutputState finished.");
MMemExit;
}
t_cmmjl_error cmmjl_osc_formatMessage(void *x,
char *address,
void *v,
long n,
void (*cbk)(void *x, t_symbol *msg, int argc, t_atom *argv))
{
int i, j, k;
float *floats;
long *ints;
char *chars;
char *string, *nextString, *typeTags, *thisType;
//unsigned char *p;
char *p;
Symbol *addressSymbol, *argSymbol;
if(!cbk){
CMMJL_ERROR(x, CMMJL_FAILURE,
"you must pass a callback to cmmjl_osc_formatMessage!");
return CMMJL_FAILURE;
}
#define MAXARGS 5000
Atom args[MAXARGS];
int numArgs = 0;
Boolean tooManyArgs = false;
t_cmmjl_error err;
addressSymbol = gensym(address);
/* Go through the arguments a word at a time */
floats = v;
ints = v;
chars = v;
//if (readTypeStrings && chars[0] == ',' && cmmjl_osc_isNiceString(chars, chars+n)) {
if (chars[0] == ',' && !cmmjl_osc_isNiceString(chars, chars+n)) {
/* Interpret the first string argument as a type string */
typeTags = chars;
if(err = cmmjl_osc_dataAfterAlignedString(chars, chars+n, &p)){
CMMJL_ERROR(x, err, cmmjl_strerror(err));
return err;
}
for (thisType = typeTags+1; *thisType != 0; ++thisType) {
switch (*thisType) {
case 'i': case 'r': case 'm': case 'c':
SETLONG(&args[numArgs], ntohl(*((int *) p)));
p += 4;
break;
case 'f':
{ // Pretend the 32 bits are an int so I can call ntohl()
long bytesAsInt = ntohl(*((int *) p));
SETFLOAT(&args[numArgs], *((float *) (& bytesAsInt)));
}
p += 4;
break;
case 't':
/* handle typetags in args as they are in bundles */
/* Could see if the data fits in a 32-bit int and output it like that if so... */
SETSYM(&args[numArgs], ps_OSCTimeTag);
numArgs++;
SETLONG(&args[numArgs], ntohl(*((int *) p)));
numArgs++;
p += 4;
SETLONG(&args[numArgs], ntohl(*((int *) p)));
p += 4;
break;
case 'h':
/* 64-bit int: interpret as zero since Max doesn't have long ints */
/* Could see if the data fits in a 32-bit int and output it like that if so... */
SETLONG(&args[numArgs], 0);
p += 8;
break;
case 'd':
/* 64-bit float: interpret as zero since Max doesn't have doubles */
/* Could see if the data fits in a 32-bit float and output it like that if so... */
SETFLOAT(&args[numArgs], 0.0);
p += 8;
break;
case 's': case 'S':
if (cmmjl_osc_isNiceString(p, typeTags+n)) {
SETSYM(&args[numArgs], gensym("¥Bogus_String"));
} else {
SETSYM(&args[numArgs], gensym(p));
if(err = cmmjl_osc_dataAfterAlignedString(p, typeTags+n, &p)){
CMMJL_ERROR(x, err, cmmjl_strerror(err));
return err;
}
}
break;
case 'b':
{
// output symbol OSCBlob, int size, int data0 ... int dataN
int size = ntohl(*((int *) p));
if (p+4+size > chars+n) {
CMMJL_ERROR(x, CMMJL_OSC_EOVRFLW,
"blob size %ld is too big for packet",
size);
return CMMJL_OSC_EOVRFLW;
}
SETSYM(&args[numArgs], ps_OSCBlob); numArgs++;
if(numArgs + 1 + size > MAXARGS) {
CMMJL_ERROR(x, CMMJL_OSC_EOVRFLW,
"blob size too big for encoding");
return CMMJL_OSC_EOVRFLW;
}
SETLONG(&args[numArgs], size); numArgs++;
for(j = 0; j < size; j++) {
SETLONG(&args[numArgs], ((long) (*(p + 4 + j)))); numArgs++;
}
numArgs--; // increments again at end of loop
p += cmmjl_osc_effectiveBlobLength(size);
}
break;
case 'T':
/* "True" value comes out as the int 1 */
SETLONG(&args[numArgs], 1);
/* Don't touch p */
break;
case 'F':
/* "False" value comes out as the int 0 */
SETLONG(&args[numArgs], 0);
/* Don't touch p */
break;
case 'N':
/* Empty lists in max? I wish! How about the symbol "nil"? */
SETSYM(&args[numArgs], gensym("nil"));
/* Don't touch p */
break;
case 'I':
/* Infinita in Max? Ha! How about the symbol "Infinitum"? */
SETSYM(&args[numArgs], gensym("Infinitum"));
/* Don't touch p */
break;
default:
CMMJL_ERROR(x, CMMJL_OSC_ETYPTAG,
"Unrecognized type tag %c", *thisType);
return CMMJL_OSC_ETYPTAG;
}
++numArgs;
}
} else {
/* Use type-guessing heuristics */
for (i = 0; i<n/4; ) {
if (numArgs >= MAXARGS) {
CMMJL_ERROR(x, CMMJL_OSC_EARGS,
"message has more than %ld args; droping extra ones",
(long)MAXARGS);
return CMMJL_OSC_EARGS;
}
string = &chars[i*4];
if (ints[i] >= -1000 && ints[i] <= 1000000) {
SETLONG(&args[numArgs], ntohl(ints[i]));
i++;
} else if (floats[i] >= -1000.f && floats[i] <= 1000000.f &&
(floats[i]<=0.0f || floats[i] >= __FLT_MIN__)) {
// Pretend the 32 bits are an int so I can call ntohl()
long bytesAsInt = ntohl(ints[i]);
SETFLOAT(&args[numArgs], *((float *) (&bytesAsInt)));
i++;
} else if (!cmmjl_osc_isNiceString(string, chars+n)) {
if(err = cmmjl_osc_dataAfterAlignedString(string, chars+n, &nextString)){
CMMJL_ERROR(x, err, cmmjl_strerror(err));
return err;
}
argSymbol = gensym(string);
SETSYM(&args[numArgs], argSymbol);
i += (nextString-string) / 4;
} else {
// Assume int if nothing looks good.
SETLONG(&args[numArgs], ntohl(ints[i]));
i++;
}
numArgs++;
}
}
cbk(x, addressSymbol, numArgs, args);
return CMMJL_SUCCESS;
}
/*------------------------------------ cmd_GetSensorType ---*/
Pvoid
cmd_GetSensorType(RcxControlPtr xx,
long slot)
{
#if (! FOR_MAC_PPC)
#pragma unused(slot)
#endif /* not FOR_MAC_PPC */
EnterCallback();
if (xx)
{
#if FOR_MAC_PPC
if (rcxSynchronize(xx))
{
if ((slot > 0) && (slot <= RCX_NUM_SENSORS))
{
long value;
if (rcxGetValue(xx, MAKE_RCX_VALUE(RCX_SENSOR_TYPE_TYPE, slot - 1), value))
{
Atom response[1];
outlet_bang(xx->fCommandComplete);
switch (value)
{
case RCX_SENSOR_NONE:
SETSYM(response, gNoSensorSymbol);
break;
case RCX_SENSOR_SWITCH:
SETSYM(response, gSwitchSymbol);
break;
case RCX_SENSOR_TEMPERATURE:
SETSYM(response, gTemperatureSymbol);
break;
case RCX_SENSOR_REFLECTION:
SETSYM(response, gReflectionSymbol);
break;
case RCX_SENSOR_ANGLE:
SETSYM(response, gAngleSymbol);
break;
default:
SETSYM(response, gUnknownSymbol);
break;
}
outlet_anything(xx->fDataOut, gSensorTypeSymbol, 1, response);
}
else
outlet_bang(xx->fErrorBangOut);
}
else
{
LOG_ERROR_2(OUTPUT_PREFIX "bad sensor index (%ld)", slot)
outlet_bang(xx->fErrorBangOut);
}
}
else
outlet_bang(xx->fErrorBangOut);
#endif /* FOR_MAC_PPC */
}
ExitMaxMessageHandler()
} /* cmd_GetSensorType */
/*------------------------------------ performGet ---*/
static bool
performGet(FidgetPtr xx,
HIDDeviceDataPtr walkerHID,
PSymbol deviceType,
const short argc,
PAtom argv)
{
bool okSoFar = true;
OSErr result;
E_PhidgResult action = kPhidgDoDefault;
if (walkerHID->fClass)
{
PhidgetDescriptorPtr kind = reinterpret_cast<PhidgetDescriptorPtr>(walkerHID->fClass);
#if defined(COMPILE_FOR_OSX_4)
action = reinterpret_cast<FpDoGet>(kind->fDoGetFun)(OUR_NAME, deviceType,
xx->fDataOut, kind->fShared,
walkerHID->fPrivate, walkerHID,
short(argc - 2), argv + 2,
&result);
#endif /* COMPILE_FOR_OSX_4 */
#if defined(COMPILE_FOR_OS9_4)
action = static_cast<E_PhidgResult>(CallUniversalProc(kind->fDoGetUpp, uppDoGetProcInfo,
OUR_NAME, deviceType, xx->fDataOut, kind->fShared,
walkerHID->fPrivate, walkerHID, short(argc - 2), argv + 2,
&result));
#endif /* COMPILE_FOR_OS9_4 */
}
if (action == kPhidgDoDefault)
{
#if defined(COMPILE_FOR_OSX_4)
// Note that 'default' is only supported with 'CATS' - there is no reasonable behaviour
// if we are using a report handler... as we do for non-'CATS'!
if (argc >= 3)
{
long element = 0;
if (argv[2].a_type == A_LONG)
element = argv[2].a_w.w_long;
else
{
okSoFar = false;
LOG_ERROR_2(OUTPUT_PREFIX "element is not an integer for '%s:get'",
deviceType->s_name);
}
if (okSoFar)
{
HIDElementDataPtr anElement = NULL_PTR;
if (element)
{
// Find the matching element:
for (anElement = walkerHID->fFirstElement; anElement; anElement = anElement->fNext)
{
if (anElement->fCookie == reinterpret_cast<IOHIDElementCookie>(element))
break;
}
}
if (anElement)
{
UInt32 extendedLength;
Pvoid extendedValue;
IOReturn result;
long value = getHIDElementValue(OUR_NAME, *walkerHID, *anElement,
extendedLength, extendedValue, result);
if (result == KERN_SUCCESS)
{
if (extendedLength)
{
PAtom newList = GETBYTES(extendedLength + 2, Atom);
Pchar longValue = reinterpret_cast<Pchar>(extendedValue);
SETSYM(newList, deviceType);
SETSYM(newList + 1, walkerHID->fSerialNumber);
for (UInt32 ii = 0; ii < extendedLength; ++ii, ++longValue)
SETLONG(newList + ii + 2, long(*longValue & 0x00FF));
genericListOutput(xx->fDataOut, short(extendedLength + 2), newList);
FREEBYTES(newList, extendedLength + 2)
}
else
{
Atom newList[3];
SETSYM(newList, deviceType);
SETSYM(newList + 1, walkerHID->fSerialNumber);
SETLONG(newList + 2, value);
genericListOutput(xx->fDataOut, sizeof(newList) / sizeof(*newList),
newList);
}
}
if (result)
outlet_int(xx->fResultOut, result);
}
else
{
okSoFar = false;
LOG_ERROR_2(OUTPUT_PREFIX "element not found for '%sget'", deviceType->s_name)
}
}
