Passing wav file samples through socket in c - c

Question

I'm (unsuccessfully) trying to pass a .wav file through a socket in C.
The following code reads the .wav file and assigns it to the short samples variable (num_samples being its size).
char* filename = "./test.wav";
FILE* f;
short* samples; // stored signal
int num_samples, curr_samples; // count of signal samples
if ((f = fopen(filename, "rb")) == NULL) {
fprintf(stderr, "cannot open %s\n", filename);
return;
}
/* reads the .wav file into memory (samples) */
if (read_wav(f, &samples, &num_samples) < 0) {
return;
}
fclose(f);
Then, the samples are loaded iteratively into buffers and passed through the socket
int buffer_size = 320;
unsigned char buffer[buffer_size];
short bufferSamples[buffer_size/2];
int curr_samples = 0;
while(curr_samples < num_samples) {
bzero(buffer,buffer_size);
bzero(bufferSamples,buffer_size/2);
// Store samples in short array
for (i = curr_samples; i < buffer_size/2 + curr_samples; i++) {
bufferSamples[i-curr_samples] = *(samples + i);
}
// assign to buffer
for (i = 0; i < buffer_size; i+=2) {
unsigned char upper = bufferSamples[i/2] & 0xFF;
unsigned char lower = bufferSamples[i/2] >> 8;
buffer[i] = lower;
buffer[i+1] = upper;
}
n = write(sockfd,buffer,strlen(buffer));
if (n < 0) error("ERROR writing to socket");
// sleep and increment
usleep(10000);
curr_samples += buffer_size/2;
}
For the sake of simplicity, I have not posted the entire code (socket definitions etc)
I believe I have confirmed that bufferSamples correctly stores the signal in shorts for each iteration (by comparing its prints with the output of the command "od -s test.wav"), so I suspect that the problem occurs when I assign the short array to the char buffer. I have tried altering the endianess to no avail.
The server also reads input from another client I have no access to, but it handles its inputs correctly, so the problem lies in this client.
I have little experience with sockets and byte conversions, so I would be grateful if you provided me with some insight. Hopefully the solution with be quite obvious for the experienced.
EDIT: As it turns out, the problem lies in the interface used to pass the signal to this code. So, apart from the strlen() function, it seems ok after all. Nevertheless, thank you for your educating tips!

Answer 1

Mostly this looks ok. The code could be tidier, more functions to convert between Short and 2x char etc... to improve readability, but what you have written looks correct at a glance.
There is one problem however.
n = write(sockfd,buffer,strlen(buffer));
strlen() is for counting the length of a null terminated string.
If your buffer has any byte which is 0, strlen will stop counting. You probably want to send the size of the buffer each time sizeof(buffer)

Answer 2

I agree with the other answer that the use of strlen is definitely going to cause you a problem. I'm answering in addition to point out that you are doing a lot of unnecessary work that may also be bug prone. Copying the samples into another short buffer and then copying that short buffer into a buffer of chars can both be skipped. Another issue you're going to have is when you reach the end of your buffer. If its not a multiple of 320 bytes then you'll just read right past the end of the buffer.
int numBytesRemaining = num_samples * 2;
int numBytesToSend = 0;
int numBytesSent = 0;
unsigned char* pBuf = (unsigned char*)samples;
while (numBytesRemaining)
{
numBytesThisTime = 320;
// don't read past the end of the buffer.
if (numBytesThisTime > numBytesRemaining)
numBytesThisTime = numBytesRemaining;
// just in case fewer bytes were written than requested.
// 0 is an example.
numBytesWritten = write(sockfd,pBuf,numBytesThisTime);
if (numBytesWritten < 0) error("ERROR writing to socket");
// sleep and increment
usleep(10000);
// only advance by numBytesWritten
numBytesRemaining -= numBytesWritten;
pBuf += numBytesWritten; // advance the pointer.
}