UDP sockets and full-duplex audio issues - c

Question

The following code is part of a C-RAN program where the server code is part of a larger module code that serves as an interface to communicate with the Remote Radio Head.
To simplify it, let us treat it as a simple client-server service. The server will send an audio file through a specific UDP socket (port1) to the client and this one will play it back. Then, the client sends an ACK to the server through another socket (port2). Afterwards, the client starts recording audio and sends the datagrams via socket (port3). FInally, the client sends again a last ack through socket (port4).
Why so many different sockets? It is mandatory, full-duplex is a must, let's leave it here.
If I "comment" the code where the client records audio, communications between client-server are fine, audio is played back properly, no choppy playback. As soon as I activate the client code for recording, the playback starts to be choppy and the recording is a mess.
I've tried all sort of tests, like reducing the number of sockets, increasing the buffer sizes, removing one or all the acks, etc..
My network programming skills are so so, thus I don't know what else I can do. One thing is for sure, either there's a datagram flow issue or the ALSA lib drives can not cope, the latter I doubt it.
The way the code is in here, audio playback will be fine, all code parts for recording are commented in the client code.
Client:
//COMPILE: gcc -o client client.c -lasound
//EXECUTE (only playback): ./client
//EXECUTE (playback&recording): ./client > recordedFilename.raw
/*
-------- Remote Radio Head - client side
Remote Radio Head recieves audio from a dedicated socket from BBU, may process it or not
and sends audio through a different socket to the BBU.
*/
/* DEPENDENCIES */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <alsa/asoundlib.h>
#include <dirent.h>
/* CONSTANTS */
#define PORT1 8070
#define PORT2 8080
#define PORT3 8090
#define PORT4 8100
#define MAXLINE 1024
#define FRAME_SIZE 512
#define PAYLOAD_SIZE (FRAME_SIZE * 4)
/* Use the newer ALSA API */
#define ALSA_PCM_NEW_HW_PARAMS_API
// START
int main(int argc, char *argv[])
{
// Sockets variables
int sockfd1, sockfd2, sockfd3, sockfd4;
int len, n;
int i = 1;
const char* ACK_play = "playback_ack";
const char* ACK_rec = "recording_ack";
const char* START_BROADCAST = "CLIENT: Connected !!!";
const char* MSG = "\nCLIENT: sending recording datagrams\n";
char buffer[MAXLINE];
struct sockaddr_in servaddr1, servaddr2, servaddr3, servaddr4;
// ALSA playback variables
int rc;
int size;
snd_pcm_t *handle;
snd_pcm_hw_params_t *params;
unsigned int val;
int dir;
snd_pcm_uframes_t frames;
// ALSA recording variables
long loops;
int rc2;
int size2;
snd_pcm_t *handle2;
snd_pcm_hw_params_t *params2;
unsigned int val2;
int dir2;
snd_pcm_uframes_t frames2;
char *buffer2;
/*********************************************
* ALSA PLAYBACK DRIVERS SETUP *
*********************************************/
// Open PCM device for playback.
rc = snd_pcm_open(&handle, "default", SND_PCM_STREAM_PLAYBACK, 0);
if (rc < 0) {
fprintf(stderr, "unable to open pcm device: %s\n", snd_strerror(rc));
exit(1);
}
// Allocate a hardware parameters object.
snd_pcm_hw_params_alloca(&params);
// Fill it in with default values.
snd_pcm_hw_params_any(handle, params);
// Set the desired hardware parameters.
// Interleaved mode
snd_pcm_hw_params_set_access(handle, params, SND_PCM_ACCESS_RW_INTERLEAVED);
// Signed 16-bit little-endian format
snd_pcm_hw_params_set_format(handle, params, SND_PCM_FORMAT_S16_LE);
// Two channels (stereo)
snd_pcm_hw_params_set_channels(handle, params, 2);
// playback sampling rate
val = 48000;
snd_pcm_hw_params_set_rate_near(handle, params, &val, &dir);
// Set period size to 32 frames.
frames = FRAME_SIZE;
snd_pcm_hw_params_set_period_size_near(handle, params, &frames, &dir);
// Write the parameters to the driver
rc = snd_pcm_hw_params(handle, params);
if (rc < 0) {
fprintf(stderr, "unable to set hw parameters: %s\n", snd_strerror(rc));
exit(1);
}
/*********************************************
* ALSA RECORDING DRIVERS SETUP *
*********************************************/
// Open PCM device for recording (capture).
rc2 = snd_pcm_open(&handle2, "default", SND_PCM_STREAM_CAPTURE, 0);
if (rc2 < 0) {
fprintf(stderr, "unable to open pcm device: %s\n", snd_strerror(rc2));
exit(1);
}
// Allocate a hardware parameters object.
snd_pcm_hw_params_alloca(&params2);
// Fill it in with default values.
snd_pcm_hw_params_any(handle2, params2);
// Set the desired hardware parameters.
// Interleaved mode
snd_pcm_hw_params_set_access(handle2, params2, SND_PCM_ACCESS_RW_INTERLEAVED);
// Signed 16-bit little-endian format
snd_pcm_hw_params_set_format(handle2, params2, SND_PCM_FORMAT_S16_LE);
// Two channels (stereo)
snd_pcm_hw_params_set_channels(handle2, params2, 2);
// recording sampling rate
val2 = 48000;
snd_pcm_hw_params_set_rate_near(handle2, params2, &val, &dir2);
// Set period size to 32 frames.
frames2 = FRAME_SIZE;
snd_pcm_hw_params_set_period_size_near(handle2, params2, &frames, &dir2);
// Write the parameters to the driver
rc2 = snd_pcm_hw_params(handle2, params2);
if (rc2 < 0) {
fprintf(stderr, "unable to set hw parameters: %s\n", snd_strerror(rc2));
exit(1);
}
/*********************************************
* CREATING SOCKET FILE DESCRIPTOR *
*********************************************/
// --------------- SOCKET 1
if ((sockfd1 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket 1 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr1, 0, sizeof(servaddr1));
// Filling server 1 information
servaddr1.sin_family = AF_INET; // ipv4
servaddr1.sin_addr.s_addr = INADDR_ANY; // Any server
servaddr1.sin_port = htons(PORT1);
// --------------- SOCKET 2
if ((sockfd2 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket 2 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr2, 0, sizeof(servaddr2));
// Filling server 2 information
servaddr2.sin_family = AF_INET; // ipv4
servaddr2.sin_addr.s_addr = INADDR_ANY; // Any server
servaddr2.sin_port = htons(PORT2);
// --------------- SOCKET 3
if ((sockfd3 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket 3 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr3, 0, sizeof(servaddr3));
// Filling server 2 information
servaddr3.sin_family = AF_INET; // ipv4
servaddr3.sin_addr.s_addr = INADDR_ANY; // Any server
servaddr3.sin_port = htons(PORT3);
// --------------- SOCKET 4
if ((sockfd4 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket 4 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr4, 0, sizeof(servaddr4));
// Filling server 2 information
servaddr4.sin_family = AF_INET; // ipv4
servaddr4.sin_addr.s_addr = INADDR_ANY; // Any server
servaddr4.sin_port = htons(PORT4);
/********************************************
* SEND MSG TO SERVER *
********************************************/
//sockfd: File descriptor of socket
//buffer: Application buffer cointaining the data to be sent
//len: Size of buffer
//flags: Bitwise OR flags to modify socket behaviour
//dest_addr: Structure containing address of destination
//addrlen: Size of dest_addr structure
sendto(sockfd1, START_BROADCAST, strlen(START_BROADCAST), 0, (const struct sockaddr *)&servaddr1, sizeof(servaddr1));
printf("CLIENT: Waiting for audio!!!\n");
/********************************************
* RECIEVE MSG FROM SERVER *
********************************************/
//sockfd: file descriptor of socket
//buffer: Apllication buffer in which to recieve data
//len: Size of buffer
//flags: Bitwise OR flags to modify socket behaviour
//src_addr: Structure containing source address is returned
//addrlen: Variable in which size of src_addr structure is returned
/* We allocate memory to store the payload of the incoming datagram. */
char *play_load = (char *)malloc(PAYLOAD_SIZE * sizeof(char));
char *rec_load = (char *)malloc(PAYLOAD_SIZE * sizeof(char));
///////////////////////////////////////////////////////////////////////////////////////
/* HERE CLIENT (RRH) RECIEVES AND SENDS DATA TO SERVER (BBU) NEEDS TO BE FULL DUPLEX */
///////////////////////////////////////////////////////////////////////////////////////
while (1)
{
//----------------------------------------- RECIEVE AUDIO DATAGRAMS
len = PAYLOAD_SIZE;
int playback_bytes = recvfrom(sockfd1, (void *)play_load, PAYLOAD_SIZE, MSG_WAITALL, (struct sockaddr *)&servaddr1, &len);
//----------------------------------------- ALSA PLAYBACK DATAGRAMS
rc = snd_pcm_writei(handle, play_load, frames);
// if true, audio is playing
if (rc>0 && i>0){
printf("CLIENT: Playing audio!!!\n");
i--;
}
if (rc == -EPIPE) {
// EPIPE means underrun
fprintf(stderr, "playback underrun occurred\n");
snd_pcm_prepare(handle);
} else if (rc < 0) {
fprintf(stderr, "playback error from writei: %s\n", snd_strerror(rc));
} else if (rc != (int)frames) {
fprintf(stderr, "playback short write, write %d frames\n", rc);
}
//------------------------------------------- SEND PLAYBACK ACK
sendto(sockfd2, ACK_play, strlen(ACK_play), 0, (const struct sockaddr *)&servaddr2, len);
printf("1 -sending audio playback ACK\n");
//------------------------------------------- ALSA RECORDING DATAGRAMS
/*//¡¡¡uncomment to record audio and send it to server!!!
rc2 = snd_pcm_readi(handle2, rec_load, frames2);
if (rc2 == -EPIPE) {
// EPIPE means overrun
fprintf(stderr, "recording overrun occurred\n");
snd_pcm_prepare(handle2);
} else if (rc2 < 0) {
fprintf(stderr, "recording error from read: %s\n", snd_strerror(rc2));
} else if (rc2 != (int)frames2) {
fprintf(stderr, "recording short read, read %d frames\n", rc2);
}
//rc2 = write(1, buffer2, size2); //Only to see recorded data// Only uncomment to save recorded audio into a raw file
if (rc2 != size2)
fprintf(stderr, "recording short write: wrote %d bytes\n", rc2);
*/
//------------------------------------------- SEND RECORDING DATAGRAMS
sendto(sockfd3, MSG, strlen(MSG), 0, (const struct sockaddr *)&servaddr3, len);
//sendto(sockfd3, rec_load, PAYLOAD_SIZE, 0, (const struct sockaddr *)&servaddr3, len);//uncomment to send audio recorded datagrams
printf("2 -sending audio recording datagrams\n");
//------------------------------------------- SEND RECORDING ACK
sendto(sockfd4, ACK_rec, strlen(ACK_rec), 0, (const struct sockaddr *)&servaddr4, len);
printf("3 -sending audio recording ACK\n\n");
//------------------------------------------- PLAYBACK FINISH
if(playback_bytes<2048){
printf("END PLAYBACK DATAGRAMS %d\n",playback_bytes);
break;
}
}
snd_pcm_drain(handle);
snd_pcm_close(handle);
close(sockfd1); //close file descriptor
close(sockfd2);
close(sockfd3);
close(sockfd4);
return 0;
}
//END
server:
//COMPILE: gcc -o server server.c
//EXECUTE: ./server < filename.wav
/*
-----Implementation Base Band Unit server side
BBU sends audio through a dedicated sockets to RRH
and recieves it throught a different socket from it
through a dedicated socket to process it afterwards
in other modules.
*/
/* DEPENDENCIES */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
/* CONSTANTS */
#define PORT1 8070
#define PORT2 8080
#define PORT3 8090
#define PORT4 8100
#define MAXLINE 1024
#define PAYLOAD_SIZE 2048
// START
int main(int argc, char *argv[])
{
int sockfd1, sockfd2, sockfd3, sockfd4;
int len, len2, len3, n, ad;
char buffer1[MAXLINE];
char buffer2[MAXLINE];
const char* msg = "\nSERVER: Sending audio complete";
const char* ACK = "ack";
struct sockaddr_in servaddr1, cliaddr1;
struct sockaddr_in servaddr2, cliaddr2;
struct sockaddr_in servaddr3, cliaddr3;
struct sockaddr_in servaddr4, cliaddr4;
/*********************************************
* CREATING SOCKET FILE DESCRIPTOR *
*********************************************/
// SOCKET 1
if ((sockfd1 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
/*AL_INET: ipv4; SOCK_DGRAM: UPD; 0: default protocol*/
perror("socket 1 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr1, 0, sizeof(servaddr1)); // Allocate memory for structure
memset(&cliaddr1, 0, sizeof(cliaddr1));
// Filling server information
servaddr1.sin_family = AF_INET; // IPv4
servaddr1.sin_addr.s_addr = INADDR_ANY; // Any client
servaddr1.sin_port = htons(PORT1);
// SOCKET 2
if ((sockfd2 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
/*AL_INET: ipv4; SOCK_DGRAM: UPD; 0: default protocol*/
perror("socket 2 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr2, 0, sizeof(servaddr2)); // Allocate memory for structure
memset(&cliaddr2, 0, sizeof(cliaddr2));
// Filling server information
servaddr2.sin_family = AF_INET; // IPv4
servaddr2.sin_addr.s_addr = INADDR_ANY; // Any client
servaddr2.sin_port = htons(PORT2);
// SOCKET 3
if ((sockfd3 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
/*AL_INET: ipv4; SOCK_DGRAM: UPD; 0: default protocol*/
perror("socket 3 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr3, 0, sizeof(servaddr3)); // Allocate memory for structure
memset(&cliaddr3, 0, sizeof(cliaddr3));
// Filling server information
servaddr3.sin_family = AF_INET; // IPv4
servaddr3.sin_addr.s_addr = INADDR_ANY; // Any client
servaddr3.sin_port = htons(PORT3);
// SOCKET 4
if ((sockfd4 = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
/*AL_INET: ipv4; SOCK_DGRAM: UPD; 0: default protocol*/
perror("socket 4 creation failed");
exit(EXIT_FAILURE);
}
memset(&servaddr4, 0, sizeof(servaddr4)); // Allocate memory for structure
memset(&cliaddr4, 0, sizeof(cliaddr4));
// Filling server information
servaddr4.sin_family = AF_INET; // IPv4
servaddr4.sin_addr.s_addr = INADDR_ANY; // Any client
servaddr4.sin_port = htons(PORT4);
/********************************************
* BIND THE SOCKET WITH THE SERVER ADDRESS *
********************************************/
//sockfd: File descriptor of socket to be binded
//addr: Structure in which address to be binded to is specified
//addrlen: Size of addr structure
// BIND SOCKET 1
if (bind(sockfd1, (const struct sockaddr *)&servaddr1, sizeof(servaddr1)) < 0) {
perror("bind socket 1 failed");
exit(EXIT_FAILURE);
}
// BIND SOCKET 2
if (bind(sockfd2, (const struct sockaddr *)&servaddr2, sizeof(servaddr2)) < 0) {
perror("bind socket 2 failed");
exit(EXIT_FAILURE);
}
// BIND SOCKET 3
if (bind(sockfd3, (const struct sockaddr *)&servaddr3, sizeof(servaddr3)) < 0) {
perror("bind socket 3 failed");
exit(EXIT_FAILURE);
}
// BIND SOCKET 4
if (bind(sockfd4, (const struct sockaddr *)&servaddr4, sizeof(servaddr4)) < 0) {
perror("bind socket 4 failed");
exit(EXIT_FAILURE);
}
/********************************************
* RECEIVE MSG FROM CLIENT *
/*******************************************/
//sockfd: file descriptor of socket
//buffer: Apllication buffer in which to recieve data
//len: Size of buffer
//flags: Bitwise OR flags to modify socket behaviour
//src_addr: Structure containing source address is returned
//addrlen: Variable in which size of src_addr structure is returned
len = PAYLOAD_SIZE; // len is value/result
printf("\nSERVER: Waiting for client connection...\n");
n = recvfrom(sockfd1, (char *)buffer1, MAXLINE, MSG_WAITALL, (struct sockaddr *)&cliaddr1, &len);
buffer1[n] = '\0';
printf("%s\n", buffer1);
/********************************************
* SEND MSG TO CLIENT *
********************************************/
//sockfd: File descriptor of socket
//buffer: Application buffer cointaining the data to be sent
//len: Size of buffer
//flags: Bitwise OR flags to modify socket behaviour
//dest_addr: Structure containing address of destination
//addrlen: Size of dest_addr structure
// We allocate memory for the datagrams payload
char* payload = (char*)malloc(PAYLOAD_SIZE * sizeof(char));
printf("SERVER: Sending audio...\n");
//////////////////////////////////////////////////////////////////////////
/* HERE SERVER (BBU) SENDS DATA TO CLIENT (RRH) NEEDS TO BE FULL DUPLEX */
//////////////////////////////////////////////////////////////////////////
while (1)
{
//---------------------------------------- READING AUDIO FILE
int playback = read(0, (void*)payload, PAYLOAD_SIZE);
if (playback <= 0){// If true, audio send end
printf("%s\n\n", msg);
break;
}
//--------------------------------------- SEND AUDIO PLAYBACK DATAGRAMS
sendto(sockfd1, (void*)payload, playback, 0, (struct sockaddr *)&cliaddr1, len);
printf(" 1- Sending audio playback datagrams\n");
//--------------------------------------- RECIEVE AUDIO PLAYBACK ACK
len2 = sizeof(cliaddr2);
n = recvfrom(sockfd2, (char *)buffer1, MAXLINE, MSG_WAITALL, (struct sockaddr *)&cliaddr2, &len);
buffer1[n] = '\0';
//printf("CLIENT: %s\n", buffer1);// to check incoming ack
printf(" 2- Receiving audio playback ACK\n");
//--------------------------------------- RECIEVE AUDIO RECORDING DATAGRAMS
ad = recvfrom(sockfd3, (char *)buffer2, PAYLOAD_SIZE, MSG_WAITALL, (struct sockaddr *)&cliaddr3, &len);
printf(" 3- Receiving audio recording datagrams\n");
buffer2[ad] = '\0';
printf("%s\n", buffer2);
//--------------------------------------- RECEIVE RECORDING ACK
n = recvfrom(sockfd4, (char *)buffer1, MAXLINE, MSG_WAITALL, (struct sockaddr *)&cliaddr4, &len);
buffer1[n] = '\0';
//printf("CLIENT: %s\n", buffer1);//to check incoming ack
printf(" 4- Receiving audio recording ACK\n");
}
return 0;
}
//END