BenCello

I'm new on the forum and practicing MaxMSP for one year now.

I wrote my first external a few days ago. Here is the problem : I need an object that receive UDP packets but not in OSC-style. I already have the parser and it works a little with my C code.

But it crashes quite often and I made the receiving of each packet with a clock system which is heavy for Max.

So I'm wondering how can I code this things more efficientely.

Hi !
I'm new on the forum and practicing MaxMSP for one year now.

I wrote my first external a few days ago. Here is the problem : I need an object that receive UDP packets but not in OSC-style. I already have the parser and it works a little with my C code.
But it crashes quite often and I made the receiving of each packet with a clock system which is heavy for Max.

udp-external-in-c

I manage to make it with an other schedule than the Max main schedule and I also set the Socket on non-blocking mode to avoid lags.

If interested,
I manage to make it with an other schedule than the Max main schedule and I also set the Socket on non-blocking mode to avoid lags.
It works perfectly.


Yeah, if you want, no problem. But it's quite long, should I copy it directly in a post ?

Here is the C source code. The parsing code will not be very interesting because it goes with a plugin wrote specially for the system I needed to use. But what is interesting, I think, is :

- the management of the socket and schedule

- the possibility to receive binary datas (which is impossible with "mxj net.udp.recv" for example) directly to a buffer to parse it.

If you have some remarks about my programming, please tell me, it's my first external and I really want to improve my programming for MaxMSP.

Last remark : it was develop for MacIntel architecture. The management of the socket on windows needs some modifications.

typedef struct TRawSensor TSensorMatrix[2][16];

void *udp_parser_new(long tempo, long port);

void socket_bind(b_udp_parser *d, int port);

void parse(b_udp_parser *d,char* mess,int size,TSensorMatrix* sensorMatrix);

void output(b_udp_parser * d, struct TRawSensor* sensdata,int numcapt);

    setup((t_messlist **)&udp_parser_class, (method)udp_parser_new,(method)udp_parser_free, (short)sizeof(b_udp_parser), 0L, A_LONG, A_LONG,0); //creation

    addmess((method)start,"start",0); //start message handeling

    addmess((method)stop,"stop",0); //stop message handeling

void *udp_parser_new(long tempo,long port)

    udpars = (b_udp_parser *)newobject(udp_parser_class);

    if((*udpars->buf=malloc(sizeof(char)*500))==NULL)

        error("memory allocation");

    if((udpars->sensors=malloc(sizeof(TSensorMatrix[2][16])))==NULL)

    //udpars->s_schedul=scheduler_new();

    udpars->c_clock=clock_new(udpars,(method)clock_function);

        post("MoCap already parsing on port %d",d->port);

    post("MoCap Parsing on port %d",d->port);

    d->max_schedul=scheduler_set(d->s_schedul);

        post("MoCap already stoped on port %d",d->port);

    post("MoCap Parsing Stoped on port %d",d->port);

void socket_bind(b_udp_parser *d, int port)

    d->sock = socket(AF_INET, SOCK_DGRAM, 0);

        error("in opening socket");

    d->source.sin_port = htons(port);

    d->source.sin_addr.s_addr = INADDR_ANY;

    fcntl(d->sock,F_SETFL,O_NONBLOCK);

    if (bind(d->sock,(struct sockaddr*)&d->source,sizeof(d->source))!=0)

        error("in binding socket");

    socklen_t size=sizeof(struct sockaddr_in);

    int nbcar=recvfrom(d->sock,d->buf, sizeof(d->buf),0,(struct sockaddr*)&d->source,&size);

            error("no incoming message, please retry");

    parse(d,(char*)d->buf,nbcar,d->sensors);

void parse(b_udp_parser *d,char* mess,int size,TSensorMatrix* sensorMatrix)

    char* eol = (char*)memchr(mess,10, size);

        //error("incorrect incoming message");

    int frame, frameSize, headerSize,recordSize;

    sscanf(mess, "Frame %d FrameSize %d HeaderSize %d RecordSize %d",&frame, &frameSize, &headerSize, &recordSize);

    int records = (frameSize - headerSize) / recordSize;

        char *record = (char*)(mess + i*recordSize + headerSize);

        memcpy(leader, record,5);

        int board = leader[1] - '0';

        int station = leader[3] - '0' - 1 ;

        memcpy(&(sensorMatrix[station][board]),record, recordSize);

        sensorMatrix[station][board]->valid = true;

        int numcapt = (station)*8+board;

        output(d, sensorMatrix[station][board],numcapt);

void output(b_udp_parser * d,struct TRawSensor* sensdata, int numcapt)

        SETFLOAT(d->list_sens+j+1,sensdata->pos[j]);

        SETFLOAT(d->list_sens+j+4,sensdata->rot[j]);

    outlet_list(d->l_out,0L,7,d->list_sens);

    clock_delay(d->c_clock,d->tempo);

Ok
Here is the C source code. The parsing code will not be very interesting because it goes with a plugin wrote specially for the system I needed to use. But what is interesting, I think, is :

- the management of the socket and schedule
- the possibility to receive binary datas (which is impossible with "mxj net.udp.recv" for example) directly to a buffer to parse it.

#include "ext.h"
#include "ext_mess.h"
#include 
#include  
#include 
#include 
#include 
#include 
#include 

#pragma pack(1)
struct TRawSensor
{
	char leader[5];
	float pos[3];
	float rot[3];
	bool valid;
};
#pragma pack()
typedef struct TRawSensor TSensorMatrix[2][16];

typedef struct _udp_parser
{
	struct object m_ob;
	void* l_out;
	long tempo;
	void* max_schedul;
	void* s_schedul;
	void* c_clock;
	long port;
	Atom list_sens[7];
	int i_status;
	struct sockaddr_in source;
	int sock;
	int try;
	char* buf[500];
	TSensorMatrix* sensors;
} b_udp_parser;

void *udp_parser_new(long tempo, long port);
void start(b_udp_parser *d);
void stop(b_udp_parser *d);
void socket_bind(b_udp_parser *d, int port);
void recep(b_udp_parser *d);
void close_socket(b_udp_parser *d);
void parse(b_udp_parser *d,char* mess,int size,TSensorMatrix* sensorMatrix);
void output(b_udp_parser * d, struct TRawSensor* sensdata,int numcapt);
void clock_function(b_udp_parser* d);
void udp_parser_free(b_udp_parser* d);

int main(void)
{
	setup((t_messlist **)&udp_parser_class, (method)udp_parser_new,(method)udp_parser_free, (short)sizeof(b_udp_parser), 0L, A_LONG, A_LONG,0); //creation
	addmess((method)start,"start",0); //start message handeling
	addmess((method)stop,"stop",0); //stop message handeling
	return 0;
}

void *udp_parser_new(long tempo,long port)
{
	b_udp_parser *udpars;
	udpars = (b_udp_parser *)newobject(udp_parser_class);
	udpars->l_out = listout(udpars);
	if((*udpars->buf=malloc(sizeof(char)*500))==NULL)
	{
		error("memory allocation");
		exit(EXIT_FAILURE);
	}
	if((udpars->sensors=malloc(sizeof(TSensorMatrix[2][16])))==NULL)
	{
		error("memory allocation");
		exit(EXIT_FAILURE);
	}
	//udpars->s_schedul=scheduler_new();
	udpars->tempo=tempo;
	udpars->port=port;
	udpars->c_clock=clock_new(udpars,(method)clock_function);
	return udpars;
}

void start(b_udp_parser * d)
{
	if(d->i_status==1)
	{
		post("MoCap already parsing on port %d",d->port);
		return;
	}
	post("MoCap Parsing on port %d",d->port);
	d->i_status=1;
	d->try=0;
	socket_bind(d,d->port);
	d->max_schedul=scheduler_set(d->s_schedul);
	clock_delay(d->c_clock,0L);
}

void stop(b_udp_parser * d)
{
	if(d->i_status==0)
	{
		post("MoCap already stoped on port %d",d->port);
		return;
	}
	clock_unset(d->c_clock);
	post("MoCap Parsing Stoped on port %d",d->port);
	close_socket(d);
	d->i_status=0;
}

void socket_bind(b_udp_parser *d, int port)
{
	d->sock = socket(AF_INET, SOCK_DGRAM, 0);
	if (d->sock
		error("in opening socket");
	//else
		//post("socket : ok");

	d->source.sin_family = AF_INET;
	d->source.sin_port = htons(port);
	d->source.sin_addr.s_addr = INADDR_ANY;
	fcntl(d->sock,F_SETFL,O_NONBLOCK);
	if (bind(d->sock,(struct sockaddr*)&d->source,sizeof(d->source))!=0)
		error("in binding socket");
	//else
		//post("bind : ok");
}

void recep(b_udp_parser *d)
{
	socklen_t size=sizeof(struct sockaddr_in);
	int nbcar=recvfrom(d->sock,d->buf, sizeof(d->buf),0,(struct sockaddr*)&d->source,&size);
	if(nbcar
	{
		d->try++;
		if(d->try==100)
		{
			error("no incoming message, please retry");
			stop(d);
		}
		return;
	}
	parse(d,(char*)d->buf,nbcar,d->sensors);
	d->try=0;
}

void close_socket(b_udp_parser *d)
{
	if(close(d->sock)!=0)
	   error("in closing socket");
}

void parse(b_udp_parser *d,char* mess,int size,TSensorMatrix* sensorMatrix)
{
	char* eol = (char*)memchr(mess,10, size);
	if (eol == NULL)
	{
		//error("incorrect incoming message");
		return;
	}
	//*eol = '';
	int frame, frameSize, headerSize,recordSize;
	sscanf(mess, "Frame %d FrameSize %d HeaderSize %d RecordSize %d",&frame, &frameSize, &headerSize, &recordSize);
	int records = (frameSize - headerSize) / recordSize;
	char leader[6];
	recordSize = sizeof(float)*6+5;
	leader[5]='';
	int i=0;
	for (i=0; i
	{
		char *record = (char*)(mess + i*recordSize + headerSize);
		memcpy(leader, record,5);
		int board = leader[1] - '0';
		int station = leader[3] - '0' - 1 ;
		memcpy(&(sensorMatrix[station][board]),record, recordSize);
		sensorMatrix[station][board]->valid = true;
		int numcapt = (station)*8+board;
		output(d, sensorMatrix[station][board],numcapt);
	}
}

void output(b_udp_parser * d,struct TRawSensor* sensdata, int numcapt)
{
	SETLONG(d->list_sens,numcapt);
	int j;
	for (j=0;j
	{
		SETFLOAT(d->list_sens+j+1,sensdata->pos[j]);
		SETFLOAT(d->list_sens+j+4,sensdata->rot[j]);
	}
	outlet_list(d->l_out,0L,7,d->list_sens);
}

void clock_function(b_udp_parser* d)
{
	scheduler_set(d->s_schedul);
	clock_delay(d->c_clock,d->tempo);
	recep(d);
}

void udp_parser_free(b_udp_parser* d)
{
	clock_unset(d->c_clock);
	clock_free(d->c_clock);
	scheduler_set(d->max_schedul);
}


With further tests (mostly in real time), I try to refresh the UDP socket as fastest as possible and I am currently using it with a 1 ms interval between each try on the socket. It still works perfectly at this rate.

I will probably port this object for windows also but maybe a little later.

If anyone as some remarks or questions, do not hesitate really !

I am working on improving BenCello's external. I've been practising Max/MSP for one year and external writing in C and C++ for 1 week so it's not exactly easy for me...

My goal is to change the method of reading the socket. BenCello used a clock and a scheduler and I would like to bufferize the data as soon as a new complete packet has arrived and not before. So I can be sure that not any data is lost.

Does somebody know how to be sure that a complete packet has arrived in a socket in non-blocking and non-connected mode?

UDP external in C