zx/quisk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ffa047c2ef5a66bc5fa36df4cd0f45ed3b0f9eb5
quisk/ac2yd/remote.c
T

749 lines
23 KiB
C
Raw Blame History

/*
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;
}
Reference in New Issue View Git Blame Copy Permalink