diff options
Diffstat (limited to 'netsend~/netreceive~.c')
| -rw-r--r-- | netsend~/netreceive~.c | 1358 |
1 files changed, 1358 insertions, 0 deletions
diff --git a/netsend~/netreceive~.c b/netsend~/netreceive~.c new file mode 100644 index 0000000..5998872 --- /dev/null +++ b/netsend~/netreceive~.c @@ -0,0 +1,1358 @@ +/* ------------------------ netreceive~ --------------------------------------- */
+/* */
+/* Tilde object to receive uncompressed audio data from netsend~. */
+/* Written by Olaf Matthes <olaf.matthes@gmx.de>. */
+/* Based on streamin~ by Guenter Geiger. */
+/* Get source at http://www.akustische-kunst.org/ */
+/* */
+/* This program is free software; you can redistribute it and/or */
+/* modify it under the terms of the GNU General Public License */
+/* as published by the Free Software Foundation; either version 2 */
+/* of the License, or (at your option) any later version. */
+/* */
+/* See file LICENSE for further informations on licensing terms. */
+/* */
+/* This program is distributed in the hope that it will be useful, */
+/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
+/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
+/* GNU General Public License for more details. */
+/* */
+/* You should have received a copy of the GNU General Public License */
+/* along with this program; if not, write to the Free Software */
+/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+/* */
+/* Based on PureData by Miller Puckette and others. */
+/* */
+/* This project was commissioned by the Society for Arts and Technology [SAT], */
+/* Montreal, Quebec, Canada, http://www.sat.qc.ca/. */
+/* */
+/* ---------------------------------------------------------------------------- */
+
+
+#ifdef PD
+#include "m_pd.h"
+#else
+#include "ext.h"
+#include "z_dsp.h"
+#endif
+
+#include "netsend~.h"
+
+#ifdef USE_FAAC
+#include "faad/faad.h"
+#endif
+
+#include <sys/types.h>
+#include <string.h>
+#ifdef UNIX
+#include <sys/socket.h>
+#include <errno.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#define SOCKET_ERROR -1
+#else
+#include <winsock.h>
+#endif
+
+#ifndef SOL_IP
+#define SOL_IP IPPROTO_IP
+#endif
+
+#ifdef NT
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+
+#define DEFAULT_AUDIO_BUFFER_FRAMES 16 /* a small circ. buffer for 16 frames */
+#define DEFAULT_AVERAGE_NUMBER 10 /* number of values we store for average history */
+#define DEFAULT_NETWORK_POLLTIME 1 /* interval in ms for polling for input data (Max/MSP only) */
+#define DEFAULT_QUEUE_LENGTH 3 /* min. number of buffers that can be used reliably on your hardware */
+
+
+#ifdef UNIX
+#define CLOSESOCKET(fd) close(fd)
+#endif
+#ifdef _WINDOWS
+#define CLOSESOCKET(fd) closesocket(fd)
+#endif
+
+#ifdef PD
+/* these would require to include some headers that are different
+ between pd 0.36 and later, so it's easier to do it like this! */
+EXTERN void sys_rmpollfn(int fd);
+EXTERN void sys_addpollfn(int fd, void* fn, void *ptr);
+#endif
+
+static int netreceive_tilde_sockerror(char *s)
+{
+#ifdef NT
+ int err = WSAGetLastError();
+ if (err == 10054) return 1;
+ else if (err == 10040) post("netsend~: %s: message too long (%d)", s, err);
+ else if (err == 10053) post("netsend~: %s: software caused connection abort (%d)", s, err);
+ else if (err == 10055) post("netsend~: %s: no buffer space available (%d)", s, err);
+ else if (err == 10060) post("netsend~: %s: connection timed out (%d)", s, err);
+ else if (err == 10061) post("netsend~: %s: connection refused (%d)", s, err);
+ else post("netreceive~: %s: %s (%d)", s, strerror(err), err);
+#else
+ int err = errno;
+ post("netreceive~: %s: %s (%d)", s, strerror(err), err);
+#endif
+#ifdef NT
+ if (err == WSAEWOULDBLOCK)
+#endif
+#ifdef UNIX
+ if (err == EAGAIN)
+#endif
+ {
+ return 1; /* recoverable error */
+ }
+ return 0; /* indicate non-recoverable error */
+}
+
+
+static int netreceive_tilde_setsocketoptions(int sockfd)
+{
+ int sockopt = 1;
+ if (setsockopt(sockfd, SOL_IP, TCP_NODELAY, (const char*)&sockopt, sizeof(int)) < 0)
+ post("setsockopt NODELAY failed");
+
+ sockopt = 1;
+ if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, (const char*)&sockopt, sizeof(int)) < 0)
+ post("netreceive~: setsockopt REUSEADDR failed");
+ return 0;
+}
+
+
+
+/* ------------------------ netreceive~ ----------------------------- */
+
+
+static t_class *netreceive_tilde_class;
+static t_symbol *ps_format, *ps_channels, *ps_framesize, *ps_overflow, *ps_underflow,
+ *ps_queuesize, *ps_average, *ps_sf_float, *ps_sf_16bit, *ps_sf_8bit,
+ *ps_sf_mp3, *ps_sf_aac, *ps_sf_unknown, *ps_bitrate, *ps_hostname, *ps_nothing;
+
+
+typedef struct _netreceive_tilde
+{
+#ifdef PD
+ t_object x_obj;
+ t_outlet *x_outlet1;
+ t_outlet *x_outlet2;
+#else
+ t_pxobject x_obj;
+ void *x_outlet1;
+ void *x_outlet2;
+ void *x_connectpoll;
+ void *x_datapoll;
+#endif
+ int x_socket;
+ int x_connectsocket;
+ int x_nconnections;
+ int x_ndrops;
+ int x_tcp;
+ t_symbol *x_hostname;
+
+ /* buffering */
+ int x_framein;
+ int x_frameout;
+ t_frame x_frames[DEFAULT_AUDIO_BUFFER_FRAMES];
+ int x_maxframes;
+ long x_framecount;
+ int x_blocksize;
+ int x_blocksperrecv;
+ int x_blockssincerecv;
+
+ int x_nbytes;
+ int x_counter;
+ int x_average[DEFAULT_AVERAGE_NUMBER];
+ int x_averagecur;
+ int x_underflow;
+ int x_overflow;
+
+#ifdef USE_FAAC
+ faacDecHandle x_faac_decoder;
+ faacDecFrameInfo x_faac_frameInfo;
+ faacDecConfigurationPtr x_faac_config;
+ int x_faac_init;
+ unsigned char x_faac_buf[FAAD_MIN_STREAMSIZE * DEFAULT_AUDIO_CHANNELS];
+ unsigned long x_faac_bytes;
+#endif
+
+ long x_samplerate;
+ int x_noutlets;
+ int x_vecsize;
+ t_int **x_myvec; /* vector we pass on to the DSP routine */
+} t_netreceive_tilde;
+
+
+
+/* prototypes (as needed) */
+static void netreceive_tilde_kick(t_netreceive_tilde *x);
+
+
+
+#ifdef USE_FAAC
+/* open encoder and set default values */
+static void netreceive_tilde_faac_open(t_netreceive_tilde* x)
+{
+ x->x_faac_decoder = faacDecOpen();
+ x->x_faac_config = faacDecGetCurrentConfiguration(x->x_faac_decoder);
+ x->x_faac_config->defSampleRate = x->x_samplerate;
+ x->x_faac_config->defObjectType = MAIN; // LC;
+ x->x_faac_config->outputFormat = FAAD_FMT_FLOAT;
+ faacDecSetConfiguration(x->x_faac_decoder, x->x_faac_config);
+ x->x_faac_init = 0;
+ x->x_faac_bytes = 0;
+}
+
+static void netreceive_tilde_faac_close(t_netreceive_tilde* x)
+{
+ if (x->x_faac_decoder != NULL)
+ faacDecClose(x->x_faac_decoder);
+ x->x_faac_decoder = NULL;
+ x->x_faac_init = 0;
+}
+
+/* init decoder when we get a new stream */
+static int netreceive_tilde_faac_init(t_netreceive_tilde* x, int frame)
+{
+ unsigned long samplerate;
+ unsigned char channels;
+ long bytes_consumed = 0;
+
+ if ((bytes_consumed = faacDecInit(x->x_faac_decoder, x->x_faac_buf, x->x_faac_bytes, &samplerate, &channels)) < 0)
+ {
+ faacDecConfigurationPtr config;
+ error("netreceive~: faac: initializing decoder library failed");
+ netreceive_tilde_faac_close(x);
+ return -1;
+ }
+ else if (samplerate != (unsigned long)x->x_samplerate)
+ {
+ error("netreceive~: incoming stream has wrong samplerate");
+ netreceive_tilde_faac_close(x);
+ return -1;
+ }
+
+ /* adjust accumulating AAC buffer */
+ memmove(x->x_faac_buf, x->x_faac_buf + bytes_consumed, x->x_faac_bytes - bytes_consumed);
+ x->x_faac_bytes -= bytes_consumed;
+
+ x->x_faac_init = 1; /* indicate that decoder is ready */
+ return 0;
+}
+
+/* decode AAC using FAAD2 library */
+static int netreceive_tilde_faac_decode(t_netreceive_tilde* x, int frame)
+{
+ unsigned int i, ret;
+ float *sample_buffer;
+
+ /* open decoder, if not yet done */
+ if (x->x_faac_decoder == NULL)
+ {
+ netreceive_tilde_faac_open(x);
+ }
+
+ /* add new AAC data into buffer */
+ memcpy(x->x_faac_buf + x->x_faac_bytes, x->x_frames[frame].data, x->x_frames[frame].tag.framesize);
+ x->x_faac_bytes += x->x_frames[frame].tag.framesize;
+
+ /* in case we have more than FAAD_MIN_STREAMSIZE bytes per channel try decoding */
+ if (x->x_faac_bytes >= (unsigned long)(FAAD_MIN_STREAMSIZE * x->x_frames[frame].tag.channels))
+ {
+ /* init decoder, if not yet done */
+ if (!x->x_faac_init)
+ {
+ ret = netreceive_tilde_faac_init(x, frame);
+ if (ret == -1)
+ {
+ return -1;
+ }
+ }
+
+ /* decode data */
+ memset(&x->x_faac_frameInfo, 0, sizeof(faacDecFrameInfo));
+ sample_buffer = (float *)faacDecDecode(x->x_faac_decoder, &x->x_faac_frameInfo, x->x_faac_buf, x->x_faac_bytes);
+ if (x->x_faac_frameInfo.error != 0)
+ {
+ error("netreceive~: faac: %s", faacDecGetErrorMessage(x->x_faac_frameInfo.error));
+ netreceive_tilde_faac_close(x);
+ return -1;
+ }
+
+ /* adjust accumulating AAC buffer */
+ memmove(x->x_faac_buf, x->x_faac_buf + x->x_faac_frameInfo.bytesconsumed, x->x_faac_bytes - x->x_faac_frameInfo.bytesconsumed);
+ x->x_faac_bytes -= x->x_faac_frameInfo.bytesconsumed;
+
+ /* copy decoded PCM samples back to frame */
+ memcpy(x->x_frames[frame].data, sample_buffer, x->x_faac_frameInfo.samples * sizeof(float));
+
+ /* return number of decoded PCM samples */
+ return x->x_faac_frameInfo.samples * SF_SIZEOF(SF_FLOAT);
+ }
+ else
+ {
+ return 0; /* indicate we didn't get any new audio data */
+ }
+}
+#endif /* USE_FAAC */
+
+
+
+
+/* remove all pollfunctions and close socket */
+static void netreceive_tilde_closesocket(t_netreceive_tilde* x)
+{
+#ifdef PD
+ sys_rmpollfn(x->x_socket);
+ outlet_float(x->x_outlet1, 0);
+#else
+ clock_unset(x->x_datapoll);
+ outlet_int(x->x_outlet1, 0);
+#endif
+ CLOSESOCKET(x->x_socket);
+ x->x_socket = -1;
+}
+
+
+
+#ifdef PD
+static void netreceive_tilde_reset(t_netreceive_tilde* x, t_floatarg buffer)
+#else
+static void netreceive_tilde_reset(t_netreceive_tilde* x, double buffer)
+#endif
+{
+ int i;
+ x->x_counter = 0;
+ x->x_nbytes = 0;
+ x->x_framein = 0;
+ x->x_frameout = 0;
+ x->x_blockssincerecv = 0;
+ x->x_blocksperrecv = x->x_blocksize / x->x_vecsize;
+#ifdef USE_FAAC
+ x->x_faac_bytes = 0;
+#endif
+
+ for (i = 0; i < DEFAULT_AVERAGE_NUMBER; i++)
+ x->x_average[i] = x->x_maxframes;
+ x->x_averagecur = 0;
+
+ if (buffer == 0.0) /* set default */
+ x->x_maxframes = DEFAULT_QUEUE_LENGTH;
+ else
+ {
+ buffer = (float)CLIP((float)buffer, 0., 1.);
+ x->x_maxframes = (int)(DEFAULT_AUDIO_BUFFER_FRAMES * buffer);
+ x->x_maxframes = CLIP(x->x_maxframes, 1, DEFAULT_AUDIO_BUFFER_FRAMES - 1);
+ post("netreceive~: set buffer to %g (%d frames)", buffer, x->x_maxframes);
+ }
+ x->x_underflow = 0;
+ x->x_overflow = 0;
+}
+
+
+static void netreceive_tilde_datapoll(t_netreceive_tilde *x)
+{
+#ifndef PD
+ int ret;
+ struct timeval timout;
+ fd_set readset;
+ timout.tv_sec = 0;
+ timout.tv_usec = 0;
+ FD_ZERO(&readset);
+ FD_SET(x->x_socket, &readset);
+
+ ret = select(x->x_socket + 1, &readset, NULL, NULL, &timout);
+ if (ret < 0)
+ {
+ netreceive_tilde_sockerror("select");
+ return;
+ }
+
+ if (FD_ISSET(x->x_socket, &readset)) /* data available */
+#endif
+ {
+ int ret;
+ int n;
+
+ if (x->x_tcp)
+ {
+ n = x->x_nbytes;
+
+ if (x->x_nbytes == 0) /* we ate all the samples and need a new header tag */
+ {
+ /* get the new tag */
+ ret = recv(x->x_socket, (char*)&x->x_frames[x->x_framein].tag, sizeof(t_tag), MSG_PEEK);
+ if (ret == 0) /* disconnect */
+ {
+ post("netreceive~: EOF on socket %d", x->x_socket);
+ netreceive_tilde_closesocket(x);
+ x->x_socket = -1;
+ x->x_counter = 0;
+ return;
+ }
+ if (ret < 0) /* error */
+ {
+ if (netreceive_tilde_sockerror("recv tag"))
+ goto bail;
+ netreceive_tilde_closesocket(x);
+ x->x_socket = -1;
+ x->x_counter = 0;
+ return;
+ }
+ else if (ret != sizeof(t_tag))
+ {
+ /* incomplete header tag: return and try again later */
+ /* in the hope that more data will be available */
+ return;
+ }
+
+ /* receive header tag */
+ ret = recv(x->x_socket, (char*)&x->x_frames[x->x_framein].tag, sizeof(t_tag), 0);
+
+ /* adjust byte order if neccessarry */
+ if (x->x_frames[x->x_framein].tag.version != SF_BYTE_NATIVE)
+ {
+ x->x_frames[x->x_framein].tag.count = netsend_long(x->x_frames[x->x_framein].tag.count);
+ x->x_frames[x->x_framein].tag.framesize = netsend_long(x->x_frames[x->x_framein].tag.framesize);
+ }
+
+ /* get info from header tag */
+ if (x->x_frames[x->x_framein].tag.channels > x->x_noutlets)
+ {
+ error("netreceive~: incoming stream has too many channels (%d), kicking client", x->x_frames[x->x_framein].tag.channels);
+ netreceive_tilde_kick(x);
+ x->x_socket = -1;
+ x->x_counter = 0;
+ return;
+ }
+ x->x_nbytes = n = x->x_frames[x->x_framein].tag.framesize;
+
+ /* check whether the data packet has the correct count */
+ if ((x->x_framecount != x->x_frames[x->x_framein].tag.count)
+ && (x->x_frames[x->x_framein].tag.count > 2))
+ {
+ error("netreceive~: we lost %d frames", (int)(x->x_frames[x->x_framein].tag.count - x->x_framecount));
+ post("netreceive~: current package is %d, expected %d", x->x_frames[x->x_framein].tag.count, x->x_framecount);
+ }
+ x->x_framecount = x->x_frames[x->x_framein].tag.count + 1;
+ }
+ else /* we already have the header tag or some data and need more */
+ {
+ ret = recv(x->x_socket, (char*)x->x_frames[x->x_framein].data + x->x_frames[x->x_framein].tag.framesize - n, n, 0);
+ if (ret > 0)
+ {
+ n -= ret;
+ }
+ else if (ret < 0) /* error */
+ {
+ if (netreceive_tilde_sockerror("recv data"))
+ goto bail;
+ netreceive_tilde_closesocket(x);
+ x->x_socket = -1;
+ x->x_counter = 0;
+ return;
+ }
+
+ x->x_nbytes = n;
+ if (n == 0) /* a complete packet is received */
+ {
+#ifdef USE_FAAC /* decode aac data if format is SF_AAC */
+ if (x->x_frames[x->x_framein].tag.format == SF_AAC)
+ {
+ ret = netreceive_tilde_faac_decode(x, x->x_framein);
+ if (ret == -1)
+ {
+ netreceive_tilde_kick(x);
+ x->x_socket = -1;
+ x->x_counter = 0;
+ return;
+ }
+ else
+ {
+ /* update framesize */
+ x->x_frames[x->x_framein].tag.framesize = ret;
+ }
+ }
+#else
+ if (x->x_frames[x->x_framein].tag.format == SF_AAC)
+ {
+ error("netreceive~: don't know how to decode AAC format");
+ netreceive_tilde_kick(x);
+ x->x_socket = -1;
+ x->x_counter = 0;
+ return;
+ }
+#endif
+
+ x->x_counter++;
+ x->x_framein++;
+ x->x_framein %= DEFAULT_AUDIO_BUFFER_FRAMES;
+
+ /* check for buffer overflow */
+ if (x->x_framein == x->x_frameout)
+ {
+ x->x_overflow++;
+ }
+ }
+ }
+ }
+ else /* UDP */
+ {
+ n = x->x_nbytes;
+
+ if (x->x_nbytes == 0) /* we ate all the samples and need a new header tag */
+ {
+ /* receive header tag */
+ ret = recv(x->x_socket, (char*)&x->x_frames[x->x_framein].tag, sizeof(t_tag), 0);
+ if (ret <= 0) /* error */
+ {
+ if (netreceive_tilde_sockerror("recv tag"))
+ goto bail;
+ netreceive_tilde_reset(x, 0);
+ x->x_counter = 0;
+ return;
+ }
+ else if (ret != sizeof(t_tag))
+ {
+ /* incomplete header tag: return and try again later */
+ /* in the hope that more data will be available */
+ error("netreceive~: got incomplete header tag");
+ return;
+ }
+ /* adjust byte order if neccessarry */
+ if (x->x_frames[x->x_framein].tag.version != SF_BYTE_NATIVE)
+ {
+ x->x_frames[x->x_framein].tag.count = netsend_long(x->x_frames[x->x_framein].tag.count);
+ x->x_frames[x->x_framein].tag.framesize = netsend_long(x->x_frames[x->x_framein].tag.framesize);
+ }
+ /* get info from header tag */
+ if (x->x_frames[x->x_framein].tag.channels > x->x_noutlets)
+ {
+ error("netreceive~: incoming stream has too many channels (%d)", x->x_frames[x->x_framein].tag.channels);
+ x->x_counter = 0;
+ return;
+ }
+ x->x_nbytes = n = x->x_frames[x->x_framein].tag.framesize;
+ }
+ else /* we already have header tag or some data and need more */
+ {
+ ret = recv(x->x_socket, (char*)x->x_frames[x->x_framein].data + x->x_frames[x->x_framein].tag.framesize - n, n, 0);
+ if (ret > 0)
+ {
+ n -= ret;
+ }
+ else if (ret < 0) /* error */
+ {
+ if (netreceive_tilde_sockerror("recv data"))
+ goto bail;
+ netreceive_tilde_reset(x, 0);
+ x->x_counter = 0;
+ return;
+ }
+
+ x->x_nbytes = n;
+ if (n == 0) /* a complete packet is received */
+ {
+#ifdef USE_FAAC /* decode aac data if format is SF_AAC and update framesize */
+ if (x->x_frames[x->x_framein].tag.format == SF_AAC)
+ {
+ ret = netreceive_tilde_faac_decode(x, x->x_framein);
+ if (ret == -1)
+ {
+ return;
+ }
+ else
+ {
+ /* update framesize */
+ x->x_frames[x->x_framein].tag.framesize = ret;
+ }
+ }
+#else
+ if (x->x_frames[x->x_framein].tag.format == SF_AAC)
+ {
+ error("netreceive~: don't know how to decode AAC format");
+ return;
+ }
+#endif
+ x->x_counter++;
+ x->x_framein++;
+ x->x_framein %= DEFAULT_AUDIO_BUFFER_FRAMES;
+
+ /* check for buffer overflow */
+ if (x->x_framein == x->x_frameout)
+ {
+ x->x_overflow++;
+ }
+ }
+ }
+ }
+ }
+bail:
+ ;
+#ifndef PD
+ clock_delay(x->x_datapoll, DEFAULT_NETWORK_POLLTIME);
+#endif
+}
+
+
+static void netreceive_tilde_connectpoll(t_netreceive_tilde *x)
+{
+#ifndef PD
+ int ret;
+ struct timeval timout;
+ fd_set readset;
+ timout.tv_sec = 0;
+ timout.tv_usec = 0;
+ FD_ZERO(&readset);
+ FD_SET(x->x_connectsocket, &readset);
+
+ ret = select(x->x_connectsocket + 1, &readset, NULL, NULL, &timout);
+ if (ret < 0)
+ {
+ netreceive_tilde_sockerror("select");
+ return;
+ }
+
+ if (FD_ISSET(x->x_connectsocket, &readset)) /* pending connection */
+#endif
+ {
+ int sockaddrl = (int)sizeof(struct sockaddr);
+ struct sockaddr_in incomer_address;
+ int fd = accept(x->x_connectsocket, (struct sockaddr*)&incomer_address, &sockaddrl);
+ if (fd < 0)
+ {
+ post("netreceive~: accept failed");
+ return;
+ }
+#ifdef O_NONBLOCK
+ fcntl(fd, F_SETFL, O_NONBLOCK);
+#endif
+ if (x->x_socket != -1)
+ {
+ post("netreceive~: new connection");
+ netreceive_tilde_closesocket(x);
+ }
+
+ netreceive_tilde_reset(x, 0);
+ x->x_socket = fd;
+ x->x_nbytes = 0;
+ x->x_hostname = gensym(inet_ntoa(incomer_address.sin_addr));
+#ifdef PD
+ sys_addpollfn(fd, netreceive_tilde_datapoll, x);
+ outlet_float(x->x_outlet1, 1);
+#else
+ clock_delay(x->x_datapoll, 0);
+ outlet_int(x->x_outlet1, 1);
+#endif
+ }
+#ifndef PD
+ clock_delay(x->x_connectpoll, DEFAULT_NETWORK_POLLTIME);
+#endif
+}
+
+
+static int netreceive_tilde_createsocket(t_netreceive_tilde* x, int portno)
+{
+ struct sockaddr_in server;
+ int sockfd;
+ int tcp = x->x_tcp;
+
+ /* create a socket */
+ if (!tcp)
+ sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+ else
+ sockfd = socket(AF_INET, SOCK_STREAM, 0);
+
+ if (sockfd < 0)
+ {
+ netreceive_tilde_sockerror("socket");
+ return 0;
+ }
+ server.sin_family = AF_INET;
+ server.sin_addr.s_addr = INADDR_ANY;
+
+ /* assign server port number */
+
+ server.sin_port = htons((u_short)portno);
+ post("listening to port number %d", portno);
+
+ netreceive_tilde_setsocketoptions(sockfd);
+
+ /* name the socket */
+ if (bind(sockfd, (struct sockaddr *)&server, sizeof(server)) < 0)
+ {
+ netreceive_tilde_sockerror("bind");
+ CLOSESOCKET(sockfd);
+ return 0;
+ }
+
+
+ if (!tcp)
+ {
+ x->x_socket = sockfd;
+ x->x_nbytes = 0;
+#ifdef PD
+ sys_addpollfn(sockfd, netreceive_tilde_datapoll, x);
+#else
+ clock_delay(x->x_datapoll, 0);
+#endif
+ }
+ else
+ {
+ if (listen(sockfd, 5) < 0)
+ {
+ netreceive_tilde_sockerror("listen");
+ CLOSESOCKET(sockfd);
+ return 0;
+ }
+ else
+ {
+ x->x_connectsocket = sockfd;
+ /* start polling for connection requests */
+#ifdef PD
+ sys_addpollfn(sockfd, netreceive_tilde_connectpoll, x);
+#else
+ clock_delay(x->x_connectpoll, 0);
+#endif
+ }
+ }
+ return 1;
+}
+
+
+
+/* kick connected client */
+static void netreceive_tilde_kick(t_netreceive_tilde *x)
+{
+ if (x->x_tcp)
+ {
+ if (x->x_socket != -1)
+ {
+ shutdown(x->x_socket, 1);
+ netreceive_tilde_closesocket(x);
+ post("netreceive~: kicked client!");
+ }
+ else error("netreceive~: no client to kick");
+ }
+ else error("netreceive~: kicking clients in UDP mode not possible");
+}
+
+
+#define QUEUESIZE (int)((x->x_framein + DEFAULT_AUDIO_BUFFER_FRAMES - x->x_frameout) % DEFAULT_AUDIO_BUFFER_FRAMES)
+#define BLOCKOFFSET (x->x_blockssincerecv * x->x_vecsize * x->x_frames[x->x_frameout].tag.channels)
+
+static t_int *netreceive_tilde_perform(t_int *w)
+{
+ t_netreceive_tilde *x = (t_netreceive_tilde*) (w[1]);
+ int n = (int)(w[2]);
+ t_float *out[DEFAULT_AUDIO_CHANNELS];
+ const int offset = 3;
+ const int channels = x->x_frames[x->x_frameout].tag.channels;
+ int i = 0;
+
+ for (i = 0; i < x->x_noutlets; i++)
+ {
+ out[i] = (t_float *)(w[offset + i]);
+ }
+
+ if (n != x->x_vecsize)
+ {
+ x->x_vecsize = n;
+ x->x_blocksperrecv = x->x_blocksize / x->x_vecsize;
+ x->x_blockssincerecv = 0;
+ }
+
+ /* check whether there is enough data in buffer */
+ if (x->x_counter < x->x_maxframes)
+ {
+ goto bail;
+ }
+
+ /* check for buffer underflow */
+ if (x->x_framein == x->x_frameout)
+ {
+ x->x_underflow++;
+ goto bail;
+ }
+
+
+ /* queue balancing */
+ x->x_average[x->x_averagecur] = QUEUESIZE;
+ if (++x->x_averagecur >= DEFAULT_AVERAGE_NUMBER)
+ x->x_averagecur = 0;
+
+ switch (x->x_frames[x->x_frameout].tag.format)
+ {
+ case SF_FLOAT:
+ {
+ t_float* buf = (t_float *)x->x_frames[x->x_frameout].data + BLOCKOFFSET;
+
+ if (x->x_frames[x->x_frameout].tag.version == SF_BYTE_NATIVE)
+ {
+ while (n--)
+ {
+ for (i = 0; i < channels; i++)
+ {
+ *out[i]++ = *buf++;
+ }
+ for (i = channels; i < x->x_noutlets; i++)
+ {
+ *out[i]++ = 0.;
+ }
+ }
+ }
+ else /* swap bytes */
+ {
+ while (n--)
+ {
+ for (i = 0; i < channels; i++)
+ {
+ *out[i]++ = netsend_float(*buf++);
+ }
+ for (i = channels; i < x->x_noutlets; i++)
+ {
+ *out[i]++ = 0.;
+ }
+ }
+ }
+ break;
+ }
+ case SF_16BIT:
+ {
+ short* buf = (short *)x->x_frames[x->x_frameout].data + BLOCKOFFSET;
+
+ if (x->x_frames[x->x_frameout].tag.version == SF_BYTE_NATIVE)
+ {
+ while (n--)
+ {
+ for (i = 0; i < channels; i++)
+ {
+ *out[i]++ = (t_float)(*buf++ * 3.051850e-05);
+ }
+ for (i = channels; i < x->x_noutlets; i++)
+ {
+ *out[i]++ = 0.;
+ }
+ }
+ }
+ else /* swap bytes */
+ {
+ while (n--)
+ {
+ for (i = 0; i < channels; i++)
+ {
+ *out[i]++ = (t_float)(netsend_short(*buf++) * 3.051850e-05);
+ }
+ for (i = channels; i < x->x_noutlets; i++)
+ {
+ *out[i]++ = 0.;
+ }
+ }
+ }
+ break;
+ }
+ case SF_8BIT:
+ {
+ unsigned char* buf = (char *)x->x_frames[x->x_frameout].data + BLOCKOFFSET;
+
+ while (n--)
+ {
+ for (i = 0; i < channels; i++)
+ {
+ *out[i]++ = (t_float)((0.0078125 * (*buf++)) - 1.0);
+ }
+ for (i = channels; i < x->x_noutlets; i++)
+ {
+ *out[i]++ = 0.;
+ }
+ }
+ break;
+ }
+ case SF_MP3:
+ {
+ post("netreceive~: mp3 format not supported");
+ if (x->x_tcp)
+ netreceive_tilde_kick(x);
+ break;
+ }
+ case SF_AAC:
+ {
+#ifdef USE_FAAC
+ t_float* buf = (t_float *)x->x_frames[x->x_frameout].data + BLOCKOFFSET;
+
+ while (n--)
+ {
+ for (i = 0; i < channels; i++)
+ {
+ *out[i]++ = (t_float)(*buf++);
+ }
+ for (i = channels; i < x->x_noutlets; i++)
+ {
+ *out[i]++ = 0.;
+ }
+ }
+ break;
+#else
+ post("netreceive~: aac format not supported");
+ if (x->x_tcp)
+ netreceive_tilde_kick(x);
+#endif
+ break;
+ }
+ default:
+ post("netreceive~: unknown format (%d)",x->x_frames[x->x_frameout].tag.format);
+ if (x->x_tcp)
+ netreceive_tilde_kick(x);
+ break;
+ }
+
+ if (!(x->x_blockssincerecv < x->x_blocksperrecv - 1))
+ {
+ x->x_blockssincerecv = 0;
+ x->x_frameout++;
+ x->x_frameout %= DEFAULT_AUDIO_BUFFER_FRAMES;
+ }
+ else
+ {
+ x->x_blockssincerecv++;
+ }
+
+ return (w + offset + x->x_noutlets);
+
+bail:
+ /* set output to zero */
+ while (n--)
+ {
+ for (i = 0; i < x->x_noutlets; i++)
+ {
+ *(out[i]++) = 0.;
+ }
+ }
+ return (w + offset + x->x_noutlets);
+}
+
+
+
+static void netreceive_tilde_dsp(t_netreceive_tilde *x, t_signal **sp)
+{
+ int i;
+
+ x->x_myvec[0] = (t_int*)x;
+ x->x_myvec[1] = (t_int*)sp[0]->s_n;
+
+ x->x_samplerate = (long)sp[0]->s_sr;
+
+ if (DEFAULT_AUDIO_BUFFER_SIZE % sp[0]->s_n)
+ {
+ error("netsend~: signal vector size too large (needs to be even divisor of %d)", DEFAULT_AUDIO_BUFFER_SIZE);
+ }
+ else
+ {
+#ifdef PD
+ for (i = 0; i < x->x_noutlets; i++)
+ {
+ x->x_myvec[2 + i] = (t_int*)sp[i + 1]->s_vec;
+ }
+ dsp_addv(netreceive_tilde_perform, x->x_noutlets + 2, (t_int*)x->x_myvec);
+#else
+ for (i = 0; i < x->x_noutlets; i++)
+ {
+ x->x_myvec[2 + i] = (t_int*)sp[i]->s_vec;
+ }
+ dsp_addv(netreceive_tilde_perform, x->x_noutlets + 2, (void **)x->x_myvec);
+#endif /* PD */
+ }
+}
+
+
+/* send stream info when banged */
+static void netreceive_tilde_bang(t_netreceive_tilde *x)
+{
+ t_atom list[2];
+ t_symbol *sf_format;
+ t_float bitrate;
+ int i, avg = 0;
+ for (i = 0; i < DEFAULT_AVERAGE_NUMBER; i++)
+ avg += x->x_average[i];
+
+ bitrate = (t_float)((SF_SIZEOF(x->x_frames[x->x_frameout].tag.format) * x->x_samplerate * 8 * x->x_frames[x->x_frameout].tag.channels) / 1000.);
+
+ switch (x->x_frames[x->x_frameout].tag.format)
+ {
+ case SF_FLOAT:
+ {
+ sf_format = ps_sf_float;
+ break;
+ }
+ case SF_16BIT:
+ {
+ sf_format = ps_sf_16bit;
+ break;
+ }
+ case SF_8BIT:
+ {
+ sf_format = ps_sf_8bit;
+ break;
+ }
+ case SF_MP3:
+ {
+ sf_format = ps_sf_mp3;
+ break;
+ }
+ case SF_AAC:
+ {
+ sf_format = ps_sf_aac;
+ break;
+ }
+ default:
+ {
+ sf_format = ps_sf_unknown;
+ break;
+ }
+ }
+
+#ifdef PD
+ /* --- stream information (t_tag) --- */
+ /* audio format */
+ SETSYMBOL(list, (t_symbol *)sf_format);
+ outlet_anything(x->x_outlet2, ps_format, 1, list);
+
+ /* channels */
+ SETFLOAT(list, (t_float)x->x_frames[x->x_frameout].tag.channels);
+ outlet_anything(x->x_outlet2, ps_channels, 1, list);
+
+ /* framesize */
+ SETFLOAT(list, (t_float)x->x_frames[x->x_frameout].tag.framesize);
+ outlet_anything(x->x_outlet2, ps_framesize, 1, list);
+
+ /* bitrate */
+ SETFLOAT(list, (t_float)bitrate);
+ outlet_anything(x->x_outlet2, ps_bitrate, 1, list);
+
+ /* --- internal info (buffer and network) --- */
+ /* overflow */
+ SETFLOAT(list, (t_float)x->x_overflow);
+ outlet_anything(x->x_outlet2, ps_overflow, 1, list);
+
+ /* underflow */
+ SETFLOAT(list, (t_float)x->x_underflow);
+ outlet_anything(x->x_outlet2, ps_underflow, 1, list);
+
+ /* queuesize */
+ SETFLOAT(list, (t_float)QUEUESIZE);
+ outlet_anything(x->x_outlet2, ps_queuesize, 1, list);
+
+ /* average queuesize */
+ SETFLOAT(list, (t_float)((t_float)avg / (t_float)DEFAULT_AVERAGE_NUMBER));
+ outlet_anything(x->x_outlet2, ps_average, 1, list);
+
+ if (x->x_tcp)
+ {
+ /* IP address */
+ SETSYMBOL(list, (t_symbol *)x->x_hostname);
+ outlet_anything(x->x_outlet2, ps_hostname, 1, list);
+ }
+#else
+ /* --- stream information (t_tag) --- */
+ /* audio format */
+ SETSYM(list, ps_format);
+ SETSYM(list + 1, (t_symbol *)sf_format);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* channels */
+ SETSYM(list, ps_channels);
+ SETLONG(list + 1, (int)x->x_frames[x->x_frameout].tag.channels);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* framesize */
+ SETSYM(list, ps_framesize);
+ SETLONG(list + 1, (int)x->x_frames[x->x_frameout].tag.framesize);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* bitrate */
+ SETSYM(list, ps_bitrate);
+ SETFLOAT(list + 1, (t_float)bitrate);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* --- internal info (buffer and network) --- */
+ /* overflow */
+ SETSYM(list, ps_overflow);
+ SETLONG(list + 1, (int)x->x_overflow);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* underflow */
+ SETSYM(list, ps_underflow);
+ SETLONG(list + 1, (int)x->x_underflow);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* queuesize */
+ SETSYM(list, ps_queuesize);
+ SETLONG(list + 1, (int)QUEUESIZE);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ /* average queuesize */
+ SETSYM(list, ps_average);
+ SETFLOAT(list + 1, (t_float)((t_float)avg / (t_float)DEFAULT_AVERAGE_NUMBER));
+ outlet_list(x->x_outlet2, NULL, 2, list);
+
+ if (x->x_tcp)
+ {
+ /* IP address */
+ SETSYM(list, (t_symbol *)ps_hostname);
+ SETSYM(list + 1, x->x_hostname);
+ outlet_list(x->x_outlet2, NULL, 2, list);
+ }
+#endif
+}
+
+
+
+static void netreceive_tilde_print(t_netreceive_tilde* x)
+{
+ int i, avg = 0;
+ for (i = 0; i < DEFAULT_AVERAGE_NUMBER; i++)
+ avg += x->x_average[i];
+ post("netreceive~: last size = %d, avg size = %g, %d underflows, %d overflows", QUEUESIZE, (float)((float)avg / (float)DEFAULT_AVERAGE_NUMBER), x->x_underflow, x->x_overflow);
+ post("netreceive~: channels = %d, framesize = %d, packets = %d", x->x_frames[x->x_framein].tag.channels, x->x_frames[x->x_framein].tag.framesize, x->x_counter);
+}
+
+
+
+#ifdef PD
+static void *netreceive_tilde_new(t_floatarg fportno, t_floatarg outlets, t_floatarg prot)
+#else
+static void *netreceive_tilde_new(long fportno, long outlets, long prot)
+#endif
+{
+ t_netreceive_tilde *x;
+ int i;
+
+ if (fportno == 0) fportno = DEFAULT_PORT;
+
+#ifdef PD
+ x = (t_netreceive_tilde *)pd_new(netreceive_tilde_class);
+ if (x)
+ {
+ for (i = sizeof(t_object); i < (int)sizeof(t_netreceive_tilde); i++)
+ ((char *)x)[i] = 0;
+ }
+
+ x->x_noutlets = CLIP((int)outlets, 1, DEFAULT_AUDIO_CHANNELS);
+ for (i = 0; i < x->x_noutlets; i++)
+ outlet_new(&x->x_obj, &s_signal);
+ if (!prot)
+ x->x_outlet1 = outlet_new(&x->x_obj, &s_anything); /* outlet for connection state (TCP/IP) */
+ x->x_outlet2 = outlet_new(&x->x_obj, &s_anything);
+#else
+ x = (t_netreceive_tilde *)newobject(netreceive_tilde_class);
+ if (x)
+ {
+ for (i = sizeof(t_pxobject); i < (int)sizeof(t_netreceive_tilde); i++)
+ ((char *)x)[i] = 0;
+ }
+
+ dsp_setup((t_pxobject *)x, 0); /* no signal inlets */
+ x->x_noutlets = CLIP((int)outlets, 1, DEFAULT_AUDIO_CHANNELS);
+ x->x_outlet2 = listout(x); /* outlet for info list */
+ if (!prot)
+ x->x_outlet1 = listout(x); /* outlet for connection state (TCP/IP) */
+ for (i = 0 ; i < x->x_noutlets; i++)
+ outlet_new(x, "signal");
+ x->x_connectpoll = clock_new(x, (method)netreceive_tilde_connectpoll);
+ x->x_datapoll = clock_new(x, (method)netreceive_tilde_datapoll);
+#endif
+
+ x->x_myvec = (t_int **)t_getbytes(sizeof(t_int *) * (x->x_noutlets + 3));
+ if (!x->x_myvec)
+ {
+ error("netreceive~: out of memory");
+ return NULL;
+ }
+
+#ifdef USE_FAAC
+ x->x_faac_decoder = NULL;
+ x->x_faac_init = 0;
+#endif
+
+ x->x_connectsocket = -1;
+ x->x_socket = -1;
+ x->x_tcp = 1;
+ x->x_nconnections = 0;
+ x->x_ndrops = 0;
+ x->x_underflow = 0;
+ x->x_overflow = 0;
+ x->x_hostname = ps_nothing;
+
+ for (i = 0; i < DEFAULT_AUDIO_BUFFER_FRAMES; i++)
+ {
+ x->x_frames[i].data = (char *)t_getbytes(DEFAULT_AUDIO_BUFFER_SIZE * x->x_noutlets * sizeof(t_float));
+ }
+ x->x_framein = 0;
+ x->x_frameout = 0;
+ x->x_maxframes = DEFAULT_QUEUE_LENGTH;
+ x->x_vecsize = 64; /* we'll update this later */
+ x->x_blocksize = DEFAULT_AUDIO_BUFFER_SIZE; /* LATER make this dynamic */
+ x->x_blockssincerecv = 0;
+ x->x_blocksperrecv = x->x_blocksize / x->x_vecsize;
+
+ if (prot)
+ x->x_tcp = 0;
+
+ if (!netreceive_tilde_createsocket(x, (int)fportno))
+ {
+ error("netreceive~: failed to create listening socket");
+ return (NULL);
+ }
+
+ return (x);
+}
+
+
+
+static void netreceive_tilde_free(t_netreceive_tilde *x)
+{
+ int i;
+
+ if (x->x_connectsocket != -1)
+ {
+#ifdef PD
+ sys_rmpollfn(x->x_connectsocket);
+#else
+ clock_unset(x->x_connectpoll);
+#endif
+ CLOSESOCKET(x->x_connectsocket);
+ }
+ if (x->x_socket != -1)
+ {
+#ifdef PD
+ sys_rmpollfn(x->x_socket);
+#else
+ clock_unset(x->x_datapoll);
+#endif
+ CLOSESOCKET(x->x_socket);
+ }
+
+#ifndef PD
+ dsp_free((t_pxobject *)x); /* free the object */
+ clock_free(x->x_connectpoll);
+ clock_free(x->x_datapoll);
+#endif
+
+#ifdef USE_FAAC
+ netreceive_tilde_faac_close(x);
+#endif
+
+ /* free memory */
+ t_freebytes(x->x_myvec, sizeof(t_int *) * (x->x_noutlets + 3));
+ for (i = 0; i < DEFAULT_AUDIO_BUFFER_FRAMES; i++)
+ {
+ t_freebytes(x->x_frames[i].data, DEFAULT_AUDIO_BUFFER_SIZE * x->x_noutlets * sizeof(t_float));
+ }
+}
+
+
+
+#ifdef PD
+void netreceive_tilde_setup(void)
+{
+ netreceive_tilde_class = class_new(gensym("netreceive~"),
+ (t_newmethod) netreceive_tilde_new, (t_method) netreceive_tilde_free,
+ sizeof(t_netreceive_tilde), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_NULL);
+
+ class_addmethod(netreceive_tilde_class, nullfn, gensym("signal"), 0);
+ class_addbang(netreceive_tilde_class, (t_method)netreceive_tilde_bang);
+ class_addmethod(netreceive_tilde_class, (t_method)netreceive_tilde_dsp, gensym("dsp"), 0);
+ class_addmethod(netreceive_tilde_class, (t_method)netreceive_tilde_print, gensym("print"), 0);
+ class_addmethod(netreceive_tilde_class, (t_method)netreceive_tilde_kick, gensym("kick"), 0);
+ class_addmethod(netreceive_tilde_class, (t_method)netreceive_tilde_reset, gensym("reset"), A_DEFFLOAT, 0);
+ class_addmethod(netreceive_tilde_class, (t_method)netreceive_tilde_reset, gensym("buffer"), A_DEFFLOAT, 0);
+ class_sethelpsymbol(netreceive_tilde_class, gensym("netsend~"));
+ post("netreceive~ v%s, (c) 2004 Olaf Matthes", VERSION);
+
+ ps_format = gensym("format");
+ ps_channels = gensym("channels");
+ ps_framesize = gensym("framesize");
+ ps_bitrate = gensym("bitrate");
+ ps_overflow = gensym("overflow");
+ ps_underflow = gensym("underflow");
+ ps_queuesize = gensym("queuesize");
+ ps_average = gensym("average");
+ ps_hostname = gensym("ipaddr");
+ ps_sf_float = gensym("_float_");
+ ps_sf_16bit = gensym("_16bit_");
+ ps_sf_8bit = gensym("_8bit_");
+ ps_sf_mp3 = gensym("_mp3_");
+ ps_sf_aac = gensym("_aac_");
+ ps_sf_unknown = gensym("_unknown_");
+ ps_nothing = gensym("");
+}
+
+#else
+
+void netreceive_tilde_assist(t_netreceive_tilde *x, void *b, long m, long a, char *s)
+{
+ switch (m)
+ {
+ case 1: /* inlet */
+ sprintf(s, "(Anything) Control Messages");
+ break;
+ case 2: /* outlets */
+ sprintf(s, "(Signal) Audio Channel %d", (int)(a + 1));
+ break;
+ break;
+ }
+
+}
+
+void main()
+{
+#ifdef _WINDOWS
+ short version = MAKEWORD(2, 0);
+ WSADATA nobby;
+#endif /* _WINDOWS */
+
+ setup((t_messlist **)&netreceive_tilde_class, (method)netreceive_tilde_new, (method)netreceive_tilde_free,
+ (short)sizeof(t_netreceive_tilde), 0L, A_DEFLONG, A_DEFLONG, A_DEFLONG, 0);
+ addmess((method)netreceive_tilde_dsp, "dsp", A_CANT, 0);
+ addmess((method)netreceive_tilde_assist, "assist", A_CANT, 0);
+ addmess((method)netreceive_tilde_print, "print", 0);
+ addmess((method)netreceive_tilde_kick, "kick", 0);
+ addmess((method)netreceive_tilde_reset, "reset", A_DEFFLOAT, 0);
+ addmess((method)netreceive_tilde_reset, "buffer", A_DEFFLOAT, 0);
+ addbang((method)netreceive_tilde_bang);
+ dsp_initclass();
+ finder_addclass("System", "netreceive~");
+ post("netreceive~ v%s, © 2004 Olaf Matthes", VERSION);
+
+ ps_format = gensym("format");
+ ps_channels = gensym("channels");
+ ps_framesize = gensym("framesize");
+ ps_bitrate = gensym("bitrate");
+ ps_overflow = gensym("overflow");
+ ps_underflow = gensym("underflow");
+ ps_queuesize = gensym("queuesize");
+ ps_average = gensym("average");
+ ps_hostname = gensym("ipaddr");
+ ps_sf_float = gensym("_float_");
+ ps_sf_16bit = gensym("_16bit_");
+ ps_sf_8bit = gensym("_8bit_");
+ ps_sf_mp3 = gensym("_mp3_");
+ ps_sf_aac = gensym("_aac_");
+ ps_sf_unknown = gensym("_unknown_");
+ ps_nothing = gensym("");
+
+#ifdef _WINDOWS
+ if (WSAStartup(version, &nobby)) error("netreceive~: WSAstartup failed");
+#endif /* _WINDOWS */
+}
+#endif /* PD */
|