#include "win_audio.h"
 
win_audio::win_audio(){
 
	campioni_per_secondo = WA_CAMPIONI_PER_SECONDO;
	bit_per_campione = WA_BIT_PER_CAMPIONE;
	canali = 1;
 
	playing_event = 0;
	recording_event = 0;
 
	input_device = NULL;
	output_device = NULL;
 
	audio_buffer = NULL;
	audio_buffer_size = 0;
	audio_buffer_setted = 0;
 
	err = 0;
	err_size = 2000;
	err_buffer = new char[err_size];
}
 
win_audio::~win_audio(){
 
	delete [] err_buffer;
 
	if(audio_buffer_setted == 1)
		delete [] audio_buffer;
 
	printf("win_audio distrutta...\n");
}
 
int win_audio::input_open_device(){
 
	WAVEFORMATEX formato_wave;
	formato_wave.wFormatTag = WAVE_FORMAT_PCM;
	formato_wave.nChannels = canali;
	formato_wave.nSamplesPerSec = campioni_per_secondo;
	formato_wave.nAvgBytesPerSec = campioni_per_secondo*bit_per_campione*canali/8;
	formato_wave.nBlockAlign = canali*bit_per_campione/8;
	formato_wave.wBitsPerSample = bit_per_campione;
	formato_wave.cbSize = sizeof(WAVEFORMATEX);
 
	err = waveInOpen(&input_device, WAVE_MAPPER, &formato_wave, (DWORD_PTR)waveInProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
	if(err != MMSYSERR_NOERROR ){ 
		waveInGetErrorText(err, err_buffer, err_size);
		printf("waveInOpen err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
int win_audio::input_set_buffer(long lBuffer){
 
	if(audio_buffer_setted == 1)
		delete [] audio_buffer;
	audio_buffer = new char[lBuffer];
	audio_buffer_size = lBuffer;
	audio_buffer_setted = 1;
 
	memset(&wave_in_struct, 0, sizeof(WAVEHDR));
	wave_in_struct.lpData = audio_buffer;
	wave_in_struct.dwBufferLength = lBuffer;
 
	err = waveInPrepareHeader(input_device, &wave_in_struct, sizeof(WAVEHDR));
	if(err != MMSYSERR_NOERROR ){ 
		waveInGetErrorText(err, err_buffer, err_size);
		printf("err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
int win_audio::input_record(){
 
	recording_event = 1;
 
	err = waveInAddBuffer(input_device, &wave_in_struct, sizeof(WAVEHDR));
	if(err != MMSYSERR_NOERROR ){ 
		waveInGetErrorText(err, err_buffer, err_size);
		printf("waveInAddBuffer err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	err = waveInStart(input_device);
	if(err != MMSYSERR_NOERROR ){ 
		waveInGetErrorText(err, err_buffer, err_size);
		printf("waveInStart err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	while(recording_event == 1){
		Sleep(5);
	}
 
	err = waveInStop(input_device);
	if(err != MMSYSERR_NOERROR ){ 
		waveInGetErrorText(err, err_buffer, err_size);
		printf("waveInStop err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
int win_audio::input_close_device(){
 
	err = waveInClose(input_device);
	if(err != MMSYSERR_NOERROR ){ 
		waveInGetErrorText(err, err_buffer, err_size);
		printf("waveInClose err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
int win_audio::output_open_device(){
 
	WAVEFORMATEX formato_wave;
	formato_wave.wFormatTag = WAVE_FORMAT_PCM;
	formato_wave.nChannels = canali;
	formato_wave.nSamplesPerSec = campioni_per_secondo;
	formato_wave.nAvgBytesPerSec = campioni_per_secondo*bit_per_campione*canali/8;
	formato_wave.nBlockAlign = canali*bit_per_campione/8;
	formato_wave.wBitsPerSample = bit_per_campione;
	formato_wave.cbSize = sizeof(WAVEFORMATEX);
 
	err = waveOutOpen(&output_device, WAVE_MAPPER, &formato_wave, (DWORD_PTR)waveOutProc, (DWORD_PTR)this, CALLBACK_FUNCTION);
	if(err != MMSYSERR_NOERROR ){ 
		waveOutGetErrorText(err, err_buffer, err_size);
		printf("waveOutOpen err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
int win_audio::output_set_buffer(char *buffer, long lBuffer){
 
	memset(&wave_out_struct, 0, sizeof(WAVEHDR));
	wave_out_struct.lpData = buffer;
	wave_out_struct.dwBufferLength = lBuffer;
 
	err = waveOutPrepareHeader(output_device, &wave_out_struct,sizeof(WAVEHDR));
	if(err != MMSYSERR_NOERROR ){ 
		waveOutGetErrorText(err, err_buffer, err_size);
		printf("waveOutPrepareHeader err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
int win_audio::output_play(){
 
	playing_event = 1;
 
	err = waveOutWrite(output_device, &wave_out_struct,sizeof(WAVEHDR));
	if(err != MMSYSERR_NOERROR ){ 
		waveOutGetErrorText(err, err_buffer, err_size);
		printf("waveOutWrite err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	//waveOutWrite non è bloccante, quindi aspettiamo
	while(playing_event == 1){
		Sleep(5);
	}
 
	return 1;
}
 
int win_audio::output_close_device(){
 
	err = waveOutClose(output_device);
	if(err != MMSYSERR_NOERROR ){ 
		waveOutGetErrorText(err, err_buffer, err_size);
		printf("waveOutClose err: %d %s\n",err, err_buffer);
		getchar();
		return 0;
	}
 
	return 1;
}
 
char * win_audio::get_audio_buffer(){
	return audio_buffer;
}
 
long win_audio::get_audio_buffer_size(){
	return audio_buffer_size;
}
 
void CALLBACK waveOutProc(HWAVEOUT hwo, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2){
	win_audio *classe;
	classe = (win_audio *) dwInstance;
 
	if(uMsg == WOM_OPEN)
		printf("waveOutProc: WOM_OPEN\n");
	else if(uMsg == WOM_DONE){
		//avvisiamo che la registrazione è terminata
		classe->playing_event = 0;
		printf("waveOutProc: WOM_DONE\n");
	}
	else if(uMsg == WOM_CLOSE)
		printf("waveOutProc: WOM_CLOSE\n");
	else 
		printf("waveOutProc: messaggio non riconosciuto...\n");
 
}
void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg, DWORD_PTR dwInstance, DWORD_PTR dwParam1, DWORD_PTR dwParam2){
	win_audio *classe;
	classe = (win_audio *) dwInstance;
 
	if(uMsg == WIM_OPEN)
		printf("waveInProc: WIM_OPEN\n");
	else if(uMsg == WIM_DATA){
		//avvisiamo che la registrazione è terminata
		classe->recording_event = 0;
		printf("waveInProc: WIM_DATA\n");
	}
	else if(uMsg == WIM_CLOSE)
		printf("waveInProc: WIM_CLOSE\n");
	else 
		printf("waveInProc: messaggio non riconosciuto...\n");
 
}