void otimetag_doFullPacket(t_otimetag *x,
long len,
char *ptr)
{
t_osc_timetag t = osc_timetag_now();
if(x->address){
t_osc_bndl_u *copy = osc_bundle_s_deserialize(len, ptr);
t_osc_msg_u *m = osc_message_u_allocWithTimetag(x->address->s_name, t);
osc_bundle_u_addMsgWithoutDups(copy, m);
t_osc_bndl_s *bs = osc_bundle_u_serialize(copy);
if(bs){
omax_util_outletOSC(x->outlet, osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
osc_bundle_s_deepFree(bs);
}
osc_bundle_u_free(copy);
}else{
char copy[len];
memcpy(copy, ptr, len);
osc_bundle_s_setTimetag(len, copy, t);
omax_util_outletOSC(x->outlet, len, copy);
OSC_MEM_INVALIDATE(copy);
}
}
static void udpreceive_read(t_oudpreceive *x, int sockfd)
{
int i, read = 0;
struct sockaddr_in from;
socklen_t fromlen = sizeof(from);
t_atom output_atom;
long addr;
unsigned short port;
read = recvfrom(sockfd, x->x_msginbuf, MAX_UDP_RECEIVE, 0, (struct sockaddr *)&from, &fromlen);
#ifdef DEBUG
post("udpreceive_read: read %lu x->x_connectsocket = %d",
read, x->x_connectsocket);
#endif
/* get the sender's ip */
addr = ntohl(from.sin_addr.s_addr);
port = ntohs(from.sin_port);
x->x_addrbytes[0].a_w.w_float = (addr & 0xFF000000)>>24;
x->x_addrbytes[1].a_w.w_float = (addr & 0x0FF0000)>>16;
x->x_addrbytes[2].a_w.w_float = (addr & 0x0FF00)>>8;
x->x_addrbytes[3].a_w.w_float = (addr & 0x0FF);
x->x_addrbytes[4].a_w.w_float = port;
outlet_anything(x->x_addrout, gensym("from"), 5L, x->x_addrbytes);
if (read < 0)
{
udpreceive_sock_err(x, "udpreceive_read");
sys_closesocket(x->x_connectsocket);
return;
}
if((read % 4) == 0){
char buf[read];
memcpy(buf, x->x_msginbuf, read);
critical_exit(x->lock);
omax_util_outletOSC(x->outlet, read, buf);
OSC_MEM_INVALIDATE(buf);
//oudp_sendData(x, t, x->slipibuf);
}else{
critical_exit(x->lock);
//object_error((t_object *)x, "bad packet: not a multiple of 4 length");
}
/*
if (read > 0)
{
for (i = 0; i < read; ++i)
{
oudp_decode(x, (unsigned char)x->x_msginbuf[i]);
}
oudp_decode(x, END);
x->x_total_received += read;
SETFLOAT(&output_atom, read);
outlet_anything(x->x_addrout, gensym("received"), 1, &output_atom);
}*/
}
void ocoll_bang(t_ocoll *x){
critical_enter(x->lock);
int len = x->buffer_pos;
char outbuf[len];
memcpy(outbuf, x->buffer, len);
memset(x->buffer + OSC_HEADER_SIZE, '\0', len - OSC_HEADER_SIZE);
x->buffer_pos = OSC_HEADER_SIZE;
critical_exit(x->lock);
omax_util_outletOSC(x->outlet, len, outbuf);
// invalidate outbuf:
OSC_MEM_INVALIDATE(outbuf);
}
void odisplay_output_bundle(t_odisplay *x)
{
// the use of critical sections is a little weird here, but correct.
critical_enter(x->lock);
if(x->bndl_s){
t_osc_bndl_s *b = x->bndl_s;
long len = osc_bundle_s_getLen(b);
char *ptr = osc_bundle_s_getPtr(b);
char buf[len];
memcpy(buf, ptr, len);
critical_exit(x->lock);
omax_util_outletOSC(x->outlet, len, buf);
OSC_MEM_INVALIDATE(buf);
return;
}
critical_exit(x->lock);
char buf[OSC_HEADER_SIZE];
memset(buf, '\0', OSC_HEADER_SIZE);
osc_bundle_s_setBundleID(buf);
omax_util_outletOSC(x->outlet, OSC_HEADER_SIZE, buf);
OSC_MEM_INVALIDATE(buf);
}
void osc_mem_free(void *ptr)
{
OSC_MEM_INVALIDATE(ptr);
osc_mem_free_fp(ptr);
}
void olistenumerate_doFullPacket(t_olistenumerate *x,
long len,
char *ptr)
{
if (!x->address) {
return;
}
critical_enter(x->lock);
char* address_name = x->address->s_name;
critical_exit(x->lock);
t_osc_msg_ar_s *matches = osc_bundle_s_lookupAddress(len, ptr, address_name, 1);
char delegate[len];
long dlen = len;
memcpy(delegate, ptr, len);
if (matches) {
// right outlet:
osc_bundle_s_removeMessage(address_name, &dlen, delegate, 1);
int message_count = 0;
osc_bundle_s_getMsgCount(dlen, delegate, &message_count);
if (message_count > 0) {
omax_util_outletOSC(x->outlets[0], dlen, delegate);
OSC_MEM_INVALIDATE(delegate);
}
// left outlet:
for (int i = 0; i < osc_array_getLen(matches); ++i)
{
t_osc_message_s* message_match = (t_osc_message_s*)osc_array_get(matches, i);
t_osc_message_u* unserialized_msg = osc_message_s_deserialize(message_match);
int array_length = osc_message_u_getArgCount(unserialized_msg);
if (array_length > 0)
{
for (int j = 0; j < array_length; ++j)
{
t_osc_atom_u* iter_atom = osc_message_u_getArg(unserialized_msg, j);
t_osc_atom_u* atom_copy = osc_atom_u_copy(iter_atom);
if (atom_copy)
{
t_osc_bundle_u* unserialized_result = NULL;
//char type = osc_atom_u_getTypetag(atom_copy);
unserialized_result = osc_bundle_u_alloc();
t_osc_message_u* value = osc_message_u_allocWithAddress("/value");
osc_message_u_appendAtom(value, atom_copy);
osc_bundle_u_addMsg(unserialized_result, value);
t_osc_message_u* address = osc_message_u_allocWithString("/address", address_name);
t_osc_message_u* index = osc_message_u_allocWithAddress("/index");
osc_message_u_appendInt32(index, j);
t_osc_message_u* length = osc_message_u_allocWithAddress("/length");
osc_message_u_appendInt32(length, array_length);
osc_bundle_u_addMsg(unserialized_result, address);
osc_bundle_u_addMsg(unserialized_result, index);
osc_bundle_u_addMsg(unserialized_result, length);
t_osc_bndl_s *bs = osc_bundle_u_serialize(unserialized_result);
osc_bundle_u_free(unserialized_result); // frees value, count, length and atom_copy
unserialized_result = NULL;
atom_copy = NULL;
if (bs)
{
omax_util_outletOSC(x->outlets[1], osc_bundle_s_getLen(bs), osc_bundle_s_getPtr(bs));
osc_bundle_s_deepFree(bs);
bs = NULL;
}
}
}
if (unserialized_msg) {
osc_message_u_free(unserialized_msg);
unserialized_msg = NULL;
}
} else {
olistenumerate_noMatchesOrData(x);
}
}
} else { // no matches
// right outlet:
omax_util_outletOSC(x->outlets[0], dlen, delegate);
}
if (matches) {
osc_array_free(matches);
}
}
int oudp_decode(t_oudpreceive *x, unsigned char c)
{
post("%s %x %c", __func__, c, c);
critical_enter(x->lock);
int t;
switch(x->istate)
{
case 0: // waiting for packet to start
x->istate = 1;
if(c==END){
break;
}
case 1: // packet has started
switch(c){
case END:
if((x->icount > 0)){ // it was the END byte
#ifdef untestedDEBUGOUTPUT
// full packet process
char stringbuf[4096];
int j=0;
int i;
for(p=0;i<x->icount && i<4095;++i)
{
char c = x->slipibuf[i];
if(c=='/' || c=='#' || (c>='a' && c<='z') || (c>='A' && c<='Z') || (c<='9' && c>='0') )
stringbuf[j++] = c;
else
stringbuf[j++] = '*';
}
stringbuf[j++] = '\0';
object_post((t_object *)x, "o.udp.receive: packet %d %s", x->icount, stringbuf);
#endif
// ParseOSCPacket(x, x->slipibuf, x->icount, true);
t = x->icount;
x->icount = 0;
x->istate = 0;
if((t % 4) == 0){
char buf[t];
memcpy(buf, x->slipibuf, t);
critical_exit(x->lock);
omax_util_outletOSC(x->outlet, t, buf);
OSC_MEM_INVALIDATE(buf);
//oudp_sendData(x, t, x->slipibuf);
return 0;
}else{
critical_exit(x->lock);
//object_error((t_object *)x, "bad packet: not a multiple of 4 length");
return 0;
}
}
x->istate = 0;
break;
case ESC:
x->istate = 2;
break;
// otherwise, just stick it in the packet buffer
default:
if(x->icount < MAXSLIPBUF){
x->slipibuf[(x->icount)++] = c;
}else{
x->istate = 3;
}
break;
}
break;
case 2: // process escapes
switch(c){
case ESC_END:
if(x->icount<MAXSLIPBUF){
x->slipibuf[(x->icount)++] = END;
x->istate = 1;
}
else
x->istate = 3;
break;
case ESC_ESC:
if(x->icount<MAXSLIPBUF){
x->slipibuf[(x->icount)++] = ESC;
x->istate = 1;
}
else
x->istate = 3;
break;
default:
object_post((t_object *)x, "o.udp.receive: ESC not followed by ESC_END or ESC_ESC.");
x->istate = 3;
}
break;
case 3: // error state: hunt for END character (this should probably be a hunt for a non escaped END character..
if(c == END){
x->icount = 0;
x->istate = 0;
}
break;
}
critical_exit(x->lock);
return 1;
}
