Esempio n. 1
0
void simplemax_anything(t_simplemax *x,t_symbol* s,int argc,t_atom* argv){
    
    // msg is a dispatch name (/foo), argc is # of elements, argv is element vector
    
    if (!s){object_error((t_object*)x, "NOOOOOO!!!!");}
    
    //object_post((t_object*)x, "%s",msg->s_name);
    t_osc_bundle_u *bundle = osc_bundle_u_alloc();//alloc creates memory for and initializes the bundle
    
    
    t_osc_message_u *msg = osc_message_u_alloc();
    osc_message_u_setAddress(msg, s->s_name);
    
    
    for(int i=0;i < argc;i++){ //going through all the arguments (arg vector) whos length is argc
        
        t_osc_atom_u* a = osc_atom_u_alloc();
        
        switch(atom_gettype(argv+i)){
            
            case A_LONG:
            osc_atom_u_setInt32(a, atom_getlong(argv+i));
            break;
            
            case A_FLOAT:
            osc_atom_u_setFloat(a, atom_getfloat(argv+i));
            break;
            
            case A_SYM:
            osc_atom_u_setString(a, atom_getsym(argv+i)->s_name);
            break;
        
        }
        
        osc_message_u_appendAtom(msg, a);
        //osc_message_u_appendFloat(msg, 15.0);
    }
    osc_bundle_u_addMsg(bundle, msg);
    long bytes = 0;//length of byte array
    char* pointer = NULL;
    
    osc_bundle_u_serialize(bundle, &bytes, &pointer);//& is adress of the variable
    //post("%ld %p", bytes,pointer);
    
    t_atom out[2];
    atom_setlong(out, bytes);
    atom_setlong(out+1, (long)pointer);
    outlet_anything(x->outlet, gensym("FullPacket"), 2, out);
    
    osc_bundle_u_free(bundle);//get rid of stuff in osc message
    osc_mem_free(pointer);//marks pointer address as being free (clear if you want to keep using same pointer)
    
    
}
Esempio n. 2
0
t_osc_msg_u *osc_message_s_deserialize(t_osc_msg_s *msg)
{
	t_osc_msg_u *m = osc_message_u_alloc();
	osc_message_u_setAddress(m, osc_message_s_getAddress(msg));
	t_osc_msg_it_s *it = osc_msg_it_s_get(msg);
	while(osc_msg_it_s_hasNext(it)){
		t_osc_atom_s *a = osc_msg_it_s_next(it);
		t_osc_atom_u *ua = osc_atom_s_deserialize(a);
		osc_message_u_appendAtom(m, ua);
	}
	osc_msg_it_s_destroy(it);
	return m;
}
Esempio n. 3
0
void *oedge_new(t_symbol *msg, short argc, t_atom *argv)
{
	t_oedge *x = NULL;
	if((x = (t_oedge *)object_alloc(oedge_class))){
  		dsp_setup((t_pxobject *)x, 1); 
		x->outlet = outlet_new((t_object *)x, "FullPacket");
		critical_new(&(x->lock));
		x->ac = 0;
		x->av = NULL;
		x->lastx = 0;
		x->gettime = 0;

		x->time_onset = osc_message_u_alloc();
		osc_message_u_setAddress(x->time_onset, "/zerotononzero/time");
		x->block_sample_onset = osc_message_u_alloc();
		osc_message_u_setAddress(x->block_sample_onset, "/zerotononzero/sample/withinblock");
		x->global_sample_onset = osc_message_u_alloc();
		osc_message_u_setAddress(x->global_sample_onset, "/zerotononzero/sample/sincedspstart");
		x->value_onset = osc_message_u_alloc();
		osc_message_u_setAddress(x->value_onset, "/zerotononzero/value");

		x->time_zero = osc_message_u_alloc();
		osc_message_u_setAddress(x->time_zero, "/nonzerotozero/time");
		x->block_sample_zero = osc_message_u_alloc();
		osc_message_u_setAddress(x->block_sample_zero, "/nonzerotozero/sample/withinblock");
		x->global_sample_zero = osc_message_u_alloc();
		osc_message_u_setAddress(x->global_sample_zero, "/nonzerotozero/sample/sincedspstart");

		x->bundle = osc_bundle_u_alloc();

		osc_bundle_u_addMsg(x->bundle, x->time_onset);
		osc_bundle_u_addMsg(x->bundle, x->block_sample_onset);
		osc_bundle_u_addMsg(x->bundle, x->global_sample_onset);
		osc_bundle_u_addMsg(x->bundle, x->value_onset);
		osc_bundle_u_addMsg(x->bundle, x->time_zero);
		osc_bundle_u_addMsg(x->bundle, x->block_sample_zero);
		osc_bundle_u_addMsg(x->bundle, x->global_sample_zero);
	}
	return x;
}
Esempio n. 4
0
void ovalidate_fullPacket(t_ovalidate *x, t_symbol *msg, int argc, t_atom *argv)
{
	OMAX_UTIL_GET_LEN_AND_PTR;
	/*
	t_osc_err e = osc_error_bundleSanityCheck(len, ptr);
	if(e){
		t_osc_bndl_u *b = osc_bundle_u_alloc();

		t_osc_msg_u *merr = osc_message_u_alloc();
		osc_message_u_setAddress(merr, "/error/str");
		osc_message_u_appendString(merr, osc_error_string(e));
		osc_bundle_u_addMsg(b, merr);

		long l = 0;
		char *buf = NULL;
		osc_bundle_u_serialize(b, &l, &buf);
		if(buf){
			omax_util_outletOSC(x->outletErr, l, buf);
			omax_util_outletOSC(x->outletInval, len, ptr);
			osc_mem_free(buf);
		}
		return;
	}
	*/
	if(*ptr != '#' && *ptr != '/'){
		char errstr[128];
		snprintf(errstr, 128, "invalid packet: packet does not begin with a # or a /");
		t_osc_bndl_u *b = osc_bundle_u_alloc();

		t_osc_msg_u *merr = osc_message_u_alloc();
		osc_message_u_setAddress(merr, "/error/str");
		osc_message_u_appendString(merr, errstr);
		osc_bundle_u_addMsg(b, merr);

		t_osc_bndl_s *bs = osc_bundle_u_serialize(b);
		if(bs){
			omax_util_outletOSC(x->outletErr, osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
			omax_util_outletOSC(x->outletInval, len, ptr);
			osc_bundle_s_deepFree(bs);
		}
		return;
	}
	if(len % 4){
		char errstr[128];
		snprintf(errstr, 128, "%ld is not a multiple of 4 bytes", len);
		t_osc_bndl_u *b = osc_bundle_u_alloc();

		t_osc_msg_u *merr = osc_message_u_alloc();
		osc_message_u_setAddress(merr, "/error/str");
		osc_message_u_appendString(merr, errstr);
		osc_bundle_u_addMsg(b, merr);

		t_osc_bndl_s *bs = osc_bundle_u_serialize(b);
		if(bs){
			omax_util_outletOSC(x->outletErr, osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
			omax_util_outletOSC(x->outletInval, len, ptr);
			osc_bundle_s_deepFree(bs);
		}
		return;
	}
	if(*ptr == '#'){
		char *p = ptr;
		p += OSC_HEADER_SIZE;
		while((p - ptr) < (len - 4)){
			int i = ntoh32(*((int32_t *)p));
			if(i < 0){
				break;
			}
			p += i + 4;
		}
		if((p - ptr) != len){
			char errstr[128];
			snprintf(errstr, 128, "expected %ld bytes, but found %d", len, p - ptr);
			t_osc_bndl_u *b = osc_bundle_u_alloc();

			t_osc_msg_u *merr = osc_message_u_alloc();
			osc_message_u_setAddress(merr, "/error/str");
			osc_message_u_appendString(merr, errstr);
			osc_bundle_u_addMsg(b, merr);

			t_osc_bndl_s *bs = osc_bundle_u_serialize(b);
			if(bs){
				omax_util_outletOSC(x->outletErr, osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
				omax_util_outletOSC(x->outletInval, len, ptr);
				osc_bundle_s_deepFree(bs);
			}
			return;
		}
	}
	uint64_t state = OSC_SERIAL_INIT;
	for(int i = 0; i < len; i++){
		state = osc_serial_processByte(ptr[i], state);
		if(osc_serial_errorp(state)){
			char *errstr = osc_serial_errstr(state);
			t_osc_bndl_u *b = osc_bundle_u_alloc();

			t_osc_msg_u *merr = osc_message_u_alloc();
			osc_message_u_setAddress(merr, "/error/str");
			osc_message_u_appendString(merr, errstr);
			osc_bundle_u_addMsg(b, merr);

			t_osc_msg_u *mbytenum = osc_message_u_alloc();
			osc_message_u_setAddress(mbytenum, "/error/byte/num");
			osc_message_u_appendInt32(mbytenum, i);
			osc_bundle_u_addMsg(b, mbytenum);

			if(mbytenum < len){
				t_osc_msg_u *mbyteval = osc_message_u_alloc();
				osc_message_u_setAddress(mbyteval, "/error/byte/val");
				osc_message_u_appendInt32(mbyteval, ptr[i]);
				osc_bundle_u_addMsg(b, mbyteval);
			}

			t_osc_bndl_s *bs = osc_bundle_u_serialize(b);
			if(bs){
				omax_util_outletOSC(x->outletErr, osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
				omax_util_outletOSC(x->outletInval, len, ptr);
				osc_bundle_s_deepFree(bs);
			}
			return;
		}
	}
	omax_util_outletOSC(x->outletVal, len, ptr);
}
Esempio n. 5
0
static t_osc_err osc_bundle_u_flatten_impl(t_osc_bndl_u **dest,
					   t_osc_bndl_u *src,
					   int maxlevel,
					   int level,
					   char *prefix,
					   char *sep,
					   int remove_enclosing_address_if_empty)
{
	if(!sep){
		sep = "";
	}
	if(!(*dest)){
		*dest = osc_bundle_u_alloc();
	}
	t_osc_bndl_it_u *bit = osc_bndl_it_u_get(src);
	while(osc_bndl_it_u_hasNext(bit)){
		t_osc_msg_u *m = osc_bndl_it_u_next(bit);
		t_osc_msg_u *mcopy = NULL;
		osc_message_u_deepCopy(&mcopy, m);
		if((level < maxlevel) || (maxlevel <= 0)){
			t_osc_msg_it_u *mit = osc_msg_it_u_get(mcopy);
			while(osc_msg_it_u_hasNext(mit)){
				t_osc_atom_u *a = osc_msg_it_u_next(mit);
				if(osc_atom_u_getTypetag(a) == OSC_BUNDLE_TYPETAG){
					osc_message_u_removeAtom(mcopy, a);
					t_osc_bndl_u *bu = osc_atom_u_getBndl(a);
					/*
					t_osc_bndl_u *bu = NULL;
					osc_bundle_s_deserialize(osc_bundle_s_getLen(b),
								 osc_bundle_s_getPtr(b),
								 &bu);
					*/
					t_osc_err e;
					if(prefix){
						int prefixlen = strlen(prefix) + strlen(osc_message_u_getAddress(mcopy)) + strlen(sep);
						char pfx[prefixlen + 1];
						sprintf(pfx, "%s%s%s", prefix, sep, osc_message_u_getAddress(mcopy));
						e = osc_bundle_u_flatten_impl(dest,
									      bu,
									      maxlevel,
									      level + 1,
									      pfx,
									      sep,
									      remove_enclosing_address_if_empty);
					}else{
						e = osc_bundle_u_flatten_impl(dest,
									      bu,
									      maxlevel,
									      level + 1,
									      osc_message_u_getAddress(mcopy),
									      sep,
									      remove_enclosing_address_if_empty);
					}
					if(e){
						return e;
					}
					osc_atom_u_free(a);
				}
			}
			osc_msg_it_u_destroy(mit);
		}
		if(!remove_enclosing_address_if_empty || osc_message_u_getArgCount(mcopy) > 0){
			if(prefix){
				int newaddresslen = strlen(prefix) + strlen(osc_message_u_getAddress(mcopy)) + strlen(sep);
				char newaddress[newaddresslen + 1];
				sprintf(newaddress, "%s%s%s", prefix, sep, osc_message_u_getAddress(mcopy));
				osc_message_u_setAddress(mcopy, newaddress);
			}
			osc_bundle_u_addMsgWithoutDups(*dest, mcopy);
		}else{
			osc_message_u_free(mcopy);
		}
	}
	osc_bndl_it_u_destroy(bit);
	return OSC_ERR_NONE;
}
Esempio n. 6
0
int main(int argc, char **argv)
{
	// create a bundle and add messages to it
	t_osc_bndl_u *bndl_u = osc_bundle_u_alloc();
	t_osc_msg_u *m1 = osc_message_u_alloc();
	osc_message_u_setAddress(m1, "/foo");
	osc_message_u_appendFloat(m1, 3.14);
	osc_bundle_u_addMsg(bndl_u, m1);

	t_osc_msg_u *m2 = osc_message_u_allocWithString("/bar", "whatevs");
	osc_bundle_u_addMsg(bndl_u, m2);

	t_osc_msg_u *m3 = osc_message_u_allocWithAddress("/bloo");
	t_osc_atom_u *a = osc_atom_u_allocWithInt32(12);
	osc_message_u_appendAtom(m3, a);
	osc_bundle_u_addMsg(bndl_u, m3);

	// serialize the bundle
	long len = osc_bundle_u_nserialize(NULL, 0, bndl_u);
	char bndl_s[len];
	osc_bundle_u_nserialize(bndl_s, len, bndl_u);

	// free the original unserialized bundle
	osc_bundle_u_free(bndl_u);
	bndl_u = NULL;

	// deserialize the serialized bundle
	osc_bundle_s_deserialize(len, bndl_s, &bndl_u);
	
	// iterate over messages in a serialized bundle
	t_osc_bndl_it_s *b_it_s = osc_bndl_it_s_get(len, bndl_s);
	while(osc_bndl_it_s_hasNext(b_it_s)){
		t_osc_msg_s *m = osc_bndl_it_s_next(b_it_s);
		printf("%s\n", osc_message_s_getAddress(m));
	}
	osc_bndl_it_s_destroy(b_it_s);

	// turn a serialized bundle into printable text
	long tlen = osc_bundle_s_nformat(NULL, 0, len, bndl_s, 0);
	char text[tlen + 1];
	osc_bundle_s_nformat(text, tlen, len, bndl_s, 0);
	printf("\nBUNDLE:\n");
	printf("%s\n", text);
	printf("\n");

	// turn text into an unserialized bundle
	t_osc_bndl_u *bndl_u_2 = NULL;
	char *text2 = "/jean : [1, 2, 3], /john : 6.66, /jeremy : \"is cool\"";
	osc_parser_parseString(strlen(text2), text2, &bndl_u_2);

	// iterate over messages in an unserialized bundle
	t_osc_bndl_it_u *b_it_u = osc_bndl_it_u_get(bndl_u_2);
	while(osc_bndl_it_u_hasNext(b_it_u)){
		t_osc_msg_u *m = osc_bndl_it_u_next(b_it_u);
		printf("%s has typetags ", osc_message_u_getAddress(m));
		// iterate over atoms in list
		t_osc_msg_it_u *m_it_u = osc_msg_it_u_get(m);
		while(osc_msg_it_u_hasNext(m_it_u)){
			t_osc_atom_u *a = osc_msg_it_u_next(m_it_u);
			printf("%c", osc_atom_u_getTypetag(a));
		}
		osc_msg_it_u_destroy(m_it_u);
		printf("\n");
	}
	osc_bndl_it_u_destroy(b_it_u);
}
Esempio n. 7
0
void _omax_doc_outletDoc(void *outlet,
			 char *name,
			 char *short_desc,
			 char *long_desc,
			 int ninlets,
			 char **inlets_desc,
			 int noutlets,
			 char **outlets_desc,
			 int num_see_also_refs,
			 char **see_also)
{
	t_osc_bndl_u *bndl = osc_bundle_u_alloc();
	t_osc_msg_u *msg_name = osc_message_u_alloc();
	osc_message_u_setAddress(msg_name, "/doc/name");
	osc_message_u_appendString(msg_name, name);
	osc_bundle_u_addMsg(bndl, msg_name);

	t_osc_msg_u *msg_short_desc = osc_message_u_alloc();
	osc_message_u_setAddress(msg_short_desc, "/doc/desc/short");
	osc_message_u_appendString(msg_short_desc, short_desc);
	osc_bundle_u_addMsg(bndl, msg_short_desc);

	t_osc_msg_u *msg_long_desc = osc_message_u_alloc();
	osc_message_u_setAddress(msg_long_desc, "/doc/desc/long");
	osc_message_u_appendString(msg_long_desc, long_desc);
	osc_bundle_u_addMsg(bndl, msg_long_desc);

	t_osc_msg_u *msg_ninlets = osc_message_u_alloc();
	osc_message_u_setAddress(msg_ninlets, "/doc/ninlets");
	osc_message_u_appendInt32(msg_ninlets, ninlets);
	osc_bundle_u_addMsg(bndl, msg_ninlets);

	t_osc_msg_u *msg_noutlets = osc_message_u_alloc();
	osc_message_u_setAddress(msg_noutlets, "/doc/noutlets");
	osc_message_u_appendInt32(msg_noutlets, noutlets);
	osc_bundle_u_addMsg(bndl, msg_noutlets);

	int i;
	for(i = 0; i < ninlets; i++){
		if(inlets_desc[i]){
			t_osc_msg_u *m = osc_message_u_alloc();
			char buf[64];
			sprintf(buf, "/doc/desc/inlet/%d", i + 1);
			osc_message_u_setAddress(m, buf);
			osc_message_u_appendString(m, inlets_desc[i]);
			osc_bundle_u_addMsg(bndl, m);
		}
	}
	for(i = 0; i < noutlets; i++){
		if(outlets_desc[i]){
			t_osc_msg_u *m = osc_message_u_alloc();
			char buf[64];
			sprintf(buf, "/doc/desc/outlet/%d", i + 1);
			osc_message_u_setAddress(m, buf);
			osc_message_u_appendString(m, outlets_desc[i]);
			osc_bundle_u_addMsg(bndl, m);
		}
	}

	t_osc_msg_u *msg_seealso = osc_message_u_alloc();
	osc_message_u_setAddress(msg_seealso, "/doc/seealso");
	for(i = 0; i < num_see_also_refs; i++){
		osc_message_u_appendString(msg_seealso, see_also[i]);
	}
	osc_bundle_u_addMsg(bndl, msg_seealso);
	//long len = 0;
	//char *bndl_s = NULL;
	t_osc_bndl_s *bs = osc_bundle_u_serialize(bndl);
	if(bs){
		omax_util_outletOSC(outlet, osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
		osc_bundle_s_deepFree(bs);
	}
	if(bndl){
		osc_bundle_u_free(bndl);
	}
}