static int OSC_writeStringArg(OSCbuf *buf, char *arg)
{
int len;
if (CheckTypeTag(buf, 's')) return 9;
len = OSC_effectiveStringLength(arg);
if (buf->gettingFirstUntypedArg && arg[0] == ',')
{
/* This un-type-tagged message starts with a string
that starts with a comma, so we have to escape it
(with a double comma) so it won't look like a type
tag string. */
if(OSC_CheckOverflow(buf, len+4))return 1; /* Too conservative */
buf->bufptr +=
OSC_padStringWithAnExtraStupidComma(buf->bufptr, arg);
}
else
{
if(OSC_CheckOverflow(buf, len))return 1;
buf->bufptr += OSC_padString(buf->bufptr, arg);
}
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_closeBundle(OSCbuf *buf) {
if (buf->bundleDepth == 0) {
/* This handles EMPTY, ONE_MSG, ARGS, and DONE */
OSC_errorMessage = "Can't close bundle; no bundle is open!";
return 5;
}
if (CheckTypeTag(buf, '\0')) return 9;
if (buf->state == GET_ARGS) {
PatchMessageSize(buf);
}
if (buf->bundleDepth == 1) {
/* Closing the last bundle: No bundle size to patch */
buf->state = DONE;
} else {
/* Closing a sub-bundle: patch bundle size */
int size = buf->bufptr - ((char *) buf->prevCounts[buf->bundleDepth]) - 4;
*(buf->prevCounts[buf->bundleDepth]) = htonl(size);
buf->state = NEED_COUNT;
}
--buf->bundleDepth;
buf->gettingFirstUntypedArg = 0;
buf->typeStringPtr = 0;
return 0;
}
static int OSC_writeNullArg(OSCbuf *buf, char type)
{ /* Don't write any data, just check the type tag */
if(OSC_CheckOverflow(buf, 4))return 1;
if (CheckTypeTag(buf, type)) return 9;
buf->gettingFirstUntypedArg = 0;
return 0;
}
static int OSC_writeBlobArg(OSCbuf *buf, typedArg *arg, size_t nArgs)
{
size_t i;
unsigned char b;
/* pack all the args as single bytes following a 4-byte length */
if(OSC_CheckOverflow(buf, nArgs+4))return 1;
if (CheckTypeTag(buf, 'b')) return 9;
*((int4byte *) buf->bufptr) = htonl(nArgs);
#ifdef DEBUG
post ("OSC_writeBlobArg length : %lu", nArgs);
#endif
buf->bufptr += 4;
for (i = 0; i < nArgs; i++)
{
if (arg[i].type != BLOB_osc)
{
error("packOSC: blob element %i not blob type", i);
return 9;
}
b = (unsigned char)((arg[i].datum.i)&0x0FF);/* force int to 8-bit byte */
#ifdef DEBUG
post ("OSC_writeBlobArg : %d, %d", arg[i].datum.i, b);
#endif
buf->bufptr[i] = b;
}
i = OSC_WriteBlobPadding(buf->bufptr, i);
buf->bufptr += i;
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_writeIntArg(OSCbuf *buf, int4byte arg) {
CheckOverflow(buf, 4);
if (CheckTypeTag(buf, 'i')) return 9;
*((int4byte *) buf->bufptr) = htonl(arg);
buf->bufptr += 4;
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_writeStringArg(OSCbuf *buf, char PROGMEM *arg) {
int len;
if (CheckTypeTag(buf, 's')) return 9;
len = OSC_effectiveStringLength(arg);
CheckOverflow(buf, len);
buf->bufptr += OSC_padString(buf->bufptr, arg);
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_closeAllBundles(OSCbuf *buf) {
if (buf->bundleDepth == 0) {
/* This handles EMPTY, ONE_MSG, ARGS, and DONE */
OSC_errorMessage = "Can't close all bundles; no bundle is open!";
return 6;
}
if (CheckTypeTag(buf, '\0')) return 9;
while (buf->bundleDepth > 0) {
OSC_closeBundle(buf);
}
buf->typeStringPtr = 0;
return 0;
}
static int OSC_writeAddress(OSCbuf *buf, char *name)
{
int4byte paddedLength;
if (buf->state == ONE_MSG_ARGS)
{
post("packOSC: This packet is not a bundle, so you can't write another address");
return 7;
}
if (buf->state == DONE)
{
post("packOSC: This packet is finished; can't write another address");
return 8;
}
if (CheckTypeTag(buf, '\0')) return 9;
paddedLength = OSC_effectiveStringLength(name);
if (buf->state == EMPTY)
{
/* This will be a one-message packet, so no sizes to worry about */
if(OSC_CheckOverflow(buf, paddedLength))return 1;
buf->state = ONE_MSG_ARGS;
}
else
{
/* GET_ARGS or NEED_COUNT */
if(OSC_CheckOverflow(buf, 4+paddedLength))return 1;
if (buf->state == GET_ARGS)
{
/* Close the old message */
PatchMessageSize(buf);
}
buf->thisMsgSize = (int4byte *)buf->bufptr;
*(buf->thisMsgSize) = 0xbbbbbbbb;
buf->bufptr += 4;
buf->state = GET_ARGS;
}
/* Now write the name */
buf->bufptr += OSC_padString(buf->bufptr, name);
buf->typeStringPtr = 0;
buf->gettingFirstUntypedArg = 1;
return 0;
}
int OSC_writeFloatArg(OSCbuf *buf, float arg) {
int4byte *intp;
CheckOverflow(buf, 4);
if (CheckTypeTag(buf, 'f')) return 9;
/* Pretend arg is a long int so we can use htonl() */
intp = ((int4byte *) &arg);
*((int4byte *) buf->bufptr) = htonl(*intp);
buf->bufptr += 4;
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_writeFloatArgs(OSCbuf *buf, int numFloats, float *args) {
int i;
int4byte *intp;
CheckOverflow(buf, 4 * numFloats);
/* Pretend args are long ints so we can use htonl() */
intp = ((int4byte *) args);
for (i = 0; i < numFloats; i++) {
if (CheckTypeTag(buf, 'f')) return 9;
*((int4byte *) buf->bufptr) = htonl(intp[i]);
buf->bufptr += 4;
}
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_writeAddressAndTypes(OSCbuf *buf, char *name, char *types) {
int result;
int4byte paddedLength;
if (CheckTypeTag(buf, '\0')) return 9;
result = OSC_writeAddress(buf, name);
if (result) return result;
paddedLength = OSC_effectiveStringLength(types);
CheckOverflow(buf, paddedLength);
buf->typeStringPtr = buf->bufptr + 1; /* skip comma */
buf->bufptr += OSC_padString(buf->bufptr, types);
buf->gettingFirstUntypedArg = 0;
return 0;
}
static int OSC_writeFloatArg(OSCbuf *buf, float arg)
{
union intfloat32
{
int i;
float f;
};
union intfloat32 if32;
if(OSC_CheckOverflow(buf, 4))return 1;
if (CheckTypeTag(buf, 'f')) return 9;
/* Pretend arg is a long int so we can use htonl() */
if32.f = arg;
*((int4byte *) buf->bufptr) = htonl(if32.i);
buf->bufptr += 4;
buf->gettingFirstUntypedArg = 0;
return 0;
}
int OSC_openBundle(OSCbuf *buf, OSCTimeTag tt) {
if (buf->state == ONE_MSG_ARGS) {
OSC_errorMessage = "Can't open a bundle in a one-message packet";
return 3;
}
if (buf->state == DONE) {
OSC_errorMessage = "This packet is finished; can't open a new bundle";
return 4;
}
if (++(buf->bundleDepth) >= MAX_BUNDLE_NESTING) {
OSC_errorMessage = "Bundles nested too deeply; change MAX_BUNDLE_NESTING in OpenSoundControl.h";
return 2;
}
if (CheckTypeTag(buf, '\0')) return 9;
if (buf->state == GET_ARGS) {
PatchMessageSize(buf);
}
if (buf->state == EMPTY) {
/* Need 16 bytes for "#bundle" and time tag */
CheckOverflow(buf, 16);
} else {
/* This bundle is inside another bundle, so we need to leave
a blank size count for the size of this current bundle. */
CheckOverflow(buf, 20);
*((int4byte *)buf->bufptr) = 0xaaaaaaaa;
buf->prevCounts[buf->bundleDepth] = (int4byte *)buf->bufptr;
buf->bufptr += 4;
}
buf->bufptr += OSC_padString(buf->bufptr, "#bundle");
*((OSCTimeTag *) buf->bufptr) = tt;
if (htonl(1) != 1) {
/* Byte swap the 8-byte integer time tag */
int4byte *intp = (int4byte *)buf->bufptr;
intp[0] = htonl(intp[0]);
intp[1] = htonl(intp[1]);
#ifdef HAS8BYTEINT
{ /* tt is a 64-bit int so we have to swap the two 32-bit words.
(Otherwise tt is a struct of two 32-bit words, and even though
each word was wrong-endian, they were in the right order
in the struct.) */
int4byte temp = intp[0];
intp[0] = intp[1];
intp[1] = temp;
}
#endif
}
buf->bufptr += sizeof(OSCTimeTag);
buf->state = NEED_COUNT;
buf->gettingFirstUntypedArg = 0;
buf->typeStringPtr = 0;
return 0;
}
static int OSC_openBundle(OSCbuf *buf, OSCTimeTag tt)
{
if (buf->state == ONE_MSG_ARGS)
{
post("packOSC: Can't open a bundle in a one-message packet");
return 3;
}
if (buf->state == DONE)
{
post("packOSC: This packet is finished; can't open a new bundle");
return 4;
}
if (++(buf->bundleDepth) >= MAX_BUNDLE_NESTING)
{
post("packOSC: Bundles nested too deeply: maybe change MAX_BUNDLE_NESTING from %d and recompile", MAX_BUNDLE_NESTING);
return 2;
}
if (CheckTypeTag(buf, '\0')) return 9;
if (buf->state == GET_ARGS)
{
PatchMessageSize(buf);
}
if (buf->state == EMPTY)
{
/* Need 16 bytes for "#bundle" and time tag */
if(OSC_CheckOverflow(buf, 16)) return 1;
}
else
{
/* This bundle is inside another bundle, so we need to leave
a blank size count for the size of this current bundle. */
if(OSC_CheckOverflow(buf, 20))return 1;
*((int4byte *)buf->bufptr) = 0xaaaaaaaa;
buf->prevCounts[buf->bundleDepth] = (int4byte *)buf->bufptr;
buf->bufptr += 4;
}
buf->bufptr += OSC_padString(buf->bufptr, "#bundle");
*((OSCTimeTag *) buf->bufptr) = tt;
if (htonl(1) != 1)
{
/* Byte swap the 8-byte integer time tag */
int4byte *intp = (int4byte *)buf->bufptr;
intp[0] = htonl(intp[0]);
intp[1] = htonl(intp[1]);
/* tt is a struct of two 32-bit words, and even though
each word was wrong-endian, they were in the right order
in the struct.) */
}
buf->bufptr += sizeof(OSCTimeTag);
buf->state = NEED_COUNT;
buf->gettingFirstUntypedArg = 0;
buf->typeStringPtr = 0;
return 0;
}
