Copying audio file, issue with pointers - c

Question

I was wondering if someone could help me with a problem that I'm having. I'm fairly sure that it's a pointer issue (read: I'm VERY much a C beginner), but I've been struggling with it for a fair while and have been unable to fix the issue (despite reading reference pages).
My code is meant to copy a .WAV file using two functions (the function prototypes are fixed). First it reads the file, then it writes a new file using the data samples from the old file. The header is defined in "R_WAV.h" as a typedef struct. The code is run from this:
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <malloc.h>
#include "R_WAV.h"
//Function Declarations
int read_WAV(header_type *header, char **data, char *filename);
int write_WAV(header_type *header, char *data, char *filename);
int main()
{
//Run read_WAV
{
header_type *header;
char *filename[] = {//Various files};
char **data;
read_WAV(header, data, *filename);
}
//Run write_WAV
{
header_type *header;
char *filename[] = {//Various files};
char *data;
write_WAV(header, data, *filename);
}
//Run read_WAV again on new files to ensure header info is valid
{
header_type *header;
char *filename[] = {//output files from write};
char *data;
read_WAV(header, data, *filename);
}
return(0);
}
The read_WAV function I've written (abbreviated slightly) is:
int read_WAV(header_type *header, char **data, char *filename)
{
unsigned char buffer4[4];
unsigned char buffer2[2];
FILE *fp = fopen(filename, "rb"); //Open file
//Code here that checks if file successfully opened
//If file valid, find length of file
fseek(fp, 0L, SEEK_END); //Place position at EoF
int size = ftell(fp); //Read the current value
rewind(fp); //Reset position
//Code here that checks if file size < min. header size, if true exits
header = (void*)malloc(size);
//Reading RIFF string
fread(header->ChunkID, sizeof(header->ChunkID), 1, fp);
printf("\nChunkID: %s \n", (header->ChunkID));
And so on, until it comes time to read the data:
//Read DATA samples
char *buffer_data = (char*)malloc(header->Subchunk2Size);
fread(buffer_data,1,(header->Subchunk2Size),fp);
//Error checking code here for if buffer==NULL
*data = buffer_data;
fclose(fp);
return(1);
}
The write_WAV function is:
int write_WAV(header_type *header, char *data, char *filename)
{
char n_file[50]; //Init. for new filename
int data_size = header->Subchunk2Size; //Hold size of data chunk
//CODE TO ALTER FILENAME (working properly)
//Open new file (COPY_of_filename)
FILE * fp_w = fopen(n_file, "wb");
//Check to see if file was successfully created
if (fp_w==NULL)
{
printf("\nUnable to create file.");
return(-1);
}
//Write header to new file (first 44 bytes)
fwrite(header, 1, 44, fp_w);
//Write data to new file
fwrite(data, 1, data_size, fp_w);
fclose(fp_w);
return (1);
}
I'm running into two main issues:
1) I can only get the header info (first 44 bytes) to write properly in write_WAV() if I open one of the .WAV files in that function, then use fread and a buffer to store it. Does it have to be done this way? Is there another way to use the *header that will result in this data being accessible from read_WAV() without needing to reopen the old file in write_WAV()?
2) I can't get the data samples to copy over properly. Even when I read in the header as above (and check that the header info is all correct), all I get is corrupt noise upon opening the new file. I've been trying to research this, but I've gotten nowhere. Could someone help explain/point to the mistakes in what I've done, and what I need to do in order to resolve them?
I know this is really simple stuff, and I wish that my brain was working enough to figure it out by myself. Like I said, I've read reference pages, but I'm still not getting anywhere. Not really firing on all cylinders right now.
Thank you for any (much needed) assistance!

Answer 1

Your problem is the block scoping of data in main in a few places.
That is, when you read in the file, because of variable scoping, you lose the pointer to the data. That is, when you do the write, the pointer it uses points to random memory.
I think you also have the same problem for the header pointer [although I didn't address that issue below, the fix would be similar]. Also, note that in the two read blocks, the type used for header is inconsistent even though they do the same thing.
Here's a version annotated with the bugs:
int main()
{
//Run read_WAV
{
header_type *header;
char *filename[] = {//Various files};
// NOTE/BUG: this is scoped to _this_ block, so the write section below won't
// see it
// NOTE/BUG: this should be char *data and the function call should use &data
char **data;
read_pcm_wavefile(header, data, *filename);
}
//Run write_WAV
{
pcm_wavefile_header_type *header;
char *filename[] = {//Various files};
// NOTE/BUG: this scoped 'data' declaration has none of the data in the read
// sectioon above
char *data;
write_pcm_wavefile(header, data, *filename);
}
//Run read_WAV again on new files to ensure header info is valid
{
pcm_wavefile_header_type *header;
char *filename[] = {//output files from write};
char *data;
read_pcm_wavefile(header, data, *filename);
}
return(0);
}
Here's a fixed version:
int main()
{
char *data;
//Run read_WAV
{
header_type *header;
char *filename[] = {//Various files};
read_pcm_wavefile(header, &data, *filename);
}
//Run write_WAV
{
pcm_wavefile_header_type *header;
char *filename[] = {//Various files};
write_pcm_wavefile(header, data, filename[0]);
}
free(data);
//Run read_WAV again on new files to ensure header info is valid
{
pcm_wavefile_header_type *header;
char *filename[] = {//output files from write};
read_pcm_wavefile(header, &data, filename[0]);
}
return(0);
}
UPDATE:
I've fixed that up. Still unable to get a proper output, which I'm thinking is in the passing of the data/pointer from each function?
As I mentioned you need to do the same for header because main needs the pointer to be filled in by your read function. As it is, after the read call, the value of header in main is unchanged (i.e. not updated by read_WAV as you'd like).
Change:
int read_WAV(header_type *header, char **data, char *filename)
Into:
int read_WAV(header_type **header, char **data, char *filename)
And, make all corresponding adjustments in main and read_WAV
Also, apply the same scoping fix in main for header that was done for data (i.e. header should not be block scoped, but, rather function scoped).
Because, even with the prototype change to read_WAV, main would lose the header value that read_WAV tried to pass back and write_WAV would get a garbage header pointer.
After you get this working, think about the temporal duration of the block scoped variables vs function scoped variables. In other words, if you set a variable, when does the value "go out of scope" [and become invalid].
For comparison, here's a version that does not use block scoped variables:
int
main(void)
{
char *data;
header_type *header;
char *infiles[FILECOUNT] = {//Various files};
char *outfiles[FILECOUNT] = {//Various files};
for (int fidx = 0; fidx < FILECOUNT; ++fidx) {
//Run read_WAV
read_pcm_wavefile(&header, &data, infiles[fidx]);
//Run write_WAV
write_pcm_wavefile(header, data, outfiles[fidx]);
free(header);
free(data);
//Run read_WAV again on new files to ensure header info is valid
read_pcm_wavefile(&header, &data, outfiles[fidx]);
free(header);
free(data);
}
return 0;
}