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

                             if ((lpTotalNumberOfFreeBytes/1024000)<10) continue;

                         }

                        if(Button==IDCANCEL)

                         {

                             SendMessage(hwnd,WM_COMMAND,ID_BUTTON,STOP);

                             return 0;

                         } 

                     }

                   return  lpTotalNumberOfFreeBytes/1024000;   

}

//відновлюємо запис

void Record_Sound :: StartRecord()

{

    waveInStart(hWaveIn);

    SetEvent(hEventStart);

    StateRecords=1;

    StateSave=FALSE;

}

//призупиняємо запис

void Record_Sound :: PauseRecord(){

    StateRecords=2;

    waveInStop(hWaveIn);

}

//зупиняємо запис

int Record_Sound :: StopRecord(){

   PauseRecord();

    if (!StateSave)

     {

       int Button=MessageBox(NULL,"Файл змінено.Зберігти зміни","Звукозапис",

                             MB_YESNOCANCEL|MB_ICONWARNING|MB_TASKMODAL );

       if(Button==IDYES)

        {

          Save();

          StateRecords=4;

          SetEvent(hEventStart);

        }

       if(Button==IDNO)

        {

          StateRecords=4;

          SetEvent(hEventStart);

        }

       if(Button==IDCANCEL)

        {

          return 0;

        }

       return 1;

     }     

    return 1;

}

//зберігаємо запис

void Record_Sound :: Save(){

StateRecords=2;

waveInStop(hWaveIn);

OPENFILENAME ofn; // структура стандартного діалогового вікна

char lpNewFileName[65532]; // буфер для імені файлу

// ініціалізація структури OPENFILENAME для діалогового вікна

ZeroMemory(&ofn, sizeof(OPENFILENAME));

ofn.lStructSize = sizeof(OPENFILENAME);

ofn.lpstrFile = lpNewFileName;

ofn.nMaxFile = sizeof(lpNewFileName);

ofn.lpstrFilter = "Wav \0*.wav\0All\0*.*\0";

ofn.nFilterIndex = 1;

ofn.lpstrDefExt="wav";

ofn.lpstrFileTitle = NULL;

ofn.lpstrInitialDir="Моя запись";

ofn.nMaxFileTitle = 0;

ofn.lpstrInitialDir = NULL;

ofn.Flags = OFN_OVERWRITEPROMPT ;

 

// Показуємо діалогове вікно Зберігти (Save).

if(GetSaveFileName(&ofn)==TRUE)

{

   //отримання імені директорії з програмою

   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);

   if(!CopyFile(lpFilename.c_str(),lpNewFileName,FALSE))

     MessageBox(NULL,"Невдається зберігти №1","Error",MB_OK);

}

StateSave=TRUE;

}

//отримання часу запису

int Record_Sound :: GetTimeRecord(){

return t;

}

//отримання стану запису

int Record_Sound :: GetStateRecords()

{

    return StateRecords;

}

//задання кількості каналів для запису

void Record_Sound :: SetChannel(int Channel){

    this->Channel=Channel;

}

 

/*play.h*/

#include <cstdlib>

#include <iostream>

#include "windows.h"

#include "mmsystem.h"

#include "vector"

#include <algorithm>

enum { ID_LENGTH };

enum { ID_MOVE=3 };

enum { ID_ERROR_PLAY=77};

//Клас для відтворення  звукової інформації

class Play_Sound {

   private:

    HANDLE hEventStart; //дескриптор події для керування відтворенням

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

    MCIERROR mciError;

    MCI_OPEN_PARMS mciOpenParms;

    MCI_PLAY_PARMS mciPlayParms;

    MCI_STATUS_PARMS Info;

    int Length;

    int Second; // змінна для зв'язку з повзунком

    int StatePlay;

    char *Path;

    int PositionInList;

    DWORD Volume;

   vector<string>PlayList;

    public:

    LPDWORD PlayThreadID;//область памяті для повернення ідентифікатору потокау

    Play_Sound();

    void AddToPlaylist();

    int  Play();//створює потік для відтворення

    void Play_();

    int  GetStatePlay();

    void ResumePlay(); // відновлює відтворення

    void Stop(); // зупиняє відтврорення

    void Pause(); // призупиняє відтворення

    void SetVolume(int Volume);

    int  GetVolume();

    void PlayFrom(int From);

    void MoveTrack();

    void MoveTrack_();

    void SetSecond(int Sec);

    int  GetLength();

    void OfRandom();

    void Sort();

    int  NextTrak();

    void PreviousTrak(); 

                };

Play_Sound :: Play_Sound()

{

    StatePlay=0; // 0-невідтворює

                 // 1-відтворює

                 // 2-пауза

                 // 3-шукати

    mciOpenParms.lpstrDeviceType =0;

    PositionInList=0;

    Path=NULL;

}

unsigned long _stdcall Play_threadstart(void *data)

{ 

    ((Play_Sound*)data)->Play_();

 

}

//створює потік для відтворення

int Play_Sound:: Play()

{

    if (PlayList.size()!=0)

     {

        Path=(char*)malloc(PlayList[PositionInList].size());

        Path[PlayList[PositionInList].copy(Path,PlayList[PositionInList].size(),0)]='\0';

        CreateThread(NULL,0,Play_threadstart,this ,0,PlayThreadID);         

        return 1;

     }

else

return 0;

} 

//відтворення

void Play_Sound :: Play_()

{       

        mciOpenParms.lpstrElementName =Path;

        mciError = mciSendCommand(0, MCI_OPEN, MCI_OPEN_ELEMENT ,

                    (DWORD)(LPMCI_OPEN_PARMS)&mciOpenParms);

        if (mciError)

         {  

             char lpszErrorText[256];

                   BOOL dummy = mciGetErrorString(mciError, lpszErrorText,sizeof(lpszErrorText));

           if (dummy)

        {

            MessageBox(NULL,lpszErrorText,"ERROR Can't open",MB_OK |MB_TASKMODAL);

            if (NextTrak()==0)

                         SendMessage(hwnd,ID_ERROR_PLAY,0,NULL);

                    }

           else

                   MessageBox(NULL,"Напряги извилины :-)","ERROR Can't open",MB_OK);

         }

         else

          {

              mciPlayParms.dwCallback=(DWORD)hwnd;     

              mciError = mciSendCommand(mciOpenParms.wDeviceID, MCI_PLAY,

                     MCI_NOTIFY , (DWORD)(LPMCI_PLAY_PARMS)&mciPlayParms);   

          if (mciError)

           {

                   char lpszErrorText[256];

                   BOOL dummy = mciGetErrorString(mciError, lpszErrorText,sizeof(lpszErrorText));

           if (dummy)

        {

            MessageBox(NULL,lpszErrorText,"ERROR Can't play",MB_OK);

                   }

           else

                   MessageBox(NULL,"Напряги извилины :-)","ERROR Can't play",MB_OK);

           }

          memset(&Info,0,sizeof(MCI_STATUS_PARMS));

              Info.dwItem = MCI_STATUS_LENGTH;

              mciSendCommand(mciOpenParms.wDeviceID,MCI_STATUS,MCI_STATUS_ITEM,DWORD(&Info));

              Length=Info.dwReturn/1000;

              Second=0;

              SendMessage(hwnd, ID_LENGTH,NULL,NULL);

              MoveTrack();

          StatePlay=-1;

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

          while (true)

               {

                   WaitForSingleObject(hEventStart,INFINITE);

                   // зупиняє відтворення

                   if (StatePlay==0)

                    {

                        ResetEvent(hEventStart);

                        break;

                    }

                   // призупиняє відтворення

                   if (StatePlay==2)

                    {

                        mciSendCommand(mciOpenParms.wDeviceID, MCI_PAUSE,0, NULL);

                        ResetEvent(hEventStart);

                    }

                   // відновлює відтворення

                   if (StatePlay==1)

                    {

                        ResetEvent(hEventStart);

                        mciError = mciSendCommand(mciOpenParms.wDeviceID,MCI_RESUME,

                                       NULL,(DWORD)(LPMCI_PLAY_PARMS)&mciPlayParms);

                        if (mciError)

                     {

                             char lpszErrorText[256];

                             BOOL dummy = mciGetErrorString(mciError, lpszErrorText,sizeof(lpszErrorText));

                     if (dummy)

                  {

                      MessageBox(NULL,lpszErrorText,"ERROR Can't play",MB_OK);

                              }

                     else

                                  MessageBox(NULL,"Напряги извилины :-)","ERROR Can't play",MB_OK);

                         }

                    }

                    //відтворює з певного місця

                   if (StatePlay==3)

                    {

                        mciSendCommand(mciOpenParms.wDeviceID, MCI_PLAY,MCI_FROM|MCI_NOTIFY,

                                      (DWORD)(LPMCI_PLAY_PARMS)&mciPlayParms);

                        ResetEvent(hEventStart);             

                    }     

               } 

              mciError=mciSendCommand(mciOpenParms.wDeviceID, MCI_CLOSE, NULL, NULL);

               if (mciError)

           {

                   char lpszErrorText[256];

                   BOOL dummy = mciGetErrorString(mciError, lpszErrorText,sizeof(lpszErrorText));

           if (dummy)

        {

            MessageBox(NULL,lpszErrorText,"ERROR",MB_OK);

                    }

           else

                   MessageBox(NULL,"Can't close напряги извилины :-)","ERROR",MB_OK);

           }

          }    

}

//отримає стан відтворення

int  Play_Sound :: GetStatePlay()

{

    return StatePlay;

}

//зупиняє відтворення

void Play_Sound :: Stop()

{

     StatePlay=0;

     SetEvent(hEventStart);

    

}

//призупиняє відтворення

void Play_Sound :: Pause()

{

    if (StatePlay!=2)

     {   

         StatePlay=2;

         SetEvent(hEventStart);

     }

}

//відновлюєвідтворення

void Play_Sound :: ResumePlay()

{

         StatePlay=1;

         SetEvent(hEventStart);

}

//задає гучність звуку

void Play_Sound :: SetVolume(int VolumeV)

{

Volume=VolumeV*1000;

waveOutSetVolume(0,MAKELPARAM(Volume,Volume) );

}

//повертає гучність

int  Play_Sound :: GetVolume()

{

    waveOutGetVolume(0,&Volume);

    Volume=LOWORD(Volume);

    Volume=Volume/1000;

    if (Volume==0)Volume=1;

    return Volume;

}

//відтворює з певного місця

void Play_Sound :: PlayFrom(int From)

{

    mciPlayParms.dwFrom = From*1000;

    StatePlay=3;

    SetEvent(hEventStart);

}

//функцію яку визиває потік переміщення повзунка

unsigned long _stdcall Play_threadMoveTrack(void *data)

{ 

    ((Play_Sound*)data)->MoveTrack_();

 

}

//створює потік для переміщення повзунок

void Play_Sound :: MoveTrack()

{

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

}

//переміщює повзунок

void Play_Sound :: MoveTrack_()

{

    while (Second!=GetLength())

     {

        if (StatePlay==2)

         WaitForSingleObject(hEventStart,INFINITE);   

        if (StatePlay==0)

         {

           SendMessage(hwnd,ID_MOVE, NULL,0);

           break;

         }

        Sleep(1000);

        Second++;

        SendMessage(hwnd,ID_MOVE, NULL,(LPARAM)Second);

     }

}

//зписує теперішню позицію повзунка

void Play_Sound :: SetSecond(int Sec)

{

    Second=Sec;

}

//повертає довжину треку

int  Play_Sound :: GetLength()

{

    return Length;

}

//розміщає назви треків в довільній послідовності

void Play_Sound :: OfRandom()

{

    random_shuffle(PlayList.begin(),PlayList.end()) ;

}

//відсортовує назви треків

void Play_Sound :: Sort()

{

    sort(PlayList.begin(),PlayList.end()) ;

}

//вітворення наступного треку

int Play_Sound :: NextTrak()

{  

    if (PlayList.size()>1)

     {

         Stop();

         if (PositionInList==PlayList.size()-1)

          PositionInList=0;

          else

           PositionInList++;

         Play(); 

         return 1;

      }

     return 0;

}

//відтворення попереднього треку

void Play_Sound :: PreviousTrak()

{

    if (PlayList.size()>1)

     {

         Stop();

         if (PositionInList==0)

          PositionInList=PlayList.size()-1;

          else

           PositionInList--;

         Play();  

      }

}

//додає до списку  відтворення

void Play_Sound :: AddToPlaylist()

{

    OPENFILENAME ofn;

char lpNewFileName[65532];

// ініціалізація структури  OPENFILENAME для діалогового вікна

ofn.hwndOwner=hwnd;

ZeroMemory(&ofn, sizeof(OPENFILENAME));

ofn.lStructSize = sizeof(OPENFILENAME);

ofn.lpstrFile = lpNewFileName;

ofn.nMaxFile = sizeof(lpNewFileName);

ofn.lpstrFilter = "Wav Mp3\0*.wav;*.mp3\0All\0*.*\0";

ofn.nFilterIndex = 1;

ofn.lpstrFileTitle = NULL;

ofn.nMaxFileTitle = 0;

ofn.lpstrInitialDir = NULL;

ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST|OFN_ALLOWMULTISELECT|OFN_EXPLORER;

// показуємо діалогове  вікно Відкрити (Open).

if (GetOpenFileName(&ofn)==TRUE)

{

   int i;

   string Buff;

   string Buff2;

   char *Temp;

   int nOffset = ofn.nFileOffset;

   Buff.insert(0,ofn.lpstrFile);

   if (nOffset > lstrlen(ofn.lpstrFile))

    {

        while(ofn.lpstrFile[nOffset]!='\0')

         {

             string Buff2;

             Buff2.insert(0,Buff);

             Buff2.insert(Buff2.size(),"\\");

             Buff2.insert(Buff2.size(),ofn.lpstrFile + nOffset);             

             PlayList.push_back(Buff2);

             nOffset +=strlen(ofn.lpstrFile+nOffset) + 1;          

         }

    }

    else

     {

         PlayList.push_back(Buff);

     } 

   OfRandom();

}

}

 

Додаток В 
(Обов’язковий) 
Схеми алгоритмів

 

Рисунок В.1 –  Схема алгоритму запису

Рисунок В.2 –  Схема алгоритму відтворення

 

Рисунок В.3 – Схема алгоритму додавання до списку відтворення

Рисунок В.4 –  Схема алгоритму сортування списку відтворення