/* 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 #include #include #include #include #include #include #ifdef MS_WINDOWS #include #include #else #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__)) #include #if defined(BSD) #include #endif #endif #include #include #include #include #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; ///// The jitter buffer is thanks to Karl Heinz - K5KHK // Jitter buffer for the microphone samples received from the control head. The network can hold // packets for 100 msec or more (Wi-Fi power saving and scanning) and then deliver them in a burst, // but the Hermes Tx buffer only has 50 msec of slack. Without a buffer here, each late burst is an // underflow (a gap on the air) followed by an overflow (discarded samples). So buffer mic_jb_target // frames before playing, and then release them at a steady MIC_JB_RATE. // The buffer adds its delay to the transmit audio, so it is off unless the configuration item // remote_radio_mic_jitter_ms is set. When it is off, samples are passed on as they arrive. #define MIC_JB_RATE 8000 // frames per second sent by the control head #define MIC_JB_SIZE 8000 // ring buffer size in stereo frames #define MIC_JB_MAX_MS 500 // largest configurable delay; MIC_JB_SIZE must hold this plus MIC_JB_EXTRA #define MIC_JB_EXTRA 2000 // trim back to mic_jb_target above mic_jb_target + this (clock drift): 250 msec #define MIC_JB_IDLE 0.5 // seconds without packets that end a transmission static int16_t mic_jb[MIC_JB_SIZE * 2]; static int mic_jb_target; // frames to buffer before playing, from remote_radio_mic_jitter_ms; zero for off static int mic_jb_read, mic_jb_count, mic_jb_playing, mic_jb_starved; static int mic_jb_underruns, mic_jb_overruns; static double mic_jb_time, mic_jb_frac, mic_jb_last_packet; static void mic_jb_reset(void) { int msec; msec = QuiskGetConfigInt("remote_radio_mic_jitter_ms", 0); if (msec < 0) msec = 0; else if (msec > MIC_JB_MAX_MS) msec = MIC_JB_MAX_MS; mic_jb_target = msec * MIC_JB_RATE / 1000; mic_jb_read = mic_jb_count = mic_jb_playing = mic_jb_starved = 0; mic_jb_underruns = mic_jb_overruns = 0; mic_jb_frac = 0; } // 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, j, bytes, nInt16, nSamples, nFrames; int16_t buf[UDP_SEND_INT16]; double now, due; 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 into the jitter buffer, one per loop now = QuiskTimeSec(); 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) { if (mic_jb_starved) { // the buffer ran dry; count it unless the transmission had ended mic_jb_starved = 0; if (now - mic_jb_last_packet < MIC_JB_IDLE) mic_jb_underruns++; } mic_jb_last_packet = now; nInt16 = bytes / 2; for (i = 0; i + 1 < nInt16; i += 2) { if (mic_jb_count >= MIC_JB_SIZE) { // full: drop the oldest frame mic_jb_read = (mic_jb_read + 1) % MIC_JB_SIZE; mic_jb_count--; } j = (mic_jb_read + mic_jb_count) % MIC_JB_SIZE * 2; mic_jb[j] = buf[i]; mic_jb[j + 1] = buf[i + 1]; mic_jb_count++; } } } // while(1) // release the frames that are due since the last call nSamples = 0; if (mic_jb_target == 0) { // the jitter buffer is off: pass on everything received nFrames = mic_jb_count; } else if ( ! mic_jb_playing) { nFrames = 0; if (mic_jb_count >= mic_jb_target) { mic_jb_playing = 1; mic_jb_time = now; mic_jb_frac = 0; } } else { due = (now - mic_jb_time) * MIC_JB_RATE + mic_jb_frac; if (due < 0) // the clock was set back due = 0; else if (due > MIC_JB_RATE / 2) // limit to 0.5 sec, well within SAMP_BUFFER_SIZE after interpolation due = MIC_JB_RATE / 2; mic_jb_time = now; nFrames = (int)due; mic_jb_frac = due - nFrames; if (nFrames > mic_jb_count) { // ran dry: play what is left, then buffer up again nFrames = mic_jb_count; mic_jb_playing = 0; mic_jb_starved = 1; } } for (i = 0; i < nFrames; i++) { j = mic_jb_read * 2; cSamples[nSamples++] = ((double)mic_jb[j] + I * (double)mic_jb[j + 1]) / CLIP16 * CLIP32; mic_jb_read = (mic_jb_read + 1) % MIC_JB_SIZE; } mic_jb_count -= nFrames; if (mic_jb_target && mic_jb_count > mic_jb_target + MIC_JB_EXTRA) { // the control head's clock is faster than ours i = mic_jb_count - mic_jb_target; mic_jb_read = (mic_jb_read + i) % MIC_JB_SIZE; mic_jb_count -= i; mic_jb_overruns++; } if ((mic_jb_underruns || mic_jb_overruns) && now - mic_jb_last_packet > MIC_JB_IDLE) { QuiskPrintf("Remote mic jitter buffer: %d underruns, %d overruns\n", mic_jb_underruns, mic_jb_overruns); mic_jb_underruns = mic_jb_overruns = 0; } 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; mic_jb_reset(); 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; mic_jb_reset(); QuiskPrintf("total packets sent = %i, recd = %i\n", packets_sent, packets_recd); return Py_None; }