wavfile.c

LInux下Wave文件的读写、播放的类。还在wave文件头中写入了自定义信息。Linux平台下使用

/*File Name: WavFile.c*/
#include "Ldb.h"
#include "Utility.h"

#include "WavFile.h"

#include "LocoSystem.h"

/************************************************
				文件变量定义
************************************************/
int f_riffSize;

S_VersionChunk f_ver;
char f_version[4] = {0x01, 0x00, 0x00, 0x00};

S_DescChunk f_desc;

S_FormatChunk f_fmt;
char fmt_extra_data[4] = {0x02, 0x00, 0xf9, 0x01};

S_FactChunk f_fact;

S_DataChunk f_data;

/************************************************
				函数定义
************************************************/
int wavf_writeDesc(FILE *pwav)
{
	int i_val;

	ldb_fileWrite(pwav, USER_ID, 4);
	i_val = f_desc.riff.len;
	ldb_fileWrite(pwav, endian_2little(&i_val, sizeof(int)), 4);

	ldb_fileWrite(pwav, f_desc.desc.date_start, 15);
	fprintf(pwav, "%05d", f_desc.desc.len);
	fprintf(pwav, "%02d", f_desc.desc.channel);

	ldb_fileWrite(pwav, f_desc.desc.msg, 40);
	ldb_fileWrite(pwav, f_desc.desc.reserve, 16);
	
	fflush(NULL);
	return 0;
}

/*
  + 15 个字符的开始时间 yyyymmdd.HHMMSS
  + 5  个字符的录音长度
  + 2  个字符的通道
  + 40 个字节的原始消息
  + 16 个字节的保留字
-------------------------------------------
    78
*/
int wavf_descSize()
{
	return 78;
}

/*检查录音文件，统计总共size和所有的文件名*/
int  wavf_init(FILE *pfile, int file_size)
{
	int ret;
	int data_size = file_size - sizeof(S_SndDesc);

	memset(&f_desc.desc, 0, sizeof(S_SndDesc));
	ret = fread(&f_desc.desc, 1, sizeof(S_SndDesc), pfile);
	if (ret != sizeof(S_SndDesc))
		return -1;

	f_riffSize = 0;
	
	//version chunk
	memset(&f_ver, 0, sizeof(f_ver));
	memcpy(f_ver.riff.id, VERSION_ID, ID_SIZE);
	f_ver.riff.len = 4;
	memcpy(f_ver.ver, f_version, 4);
	
	f_riffSize += sizeof (f_ver);

	//fmt chunk
	memset(&f_fmt, 0, sizeof(f_fmt));
	memcpy(f_fmt.riff.id, FMT_ID, ID_SIZE);

	f_fmt.riff.len = 20;
	f_fmt.format_tag = 0x0011;
	f_fmt.channels = 1;
	if (g_sysSampleRate == 8)
	{
		f_fmt.sample_rate = 8000;
		f_fmt.wav_byte_per_sec = 4055;
		f_fmt.block_align = 256;
		f_fmt.bits_per_sample = 4;
		memcpy(f_fmt.extra_data, fmt_extra_data, 4);
	}
	else
	{
		f_fmt.sample_rate = 16000;
		f_fmt.wav_byte_per_sec = 8055;
		f_fmt.block_align = 512;
		f_fmt.bits_per_sample = 4;
		fmt_extra_data[3] = 0x03;
		memcpy(f_fmt.extra_data, fmt_extra_data, 4);
	}
	f_riffSize += sizeof (f_fmt);

	//fact chunk
	memset(&f_fact, 0, sizeof(f_fact));
	memcpy(f_fact.riff.id, FACT_ID, ID_SIZE);
	f_fact.riff.len = 4;

	//505 sample -> 256 code then sample_number = file_size /256 * 505
	if (g_sysSampleRate == 8)
		f_fact.sample_number = data_size/256*505;
	else
		f_fact.sample_number = data_size/512*1017;

	f_riffSize += sizeof (f_fact);

	//data chunk
	memset(&f_data, 0, sizeof(f_data));
	memcpy(f_data.riff.id, DATA_ID, ID_SIZE);
	f_data.riff.len = data_size;

	f_riffSize += sizeof (f_data);

	f_riffSize += data_size;

	//desc chunk
	memcpy(f_desc.riff.id, USER_ID, ID_SIZE);
	f_desc.riff.len = wavf_descSize();
	f_desc.desc.len = f_fact.sample_number / f_fmt.sample_rate;
	
	f_riffSize += sizeof (f_desc.riff);
	f_riffSize += f_desc.riff.len;

	return 0;
}

int wavf_writeVersion(FILE *pwav)
{
	int i_val;

	ldb_fileWrite(pwav, VERSION_ID, ID_SIZE);
	i_val = f_ver.riff.len;
	ldb_fileWrite(pwav, endian_2little(&i_val, sizeof(int)), 4);
	ldb_fileWrite(pwav, f_ver.ver, 4);

	fflush(NULL);
	return 0;
}

int wavf_writeFmt(FILE *pwav)
{
	int i_val;
	short s_val;
	unsigned long l_val;
	
	//riff
	ldb_fileWrite(pwav, FMT_ID, ID_SIZE);
	i_val = f_fmt.riff.len;
	ldb_fileWrite(pwav, endian_2little(&i_val, sizeof(i_val)), 4);
	//format tag
	s_val = f_fmt.format_tag;
	ldb_fileWrite(pwav, endian_2little(&s_val, sizeof(s_val)), 2);
	//channels
	s_val = f_fmt.channels;
	ldb_fileWrite(pwav, endian_2little(&s_val, sizeof(s_val)), 2);
	//sample rate
	l_val = f_fmt.sample_rate;
	ldb_fileWrite(pwav, endian_2little(&l_val, sizeof(l_val)), 4);
	//bytes per second
	l_val = f_fmt.wav_byte_per_sec;
	ldb_fileWrite(pwav, endian_2little(&l_val, sizeof(l_val)), 4);
	//block align
	s_val = f_fmt.block_align;
	ldb_fileWrite(pwav, endian_2little(&s_val, sizeof(s_val)), 2);
	//bits per sample
	s_val = f_fmt.bits_per_sample;
	ldb_fileWrite(pwav, endian_2little(&s_val, sizeof(s_val)), 2);
	
	ldb_fileWrite(pwav, f_fmt.extra_data, sizeof(f_fmt.extra_data));

	fflush(NULL);
	return 0;
}

int wavf_writeFact(FILE *pwav)
{
	int i_val;
	unsigned long l_val;
	
	ldb_fileWrite(pwav, FACT_ID, ID_SIZE);
	i_val = f_fact.riff.len;
	ldb_fileWrite(pwav, endian_2little(&i_val, sizeof(int)), 4);
	l_val = f_fact.sample_number;
	ldb_fileWrite(pwav, endian_2little(&l_val, sizeof(l_val)), 4);
	
	fflush(NULL);
	return 0;
}

int wavf_writeHeader(FILE *pwav)
{
	int i_val;
	//RIFF
	ldb_fileWrite(pwav, RIFF_ID, ID_SIZE);
	i_val = f_riffSize;
	ldb_fileWrite(pwav, endian_2little(&i_val, sizeof(int)), 4);

	//WAVE
	ldb_fileWrite(pwav, WAV_ID, ID_SIZE);

	//version
	wavf_writeVersion(pwav);
	
	//desc
	wavf_writeDesc(pwav);
	
	//fmt
	wavf_writeFmt(pwav);
	
	//fact
	wavf_writeFact(pwav);

	fflush(NULL);
	return 0;
}

int wavf_writeData(FILE *psnd, FILE *pwav)
{
	int i_val;
	
	ldb_fileWrite(pwav, DATA_ID, ID_SIZE);
	i_val = f_data.riff.len;
	ldb_fileWrite(pwav, endian_2little(&i_val, sizeof(int)), 4);
	
	//write data
	ldb_fileAppend(psnd, pwav);

	fflush(NULL);

	return 0;
}

int  wavf_convert(const char *pSndName, const char *pWavName)
{
	FILE *pwav, *psnd;
	int ret, size;

	size = ldb_fileSize(pSndName);
	if (size == -1)
		return -1;
	
	psnd = fopen(pSndName, "rb");
	if (psnd == NULL)
	{
		LDB_ERR_MSGF("Can not open sound file %s.", pSndName);
		return -1;
	}

	pwav = fopen(pWavName, "wb");
	if (pwav == NULL)
	{
		LDB_ERR_MSGF("Can not create wave file %s.", pWavName);
		fclose(psnd);
		return -1;
	}

	if (wavf_init(psnd, size) != 0)
	{
		fclose(pwav);
		fclose(psnd);

		return -1;
	}
	
	wavf_writeHeader(pwav);
	ret = wavf_writeData(psnd, pwav);
	fclose(pwav);
	fclose(psnd);

	return ret;
}