#include <stdio.h>
#include "wave.h"

/**************** staticに関する補足説明 *********************
（１）「関数がstatic宣言されている」
関数がstatic宣言されると，この関数はこのファイルの中でしか使え
なくなる。
このファイルの関数群のうち，外部に公開されている関数と，外部に
公開している関数に分けることが出来る。
公開されている関数のプロトタイプはwave.hに記述されている。
公開されていない関数は，外部からは見えないので，別のソースファ
イルを作る上で，関数名の衝突に気をつけることが無くなるメリット
がある。
このような効果を関数の隠蔽という。

（２）「関数の外部に置かれたグローバル変数がstatic宣言されている」
関数の外部に置かれたグローバル変数がstatic宣言されると，この変
数はこのファイルの中でしか使えなくなる。
このような効果を変数の隠蔽という。

例
static FILE *fpi;
通常のCプログラミングではfpiはファイル操作の時に必ず用いるが，プロ
グラムの大きな流れを考える上では邪魔なものである。ファイルを開いて
から閉じるまではこの変数は絶えず参照されるが，毎回これへの参照をプ
ログラムに記述させないですむように隠蔽する。
static pcmheader_t pcmheaderi
waveファイルのヘッダ部も，毎回プログラミングするのは大変である。
これも隠蔽して，自動で処理させるのがよい。
新たなプログラミングの際は，waveファイルのヘッダ部操作は気にかけず
にすむようになっている。
*************************************************************/

typedef struct {
    char str_riff[4];
    unsigned long int fsize_8;/*ファイルサイズ-8 [byte]*/
    char str_wave[4];
    char str_fmt[4];
    unsigned long int info_block_size;/*format〜num_bits_sampleの部分の合計サイズ[byte]*/
    unsigned short int wave_format;/*フォーマットID リニアPCM：1*/
    unsigned short int number_of_channels;/*チャネル数 nc モノラル：1  ステレオ：2*/
    unsigned long int sampling_frequency;/*サンプリング周波数fs [Hz] */
    unsigned long int rate;/*平均データ速度r=fs*sb [byte/s]*/
    unsigned short int blocksize;/*ブロックサイズsb=(nc*INT(nb/8))[byte/sample time]*/
    unsigned short int num_bits_sample;/*1サンプル当たりのビット数nb [bit]*/
    char str_data[4];
    unsigned long int binarydatasize;/*バイナリデータのサイズ[byte]*/
} pcmheader_t;/*ヘッダ構造体の定義*/

static FILE *fpi;
static pcmheader_t pcmheaderi={
	{'R','I','F','F'},
	0L,
	{'W','A','V','E'},
	{'f','m','t',' '},
	16L,
	0,
	0,
	0L,
	0L,
	0,
	0,
	{'d','a','t','a'},
	0L
};

static void getString4(char *buff)
{
	fread(buff,1,4,fpi);
}

static short int getShortInt(void)
{
	unsigned char buff[2];
	short int x=0;
	fread(buff,1,2,fpi);
	x=(short int)buff[0]+(((short int)buff[1])<<8);
	return x;
}

static unsigned long int getLongInt(void)
{
	unsigned char buff[4];
	unsigned long int x=0;
	fread(buff,1,4,fpi);
	x=(unsigned long int)buff[0]+(((unsigned long int)buff[1])<<8)+(((unsigned long int)buff[2])<<16)+(((unsigned long int)buff[3])<<24);
	return x;
}

static int missmatch4char(char s1[],char s2[])
/*4バイトが不一致なら１　一致なら０*/
{
	int i;
	for (i=0;i<4;i++) {
		if (s1[i]!=s2[i]) return 1;
	}
	return 0;
}

static WaveConstant_t getPCMHeader(void)
{
	WaveConstant_t ret={0L,0,0L,0};
	char buff[8];
	unsigned long int li;
	unsigned long int extrasize;
	unsigned long int i;
	getString4(buff);
	if (missmatch4char(buff,pcmheaderi.str_riff)) return ret;
	pcmheaderi.fsize_8=getLongInt();
	getString4(buff);
	if (missmatch4char(buff,pcmheaderi.str_wave)) return ret;
	getString4(buff);
	if (missmatch4char(buff,pcmheaderi.str_fmt)) return ret;
	li=getLongInt();
	extrasize=li-pcmheaderi.info_block_size;
	pcmheaderi.wave_format=getShortInt();
	if (pcmheaderi.wave_format!=1) return ret;
	pcmheaderi.number_of_channels=getShortInt();
	pcmheaderi.sampling_frequency=getLongInt();
	pcmheaderi.rate=getLongInt();
	pcmheaderi.blocksize=getShortInt();
	pcmheaderi.num_bits_sample=getShortInt();
	for (i=0;i<extrasize;i++) fread(buff,1,1,fpi);
	getString4(buff);
	while (missmatch4char(buff,pcmheaderi.str_data)) {
		if (missmatch4char(buff,"fact")) {
			return ret;
		} else {
			extrasize=getLongInt();
			for (i=0;i<extrasize;i++) fread(buff,1,1,fpi);
		}
		getString4(buff);
	}
	pcmheaderi.binarydatasize=getLongInt();
	ret.SamplingFrequency=pcmheaderi.sampling_frequency;
	ret.BitsPerSample=pcmheaderi.num_bits_sample;
	ret.NumberOfSamples=pcmheaderi.binarydatasize/pcmheaderi.blocksize;
	ret.NumberOfChannels=pcmheaderi.number_of_channels;
	return ret;
}

WaveConstant_t openInputWaveFile(char *fname) /*NULL:fault*/
{
	WaveConstant_t ret={0L,0,0L,0};
	fpi=fopen(fname,"rb");
	if (fpi==NULL) return ret;
	ret=getPCMHeader();
	if (ret.NumberOfSamples==0) closeInputWaveFile();
	return ret;
}

short int getSingleCHSampleData(void)
{
	short int uc;
	short int x;
	if (pcmheaderi.num_bits_sample==8) {
		uc=fgetc(fpi);
		if (uc==EOF) return 0;
		x=((short int)(uc^0x80))<<8;
	} else {
		x=getShortInt();
	}
	return x;
}

void getSingleCHSampleDataBlock(short int x[], int number)
{
	int i;
	for (i=0;i<number;i++) {
		x[i]=getSingleCHSampleData();
	}
}

void getDualCHSampleData(short int data[2])
{
	data[0]=getSingleCHSampleData();
	data[1]=getSingleCHSampleData();
}

void getDualCHSampleDataBlock(short int data[][2], int number)
{
	int i;
	for (i=0;i<number;i++) {
		data[i][0]=getSingleCHSampleData();
		data[i][1]=getSingleCHSampleData();
	}
}

int checkEOFInputWaveFile(void)
{
	if (feof(fpi)) return EOF;
	else return 0;
}

void closeInputWaveFile(void)
{
	fclose(fpi);
}

static FILE *fpo;
static pcmheader_t pcmheadero={
	{'R','I','F','F'},
	0L,
	{'W','A','V','E'},
	{'f','m','t',' '},
	16L,
	1,
	0,
	0L,
	0L,
	0,
	0,
	{'d','a','t','a'},
	0L
};

static void putString4(char *buff)
{
	fwrite(buff,1,4,fpo);
}

static void putShortInt(short int x)
{
	unsigned char buff[2];
	buff[0]=x&0xff;
	x>>=8;
	buff[1]=x&0xff;
	fwrite(buff,1,2,fpo);
}

static void putLongInt(unsigned long int x)
{
	unsigned char buff[4];
	buff[0]=(unsigned char)(x&0xff);
	x>>=8;
	buff[1]=(unsigned char)(x&0xff);
	x>>=8;
	buff[2]=(unsigned char)(x&0xff);
	x>>=8;
	buff[3]=(unsigned char)(x&0xff);
	fwrite(buff,1,4,fpo);
}

static void putPCMHeader(WaveConstant_t *wc)
{
	pcmheadero.sampling_frequency=wc->SamplingFrequency;
	pcmheadero.num_bits_sample=wc->BitsPerSample;
	pcmheadero.number_of_channels=wc->NumberOfChannels;
	pcmheadero.blocksize=pcmheadero.num_bits_sample/8*wc->NumberOfChannels;
	pcmheadero.binarydatasize=pcmheadero.blocksize*wc->NumberOfSamples;
	pcmheadero.fsize_8=sizeof(pcmheader_t)+pcmheadero.binarydatasize-8;
	pcmheadero.rate=pcmheadero.sampling_frequency*pcmheadero.blocksize;

	putString4(pcmheadero.str_riff);
	putLongInt(pcmheadero.fsize_8);
#ifdef WAVE_OUTPUT_DEBUG
	printf("fsize_8=%ld\n",pcmheadero.fsize_8);
	printf("info_block_size=%ld\n",pcmheadero.info_block_size);
	printf("wave_format=%d\n",pcmheadero.wave_format);
	printf("number_of_channels=%d\n",pcmheadero.number_of_channels);
	printf("sampling_frequency=%ld\n",pcmheadero.sampling_frequency);
	printf("rate=%ld\n",pcmheadero.rate);
	printf("blocksize=%d\n",pcmheadero.blocksize);
	printf("num_bits_sample=%d\n",pcmheadero.num_bits_sample);
	printf("binarydatasize=%ld\n",pcmheadero.binarydatasize);
#endif
	putString4(pcmheadero.str_wave);
	putString4(pcmheadero.str_fmt);
	putLongInt(pcmheadero.info_block_size);
	putShortInt(pcmheadero.wave_format);
	putShortInt(pcmheadero.number_of_channels);
	putLongInt(pcmheadero.sampling_frequency);
	putLongInt(pcmheadero.rate);
	putShortInt(pcmheadero.blocksize);
	putShortInt(pcmheadero.num_bits_sample);
	putString4(pcmheadero.str_data);
	putLongInt(pcmheadero.binarydatasize);
}

int openOutputWaveFile(char *fname,WaveConstant_t *WaveConstant) /*0:fault*/
{
	fpo=fopen(fname,"wb");
	if (fpo==NULL) return 0;
	putPCMHeader(WaveConstant);
	return 1;
}

void putSingleCHSampleData(short int SampleData)
{
	unsigned char uc;
	if (pcmheadero.num_bits_sample==8) {
		uc=(unsigned char)(((SampleData>>8)&0xff)^0x80);
		fputc(uc,fpo);
	} else {
		putShortInt(SampleData);
	}
}

void putSingleCHSampleDataBlock(short int SampleData[], int number)
{
	int i;
	for (i=0;i<number;i++) {
		putSingleCHSampleData(SampleData[i]);
	}
}

void putDualCHSampleData(short int data[2])
{
	putSingleCHSampleData(data[0]);
	putSingleCHSampleData(data[1]);
}

void putDualCHSampleDataBlock(short int data[][2], int number)
{
	int i;
	for (i=0;i<number;i++) {
		putSingleCHSampleData(data[i][0]);
		putSingleCHSampleData(data[i][1]);
	}
}

void closeOutputWaveFile(void)
{
	fclose(fpo);
}