Аналіз методів оброблення звукової інформації в еом

                              }

                    break;

                        };

                  case ID_TRACK_VOLUME:

                      {

                     pp.SetVolume(SendMessage(hwndTrack[0],TBM_GETPOS,0,0));

                     break;

                      };

                 }

            break;

         case ID_ERROR_PLAY:

            EnableWindow(hWndButton[6],TRUE);

            break;

         case ID_ERROR_RECORD:

            PostQuitMessage (0);          

            break;

         case MM_MCINOTIFY:

            if(wParam!=MCI_NOTIFY_ABORTED)

             {

                 if(!pp.NextTrak())

                  EnableWindow(hWndButton[6],TRUE);

             }

            break;

        case WM_COMMAND:

            switch (LOWORD(wParam))

                { 

                    case ID_BUTTON:

                        {

                             if (lParam == STOP )

                              lParam=(long)hWndButton[4];

                             if (lParam == (long)hWndButton[0])

                              { 

                                  gg.Record();

                                 EnableWindow(hWndButton[0],FALSE);

                                 EnableWindow(hWndButton[1],TRUE);

                                 EnableWindow(hWndButton[3],TRUE);

                                 EnableWindow(hWndButton[4],TRUE);

                              }

                             if (lParam == (long)hWndButton[1])

                              {

                                 gg.PauseRecord();

                                 EnableWindow(hWndButton[2],TRUE);

                                 EnableWindow(hWndButton[1],FALSE);

                            }

                             if (lParam == (long)hWndButton[2])

                              {

                                  gg.StartRecord();

                                  EnableWindow(hWndButton[1],TRUE);

                                  EnableWindow(hWndButton[2],FALSE);

                              }

                             if (lParam == (long)hWndButton[3])

                              {

                                  gg.Save();

                                  EnableWindow(hWndButton[2],TRUE);

                                  EnableWindow(hWndButton[1],FALSE);

                              }

                             if (lParam == (long)hWndButton[4])

                              {

                                  if(gg.StopRecord())

                                   {

                                       for (int i=0; i<=4; i++)

                                       EnableWindow(hWndButton[i],FALSE);

                                       EnableWindow(hWndButton[0],TRUE);

                                   }

                              }

                             if (lParam == (long)hWndButton[5])

                              {

                                  pp.AddToPlaylist();

                              }

                             if (lParam == (long)hWndButton[6])

                              {

                                  if (pp.Play())

                                  EnableWindow(hWndButton[6],FALSE);

                              }

                             if (lParam == (long)hWndButton[7])

                              {

                                  pp.Pause();

                              }

                             if (lParam == (long)hWndButton[8])

                              {

                                  pp.ResumePlay();

                              }

                             if (lParam == (long)hWndButton[9])

                              {

                                  pp.Stop();

                                  EnableWindow(hWndButton[6],TRUE);

                              }

                             if (lParam == (long)hWndButton[10])

                              {

                                  if (pp.PreviousTrak()==0)

                                   EnableWindow(hWndButton[6],TRUE);

                              }

                             if (lParam == (long)hWndButton[11])

                              {

                                  if (pp.NextTrak()==0)

                                   EnableWindow(hWndButton[6],TRUE);

                              }    

 

                        }

                     //break;   

                    default:

                        return DefWindowProc (hwnd, message, wParam, lParam);   

                }

            break; 

        case WM_CLOSE:

             if (gg.GetStateRecords()!=4)

             {

              if(!gg.StopRecord())

               {

                   EnableWindow(hWndButton[2],TRUE);

                   EnableWindow(hWndButton[1],FALSE);         

                   break;

               }

             }

        case WM_DESTROY:

            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */

            break;

        default:                      /* for messages that we don't deal with */

            return DefWindowProc (hwnd, message, wParam, lParam);

    }

 

    return 0;

}

 

 

 

/*record.h*/

#include <cstdlib>

#include <iostream>

#include "windows.h"

#include "mmsystem.h"

#include "aclapi.h"

enum { ID_ERROR_RECORD=4 };

enum { STOP=5 };

class Record_Sound {

    private:

    int StateRecords; //статус запису

    boolean StateSave;//статус зберігання

    HANDLE hEventStart;//дескриптор події

    HWAVEIN hWaveIn; //покажчик на ідентифікатор пристрою вводу

    int Channel;//кількість каналів

    int t;//лічильник  кількості секунд запису

    public:

    Record_Sound(); 

    void Record_();

    void Record();      // починає записувати

    int  GetFreeMemory();

    void PauseRecord();// призупиняє запис

    void StartRecord();// відновлює запис

    int  StopRecord(); // припиняє запис

    void Save();      // зберігає 

    int  GetTimeRecord(); // отримуємо час запису

    int  GetStateRecords();

    void SetChannel(int Channel);// встановлюємо кількість каналів для запису

                };

Record_Sound::Record_Sound(){

    StateRecords=1; //стан запису

                    //1-записувати

                    //2-пауза

                    //3-закінчити запис

    Channel =1;     

    t=0;

    StateSave=TRUE;

}

unsigned long _stdcall Record_threadstart(void *data)

{ 

    ((Record_Sound*)data)->Record_();

}

//створює потік для запису

void Record_Sound:: Record()

{

CreateThread(NULL,0,Record_threadstart,this ,0 , NULL );

}  

//записуємо

void Record_Sound :: Record_(){

    StateSave=FALSE;

    WAVEFORMATEX WaveFormat; //структура з параметрами запису

    WAVEHDR WaveHdr; // структура для опису буфера і посилання на масив данних що передається

    MMRESULT mmRes; //змінна  для відтворення коду помилки

    DWORD dwCallback; // адреса функції зворотнього виклику

    MMIOINFO mmioInfo;//структура  для відтворення помилки

    char buff[100]; //повідомлення  про пимилку

    int BufferSize=0; //розмір  буфферу

    TCHAR serror[256];

    string lpFilename=GetCommandLine();

    int Position=lpFilename.find_last_of("\\");

    lpFilename.erase(Position+1,lpFilename.length()-Position);

    lpFilename.insert(Position+1,"TempSound.Wav"); 

    lpFilename.erase(0,1);

    const LPSTR szFileName=(char*)lpFilename.c_str();

        WaveFormat.wFormatTag = WAVE_FORMAT_PCM; /*лінійно імпульсна кодова модуляція (формат записі)*/

        WaveFormat.nChannels =Channel; //кількість каналів

        WaveFormat.nSamplesPerSec =32000; //частота дискретизаціїї 8кГц

        WaveFormat.wBitsPerSample = 16; // кількість біт на відлік

        WaveFormat.nBlockAlign = (WaveFormat.nChannels*WaveFormat.wBitsPerSample)/8;  /*вирівнювання в data-чанке*/

        WaveFormat.nAvgBytesPerSec = WaveFormat.nSamplesPerSec*WaveFormat.nBlockAlign*1; //байт в секунду

    //створюємо подію для заповнення буферу запису

    HANDLE hEvent = CreateEvent(0, TRUE, FALSE, 0);

    //відкриваємо пристрій запису звуку

    int NumDevs=waveInGetNumDevs();

    if (NumDevs!=0)

     {

         {

             WAVEINCAPS wavEincaps;

             waveInGetDevCaps(NumDevs-1, &wavEincaps, sizeof(wavEincaps));

         } 

         MMRESULT mmResult= waveInOpen(&hWaveIn,WAVE_MAPPER,          &WaveFormat, (DWORD)hEvent, 0,        CALLBACK_EVENT);

         if (mmResult!=MMSYSERR_NOERROR)

          { 

              serror[0]= 0;

              waveInGetErrorText(mmResult, serror, sizeof(serror));

              MessageBox(NULL,serror,"ERROR",MB_OK | MB_TASKMODAL);

              SendMessage(hwnd,ID_ERROR_RECORD,(WPARAM)serror,NULL);

          }

        BufferSize=WaveFormat.nAvgBytesPerSec; //обраховуємо розмір буферу

         WaveHdr.lpData = (char*)malloc(BufferSize); //виділяємо пам'ять для запису

         WaveHdr.dwBufferLength = BufferSize; //розмір буферу данних

         //підготовлюєм буфер для передачі пристрою вводу

         mmResult=waveInPrepareHeader(hWaveIn, &WaveHdr, sizeof(WAVEHDR));

         if (mmResult!=MMSYSERR_NOERROR)

          { 

              serror[0]= 0;

              waveInGetErrorText(mmResult, serror,sizeof(serror));

              MessageBox(NULL,serror,"ERROR",MB_OK | MB_TASKMODAL);

              SendMessage(hwnd,ID_ERROR_RECORD,(WPARAM)serror,NULL);

          }

         //створюємо файл .wav для запису

         HMMIO hMmio = mmioOpen(szFileName, NULL,MMIO_CREATE|MMIO_WRITE);

         if (!hMmio) 

          {  

              MessageBox(hWnd,"Файл неоткривается","Error ",MB_OK | MB_TASKMODAL);

              SendMessage(hwnd,ID_ERROR_RECORD,(WPARAM)serror,NULL);

          }

         else

          {

              //створення заголовка

              MMCKINFO mmCkInfo;

              mmCkInfo.ckid = mmioFOURCC('R', 'I', 'F', 'F');

              mmCkInfo.fccType = mmioFOURCC('W', 'A', 'V', 'E');

              mmCkInfo.dwFlags = MMIO_DIRTY;   

              mmioCreateChunk(hMmio, &mmCkInfo, MMIO_CREATERIFF);

           

              //створення блоку з інформацією із структури WAVEFORMATEX

              mmCkInfo.ckid = mmioFOURCC('f', 'm', 't', ' ');

              mmCkInfo.dwFlags = MMIO_DIRTY;

              mmCkInfo.cksize = sizeof(WaveFormat);

              mmioCreateChunk(hMmio, &mmCkInfo, NULL);

              mmioWrite(hMmio,(char*)&WaveFormat,sizeof(WaveFormat));

         

              //створення одного блоку з данними

              mmCkInfo.ckid = mmioFOURCC('d', 'a', 't', 'a');

              mmCkInfo.cksize =BufferSize;

              mmCkInfo.dwFlags = MMIO_DIRTY;

              mmioCreateChunk(hMmio, &mmCkInfo, NULL); 

         

              hEventStart= CreateEvent(0, TRUE, FALSE, 0);  

              StateRecords=1;

              t=0;

              if (GetFreeMemory()==0) StateRecords==4;

              while(StateRecords!=4)

               {

                   if(StateRecords==2)

                    {

                        WaitForSingleObject(hEventStart,INFINITE);

                        ResetEvent(hEventStart);

                        if(StateRecords==4)break;

                    }

                   //передаєм підготовлений буфер  пам'яті драйверу пристрою вводу 

                   waveInAddBuffer(hWaveIn, &WaveHdr, sizeof(WAVEHDR));

                   // запускаємо процес вводу данних

                   if(t==0)

                    mmResult=waveInStart(hWaveIn);

                   if (mmResult!=MMSYSERR_NOERROR)

                    { 

                        serror[0]= 0;

                        waveInGetErrorText(mmResult, serror,sizeof(serror));

                        MessageBox(NULL,serror,"ERROR",MB_OK|MB_TASKMODAL);

                     SendMessage(hwnd,ID_ERROR_RECORD,(WPARAM)serror,NULL);

                    }

                   WaitForSingleObject(hEvent,3000);

                   ResetEvent(hEvent);

                   mmioWrite(hMmio,WaveHdr.lpData,BufferSize);

                   mmioAscend (  hMmio,  &mmCkInfo, 0);

                   t++;

                   if (GetFreeMemory()==0) StateRecords==4;

               } 

              if(mmioClose(hMmio,MMIO_FHOPEN))

               MessageBox(NULL,"Неможливо закрити файл","Error ",MB_OK |          MB_TASKMODAL);  

              hMmio = mmioOpen((char*)lpFilename.c_str(), NULL,MMIO_DELETE);   

              if (hMmio)

               {

                   UINT error = GetLastError();

                   char lpMsgBuf[256];              FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_I        GNORE_INSERTS,NULL, error,0, (LPTSTR)

      &lpMsgBuf,sizeof(lpMsgBuf),NULL );

                   MessageBox(NULL,lpMsgBuf,"Error M",MB_OK| MB_TASKMODAL);

               }

              CloseHandle(hEvent);

              CloseHandle(hEventStart);

         }

        //звільняємо буфер вводу

        mmResult=waveInUnprepareHeader(hWaveIn, &WaveHdr, sizeof(WAVEHDR));

        if (mmResult!=MMSYSERR_NOERROR)

         { 

             serror[0]= 0;

             waveInGetErrorText(mmResult, serror,sizeof(serror));

             MessageBox(NULL,serror,"ERROR звільнення",MB_OK | MB_TASKMODAL);

         }

        //закриваємо аудіопристрій

        mmResult=waveInClose(hWaveIn);

        if (mmResult!=MMSYSERR_NOERROR)

         { 

             serror[0]= 0;

             waveInGetErrorText(mmResult, serror,sizeof(serror));

             MessageBox(NULL,serror,"ERROR звільнення",MB_OK | MB_TASKMODAL);

         }

     }

    else

     {

         char *Num;

         Num=(char*)malloc(10);

         itoa(NumDevs,Num,10);

         MessageBox(NULL,Num,"Кількість драйверів що підтримують імпульсно кодову модуляцію",MB_OK | MB_TASKMODAL);

     }

}

int  Record_Sound :: GetFreeMemory()

{

                   string dir=GetCommandLine();

                   int Position=dir.find_first_of("\\");

                  dir.erase(Position+1,dir.length()-Position); 

                    dir.erase(0,1);

                   __int64 lpTotalNumberOfFreeBytes;

                   GetDiskFreeSpaceEx(dir.c_str(),NULL,NULL,(PULARGE_INTEGER)&lpTotalNumberOfFreeBytes);

                   while ((lpTotalNumberOfFreeBytes/1024000)<10)

                    {

                        int Button=MessageBox(NULL,"Невистачає памяті на диску.\nДля продовження запису звільніть місце і нажміть ОК.\nЩоб закінчити і зберігти існуючі дання нажміть Отмена",

                                             "Невистачає памяті для звукозапису",MB_OKCANCEL|MB_ICONWARNING|MB_TASKMODAL );

                         if(Button==IDYES)

                         {

                             GetDiskFreeSpaceEx(dir.c_str(),NULL,NULL,(PULARGE_INTEGER)&lpTotalNumberOfFreeBytes);