Quisk version 4.2.28

2023-12-26 15:39:37 -05:00
commit ffa047c2ef
143 changed files with 52434 additions and 0 deletions
@@ -0,0 +1,748 @@
+/*
+  This software is Copyright (C) 2021-2022 by Ben Cahill and 2006-2022 by James C. Ahlstrom,
+  and is licensed for use under the GNU General Public License (GPL).
+  See http://www.opensource.org.
+  Note that there is NO WARRANTY AT ALL.  USE AT YOUR OWN RISK!!
+*/
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include <complex.h>
+#include <math.h>
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+
+#ifdef MS_WINDOWS
+#include <winsock2.h>
+#include <stdint.h>
+#else
+
+#if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
+#include <sys/param.h>
+#if defined(BSD)
+#include <netinet/in.h>
+#endif
+#endif
+
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/ip.h>
+#include <fcntl.h>
+#endif
+
+#include "../quisk.h"
+#include "../filter.h"
+
+#define GRAPH_DATA_SCALE	163
+#define MAX_UDP_INT16_T		600
+#define UDP_SEND_INT16		200
+
+#define REMOTE_DEBUG 0  //BMC TODO:  Make this a configuration option
+
+static SOCKET remote_radio_sound_socket = INVALID_SOCKET;		// send radio sound to control_head, receive mic samples
+static SOCKET control_head_sound_socket = INVALID_SOCKET;		// receive radio sound from remote_radio, send mic samples
+static SOCKET remote_radio_graph_socket = INVALID_SOCKET;		// send graph data to control_head
+static SOCKET control_head_graph_socket = INVALID_SOCKET;		// receive graph data from remote_radio
+static int control_head_sound_socket_started = 0;			// sound stream started on the control head
+static int remote_radio_sound_socket_started = 0;			// sound stream started on the remote radio
+static int control_head_graph_socket_started = 0;			// graph data stream started on the control head
+static int remote_radio_graph_socket_started = 0;			// graph data stream started on the remote radio
+static int control_head_data_width;					// app.data_width of control head for graph data
+static int packets_sent;
+static int packets_recd;
+
+// Receive stereo 16-bit pcm radio speaker sound on the control head via UDP
+int read_remote_radio_sound_socket(complex double * cSamples)
+{
+	int i, bytes, nInt16, nSamples;
+	int16_t buf[UDP_SEND_INT16];
+	double samp_r, samp_l;
+	struct timeval tm_wait;
+	fd_set fds;
+	static struct quisk_cHB45Filter HalfBand;
+	static struct quisk_cFilter cFiltInterp3;
+	static int init_filters=1;
+
+	if (control_head_sound_socket == INVALID_SOCKET)
+		return 0;
+	if (init_filters) {
+		init_filters = 0;
+		memset(&HalfBand, 0, sizeof(struct quisk_cHB45Filter));
+		quisk_filt_cInit(&cFiltInterp3, quiskAudio24p3Coefs, sizeof(quiskAudio24p3Coefs)/sizeof(double));
+	}
+	// Signal far end (server) that we're ready (this sends our address/port to far end)
+	if (!control_head_sound_socket_started) {
+		QuiskPrintf("read_remote_radio_sound_socket() sending 'rr'\n");
+		bytes = send(control_head_sound_socket, "rr\n", 3, 0);
+		if (bytes != 3)
+			QuiskPrintf("read_remote_radio_sound_socket(), sendto(): %s\n", strerror(errno));
+	}
+
+	// read all available packets, one per loop
+	nSamples = 0;
+	while (1) {
+		tm_wait.tv_sec = 0;
+		tm_wait.tv_usec = 0;
+		FD_ZERO (&fds);
+		FD_SET (control_head_sound_socket, &fds);
+		if (select(control_head_sound_socket + 1, &fds, NULL, NULL, &tm_wait) != 1) {
+			//BMC QuiskPrintf("read_remote_radio_sound_socket(): select returned %i\n", retval);
+			break;
+		}
+		bytes = recv(control_head_sound_socket, (char *)buf, UDP_SEND_INT16 * 2, 0);
+		if (bytes < 0) {
+			if (errno != EAGAIN && errno != EWOULDBLOCK)
+				QuiskPrintf("read_remote_radio_sound_socket(), recv(): %s\n", strerror(errno));
+			break;
+		}
+		if (bytes > 0) {
+			control_head_sound_socket_started = 1;
+			nInt16 = bytes / 2;
+			for (i = 0; i < nInt16; i += 2) {
+				samp_r = buf[i];
+				samp_l = buf[i + 1];
+				cSamples[nSamples++] = (samp_r + I * samp_l) / CLIP16 * CLIP32;
+			}
+		}
+	} // while(1)
+
+	nSamples = quisk_cInterpolate(cSamples, nSamples, &cFiltInterp3, 3);
+	nSamples = quisk_cInterp2HB45(cSamples, nSamples, &HalfBand);
+
+	return nSamples;
+}
+
+// Receive stereo 16-bit pcm microphone samples at the remote radio via UDP
+int read_remote_mic_sound_socket(complex double * cSamples)
+{
+	int i, bytes, nInt16, nSamples;
+	int16_t buf[UDP_SEND_INT16];
+	double samp_r, samp_l;
+	struct timeval tm_wait;
+	fd_set fds;
+	static struct quisk_cHB45Filter HalfBand;
+	static struct quisk_cFilter cFiltInterp3;
+	static int init_filters=1;
+
+	if (remote_radio_sound_socket == INVALID_SOCKET)
+		return 0;
+	if (init_filters) {
+		init_filters = 0;
+		memset(&HalfBand, 0, sizeof(struct quisk_cHB45Filter));
+		quisk_filt_cInit(&cFiltInterp3, quiskAudio24p3Coefs, sizeof(quiskAudio24p3Coefs)/sizeof(double));
+	}
+
+	// read all available packets, one per loop
+	nSamples = 0;
+	while (1) {
+		tm_wait.tv_sec = 0;
+		tm_wait.tv_usec = 0;
+		FD_ZERO (&fds);
+		FD_SET (remote_radio_sound_socket, &fds);
+		if (select(remote_radio_sound_socket + 1, &fds, NULL, NULL, &tm_wait) != 1) {
+			//BMC QuiskPrintf("read_remote_mic_sound_socket(): select returned %i\n", retval);
+			break;
+		}
+		bytes = recv(remote_radio_sound_socket, (char *)buf, UDP_SEND_INT16 * 2, 0);
+		if (bytes < 0) {
+			if (errno != EAGAIN && errno != EWOULDBLOCK)
+				QuiskPrintf("read_remote_mic_sound_socket(), recv(): %s\n", strerror(errno));
+			break;
+		}
+		if (bytes > 0) {
+			nInt16 = bytes / 2;
+			for (i = 0; i < nInt16; i += 2) {
+				samp_r = buf[i];
+				samp_l = buf[i + 1];
+				cSamples[nSamples++] = (samp_r + I * samp_l) / CLIP16 * CLIP32;
+			}
+		}
+	} // while(1)
+
+	nSamples = quisk_cInterpolate(cSamples, nSamples, &cFiltInterp3, 3);
+	nSamples = quisk_cInterp2HB45(cSamples, nSamples, &HalfBand);
+
+	return nSamples;
+}
+// Send stereo 16-bit pcm sound via UDP
+// This code acts as UDP server for radio sound (on remote radio) or mic sound (on control head)
+#define MAX_SAMPLES_FOR_REMOTE_SOUND 15000
+#define RX_BUFFER_SIZE 64
+
+// Send microphone samples from the control head to the remote radio
+void send_remote_mic_sound_socket(complex double * cSamples, int nSamples)
+{
+	int i;
+	ssize_t sent;
+	static int buffer_index=0;
+	static int16_t buffer[UDP_SEND_INT16];
+	static struct quisk_cHB45Filter HalfBand;
+	static struct quisk_cFilter cFiltDecim3;
+	static int init_filters=1, size_cBuf=0;
+	static complex double * cBuf=NULL;
+
+	if (init_filters) {
+		init_filters = 0;
+		memset(&HalfBand, 0, sizeof(struct quisk_cHB45Filter));
+		quisk_filt_cInit(&cFiltDecim3, quiskAudio24p3Coefs, sizeof(quiskAudio24p3Coefs)/sizeof(double));
+	}
+	if (nSamples > size_cBuf) {
+		size_cBuf = nSamples;
+		cBuf = (complex double *)realloc(cBuf, size_cBuf * sizeof(complex double));
+	}
+	if (control_head_sound_socket == INVALID_SOCKET)
+		return;
+
+	if (!control_head_sound_socket_started)
+		return;
+	memcpy(cBuf, cSamples, nSamples * sizeof(complex double));	// Do not alter cSamples
+	// Reduce sample rate from 48 to 8 ksps
+	nSamples = quisk_cDecim2HB45(cBuf, nSamples, &HalfBand);
+	nSamples = quisk_cDecimate(cBuf, nSamples, &cFiltDecim3, 3);
+	// Convert format from complex double to stereo pairs of 16-bit PCM samples.
+	// Buffer samples until UDP_SEND_INT16 are available, and then send the block.
+	for (i = 0; i < nSamples; i++) {
+		buffer[buffer_index++] = (int16_t)(creal(cBuf[i]) * (double)CLIP16 / CLIP32);
+		buffer[buffer_index++] = (int16_t)(cimag(cBuf[i]) * (double)CLIP16 / CLIP32);
+		if (buffer_index >= UDP_SEND_INT16) {
+			sent = send(control_head_sound_socket, (const char *)buffer, buffer_index * 2, 0);
+			if (sent != buffer_index * 2)
+				QuiskPrintf("send_remote_mic_sound_socket(), send(): %s\n", strerror(errno));
+			buffer_index = 0;
+		}
+	}
+}
+
+// Send radio speaker sound from the remote radio to the control head
+void send_remote_radio_sound_socket(complex double * cSamples, int nSamples)
+{	// Send nSamples samples.  Each sample is sent as two shorts (4 bytes) of L/R audio data.
+	int i, N, sent;
+	static int16_t sound_lr[UDP_SEND_INT16];
+	static int udp_size = 0;	// Keep track of UDP payload size, in shorts
+	char buf[RX_BUFFER_SIZE];	// For startup message
+	int recv_len;
+	int retval;
+	SOCKET * sock = &remote_radio_sound_socket;
+	static struct quisk_cHB45Filter HalfBand;
+	static struct quisk_cFilter cFiltDecim3;
+	static int init_filters=1, size_cBuf=0;
+	static complex double * cBuf=NULL;
+
+#if REMOTE_DEBUG > 0 //BMC debug
+	// measure/monitor tools:
+	static float callcount = 0;
+	static float sampcount = 0;
+	static uint64_t bunchcount = 0;
+	static float callcount_total = 0;
+	static float sampcount_total = 0;
+	static double prior_ts = 0;
+	static double delta_total = 0;
+#if REMOTE_DEBUG > 1 //BMC debug
+	static double prior_packet_ts = 0.0;
+	double now;
+#endif
+#endif
+
+	if (*sock == INVALID_SOCKET)
+		return;
+
+	if (init_filters) {
+		init_filters = 0;
+		memset(&HalfBand, 0, sizeof(struct quisk_cHB45Filter));
+		quisk_filt_cInit(&cFiltDecim3, quiskAudio24p3Coefs, sizeof(quiskAudio24p3Coefs)/sizeof(double));
+	}
+	if (nSamples > size_cBuf) {
+		size_cBuf = nSamples;
+		cBuf = (complex double *)realloc(cBuf, size_cBuf * sizeof(complex double));
+	}
+
+#if REMOTE_DEBUG > 0 //BMC debug
+	callcount++;
+#endif
+	// Wait for far end (client) to send its opening greetings, so we can grab its network address/port
+	if (!remote_radio_sound_socket_started) {
+		struct sockaddr_in far_addr;
+#ifdef MS_WINDOWS
+		int addr_len = sizeof(struct sockaddr_in);
+#else
+		socklen_t addr_len = sizeof(struct sockaddr_in);
+#endif
+		struct timeval tm_wait;
+		fd_set fds;
+		tm_wait.tv_sec = 0;
+		tm_wait.tv_usec = 0;
+		FD_ZERO (&fds);
+		FD_SET (*sock, &fds);
+		if ((retval = select(*sock + 1, &fds, NULL, NULL, &tm_wait)) != 1) {
+			//BMC QuiskPrintf("send_remote_sound_socket(): select returned %i\n", retval);
+			return;
+		}
+		// Receive short msg, grab far end address
+		if ((recv_len = recvfrom(*sock, buf, RX_BUFFER_SIZE, 0, (struct sockaddr *) &far_addr, &addr_len)) == -1) {
+			QuiskPrintf("send_remote_sound_socket(), recvfrom(): %s\n", strerror(errno));
+			return;
+		}
+		else if(recv_len > 0) {
+			if (recv_len >= RX_BUFFER_SIZE)
+				buf[RX_BUFFER_SIZE - 1] = '\n';
+			else
+				buf[recv_len] = '\n';
+			QuiskPrintf("send_remote_sound_socket(): recv_len = %i, %s", recv_len, buf);
+			if (connect(*sock, (const struct sockaddr *)&far_addr, sizeof(far_addr)) != 0) {
+				QuiskPrintf("send_remote_sound_socket), connect(): %s\n", strerror(errno));
+				close(*sock);
+				*sock = INVALID_SOCKET;
+			}
+			else
+				remote_radio_sound_socket_started = 1;
+		}
+	}
+
+	memcpy(cBuf, cSamples, nSamples * sizeof(complex double));	// Do not alter cSamples
+	// Reduce sample rate from 48 to 8 ksps
+	nSamples = quisk_cDecim2HB45(cBuf, nSamples, &HalfBand);
+	nSamples = quisk_cDecimate(cBuf, nSamples, &cFiltDecim3, 3);
+	// Convert format from complex double to stereo pairs of 16-bit PCM samples, send to client
+	for (i = 0; i < nSamples; i++) {
+		sound_lr[udp_size++] = (int16_t)(creal(cBuf[i]) * (double)CLIP16 / CLIP32);
+		sound_lr[udp_size++] = (int16_t)(cimag(cBuf[i]) * (double)CLIP16 / CLIP32);
+		if (udp_size >= UDP_SEND_INT16) {
+			N = UDP_SEND_INT16;
+			udp_size = 0;
+			sent = send(*sock, (char *)sound_lr, N * 2, 0);
+			if (sent != N * 2)
+				QuiskPrintf("send_remote_sound_socket(), send(): %s\n", strerror(errno));
+#if REMOTE_DEBUG > 0 //BMC debug
+			else {
+				sampcount += sent/4;
+				packets_sent++;
+#if REMOTE_DEBUG > 1 //BMC debug
+				now = QuiskTimeSec();
+				QuiskPrintf("%f, send_remote_sound_socket(): now - prior = %f, samples = %u, sampcount = %lu\n",
+					now, now - prior_packet_ts, sent / 4, sampcount);
+				prior_packet_ts = now;
+#endif
+			}
+#endif
+		}
+#if REMOTE_DEBUG > 1 //BMC debug
+		else {
+			now = QuiskTimeSec();
+			QuiskPrintf("%f, send_remote_sound_socket(): nSamples = %i\n", now, nSamples);
+		}
+#endif
+	}
+#if REMOTE_DEBUG > 0 //BMC debug
+	if (callcount >= 200) {
+		double new_ts = QuiskTimeSec();
+		double delta = new_ts - prior_ts;
+		prior_ts = new_ts;
+#if REMOTE_DEBUG > 1 //BMC every 200
+		QuiskPrintf("send_remote_sound_socket CURRENT calls: %lu, samples %lu, deltasec %f\n", callcount, sampcount, delta);
+		QuiskPrintf("%f: send_remote_sound_socket CURRENT RATES (HZ): calls %f, samples %f\n", new_ts, callcount / delta, sampcount / delta);
+#endif
+		if (bunchcount > 0) {	// skip the initial bunch; prebuf may distort some numbers(?)
+			callcount_total += callcount;
+			sampcount_total += sampcount;
+			delta_total += delta;
+		}
+		if (bunchcount % 10 == 0 && bunchcount > 0) {
+			QuiskPrintf("%f: send_remote_sound_socket SUMMARY calls: %f, samples %f, deltasec %f\n",
+				new_ts, callcount_total, sampcount_total, delta_total);
+			QuiskPrintf("%f: send_remote_sound_socket SUMMARY RATES (HZ): calls %f, samples %f\n",
+				new_ts, callcount_total / delta_total, sampcount_total / delta_total);
+		}
+		bunchcount++;
+		callcount = 0;
+		sampcount = 0;
+	}
+#endif
+}
+
+// Send graph data via UDP from the remote radio to the control head
+void send_graph_data(double * fft_avg, int fft_size, double zoom, double deltaf, int fft_sample_rate, double scale)
+{
+	static double * pixels = NULL;
+	static int n_pixels = 0;
+	static uint8_t sequence = 0;
+	uint8_t flags;
+	int16_t buffer[MAX_UDP_INT16_T];
+	int16_t block;
+	int pixel_index, buffer_index;
+	double d1, d2;
+	ssize_t sent;
+	char buf[RX_BUFFER_SIZE];	// For startup message
+	int recv_len;
+	struct sockaddr_in far_addr;
+#ifdef MS_WINDOWS
+	int addr_len = sizeof(struct sockaddr_in);
+#else
+	socklen_t addr_len = sizeof(struct sockaddr_in);
+#endif
+
+	if (remote_radio_graph_socket == INVALID_SOCKET)
+		return;
+	if ( !control_head_data_width)
+		return;
+	if ( !remote_radio_graph_socket_started) {
+		// Receive short msg, grab far end address
+		// Receive from control head is necessary to establish a path through NAT
+		if ((recv_len = recvfrom(remote_radio_graph_socket, buf, RX_BUFFER_SIZE, 0, (struct sockaddr *) &far_addr, &addr_len)) < 2) {
+			return;
+		}
+		else {
+			if (connect(remote_radio_graph_socket, (const struct sockaddr *)&far_addr, sizeof(far_addr)) != 0) {
+				QuiskPrintf("send_remote_graph_socket), connect(): %s\n", strerror(errno));
+				close(remote_radio_graph_socket);
+				remote_radio_graph_socket = INVALID_SOCKET;
+				return;
+			}
+			else {
+				remote_radio_graph_socket_started = 1;
+			}
+		}
+	}
+	if (control_head_data_width > n_pixels) {
+		n_pixels = control_head_data_width;
+		if (pixels)
+			free(pixels);
+		pixels = (double *)malloc(n_pixels * sizeof(double));
+	}
+	if ( ! fft_avg) {	// send dummy graph data
+		send(remote_radio_graph_socket, "dum", 3, 0);
+		return;
+	}
+	copy2pixels(pixels, control_head_data_width, fft_avg, fft_size, zoom, deltaf, fft_sample_rate);
+	// Send multiple 16-bit data blocks: {flags, sequence}, block number, 16-bit graph data
+	// 8-bit flags:
+	//	bit 0: clip indicator
+	// 8-bit sequence: 0, 1, 2, ..., 255
+	block = 0;
+	pixel_index = 0;
+	while (pixel_index < control_head_data_width) {
+		if (quisk_get_overrange())
+			flags = 0x01;
+		else
+			flags = 0x00;
+		buffer[0] = flags << 8 | sequence;
+		buffer[1] = block;
+		buffer_index = 2;
+		while (buffer_index < MAX_UDP_INT16_T && pixel_index < control_head_data_width) {
+			d1 = pixels[pixel_index++];
+			if (fabs(d1) < 1e-40)	// avoid log10(0)
+				d1 = 1E-40;
+			d2 = 20.0 * log10(d1) - scale;
+			if (d2 < -200)
+				d2 = -200;
+			else if (d2 > 0)
+				d2 = 0;
+			buffer[buffer_index++] = (int16_t)lround(d2 * GRAPH_DATA_SCALE);
+		}
+		sent = send(remote_radio_graph_socket, (const char *)buffer, buffer_index * 2, 0);
+		if (sent != buffer_index * 2)
+			QuiskPrintf("send_graph_data(), send(): %s\n", strerror(errno));
+		block++;
+	}
+	sequence += 1;
+}
+
+// Receive graph data via UDP on the control head
+int receive_graph_data(double * fft_avg)
+{ 
+	int i, i1, i2;
+	ssize_t count;
+	uint8_t seq, flags;
+	int16_t buffer[MAX_UDP_INT16_T];
+	int16_t block;
+	static int16_t * pixels = NULL;
+	static int n_pixels = 0;
+	static int total = 0;
+	static int16_t sequence = 0;
+
+	if (control_head_graph_socket == INVALID_SOCKET)
+		return 0;
+	// Signal far end (server) that we're ready (this sends our address/port to far end)
+	if ( !control_head_graph_socket_started) {
+		i = send(control_head_graph_socket, "rr\n", 3, 0);
+		if (i != 3)
+			QuiskPrintf("receive_graph_data(), send(): %s\n", strerror(errno));
+	}
+	if (n_pixels < data_width) {
+		n_pixels = data_width;
+		if (pixels)
+			free(pixels);
+		pixels = (int16_t *)malloc(n_pixels * sizeof(int16_t));
+	}
+	count = recv(control_head_graph_socket, (char *)buffer, MAX_UDP_INT16_T * 2, 0);
+	count /= 2;	// convert to int16_t
+	if (count > 2) {
+		control_head_graph_socket_started = 1;
+		flags = buffer[0] >> 8;
+		if (flags & 0x01)	// Clip
+			quisk_sound_state.overrange++;
+		seq = buffer[0] & 0xFF;
+		if (seq != sequence) {	// new graph data
+			sequence = seq;
+			total = 0;
+		}
+		block = buffer[1];
+		count -= 2;	// number of 16-bit graph data items
+		i1 = block * (MAX_UDP_INT16_T - 2);
+		i2 = i1 + count;
+		if (i1 >= 0 && i2 <= data_width) {
+			memcpy(pixels + i1, buffer + 2, count * 2);
+			total += count;
+			if (total == data_width) {
+				for (i = 0; i < data_width; i++)
+					fft_avg[i] = (double)pixels[i] / GRAPH_DATA_SCALE;
+				return data_width;
+			}
+		}
+	}
+	return 0;
+}
+
+
+static int start_winsock()
+{
+#ifdef MS_WINDOWS
+	WORD wVersionRequested = MAKEWORD(2, 2);
+	WSADATA wsaData;
+
+	if (WSAStartup(wVersionRequested, &wsaData) != 0) {
+		QuiskPrintf("start_winsock(): %s\n", strerror(errno));
+		return 0;		// failure to start winsock
+	}
+#endif
+	return 1;
+}
+
+
+
+
+
+static void open_and_bind_socket(SOCKET * sock, char * ip, int port, int sndsize, char * name, int non_block)
+{
+	struct sockaddr_in bind_addr;
+	const char enable = 1;	// for sockopt
+#ifndef MS_WINDOWS
+	int tos = 184;	// DSCP "Expedite" (46)
+#endif
+
+	if (!start_winsock()) {
+		QuiskPrintf("open_and_bind_socket for %s: Failure to start WinSock\n", name);
+		return;
+	}
+
+	*sock = socket(PF_INET, SOCK_DGRAM, 0);
+	if (*sock != INVALID_SOCKET) {
+		setsockopt(*sock, SOL_SOCKET, SO_SNDBUF, (char *)&sndsize, sizeof(sndsize));
+		setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
+#ifndef MS_WINDOWS
+		setsockopt(*sock, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
+#endif
+
+		// bind to this computer for receiving (and reading far-end address from client)
+		memset((char *) &bind_addr, 0, sizeof(bind_addr));
+		bind_addr.sin_family = AF_INET;
+		bind_addr.sin_port = htons(port);
+		bind_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+		if (bind(*sock, (const struct sockaddr *)&bind_addr, sizeof(bind_addr)) != 0) {
+			QuiskPrintf("open_and_bind_socket(), bind(): %s\n", strerror(errno));
+			close(*sock);
+			*sock = INVALID_SOCKET;
+		}
+		else if (non_block) {
+#ifdef MS_WINDOWS
+       			unsigned long one = 1;
+			ioctlsocket(*sock, FIONBIO, &one);	// set non-blocking
+#else
+			int flags;
+			flags = fcntl(*sock, F_GETFL, 0);	// set non-blocking
+			fcntl(*sock, F_SETFL, flags | O_NONBLOCK);
+#endif
+		}
+	}
+	if (*sock == INVALID_SOCKET) {
+		QuiskPrintf("open server %s: Failure to open socket\n", name);
+	}
+	else {
+		QuiskPrintf("open server %s: opened socket %s port %i\n", name, ip, port);
+	}
+}
+
+
+static void open_and_connect_socket(SOCKET * sock, char * ip, int port, int sndsize, char * name, int non_block)
+{
+	struct sockaddr_in Addr;
+	const char enable = 1;	// for sockopt
+
+	if (!start_winsock()) {
+		QuiskPrintf("open_and_connect_socket for %s: Failure to start WinSock\n", name);
+		return;
+	}
+
+	*sock = socket(PF_INET, SOCK_DGRAM, 0);
+	if (*sock != INVALID_SOCKET) {
+		setsockopt(*sock, SOL_SOCKET, SO_RCVBUF, (char *)&sndsize, sizeof(sndsize));
+		setsockopt(*sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
+
+		// set far-end address structure to enable sending initial packet to get things started
+		Addr.sin_family = AF_INET;
+		Addr.sin_port = htons(port);
+#ifdef MS_WINDOWS
+		Addr.sin_addr.S_un.S_addr = inet_addr(ip);
+#else
+		inet_aton(ip, &Addr.sin_addr);
+#endif
+		if (connect(*sock, (const struct sockaddr *)&Addr, sizeof(Addr)) != 0) {
+			close(*sock);
+			*sock = INVALID_SOCKET;
+		}
+		else if (non_block) {
+#ifdef MS_WINDOWS
+       			unsigned long one = 1;
+			ioctlsocket(*sock, FIONBIO, &one);	// set non-blocking
+#else
+			int flags;
+			flags = fcntl(*sock, F_GETFL, 0);	// set non-blocking
+			fcntl(*sock, F_SETFL, flags | O_NONBLOCK);
+#endif
+		}
+	}
+	if (*sock == INVALID_SOCKET) {
+		QuiskPrintf("open client %s: Failure to open socket\n", name);
+	}
+	else {
+		QuiskPrintf("open client %s: opened socket %s port %i\n", name, ip, port);
+	}
+}
+
+
+static void close_socket(SOCKET * sock, char * name)
+{
+	if (*sock != INVALID_SOCKET) {
+		close(*sock);
+		*sock = INVALID_SOCKET;
+#ifdef MS_WINDOWS
+		WSACleanup();
+#endif
+		QuiskPrintf("%s: closed socket\n", name);
+	}
+	else {
+		QuiskPrintf("%s: socket already closed\n", name);
+	}
+}
+
+// start running UDP remote sound on control_head ...
+// ... receive radio sound from remote_radio, send mic sound to remote_radio
+PyObject * quisk_start_control_head_remote_sound(PyObject * self, PyObject * args)
+{
+	int radio_sound_port;
+	int graph_data_port;
+	int sndsize = 48000;
+	char * remote_radio_ip;	// IP address of far end
+	char * name;
+	SOCKET * sock;
+
+	if (!PyArg_ParseTuple (args, "sii", &remote_radio_ip, &radio_sound_port, &graph_data_port))
+		return NULL;
+
+	name = "radio sound from remote_radio";
+	sock = &control_head_sound_socket;
+	open_and_connect_socket(sock, remote_radio_ip, radio_sound_port, sndsize, name, 0);
+
+	name = "graph data from remote_radio";
+	sock = &control_head_graph_socket;
+	open_and_connect_socket(sock, remote_radio_ip, graph_data_port, 1024 * 8, name, 1);
+
+	packets_sent = 0;
+	packets_recd = 0;
+
+	return Py_None;
+}
+
+// stop running UDP remote sound on control_head
+PyObject * quisk_stop_control_head_remote_sound(PyObject * self, PyObject * args)
+{
+	char * name;
+	SOCKET * sock;
+
+	if (!PyArg_ParseTuple (args, ""))
+		return NULL;
+
+	name = "radio sound from remote_radio";
+	sock = &control_head_sound_socket;
+	close_socket(sock, name);
+
+	name = "graph data from remote_radio";
+	sock = &control_head_graph_socket;
+	close_socket(sock, name);
+
+	control_head_sound_socket_started = 0;	// reset for next time
+	remote_radio_sound_socket_started = 0;
+	control_head_graph_socket_started = 0;
+	remote_radio_graph_socket_started = 0;
+
+	QuiskPrintf("total packets sent = %i, recd = %i\n", packets_sent, packets_recd);
+
+	return Py_None;
+}
+
+// start running UDP remote sound on remote_radio ...
+// ... send radio sound to control_head, receive mic sound from control_head
+PyObject * quisk_start_remote_radio_remote_sound(PyObject * self, PyObject * args)
+{
+	int radio_sound_port;
+	int graph_data_port;
+	int sndsize = 48000;
+	char * control_head_ip;	// IP address of far end
+	char * name;
+	SOCKET * sock;
+
+	if (!PyArg_ParseTuple (args, "siii", &control_head_ip, &radio_sound_port,
+                     &graph_data_port, &control_head_data_width))
+		return NULL;
+
+	name = "radio sound to control_head";
+	sock = &remote_radio_sound_socket;
+	open_and_bind_socket(sock, control_head_ip, radio_sound_port, sndsize, name, 0);
+
+	name = "graph data to control_head";
+	sock = &remote_radio_graph_socket;
+	open_and_bind_socket(sock, control_head_ip, graph_data_port, 1024 * 8, name, 1);
+
+	packets_sent = 0;
+	packets_recd = 0;
+
+	return Py_None;
+}
+
+// stop running UDP remote sound on remote_radio
+PyObject * quisk_stop_remote_radio_remote_sound(PyObject * self, PyObject * args)
+{
+	char * name;
+	SOCKET * sock;
+
+	if (!PyArg_ParseTuple (args, ""))
+		return NULL;
+
+	name = "radio sound to control_head";
+	sock = &remote_radio_sound_socket;
+	close_socket(sock, name);
+
+	name = "graph data to control_head";
+	sock = &remote_radio_graph_socket;
+	close_socket(sock, name);
+
+	control_head_sound_socket_started = 0;	// reset for next time
+	remote_radio_sound_socket_started = 0;
+	control_head_graph_socket_started = 0;
+	remote_radio_graph_socket_started = 0;
+	control_head_data_width = 0;
+
+	QuiskPrintf("total packets sent = %i, recd = %i\n", packets_sent, packets_recd);
+
+	return Py_None;
+}