waveIn/Out

#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <mmsystem.h>
 
 
/*********************************definitions*************************/
 
#define SampleRate 44100        // ×àñòîòà äèñêðåòèçàöèè
#define BitsPerSample 16        // Ðàçðÿäíîñòü îòñ÷åòà
#define Channels 1              // Êîëè÷åñòâî êàíàëîâ
 
#define BufferMS 800            // Îáùåå âðåìÿ áóôåðèçàöèè â ìèëëèñåêóíäàõ
#define Buffers 4               // Êîëè÷åñòâî áóôåðîâ
 
/****************************variables***********************************/
 
MMRESULT res;           //result of mm-functions
UINT nn;                //number of devices
 
    
HWAVEIN hInDev;         // Handle of input device
HWAVEOUT    hOutDev;            // Handle of output device
 
WAVEFORMATEX waveFormat;    //Format properties
 
UINT BytesPerSample;    
UINT BufferSize;        
 
FILE* dataFile;
 
BOOL InRecord;
unsigned int DoneAll;
 
/*****************************CallBackProc********************************/
 
 
 
void CALLBACK CallbackProc (HWAVE Handle,UINT Msg,DWORD Instance,DWORD Param1,DWORD Param2)
{
    switch(Msg)
    {
    case WIM_DATA:
        {
            WAVEHDR *hdr = (WAVEHDR *)Param1;
 
            waveInUnprepareHeader(hInDev,hdr,sizeof (WAVEHDR));
 
            if(hdr->dwBytesRecorded)
            {
                fwrite(hdr->lpData,hdr->dwBytesRecorded,sizeof(char),dataFile);
                printf("%d",ftell(dataFile));
            }
            if(InRecord)
            {
                waveInPrepareHeader(hInDev,hdr,sizeof (WAVEHDR));
                waveInAddBuffer(hInDev,hdr,sizeof(*hdr));
                printf("buffer has writed\n");
            }
            else
            {
                printf("buffer is free\n");
                DoneAll++;
            }
            break;
        }
    case WOM_DONE:
        {
            WAVEHDR *hdr = (WAVEHDR *)Param1;
 
            waveInUnprepareHeader(hInDev,hdr,sizeof (WAVEHDR));
            if(fread(hdr->lpData,hdr->dwBufferLength,1,dataFile)==0)
            {
                DoneAll++;
                break;
            }
            printf("%d",ftell(dataFile));
            if(InRecord)
            {
                waveInPrepareHeader(hInDev,hdr,sizeof (WAVEHDR));
                waveOutWrite(hOutDev,hdr,sizeof(*hdr));
                printf("buffer has played\n");
            }
            else
            {
                printf("buffer is free\n");
                DoneAll++;
            }
            break;
 
        }
    case WIM_OPEN:
            DoneAll=0;
            break;
    case WOM_OPEN:
            DoneAll=0;
            break;
    }
    return;
}
 
void fill_wave_format(LPWAVEFORMATEX fmt,UINT channels,UINT bits_per_sample,UINT sample_rate)
{
    BytesPerSample = (bits_per_sample+7) / 8;
 
    fmt->wFormatTag = WAVE_FORMAT_PCM;
    fmt->nChannels = channels;
    fmt->wBitsPerSample = bits_per_sample;
    fmt->nBlockAlign = (WORD)(channels * BytesPerSample);
    fmt->nSamplesPerSec = sample_rate;
    fmt->nAvgBytesPerSec = waveFormat.nSamplesPerSec * waveFormat.nBlockAlign;
    fmt->cbSize = 0;
}
 
 
/************************************Get Devices List***************************/
int get_devices_list(char** list,bool in)
{
    int nn;
    int i;
    char* src;
    if(in)
        nn=waveInGetNumDevs();
    else
        nn=waveOutGetNumDevs();
    list=new char*[nn];
    for(i=0; i<nn; i++)
    {
        if(in)
        {
            WAVEINCAPS InCaps;
            waveInGetDevCaps(0,&InCaps,sizeof(InCaps)); //getting caps
            src=InCaps.szPname;
            list[i]=new char[strlen(src)+1];
            strcpy(list[i],src);
        }
        else
        {
            WAVEOUTCAPS OutCaps;
            waveOutGetDevCaps(0,&OutCaps,sizeof(OutCaps));  //getting caps
            src=OutCaps.szPname;
            list[i]=new char[strlen(src)+1];
            strcpy(list[i],src);
        }
    }
    if(res) return 0;
    else return nn;
}
 
/*****************************Get Bufer Size****************************/
 
UINT get_buffer_size(LPWAVEFORMATEX fmt, UINT buffering_time, UINT buffers_count)
{
    //calculcating buffers size in blocks
    UINT result = (fmt->nSamplesPerSec *buffering_time/buffers_count+500) /1000;
    if(!result)
    {
        result++;
    }
    
    //calculcating buffers size in bytes
    result *= fmt->nBlockAlign;
    return result;
}
 
/****************************Allocating buffers*************************/
 
LPWAVEHDR allocate_buffer(UINT size, LPWAVEHDR hdr)
{
    char *buf = (char *)GlobalAlloc (GMEM_FIXED, size);
    hdr= (WAVEHDR *)LocalAlloc (LMEM_FIXED, sizeof (WAVEHDR));
 
    //Filling header of waves blocks
    hdr->lpData = buf;
    hdr->dwBufferLength = size;
    hdr->dwFlags = 0;
    hdr->dwLoops = 0;
    hdr->dwUser = 0;
    return hdr;
}
 
/***********************************MAIN*****************************/
int main()
{
    unsigned int i;
 
    system("chcp 1251");
 
    fill_wave_format(&waveFormat,Channels,BitsPerSample,SampleRate);
 
    res=waveInOpen(&hInDev,0,&waveFormat,(unsigned long)CallbackProc,0,CALLBACK_FUNCTION);
    
    BufferSize=get_buffer_size(&waveFormat,BufferMS,Buffers);
 
    LPWAVEHDR *hdrs=new LPWAVEHDR[Buffers];
 
    for(i=0; i<Buffers; i++)
    {
        hdrs[i]=allocate_buffer(BufferSize,hdrs[i]);
        res=waveInPrepareHeader (hInDev, hdrs[i], sizeof (WAVEHDR));
        res=waveInAddBuffer (hInDev, hdrs[i], sizeof (WAVEHDR));
    }
 
    //////////Open buffer file
    dataFile=fopen("c:\\buffer.wav","w");
 
    //////////GUI o_O
    printf("Press any key...\n");
    getch();
    InRecord=TRUE;
 
    waveInStart(hInDev);
 
    printf("recording has started\n");
    getch();
    InRecord=FALSE;
 
    while (DoneAll < Buffers) 
        Sleep(100);
 
    printf("record has stoped\n");
 
    ///////////////
    fclose(dataFile);
    
    dataFile=fopen("c:\\buffer.wav","r");
 
    fseek(dataFile, 0, SEEK_END);
    long size = ftell(dataFile);
    fseek(dataFile, 0, SEEK_SET);
 
    //open device
    res = waveOutOpen(&hOutDev,0,&waveFormat,(unsigned long)CallbackProc,0,CALLBACK_FUNCTION);
 
    waveOutPause(hOutDev);
 
    for(i=0; i<Buffers; i++)
    {
        hdrs[i]=allocate_buffer(BufferSize,hdrs[i]);
 
        waveOutPrepareHeader (hOutDev, hdrs[i], sizeof (*hdrs[i]));
 
        fread(hdrs[i]->lpData,hdrs[i]->dwBufferLength,1,dataFile);
        
        waveOutWrite(hOutDev, hdrs[i], sizeof (*hdrs[i]));
    }
 
    printf("Press any key...");
    
    getch();
    InRecord=TRUE;
    
    waveOutRestart(hOutDev);
    
    printf("playin has started\n");
    getch();
    InRecord=FALSE;
 
    while (DoneAll < Buffers) 
        Sleep(100);
    printf("playin has stoped\n");
 
    return 0;
}