#include <stdio.

h>
#include <conio.h>
#include <windows.h>
#include "aviriff.h"
#include <iostream>
#include <mmsystem.h>
using namespace std;

//WAV format def

int sps = 22050; // sample per seconds

int channels = 1; //numbers of channels
int bits = 8; //Bit rate. Why does it not works with 16?
int wav_length_sec = 60; //Rec length (sec)

int WAVBUFFERLENGTH((channels * bits * sps * wav_length_sec)/8);

WAVEFORMATEX g_WavFmt = {0};

//Wave header length

int HEADERLENGTH (sizeof(RIFFLIST) + sizeof(RIFFCHUNK) + sizeof(WAVEFORMATEX) +

sizeof(RIFFCHUNK));

void InitWavFmt(void)
{
g_WavFmt.wFormatTag = WAVE_FORMAT_PCM;
g_WavFmt.nChannels = 1;
g_WavFmt.nSamplesPerSec = 8000;
g_WavFmt.wBitsPerSample = 16;
g_WavFmt.nBlockAlign = g_WavFmt.nChannels * g_WavFmt.wBitsPerSample / 8;
g_WavFmt.nAvgBytesPerSec = g_WavFmt.nChannels * g_WavFmt.wBitsPerSample / 8 *
g_WavFmt.nSamplesPerSec;
g_WavFmt.cbSize = 0;

/*g_WavFmt.wFormatTag = WAVE_FORMAT_PCM;
g_WavFmt.nChannels = channels;
g_WavFmt.nSamplesPerSec = sps;
g_WavFmt.wBitsPerSample = bits;
g_WavFmt.nBlockAlign = 1;
g_WavFmt.nAvgBytesPerSec = g_WavFmt.nChannels * g_WavFmt.wBitsPerSample /
bits * g_WavFmt.nSamplesPerSec;*/
// g_WavFmt.nBlockAlign = g_WavFmt.nChannels * g_WavFmt.wBitsPerSample /
8;

// g_WavFmt.nAvgBytesPerSec = g_WavFmt.nChannels * g_WavFmt.wBitsPerSample /

bits * g_WavFmt.nSamplesPerSec;

// g_WavFmt.nAvgBytesPerSec = g_WavFmt.nSamplesPerSec *
g_WavFmt.nBlockAlign;

g_WavFmt.cbSize = 0;
}

char* AddWavHdr(char *pinBuffer, int inWavLength)

{
 BYTE *pWavHdr = NULL;
RIFFLIST *pRiffWave = NULL;
RIFFCHUNK *pRiffFmt = NULL;
RIFFCHUNK *pRiffData = NULL;
char* outWavBuffer = NULL;
if (NULL == pinBuffer)
{
return NULL;
}
pWavHdr = new BYTE[HEADERLENGTH];
if ( NULL == pWavHdr)
{
return NULL;
}
else
{
memset(pWavHdr, 0, sizeof(BYTE) * HEADERLENGTH);
}
pRiffWave = (RIFFLIST*)pWavHdr;
pRiffFmt = (RIFFCHUNK*)(pRiffWave + 1);
pRiffData = (RIFFCHUNK*)(((BYTE*)(pRiffFmt + 1)) + sizeof(WAVEFORMATEX));
pRiffWave->fcc = FCC('RIFF');
pRiffWave->cb = inWavLength + HEADERLENGTH - sizeof(RIFFCHUNK);
pRiffWave->fccListType = FCC('WAVE');
pRiffFmt->fcc = FCC('fmt ');
pRiffFmt->cb = sizeof(WAVEFORMATEX);
pRiffData->fcc = FCC('data');
pRiffData->cb = inWavLength;
memcpy(pRiffFmt + 1, &g_WavFmt, pRiffFmt->cb);
outWavBuffer = (char*)new BYTE[inWavLength+HEADERLENGTH];
if (NULL == outWavBuffer)
{
return NULL;
}
else
{
memset(outWavBuffer, 0, sizeof(BYTE) * (inWavLength + HEADERLENGTH));
}
memcpy(outWavBuffer, pWavHdr, sizeof(BYTE) * HEADERLENGTH);
memcpy(outWavBuffer + HEADERLENGTH, pinBuffer, (sizeof(BYTE) * inWavLength));
return outWavBuffer;
}

void main ()
{
HWAVEIN hWavIn;
WAVEHDR WavHdr;
char *pBuffer = NULL;
char *pWavBuffer = NULL;
MMRESULT ret;
FILE *fpPCMFile;
FILE *fpWavFile;
MMTIME MMTime = {0};
unsigned int numwritten = 0;
MMTime.wType = TIME_BYTES;
InitWavFmt();
cout << "NumDev = " << waveInGetNumDevs() << endl;
 if ( waveInGetNumDevs()==0)
{
cout << "Audio device not found!\n";
exit(0);
}
ret = waveInOpen(&hWavIn, WAVE_MAPPER, &g_WavFmt, 0, 0, WAVE_FORMAT_QUERY);
if (MMSYSERR_NOERROR != ret)
{
cout << "Unsupported WAV format.\n";
exit(0);
}
ret = waveInOpen(&hWavIn, WAVE_MAPPER, &g_WavFmt, 0, 0, CALLBACK_NULL);
if (MMSYSERR_NOERROR != ret)
{
exit(0);
}
pBuffer = (char*)malloc(WAVBUFFERLENGTH);
if ( NULL != pBuffer)
{
memset(pBuffer, 0, WAVBUFFERLENGTH);
}
else
{
exit(0);
}
WavHdr.lpData = pBuffer;
WavHdr.dwBufferLength = WAVBUFFERLENGTH;
WavHdr.dwBytesRecorded = 0;
WavHdr.dwUser = 0;
WavHdr.dwFlags = 0;
WavHdr.dwLoops = 1;
WavHdr.lpNext = 0;
WavHdr.reserved = 0;
ret = waveInPrepareHeader(hWavIn,&WavHdr,sizeof(WAVEHDR));
// res=waveInPrepareHeader(hWaveIn,&WaveHeader,sizeof(WAVEHDR));
if (MMSYSERR_NOERROR != ret)
{
free(pBuffer);
exit(0);
}
ret = waveInAddBuffer(hWavIn,&WavHdr,sizeof(WAVEHDR));
if (MMSYSERR_NOERROR != ret)
{
free(pBuffer);
exit(0);
}
cout <<"Press any key to start recording...\n";
_getch();
cout << "Recording now\n";
ret = waveInStart(hWavIn);
if (MMSYSERR_NOERROR != ret)
{
free(pBuffer);
exit(0);
}
cout << "Press any key to stop Recording\n";
_getch();
waveInGetPosition(hWavIn, &MMTime, sizeof(MMTime));
 waveInReset(hWavIn);
// cout << "sizeof MMTime = " << sizeof(MMTime) << endl;
waveInUnprepareHeader(hWavIn,&WavHdr,sizeof(WAVEHDR));
waveInClose(hWavIn);
/*fpPCMFile = fopen("pcm","w");
if (NULL == fpPCMFile)
{
cout <<"Creating PCM file failed\n";
free(pBuffer);
exit(0);
}
numwritten = fwrite(pBuffer, sizeof(char), MMTime.u.cb, fpPCMFile);
cout <<"Recording done, %d bytes recorded, %d bytes written: " << MMTime.u.cb <<
endl << " numwritten: " << numwritten;
fclose(fpPCMFile);*/
pWavBuffer = AddWavHdr(pBuffer, MMTime.u.cb);
if ( NULL == pWavBuffer)
{
cout <<"Add header failed\n";
}
else
{
fpWavFile = fopen("testfile.wav", "w");
if (NULL == fpWavFile)
{
cout <<"Creating WAV file failed\n";
}
else
{
numwritten = fwrite(pWavBuffer, sizeof(char), sizeof(BYTE) *
(HEADERLENGTH + MMTime.u.cb), fpWavFile);
// cout <<"%d bytes of WAV file written\n",
numwritten;
fclose(fpWavFile);
free(pWavBuffer);
}
}

//typedef struct{
//char RIFF[4];
//DWORD bytes;
//char WAVE[4];
//char fmt[4];
//int siz_wf;
//WORD wFormatTag;
//WORD nChannels;
//DWORD nSamplesPerSec;
//DWORD nAvgBytesPerSec;
//WORD nBlockAlign;
//WORD wBitsPerSample;
//char data[4];
//DWORD pcmbytes;
//} WAVHEADER;
//
//WAVHEADER wh;
// memcpy(wh.RIFF, "RIFF", 4);
// memcpy(wh.WAVE, "WAVE", 4);
// memcpy(wh.fmt, "fmt ", 4);
// wh.siz_wf = 16;
// memcpy(wh.data, "data", 4);
// wh.wFormatTag = 1; /* data format */
// wh.nChannels = 1; /* number of channels */
// wh.nSamplesPerSec = 22050; /* samples per second per channel */
// wh.nAvgBytesPerSec = 22050;
// wh.nBlockAlign = 1; /* byte alignment of a basic sample block */
// wh.wBitsPerSample = 16; /* bits per sample */
// DWORD blocksize = (seconds_to_record1) * wh.nSamplesPerSec *
wh.wBitsPerSample / 8;
//
// wh.bytes = blocksize + 36;
// wh.pcmbytes = blocksize;
//
// HANDLE hFile = CreateFile("audio1.wav", // file to create
// GENERIC_WRITE, // open for writing
// 0, // do not share
// NULL, // default security
// CREATE_ALWAYS, // overwrite existing
// FILE_ATTRIBUTE_NORMAL, // normal file
// NULL);
//
// // cout<< &wh <<endl;
//
// WriteFile(hFile,&wh,sizeof(wh),&bWrite,NULL);
//
// WriteFile(hFile,WaveHeader.lpData,WaveHeader.dwBufferLength,&bWrite,NULL);
//
// CloseHandle(hFile);

free(pBuffer);
_getch();
return;
}