from my experience WAVEIN/WAVEOUT is the best sound api on win for this purpose... DirectSound is(was) buggy and very big latency so I stopped using it for good years ago...
Here my ancient C++ lib I originally wrote for my oscilloscope,spectral analyzator,signal generator apps but using it everywhere even in my ZXSpectrum emulator:
waveout.h:
//---------------------------------------------------------------------------
//--- WAVE IN/OUT class ver: 4.02 -------------------------------------------
//---------------------------------------------------------------------------
#ifndef _waveout_h
#define _waveout_h
//---------------------------------------------------------------------------
#include <mmsystem.h>
#include "fifo.h"
#include "lock.h"
//---------------------------------------------------------------------------
void CALLBACK wave_in_event(HWAVEIN hw,UINT msg,DWORD inst,DWORD p1,DWORD p2);
void CALLBACK wave_out_event(HWAVEOUT hw,UINT msg,DWORD inst,DWORD p1,DWORD p2);
//---------------------------------------------------------------------------
class wave_in
{
public:
bool _init,_fifo;
FIFO<BYTE> fifo;
WAVEHDR *hdr;
HWAVEIN hw;
WAVEFORMATEX buff_format;
DWORD buff_size;
DWORD freq; WORD chanels,bits,samples,buffers;
BYTE **buff;
int adr,num;
void CALLBACK (*event)(HWAVEIN hw,UINT msg,DWORD inst,DWORD p1,DWORD p2);
// void (*onreceive)(wave_in *wi,BYTE *data,int size);
void (__closure *onreceive)(wave_in *wi,BYTE *data,int size);
wave_in()
{
hdr=NULL;
buff=NULL;
buffers=0;
buff_size=0;
_init=false;
adr=0;
num=0;
event=wave_in_event;
onreceive=NULL;
}
~wave_in()
{
_free();
}
wave_in(wave_in& a) { *this=a; }
wave_in* operator = (const wave_in *a) { *this=*a; return this; }
//wave_in* operator = (const wave_in &a) { ...copy... return this; }
void _free()
{
adr=0;
num=0;
if (_init) { waveInClose(hw); _init=false; }
#ifdef _mmap_h
if (buff) for (int i=0;i<buffers;i++) if (buff[i]) mmap_del(buff[i]);
if (buff) mmap_del(buff);
if (hdr ) mmap_del(hdr );
#endif
if (buff)
{
for (int i=0;i<buffers;i++) if (buff[i]) delete[] buff[i];
delete[] buff;
buff=NULL;
}
if (hdr) { delete[] hdr; hdr=NULL; }
}
void init(DWORD _freq,WORD _chanels,WORD _bits,WORD _samples,WORD _buffers=5)
{
int i,ret;
_free();
buffers=_buffers;
if (buffers<1) buffers=1;
hdr=new WAVEHDR[buffers];
buff=new BYTE*[buffers];
#ifdef _mmap_h
if (hdr ) mmap_new(hdr ,buffers*sizeof(WAVEHDR));
if (buff) mmap_new(buff,buffers*sizeof(BYTE*));
#endif
freq =_freq;
chanels =_chanels;
bits =_bits;
samples =_samples;
buff_size=(chanels*bits*samples)>>3;
samples=(buff_size<<3)/(chanels*bits);
for (i=0;i<buffers;i++) buff[i]=new BYTE[buff_size];
#ifdef _mmap_h
for (i=0;i<buffers;i++) if (buff[i]) mmap_new(buff[i],buff_size);
#endif
buff_format.wFormatTag =WAVE_FORMAT_PCM; // set buffer format
buff_format.nChannels =chanels;
buff_format.nSamplesPerSec =freq;
buff_format.wBitsPerSample =bits;
buff_format.cbSize =0;
buff_format.nAvgBytesPerSec =(freq*chanels*bits)>>3;
buff_format.nBlockAlign =(chanels*bits)>>3;
if (event) ret=waveInOpen(&hw,WAVE_MAPPER,&buff_format,(DWORD_PTR)event,(DWORD_PTR)this,CALLBACK_FUNCTION);
else ret=waveInOpen(&hw,WAVE_MAPPER,&buff_format,0,0,CALLBACK_NULL);
if (ret!=MMSYSERR_NOERROR)
{
// waveInGetErrorText(ret,err,255);
return;
}
WAVEHDR hdr0;
hdr0.dwBufferLength=buff_size;
hdr0.dwUser=0;
hdr0.dwFlags=0;
hdr0.dwLoops=0;
hdr0.lpNext=NULL;
for (i=0;i<buffers;i++)
{
hdr[i]=hdr0;
hdr[i].lpData=buff[i];
}
_init=true;
}
void add()
{
if (!_init) return;
int i,ret;
BYTE *p;
p=buff[adr];
ret=waveInPrepareHeader(hw,&hdr[adr],sizeof(WAVEHDR));
if (ret!=MMSYSERR_NOERROR)
{
// waveInGetErrorText(ret,err,255);
return;
}
waveInAddBuffer(hw,&hdr[adr],sizeof(WAVEHDR));
if (ret!=MMSYSERR_NOERROR)
{
// waveInGetErrorText(ret,err,255);
return;
}
adr++;
if (adr>=buffers) adr=0;
num++;
}
void start()
{
if (!_init) return;
while (num<buffers) add();
waveInStart(hw);
}
void stop()
{
if (!_init) return;
waveInStop(hw);
}
};
//---------------------------------------------------------------------------
class wave_out:public multi_lock
{
public:
bool _init,_fifo;
FIFO<BYTE> fifo;
WAVEHDR *hdr;
HWAVEOUT hw;
WAVEFORMATEX buff_format;
DWORD buff_size;
DWORD freq; WORD chanels,bits,samples,buffers;
BYTE **buff;
int adr,num,err;
void CALLBACK (*event)(HWAVEOUT hw,UINT msg,DWORD inst,DWORD p1,DWORD p2);
wave_out()
{
hdr=NULL;
buff=NULL;
buffers=0;
buff_size=0;
_init=false;
adr=0;
num=0;
err=0;
event=wave_out_event;
}
~wave_out()
{
_free();
}
wave_out(wave_out& a) { *this=a; }
wave_out* operator = (const wave_out *a) { *this=*a; return this; }
//wave_out* operator = (const wave_out &a) { ...copy... return this; }
void _free()
{
adr=0;
num=0;
if (_init) { waveOutClose(hw); _init=false; }
#ifdef _mmap_h
if (buff) for (int i=0;i<buffers;i++) if (buff[i]) mmap_del(buff[i]);
if (buff) mmap_del(buff);
if (hdr ) mmap_del(hdr );
#endif
if (buff)
{
for (int i=0;i<buffers;i++) if (buff[i]) delete[] buff[i];
delete[] buff;
buff=NULL;
}
if (hdr) { delete[] hdr; hdr=NULL; }
}
void init(DWORD _freq,WORD _chanels,WORD _bits,WORD _samples,WORD _buffers=10)
{
int i,ret;
_free();
buffers=_buffers;
if (buffers<1) buffers=1;
hdr=new WAVEHDR[buffers];
buff=new BYTE*[buffers];
#ifdef _mmap_h
if (hdr ) mmap_new(hdr ,buffers*sizeof(WAVEHDR));
if (buff) mmap_new(buff,buffers*sizeof(BYTE*));
#endif
freq =_freq;
chanels =_chanels;
bits =_bits;
samples =_samples;
buff_size=(chanels*bits*samples)>>3;
samples=(buff_size<<3)/(chanels*bits);
for (i=0;i<buffers;i++) buff[i]=new BYTE[buff_size];
#ifdef _mmap_h
for (i=0;i<buffers;i++) if (buff[i]) mmap_new(buff[i],buff_size);
#endif
buff_format.wFormatTag =WAVE_FORMAT_PCM; // set buffer format
buff_format.nChannels =chanels;
buff_format.nSamplesPerSec =freq;
buff_format.wBitsPerSample =bits;
buff_format.cbSize =0;
buff_format.nAvgBytesPerSec =(freq*chanels*bits)>>3;
buff_format.nBlockAlign =(chanels*bits)>>3;
if (event) ret=waveOutOpen(&hw,WAVE_MAPPER,&buff_format,(DWORD_PTR)event,(DWORD_PTR)this,CALLBACK_FUNCTION);
else ret=waveOutOpen(&hw,WAVE_MAPPER,&buff_format,0,0,CALLBACK_NULL);
if (ret!=MMSYSERR_NOERROR)
{
// waveOutGetErrorText(ret,err,255);
return;
}
WAVEHDR hdr0;
hdr0.dwBufferLength=buff_size;
hdr0.dwUser=0;
hdr0.dwFlags=WHDR_INQUEUE;
hdr0.dwLoops=0;
hdr0.lpNext=NULL;
for (i=0;i<buffers;i++)
{
hdr[i]=hdr0;
hdr[i].lpData=buff[i];
}
_init=true;
}
void send(BYTE *data)
{
if (!_init) return;
lock();
if (num>buffers)
{
err++;
adr=0;
num=0;
}
DWORD i;
int ret;
BYTE *p;
p=buff[adr];
for (i=0;i<buff_size;i++) p[i]=data[i];
ret=waveOutPrepareHeader(hw,&hdr[adr],sizeof(WAVEHDR));
if (ret!=MMSYSERR_NOERROR)
{
// waveOutGetErrorText(ret,err,255);
unlock();
return;
}
waveOutWrite(hw,&hdr[adr],sizeof(WAVEHDR));
if (ret!=MMSYSERR_NOERROR)
{
// waveOutGetErrorText(ret,err,255);
unlock();
return;
}
adr++;
if (adr>=buffers) adr=0;
num++;
unlock();
}
void stop()
{
waveOutReset(hw);
}
};
//---------------------------------------------------------------------------
void CALLBACK wave_in_event(HWAVEIN hw,UINT msg,DWORD inst,DWORD p1,DWORD p2)
{
wave_in *w=(wave_in*)(void*)(DWORD_PTR)inst;
if (w==NULL) return;
if (msg==WIM_OPEN); // open wave HW
if (msg==WIM_DATA) // wave data send done
{
int adr0=w->adr-w->num;
while (adr0>=w->buffers) adr0-=w->buffers;
while (adr0< 0) adr0+=w->buffers;
if (w->onreceive) w->onreceive(w,w->buff[adr0],w->buff_size);
w->num--;
}
if (msg==WIM_CLOSE); // close wave HW
}
//---------------------------------------------------------------------------
void CALLBACK wave_out_event(HWAVEOUT hw,UINT msg,DWORD inst,DWORD p1,DWORD p2)
{
wave_out *w=(wave_out*)(void*)(DWORD_PTR)inst;
if (w==NULL) return;
w->lock();
if (msg==WOM_OPEN); // open wave HW
if (msg==WOM_DONE) w->num--; // wave data send done
if (msg==WOM_CLOSE); // close wave HW
w->unlock();
}
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
support file lock.h:
//---------------------------------------------------------------------------
//--- Multithread lock class ver 1.00 ---------------------------------------
//---------------------------------------------------------------------------
#ifndef _lock_h
#define _lock_h
//---------------------------------------------------------------------------
class single_lock
{
public:
CRITICAL_SECTION hnd;
single_lock() { InitializeCriticalSectionAndSpinCount(&hnd,0x00000400); }
~single_lock() { DeleteCriticalSection(&hnd); }
single_lock(single_lock& a) { *this=a; }
single_lock* operator = (const single_lock *a) { *this=*a; return this; }
// single_lock* operator = (const single_lock &a) { **** }
// thread safe functions
inline void lock() { EnterCriticalSection(&hnd); }
inline void unlock() { LeaveCriticalSection(&hnd); }
};
//---------------------------------------------------------------------------
const int _multi_lock_size=16; // max number of simultanious access
class multi_lock
{
public:
CRITICAL_SECTION hnd;
CRITICAL_SECTION dat[_multi_lock_size];
DWORD adr0,adr1,siz;
multi_lock() { InitializeCriticalSectionAndSpinCount(&hnd,0x00000400); for(int i=0;i<_multi_lock_size;i++) InitializeCriticalSectionAndSpinCount(&dat[i],0x00000400); adr0=0; adr1=0; siz=0; }
~multi_lock() { DeleteCriticalSection(&hnd); for(int i=0;i<_multi_lock_size;i++) DeleteCriticalSection(&dat[i]); }
multi_lock(multi_lock& a) { *this=a; }
multi_lock* operator = (const multi_lock *a) { *this=*a; return this; }
// multi_lock* operator = (const multi_lock &a) { **** }
// thread safe functions
inline void lock()
{
EnterCriticalSection(&hnd);
if (siz<_multi_lock_size)
{
siz++;
EnterCriticalSection(&dat[adr1]);
adr1++; if (adr1>=_multi_lock_size) adr1=0;
}
// else error();
LeaveCriticalSection(&hnd);
}
inline void unlock()
{
EnterCriticalSection(&hnd);
if (siz>0)
{
siz--;
LeaveCriticalSection(&dat[adr0]);
adr0++; if (adr0>=_multi_lock_size) adr0=0;
}
// else error();
LeaveCriticalSection(&hnd);
}
};
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
support file FIFO.h:
//---------------------------------------------------------------------------
//--- FIFO template class ver 2.08 ------------------------------------------
//---------------------------------------------------------------------------
#ifndef _fifo_h
#define _fifo_h
//---------------------------------------------------------------------------
//static bool _enable_fifo_debug=false;
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template <class T> class FIFO
{
public:
T *dat;
int adr0,adr1,size;
CRITICAL_SECTION lock;
FIFO() { dat=NULL; InitializeCriticalSectionAndSpinCount(&lock,0x00000400); alloc(16); }
~FIFO() { _free(); DeleteCriticalSection(&lock); }
FIFO(FIFO& a) { *this=a; }
FIFO* operator = (const FIFO *a){ *this=*a; return this; }
FIFO* operator = (const FIFO &a){ EnterCriticalSection(&a.lock); EnterCriticalSection(&lock); _alloc(a.size); adr0=a.adr0; adr1=a.adr1; for (int i=0;i<size;i++) dat[i]=a.dat[i]; LeaveCriticalSection(&lock); LeaveCriticalSection(&a.lock); return this; }
// already locked functions
inline int _adr_inc(int a) volatile { a++; if (a>=size) a=0; return a; }
inline int _adr_dec(int a) volatile { if (a!=adr0) a--; if (a<0) a=size-1; return a; }
inline void _alloc(int _size)volatile { if (dat) delete[] dat; dat=NULL; size=_size; adr0=0; adr1=0; dat=new T[size]; if (dat==NULL) size=0; _reset(); }
inline void _free() volatile { if (dat) delete[] dat; dat=NULL; size= 0; adr0=0; adr1=0; }
inline void _reset() volatile { adr0=0; adr1=0; }
inline void _in(T x) volatile { if (_is_full()) return; dat[adr1]=x; adr1=_adr_inc(adr1); }
inline T _out() volatile { if (_is_empty()){ T null; return null; } T x=dat[adr0]; adr0=_adr_inc(adr0); return x; }
inline T _peek_first() volatile { if (_is_empty()){ T null; return null; } T x=dat[adr0]; return x; }
inline T _peek_last() volatile { if (_is_empty()){ T null; return null; } int a=_adr_dec(adr1); T x=dat[a]; return x; }
inline bool _is_empty() volatile { bool ret=(adr0==adr1); return ret; }
inline bool _is_full() volatile { int a=_adr_inc(adr1); bool ret=(a==adr0); return ret; }
inline int _get_size() volatile { if (_is_empty()) return 0; if (_is_full()) return size; if (adr0<adr1) return adr1-adr0; else return size+adr1-adr0; }
// thread safe functions
void _lock() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); }
void _unlock() volatile { LeaveCriticalSection((CRITICAL_SECTION*)&lock); }
void alloc(int _size) volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); _alloc(_size); LeaveCriticalSection((CRITICAL_SECTION*)&lock); }
void reset() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); _reset(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); }
void in(T x) volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); _in(x); LeaveCriticalSection((CRITICAL_SECTION*)&lock); }
T out() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); T x=_out(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); return x; }
T peek_first() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); T x=_peek_first(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); return x; }
T peek_last() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); T x=_peek_last(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); return x; }
bool is_empty() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); bool x=_is_empty(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); return x; }
bool is_full() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); bool x=_is_full(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); return x; }
int get_size() volatile { EnterCriticalSection((CRITICAL_SECTION*)&lock); int x=_get_size(); LeaveCriticalSection((CRITICAL_SECTION*)&lock); return x; }
};
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
here simple usage (extracted from my generator hope I did not forget anything):
// globals and init
const int _size=20*1024;
wave_out wo;
WORD buffer[_size]; // your PCM sound data matching the init operands
wo.init(44100,2,16,_size,10); // sampling_freq,channels,bits,buffer size,buffers
// this in some timer or thread (fast enbough)
while (wo.num<4)
{
// here prepare buff[] data
wo.send((BYTE*)buff);
}
// force to stop on app exit or when needed
wo.stop();
The stuff was compiled on BDS2006 C++ Builder so in case you use newer compiler you might need to tweak some stuff...had not time will to port this to new compiler yet so if the case see this.
wave_out is for sound playback and wave_in is for recording both are using preferred windows sound device selected in control panel of Windows. To enable smooth playback just make sure that at least 4 buffers are filled in the sound que while (wo.num<4)... otherwise sound glitches might occur
You might also need to decode WAV files so here another ancient lib of mine RIFF.h:
//---------------------------------------------------------------------------
//--- RIFF WAVE format: 1.01 ------------------------------------------------
//---------------------------------------------------------------------------
#ifndef _RIFF_h
#define _RIFF_h
//---------------------------------------------------------------------------
// 8bit PCM is unsigned
// 16bit PCM is signed 2'os complement little endian (big endian is RIFX)
//---------------------------------------------------------------------------
struct _wave_chunk
{
DWORD ids;
DWORD len;
_wave_chunk(){ ids=' '; len=0; }
_wave_chunk(_wave_chunk& a){ *this=a; }; ~_wave_chunk(){}; _wave_chunk* operator = (const _wave_chunk *a) { *this=*a; return this; }; /*_wave_chunk* operator = (const _wave_chunk &a) { ...copy... return this; };*/
};
struct _wave_hdr
{
DWORD ids; // "RIFF"
DWORD len;
DWORD tps; // "WAVE"
_wave_hdr(){ ids='FFIR'; len=0; tps='EVAW'; }
_wave_hdr(_wave_hdr& a){ *this=a; }; ~_wave_hdr(){}; _wave_hdr* operator = (const _wave_hdr *a) { *this=*a; return this; }; /*_wave_hdr* operator = (const _wave_hdr &a) { ...copy... return this; };*/
};
struct _wave_fmt
{
DWORD ids; // "fmt "
DWORD len; // 16,18,40
WORD format; // 1 = PCM linear quantization
/* 0x0001 WAVE_FORMAT_PCM PCM
0x0003 WAVE_FORMAT_IEEE_FLOAT IEEE float
0x0006 WAVE_FORMAT_ALAW 8-bit ITU-T G.711 A-law
0x0007 WAVE_FORMAT_MULAW 8-bit ITU-T G.711 µ-law
0xFFFE WAVE_FORMAT_EXTENSIBLE Determined by SubFormat */
WORD chanels;
DWORD samplerate;
DWORD byterate;
WORD blockalign;
WORD bits;
WORD ext_len; // extension length 0,22
WORD ext_validbits;
DWORD ext_channelmask;
BYTE ext_subformat[16];
_wave_fmt(){ ids=' tmf'; len=16; format=1; chanels=1; samplerate=44100; bits=8; ext_len=0; ext_validbits=0; ext_channelmask=0; for (int i=0;i<16;i++) ext_subformat[i]=0; compute(); }
_wave_fmt(_wave_fmt& a){ *this=a; }; ~_wave_fmt(){}; _wave_fmt* operator = (const _wave_fmt *a) { *this=*a; return this; }; /*_wave_fmt* operator = (const _wave_fmt &a) { ...copy... return this; };*/
void compute()
{
byterate=(chanels*samplerate*bits)/8;
blockalign=(chanels*bits)/8;
}
};
struct _wave_dat
{
DWORD ids; // "data"
DWORD len;
_wave_dat(){ ids='atad'; len=0; }
_wave_dat(_wave_dat& a){ *this=a; }; ~_wave_dat(){}; _wave_dat* operator = (const _wave_dat *a) { *this=*a; return this; }; /*_wave_dat* operator = (const _wave_dat &a) { ...copy... return this; };*/
};
//---------------------------------------------------------------------------
class wave
{
public:
AnsiString name;
int hnd;
bool readonly;
_wave_hdr hdr;
_wave_fmt fmt;
_wave_dat dat;
wave();
~wave();
void create(AnsiString _name);
void write(BYTE *data,DWORD size);
bool open(AnsiString _name);
DWORD read(BYTE *data,DWORD size);
void close();
};
//---------------------------------------------------------------------------
wave::wave()
{
name=0;
hnd=-1;
readonly=true;
}
//---------------------------------------------------------------------------
wave::~wave()
{
close();
}
//---------------------------------------------------------------------------
void wave::create(AnsiString _name)
{
close();
readonly=true;
// hdr=_wave_hdr();
// fmt=_wave_fmt();
// dat=_wave_dat();
hdr.len=sizeof(hdr)-8;
dat.len=0;
fmt.compute();
name=_name;
hnd=FileCreate(name);
if (hnd<0) return;
FileWrite(hnd,&hdr,sizeof(hdr));
FileWrite(hnd,&fmt,fmt.len+8);
FileWrite(hnd,&dat,sizeof(dat));
readonly=false;
}
//---------------------------------------------------------------------------
bool wave::open(AnsiString _name)
{
close();
readonly=true;
name=_name;
hnd=FileOpen(name,fmOpenRead);
if (hnd<0) return false;
if (FileRead(hnd,&hdr,sizeof(hdr))<sizeof(hdr)){ close(); return false; }
if (hdr.ids!='FFIR') return false;
if (hdr.tps!='EVAW') return false;
_wave_chunk chk;
DWORD sz=sizeof(chk),l;
for(;;)
{
if (FileRead(hnd,&chk,sz)<sz){ close(); return false; }
if (chk.ids==' tmf')
{
fmt.ids=chk.ids;
fmt.len=chk.len;
if (FileRead(hnd,((BYTE*)&fmt)+sz,chk.len)<chk.len){ close(); return false; }
}
else if (chk.ids=='atad')
{
dat.ids=chk.ids;
dat.len=chk.len;
return true;
}
else FileSeek(hnd,int(chk.len),1);
}
}
//---------------------------------------------------------------------------
void wave::write(BYTE *data,DWORD size)
{
if (hnd<0) return;
hdr.len+=size;
dat.len+=size;
if (!readonly) FileWrite(hnd,data,size);
}
//---------------------------------------------------------------------------
DWORD wave::read(BYTE *data,DWORD size)
{
if (hnd<0) return 0;
return FileRead(hnd,data,size);
}
//---------------------------------------------------------------------------
void wave::close()
{
name="";
if (hnd<0) return;
FileSeek(hnd,0,0);
if (!readonly) FileWrite(hnd,&hdr,sizeof(hdr));
FileClose(hnd);
hnd=-1;
}
//---------------------------------------------------------------------------
#endif
//---------------------------------------------------------------------------
And usage:
// globals
wave wav;
wave_out wo;
BYTE *buff;
// init
wav.open("tetris2.wav"); // any file ...
wo.init(wav.fmt.samplerate,wav.fmt.chanels,wav.fmt.bits,dt*wav.fmt.samplerate/1000,10);
buff=new BYTE[wo.buff_size];
// timer 20ms ...
while (wo.num<4)
{
wav.read(buff,wo.buff_size);
wo.send(buff);
}
// exit
wo.stop();
wav.close();
delete[] buff;
the wav.read(...) returns number of BYTEs read so once it hit less than buffer size or even equals to zero it means you already on end of wavefile ... Now as you will have the wav in memory just rewrite the file access to memory access ...
