Added a blob type, changed some post()s to error()s.

svn path=/trunk/externals/mrpeach/; revision=11719

1 files changed, 166 insertions, 52 deletions

diff --git a/osc/packOSC.c b/osc/packOSC.c
index 95873c3..f06004c 100644
--- a/osc/packOSC.c
+++ b/osc/packOSC.c
@@ -124,21 +124,32 @@ typedef int int4byte;
 
 typedef struct OSCbuf_struct
 {
-    char      *buffer; /* The buffer to hold the OSC packet */
-    int       size; /* Size of the buffer */
-    char      *bufptr; /* Current position as we fill the buffer */
-    int       state; /* State of partially-constructed message */
-    int4byte  *thisMsgSize; /* Pointer to count field before */
+	char		*buffer; /* The buffer to hold the OSC packet */
+    size_t		size; /* Size of the buffer */
+    char		*bufptr; /* Current position as we fill the buffer */
+    int			state; /* State of partially-constructed message */
+    int4byte	*thisMsgSize; /* Pointer to count field before */
                       /* currently-being-written message */
-    int4byte  *prevCounts[MAX_BUNDLE_NESTING]; /* Pointers to count */
+    int4byte	*prevCounts[MAX_BUNDLE_NESTING]; /* Pointers to count */
                       /* field before each currently open bundle */
-    int       bundleDepth; /* How many sub-sub-bundles are we in now? */
-    char      *typeStringPtr; /* This pointer advances through the type */
+    int			bundleDepth; /* How many sub-sub-bundles are we in now? */
+    char		*typeStringPtr; /* This pointer advances through the type */
                       /* tag string as you add arguments. */
-    int       gettingFirstUntypedArg; /* nonzero if this message doesn't have */
+    int			gettingFirstUntypedArg; /* nonzero if this message doesn't have */
                       /*  a type tag and we're waiting for the 1st arg */
 } OSCbuf;
 
+typedef struct
+{
+    enum {INT_osc, FLOAT_osc, STRING_osc, BLOB_osc, NOTYPE_osc} type;
+    union
+    {
+        int   i;
+        float f;
+        char  *s;
+	} datum;
+} typedArg;
+
 /* Here are the possible values of the state field: */
 
 #define EMPTY 0	/* Nothing written to packet yet */
@@ -162,7 +173,7 @@ static int CheckTypeTag(OSCbuf *buf, char expectedType);
    block of memory that this OSCbuf will use for a buffer, and the number of
    bytes in that block.  (It's the user's job to allocate the memory because
    you do it differently in different systems.) */
-static void OSC_initBuffer(OSCbuf *buf, int size, char *byteArray);
+static void OSC_initBuffer(OSCbuf *buf, size_t size, char *byteArray);
 
 
 /* Reset the given OSCbuf.  Do this after you send out the contents of
@@ -176,7 +187,7 @@ static int OSC_isBufferEmpty(OSCbuf *buf);
 
 
 /* How much space is left in the buffer? */
-static int OSC_freeSpaceInBuffer(OSCbuf *buf);
+static size_t OSC_freeSpaceInBuffer(OSCbuf *buf);
 
 /* Does the buffer contain a valid OSC packet?  (Returns nonzero if yes.) */
 static int OSC_isBufferDone(OSCbuf *buf);
@@ -187,7 +198,7 @@ static int OSC_isBufferDone(OSCbuf *buf);
    want to re-use this OSCbuf for the next packet.)  */
 static char *OSC_getPacket(OSCbuf *buf);
 static int OSC_packetSize(OSCbuf *buf);
-static int OSC_CheckOverflow(OSCbuf *buf, int bytesNeeded);
+static int OSC_CheckOverflow(OSCbuf *buf, size_t bytesNeeded);
 
 /* Here's the basic model for building up OSC messages in an OSCbuf:
     - Make sure the OSCbuf has been initialized with OSC_initBuffer().
@@ -218,6 +229,7 @@ static int OSC_writeAddress(OSCbuf *buf, char *name);
 static int OSC_writeAddressAndTypes(OSCbuf *buf, char *name, char *types);
 static int OSC_writeFloatArg(OSCbuf *buf, float arg);
 static int OSC_writeIntArg(OSCbuf *buf, int4byte arg);
+static int OSC_writeBlobArg(OSCbuf *buf, typedArg *arg, size_t nArgs);
 static int OSC_writeStringArg(OSCbuf *buf, char *arg);
 static int OSC_writeNullArg(OSCbuf *buf, char type);
 
@@ -226,17 +238,6 @@ static int OSC_writeNullArg(OSCbuf *buf, char type);
    needed for 4-byte alignment. */
 static int OSC_effectiveStringLength(char *string);
 
-typedef struct
-{
-    enum {INT_osc, FLOAT_osc, STRING_osc, NOTYPE_osc} type;
-    union
-    {
-        int   i;
-        float f;
-        char  *s;
-    } datum;
-} typedArg;
-
 
 static t_class *packOSC_class;
 
@@ -270,6 +271,7 @@ static void packOSC_free(t_packOSC *x);
 void packOSC_setup(void);
 static typedArg packOSC_parseatom(t_atom *a);
 static typedArg packOSC_forceatom(t_atom *a, char ctype);
+static typedArg packOSC_blob(t_atom *a);
 static int packOSC_writetypedmessage(t_packOSC *x, OSCbuf *buf, char *messageName, int numArgs, typedArg *args, char *typeStr);
 static int packOSC_writemessage(t_packOSC *x, OSCbuf *buf, char *messageName, int numArgs, typedArg *args);
 static void packOSC_sendbuffer(t_packOSC *x);
@@ -326,7 +328,7 @@ static void packOSC_closebundle(t_packOSC *x)
 {
     if (OSC_closeBundle(x->x_oscbuf))
     {
-        post("packOSC: Problem closing bundle.");
+        error("packOSC: Problem closing bundle.");
         return;
     }
     outlet_float(x->x_bdpthout, (float)x->x_oscbuf->bundleDepth);
@@ -373,17 +375,17 @@ static void packOSC_setTimeTagOffset(t_packOSC *x, t_floatarg f)
 static void packOSC_sendtyped(t_packOSC *x, t_symbol *s, int argc, t_atom *argv)
 {
     char            messageName[MAXPDSTRING];
-    unsigned int    nTypeTags = 0, typeStrTotalSize = 0;
+    unsigned int	nTypeTags = 0, typeStrTotalSize = 0;
     unsigned int    argsSize = sizeof(typedArg)*argc;
     char*           typeStr = NULL; /* might not be used */
     typedArg*       args = (typedArg*)getbytes(argsSize);
-    int             i, nTags, nArgs;
+    unsigned int    i, nTagsWithData, nArgs, blobCount;
     unsigned int    m, j, k;
     char            c;
 
     if (args == NULL)
     {
-        post("packOSC: unable to allocate %lu bytes for args", argsSize);
+        error("packOSC: unable to allocate %lu bytes for args", argsSize);
         return;
     }
     messageName[0] = '\0'; /* empty */
@@ -394,7 +396,7 @@ static void packOSC_sendtyped(t_packOSC *x, t_symbol *s, int argc, t_atom *argv)
         len = MAXPDSTRING-1;
 
         strncpy(messageName, x->x_prefix, MAXPDSTRING);
-        atom_string(&argv[0], messageName+len, MAXPDSTRING-len);
+        atom_string(&argv[0], messageName+len, (unsigned)(MAXPDSTRING-len));
     }
     else
         atom_string(&argv[0], messageName, MAXPDSTRING); /* the OSC address string */
@@ -402,12 +404,12 @@ static void packOSC_sendtyped(t_packOSC *x, t_symbol *s, int argc, t_atom *argv)
     if (x->x_typetags & 2)
     { /* second arg is typestring */
         /* we need to find out how long the type string is before we copy it*/
-        nTypeTags = strlen(atom_getsymbol(&argv[1])->s_name);
+        nTypeTags = (unsigned int)strlen(atom_getsymbol(&argv[1])->s_name);
         typeStrTotalSize = nTypeTags + 2;
         typeStr = (char*)getzbytes(typeStrTotalSize);
         if (typeStr == NULL)
         {
-            post("packOSC: unable to allocate %lu bytes for typeStr", nTypeTags);
+            error("packOSC: unable to allocate %lu bytes for typeStr", nTypeTags);
             return;
         }
         typeStr[0] = ',';
@@ -416,24 +418,50 @@ static void packOSC_sendtyped(t_packOSC *x, t_symbol *s, int argc, t_atom *argv)
         post("typeStr: %s, nTypeTags %lu", typeStr, nTypeTags);
 #endif
         nArgs = argc-2;
-        for (m = nTags = 0; m < nTypeTags; ++m)
+		for (m = nTagsWithData = blobCount = 0; m < nTypeTags; ++m)
         {
 #ifdef DEBUG
             post("typeStr[%d] %c", m+1, typeStr[m+1]);
 #endif
             if ((c = typeStr[m+1]) == 0) break;
             if (!(c == 'T' || c == 'F' || c == 'N' || c == 'I'))
-                ++nTags; /* these tags have data */
+                ++nTagsWithData; /* these tags have data */
+/*OSC-blob
+    An int32 size count, followed by that many 8-bit bytes of arbitrary binary data, 
+	followed by 0-3 additional zero bytes to make the total number of bits a multiple of 32.
+*/			if (c == 'b')
+			{
+				++nTagsWithData ; /* at least one byte of data, */
+				blobCount++; /* but probably more, so set a flag */
+			}
+		}
+        if (((blobCount == 0)&&(nTagsWithData != nArgs)) || ((blobCount != 0)&&(nTagsWithData > nArgs)))
+        {
+            error("packOSC: Tags count %d doesn't match argument count %d", nTagsWithData, nArgs);
+	        goto cleanup;
         }
-        if (nTags != nArgs)
+        if (blobCount > 1)
         {
-            post("packOSC: Tags count %d doesn't match argument count %d", nTags, nArgs);
+            error("packOSC: Only one blob per packet at the moment...");
 	        goto cleanup;
         }
         for (j = k = 0; j < m; ++j) /* m is the number of tags */
         {
             c = typeStr[j+1];
-            if (!(c == 'T' || c == 'F' || c == 'N' || c == 'I')) /* not no data */
+			if (c == 'b')
+			{ /* A blob has to be the last item, until we get more elaborate. */
+				if (j != m-1)
+				{
+		            error("packOSC: Since I don't know how big the blob is, Blob must be the last item in the list");
+			        goto cleanup;
+				}
+				/* Pack all the remaining arguments as a blob */
+				for (; k < nArgs; ++k)
+				{
+					args[k] = packOSC_blob(&argv[k+2]);
+				}
+			}
+            else if (!(c == 'T' || c == 'F' || c == 'N' || c == 'I')) /* not no data */
             {
                 args[k] = packOSC_forceatom(&argv[k+2], c);
                 ++k;
@@ -441,13 +469,13 @@ static void packOSC_sendtyped(t_packOSC *x, t_symbol *s, int argc, t_atom *argv)
         }
         if(packOSC_writetypedmessage(x, x->x_oscbuf, messageName, nArgs, args, typeStr))
         {
-            post("packOSC: usage error, write-msg failed.");
+            error("packOSC: usage error, write-msg failed.");
 	        goto cleanup;
         }
     }
     else
     {
-        for (i = 0; i < argc-1; i++)
+        for (i = 0; i < (unsigned)(argc-1); i++)
         {
             args[i] = packOSC_parseatom(&argv[i+1]);
 #ifdef DEBUG
@@ -471,7 +499,7 @@ static void packOSC_sendtyped(t_packOSC *x, t_symbol *s, int argc, t_atom *argv)
         }
         if(packOSC_writemessage(x, x->x_oscbuf, messageName, i, args))
         {
-            post("packOSC: usage error, write-msg failed.");
+            error("packOSC: usage error, write-msg failed.");
 	        goto cleanup;
         }
     }
@@ -600,6 +628,42 @@ static typedArg packOSC_parseatom(t_atom *a)
     }
 }
 
+static typedArg packOSC_blob(t_atom *a)
+{ /* ctype is one of i,f,s,T,F,N,I*/
+    typedArg    returnVal;
+    t_float     f;
+    t_int       i;
+    t_symbol    s;
+    static char buf[MAXPDSTRING];
+  
+    returnVal.type = NOTYPE_osc;
+    returnVal.datum.s = NULL;
+#ifdef DEBUG
+    post("packOSC_blob %d:", nArgs);
+#endif
+    /* the atoms must all be bytesl */
+    if(a->a_type != A_FLOAT)
+    {
+		error("packOSC_blob: all values must be floats");
+	    return returnVal;
+	}
+	f = atom_getfloat(a);
+	i = (int)f;
+	if (i != f)
+	{
+		error("packOSC_blob: all values must be whole numbers");
+	    return returnVal;
+	}
+	if ((i < -128) || (i > 255))
+	{
+		error("packOSC_blob: all values must be bytes");
+	    return returnVal;
+	}
+	returnVal.type = BLOB_osc;
+	returnVal.datum.i = i;
+    return returnVal;
+}
+
 static typedArg packOSC_forceatom(t_atom *a, char ctype)
 { /* ctype is one of i,f,s,T,F,N,I*/
     typedArg    returnVal;
@@ -699,7 +763,7 @@ static int packOSC_writetypedmessage
 
     if (returnVal)
     {
-        post("packOSC: Problem writing address. (%d)", returnVal);
+        error("packOSC: Problem writing address. (%d)", returnVal);
         return returnVal;
     }
     for (j = i = 0; (typeStr[i+1]!= 0) || (j < numArgs); j++, i++)
@@ -734,6 +798,12 @@ static int packOSC_writetypedmessage
 #endif
 	                returnVal = OSC_writeStringArg(buf, args[j].datum.s);
 	                break;
+				case BLOB_osc:
+					/* write all the blob elements at once */
+#ifdef DEBUG
+					post("packOSC_writetypedmessage calling OSC_writeBlobArg\n");
+#endif
+					return OSC_writeBlobArg(buf, &args[j], numArgs-j);
 	            default:
 
 	                break; /* types with no data */
@@ -745,9 +815,7 @@ static int packOSC_writetypedmessage
 
 static int packOSC_writemessage(t_packOSC *x, OSCbuf *buf, char *messageName, int numArgs, typedArg *args)
 {
-    int j, returnVal;
-
-    returnVal = 0;
+    int j, returnVal = 0, numTags;
 
     if (!x->x_typetags)
     {
@@ -759,11 +827,17 @@ static int packOSC_writemessage(t_packOSC *x, OSCbuf *buf, char *messageName, in
     }
     else
     {
-        /* First figure out the type tags */
-        char *typeTags=(char*)getbytes(sizeof(char)*(numArgs+2));
+		char *typeTags;
+
+		/* First figure out the type tags */
+		for (numTags = 0; numTags < numArgs; numTags++)
+		{
+			if (args[numTags].type == BLOB_osc) break; /* blob has one type tag and is the last element */
+		}
+        typeTags=(char*)getbytes(sizeof(char)*(numTags+2)); /* number of args + ',' + '\0' */
 
         typeTags[0] = ',';
-        for (j = 0; j < numArgs; ++j)
+        for (j = 0; j < numTags; ++j)
         {
             switch (args[j].type)
             {
@@ -776,8 +850,11 @@ static int packOSC_writemessage(t_packOSC *x, OSCbuf *buf, char *messageName, in
                 case STRING_osc:
                     typeTags[j+1] = 's';
                     break;
+                case BLOB_osc:
+                    typeTags[j+1] = 'b';
+                    break;
                 default:
-                    post("packOSC: arg %d type is unrecognized(%d)", j, args[j].type);
+                    error("packOSC: arg %d type is unrecognized(%d)", j, args[j].type);
                     break;
             }
         }
@@ -785,9 +862,9 @@ static int packOSC_writemessage(t_packOSC *x, OSCbuf *buf, char *messageName, in
         returnVal = OSC_writeAddressAndTypes(buf, messageName, typeTags);
         if (returnVal)
         {
-            post("packOSC: Problem writing address.");
+            error("packOSC: Problem writing address.");
         }
-	freebytes(typeTags, sizeof(char)*(numArgs+2));
+		freebytes(typeTags, sizeof(char)*(numTags+2));
     }
     for (j = 0; j < numArgs; j++)
     {
@@ -802,6 +879,9 @@ static int packOSC_writemessage(t_packOSC *x, OSCbuf *buf, char *messageName, in
             case STRING_osc:
                 returnVal = OSC_writeStringArg(buf, args[j].datum.s);
                 break;
+            case BLOB_osc:
+				post ("packOSC_writemessage calling OSC_writeBlobArg\n");
+                return OSC_writeBlobArg(buf, &args[j], numArgs-j); /* All the remaining args are blob */
             default:
                 break; /* just skip bad types (which we won't get anyway unless this code is buggy) */
         }
@@ -859,7 +939,7 @@ static void packOSC_sendbuffer(t_packOSC *x)
 */
 
 
-static void OSC_initBuffer(OSCbuf *buf, int size, char *byteArray)
+static void OSC_initBuffer(OSCbuf *buf, size_t size, char *byteArray)
 {
     buf->buffer = byteArray;
     buf->size = size;
@@ -881,7 +961,7 @@ static int OSC_isBufferEmpty(OSCbuf *buf)
     return buf->bufptr == buf->buffer;
 }
 
-static int OSC_freeSpaceInBuffer(OSCbuf *buf)
+static size_t OSC_freeSpaceInBuffer(OSCbuf *buf)
 {
     return buf->size - (buf->bufptr - buf->buffer);
 }
@@ -901,11 +981,11 @@ static int OSC_packetSize(OSCbuf *buf)
     return (buf->bufptr - buf->buffer);
 }
 
-static int OSC_CheckOverflow(OSCbuf *buf, int bytesNeeded)
+static int OSC_CheckOverflow(OSCbuf *buf, size_t bytesNeeded)
 {
     if ((bytesNeeded) > OSC_freeSpaceInBuffer(buf))
     {
-        post("packOSC: buffer overflow");
+        error("packOSC: buffer overflow");
         return 1;
     }
     return 0;
@@ -1159,6 +1239,40 @@ static int OSC_writeIntArg(OSCbuf *buf, int4byte arg)
     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_WritePadding(buf->bufptr, i);
+	buf->bufptr += i;
+	buf->gettingFirstUntypedArg = 0;
+    return 0;
+}
+
 static int OSC_writeStringArg(OSCbuf *buf, char *arg)
 {
     int len;