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; }