Форум на Исходниках.RU

//---------------------------------------------------------------------------

#ifndef AudioUnitH

#define AudioUnitH

#include "UtilUnit.h"

#include "mmsystem.hpp"

#include "DataUnit.h"

#include <Classes.hpp>

class CPlayer;

class CBuffer {

private:

AudioFmt Fmt;

int Size;

int Rate;

void *WO;

char *Buf;

WAVEHDR WH[2];

public:

CBuffer(AudioFmt aFmt, int aSize, int aRate);

~CBuffer();

void Play(int n);

void Pause();

void Restart();

void Reset();

void SetVol(int aVol);

CPlayer *pPlayer;

int GetBufNum(void *P);

void *GetBufPtr(int N);

};

class CPlayTh: public TThread {

private:

CPlayer *Player;

HANDLE SignalDone;

public:

CPlayTh(CPlayer *aPlayer);

void __fastcall Execute();

void Done();

};

enum TPlayMsg {PM_DONE_BUF,PM_DONE_FILE};

class CPlayer {

private:

CBuffer *Buf;

CWAVE *Wav;

CPlayTh *Th;

int nBuf;

bool Paused;

bool Played;

TRTLCriticalSection CS;

HWND Wnd;

void LoadNextFrame(int nBuf);

public:

CPlayer(CWAVE *aWav, HWND W=0);

~CPlayer();

void DoneBuf(int n);

void __fastcall LoadTh();

void SetPos(int nPos);

void SetVol(int aVol);

void Play();

void Pause();

};

//---------------------------------------------------------------------------

#endif

//---------------------------------------------------------------------------

#pragma hdrstop

#include "AudioUnit.h"

#include <mmsystem.hpp>

//---------------------------------------------------------------------------

#pragma package(smart_init)

void CALLBACK waveOutCallBack(int WO, UINT Msg, CBuffer *P, void *a1, int a2)

{

if (Msg==WOM_DONE)

if (P->pPlayer!=NULL)

P->pPlayer->DoneBuf( P->GetBufNum(a1) );

}

CBuffer::CBuffer(AudioFmt aFmt, int aSize, int aRate) {

Fmt = aFmt;

Size = aSize;

Rate = aRate;

WAVEFORMATEX WF;

WF.wFormatTag = WAVE_FORMAT_PCM;

WF.nChannels = CannalsFmt(Fmt);

WF.nSamplesPerSec = Rate;

WF.nAvgBytesPerSec = BytesFmt(Fmt)*Rate;

WF.nBlockAlign = BytesFmt(Fmt);

WF.wBitsPerSample = BitsFmt(Fmt);

WF.cbSize = sizeof(WF);

int R = waveOutOpen(&WO,0,&WF,(UINT)&waveOutCallBack,(UINT)this,CALLBACK_FUNCTION);

assert(R==0);

int BufSize = BytesFmt(Fmt)*Size;

Buf = new char [2*BufSize];

for (int i = 0; i < BufSize; i++) {

Buf[i] = random(16000);

}

for (int i = BufSize; i < 2*BufSize; i++) {

Buf[i] = random(100);

}

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

{

ZeroMemory(&WH[i],sizeof(WAVEHDR));

WH[i].lpData = Buf + i*BufSize;

WH[i].dwBufferLength = BufSize;

R = waveOutPrepareHeader(WO,&WH[i],sizeof(WAVEHDR));

assert(R==0);

}

CBuffer::~CBuffer()

{

waveOutPause(WO);

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

{

waveOutUnprepareHeader(WO,&WH[i],sizeof(WAVEHDR));

}

waveOutClose(WO);

}

void CBuffer::Play(int n)

{

int R = waveOutWrite(WO, &WH[n], sizeof(WAVEHDR));

//if (R!=0)

assert((R==0)|(R==33));

}

void CBuffer::Pause()

{

int R = waveOutPause(WO);

assert(R==0);

}

void CBuffer::Restart()

{

int R = waveOutRestart(WO);

assert(R==0);

}

void CBuffer::Reset()

{

int R = waveOutReset(WO);

assert(R==0);

}

void CBuffer::SetVol(int aVol)

{

unsigned int V = aVol*256*256+aVol;

int R = waveOutSetVolume(WO,V);

assert(R==0);

}

int CBuffer::GetBufNum(void *P)

{

if (P==&WH[0]) return 0;

if (P==&WH[1]) return 1;

assert(false);

return -1;

}

void *CBuffer::GetBufPtr(int N)

{

return WH[N].lpData;

//return Buf+N*BufSize;

}

CPlayTh::CPlayTh(CPlayer *aPlayer):TThread(true)

{

Player = aPlayer;

Priority = tpTimeCritical;

SignalDone = CreateEvent(NULL,true,false,NULL);

Resume();

}

void __fastcall CPlayTh::Execute()

{

do{

WaitForSingleObject(SignalDone,INFINITE);

ResetEvent(SignalDone);

if (!Terminated)

Player->LoadTh();

}while (!Terminated);

}

void CPlayTh::Done()

{

SetEvent(SignalDone);

}

void CPlayer::LoadNextFrame(int nBuf)

{

Wav->Read( Buf->GetBufPtr(nBuf) );

}

void CPlayer::DoneBuf(int n)

{

//if (n==0) {n = 1;} else n = 0;

nBuf = n;

bool DoneFile = Wav->GetPos() >= Wav->GetBufCount();

if (!DoneFile)

Th->Done();

if (Wnd!=0)

{

PostMessage(Wnd,WM_USER,PM_DONE_BUF,n);

if (DoneFile)

PostMessage(Wnd,WM_USER,PM_DONE_FILE,0);

}

void __fastcall CPlayer::LoadTh()

{

EnterCriticalSection(&CS);

int Temp = nBuf;

LoadNextFrame(Temp);

if (Played)

Buf->Play(Temp);

LeaveCriticalSection(&CS);

}

CPlayer::CPlayer(CWAVE *aWav, HWND W)

{

Wav = aWav;

Buf = new CBuffer(Wav->GetFmt(), Wav->GetSize(), Wav->GetRate());

Buf->pPlayer = this;

InitializeCriticalSection(&CS);

SetPos(0);

Th = new CPlayTh(this);

Paused = false;

Played = false;

Wnd = W;

}

CPlayer::~CPlayer()

{

Th->Terminate();

Th->Done();

Th->WaitFor();

delete Th;

delete Buf;

}

void CPlayer::SetPos(int nPos)

{

bool Pl = (Played)&&(!Paused);

Played = false;

Paused = false;

EnterCriticalSection(&CS);

Buf->Reset();

Wav->SetPos(nPos);

LoadNextFrame(0);

LoadNextFrame(1);

if (Pl)

Play();

LeaveCriticalSection(&CS);

}

void CPlayer::SetVol(int aVol)

{

Buf->SetVol(aVol);

}

void CPlayer::Play()

{

if (!Paused)

{

Buf->Play(0);

Buf->Play(1);

}else

Buf->Restart();

Paused = false;

Played = true;

}

void CPlayer::Pause()

{

Buf->Pause();

Paused = true;

}