C 프로그래밍 중 파일입출력에 대한 질문이 있습니다.

#define ALSA_PCM_NEW_HW_PARAMS_API
 
#include <alsa/asoundlib.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <getopt.h>
#include <fcntl.h>
#include <sys/ioctl.h>
 
#include <sndfile.h>
#include <malloc.h>
 
#include <math.h>
#include <time.h>
 
#include <wiringPi.h>
 
//# include <fftw3.h>
 
#include "/opt/vc/src/hello_pi/hello_fft/mailbox.h"
#include "/opt/vc/src/hello_pi/hello_fft/gpu_fft.h"
 
#define SIZE 1024 //FFT ?
 
#define sRate 44100
#define rSec 1
#define frame 16
#define LENGTH sRate*rSec //read size
#define channel 1
//#define Input_Leng 2048 //fft re.im send to fft.power by input_leng
#define Input_Leng 1024
#define Buff_size 1024
#define BUFF_SIZE 1024
#define waittime 3
#define sleepTime 20
#define stime1 0
#define stime2 2
 
float fft_calculate_ready(char *inputfile, char *outputfile, long int offset, int log2_N);
//int fft_calculate(float *inputfile, int log2_N, char *filename, struct GPU_FFT_COMPLEX *base, struct GPU_FFT *fft);
 
float Auto_correlation(char *inputfile, int log2_N);
//float Cross_correlation(float *input1, float *input2, int time_lag);
 
struct GPU_FFT_COMPLEX *base; // float re[],im[]
struct GPU_FFT *fft;
 
int log2_N = 10;
 
 
int main()
{
 
	int i,k,j,N,M;
	FILE *fp_write;
	//FILE *fp_read;
	long timeLoops;
	int status;
 
	int rc;
	int size;
	snd_pcm_t *handle;
	snd_pcm_hw_params_t *params;
	unsigned int sampleRate = sRate;
	unsigned int channels = channel;
	unsigned int sSec1, sSec2;
	//unsigned int Input_Leng;
	int recordSec = rSec;
	int dir;
	snd_pcm_uframes_t frames;
	float *buffer; // pcm data
	float *tBuffer;
	//float tBuffer[N];
 
	time_t tm_time;
	struct tm *st_time;
	char buff[Buff_size]; // file name temp buffer
	char strbuff[Buff_size]; //save data file name
	char str2buff[Buff_size]; //resave file name
	char spbuff[Buff_size]; //signal processing data file name
	float buf[Buff_size]; //temp buffer
	float *Auto_result;
	//double *Auto_result;
 
	N = 1<<log2_N;
 
	//Auto_result = (double *)malloc(sizeof(double)*N);
	//float tBuffer[N];
	Auto_result = (float *)malloc(sizeof(float)*N);
 
	/* Open PCM device for recording (capture). */
	rc = snd_pcm_open(&handle, "default", SND_PCM_STREAM_CAPTURE, 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);
 
	/* 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, channels);
 
	/* 44100 bits/second sampling rate (CD quality) */
	//sampleRate = 44100;
	snd_pcm_hw_params_set_rate_near(handle, params, &sampleRate, &dir);
 
	/* Set period size to 32 frames. */
	frames = frame;
	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);
	}
 
	/* Use a buffer large enough to hold one period */
	snd_pcm_hw_params_get_period_size(params, &frames, &dir);
	//size = frames * channel *2; // 2 bytes/sample, 2 channels // 4096
	size = frames * 4; // 2 bytes/sample, 2 channels // 4096
	buffer = (float *) malloc(size);
	if(buffer == NULL) printf("buffer malloc failed\n");
	tBuffer = (float *) malloc(sizeof(float)*N);
	if(tBuffer == NULL) printf("tBuffer malloc failed\n");
 
	//sampleRate 44100, 2byte per sample and 2 channels, 5 sec record. so 44100*2*2*5 = 882000 byte
	/* We want to loop for 5 seconds */
	snd_pcm_hw_params_get_period_time(params, &sampleRate, &dir);
	timeLoops = recordSec*1000000 /sampleRate;
 
	time(&tm_time);
	st_time = localtime(&tm_time);
	strftime(buff,Buff_size,"%Y-%m-%d %H:%M:%S",st_time);
	printf(buff);
	printf("\n");
	sprintf(strbuff,"TEST_%s.txt",buff);
	sprintf(str2buff,"ACC_%s.txt",buff);
	sprintf(spbuff,"SP_%s.txt",buff);
 
	printf("setup complete...and wait %d sec\n",waittime);
	sleep(waittime); // prevent beginning codec noise from sound data
	printf("ok..start recording %d sec...\n",rSec);
 
	int p_delay = 10;
 
	while (timeLoops > 0)
	{
		timeLoops--;
		rc = snd_pcm_readi(handle, buffer, frames);
		if (rc == -EPIPE)
		{
			/* EPIPE means overrun */
			fprintf(stderr, "overrun occurred\n");
			snd_pcm_prepare(handle);
		}
		else if (rc < 0)
		{
			fprintf(stderr, "error from read: %s\n", snd_strerror(rc));
		}
		else if (rc != (int)frames)
		{
			fprintf(stderr, "short read, read %d frames\n", rc);
		}
			fp_write = fopen(strbuff,"ab");
			//fwrite( buffer,sizeof(float),rc,fp_write);
			fwrite(buffer,sizeof(float),frames,fp_write); //fwrite inner buffer 512 so... if frames 1024, no wait and send buffer to disk immediatedly
			fflush(fp_write);
	}
	printf("file save complete...\n");
	status = fclose(fp_write);
	if(status != 0)
	{
		printf("txt file save error!!\n");
		return -1;
	}
	free(buffer);
//////////////////////////////////////////////////////////////////////////////////////////////////////////
	//sleep(waittime);
	printf("time data file reading.....FFT process....\n");
 
	fft_calculate_ready(strbuff, str2buff, 0, log2_N);
 
	for(i=0;i<100000;i++);
 
	Auto_correlation(str2buff, log2_N);
 
//////////////////////////////////////////////////////////////////////////////////////////////////////////
 
	snd_pcm_drain(handle);
	snd_pcm_close(handle);
 
	return 0;
}
 
float fft_calculate_ready(char *inputfile, char *outputfile, long int offset, int log2_N)
{
	FILE *input;
	FILE *out_file;
	int N,i;
	int p_delay = 10;
 
	N = 1<<log2_N; // FFT length
 
	printf("file reading...\n");
	//input = fopen(inputfile, "rb");
	input = fopen(inputfile, "rb");
	out_file = fopen(outputfile,"ab");
	if(input == NULL)
	{
		printf("ERROR: File %s not found.\n",inputfile);
		exit(1);
	}
 
	float *F_input, *F_out, *F_out2;
	//float F_input[N];
	int f_size;
	F_input = (float*)malloc(N*sizeof(float));
	F_out2 = (float*)malloc(N*sizeof(float));
	if(F_input == NULL) printf("F_input buffer failed\n");
	memset(F_input, 0, N);
	fseek(input,offset,SEEK_SET);
	while((f_size = fread(F_input,sizeof(float),N,input)) < N); fflush(input);
	if(f_size != N)
	{
		printf("file reading error..\n");
	}
 
	F_out = &F_input[0];
 
	for(i=0;i<N;i++)
	{
		F_out2[i] = *(F_out+i);
	}
 
	if((f_size = fwrite(F_out2, sizeof(float),f_size,out_file)) < 0)
	{
		printf("file %s write error\n",outputfile);
	}
	fflush(out_file);
	delay(p_delay);
 
	fclose(input);
	fclose(out_file);
	free(F_input);
	free(F_out2);
 
	//return 0;
}
 
//float Auto_correlation(float *input, int time_lag)
float Auto_correlation(char *inputfile, int log2_N)
{
	FILE *fp_auto;
	int i = 0;
	int N;
	N = 1<<log2_N;
 
	//float result = 0;
	float *inputdata;
	inputdata = (float *)malloc(sizeof(float)*N);
 
	float result = 0;
 
	fp_auto = fopen(inputfile,"rb");
	if(fp_auto = NULL) printf("file read failed\n");
 
	fread(inputdata, sizeof(float),N,fp_auto);
 
	//for(i=0;i<N;i++) printf("%f",inputdata[i]);
 
	//delay(10);
 
	fclose(fp_auto);
 
/*
	for(i = 0; i<Input_Leng - time_lag; i++)
		result = result + input[i] * input[i + time_lag];
 
	return result;
*/
	return 0;
}