//--------------------------------------------------------------------------------------
// Class: SoundResources
// Method: (protected) _prepareBuffer
// Description: Prepares the internal buffers for the doble buffering.
//--------------------------------------------------------------------------------------
void
SoundResources::_prepareBuffers(void)
{
//----------------------------------------------------------------------
// Preparing all memory buffer allocation
//----------------------------------------------------------------------
m_WaveHeader[2].dwBufferLength =
m_WaveHeader[1].dwBufferLength =
m_WaveHeader[0].dwBufferLength = dwBufferLength;
m_WaveHeader[0].lpData = (char *)VirtualAlloc(0,
m_WaveHeader[0].dwBufferLength,
MEM_COMMIT,
PAGE_READWRITE);
m_WaveHeader[1].lpData = (char *)VirtualAlloc(0,
m_WaveHeader[1].dwBufferLength,
MEM_COMMIT,
PAGE_READWRITE);
m_WaveHeader[2].lpData = (char *)VirtualAlloc(0,
m_WaveHeader[2].dwBufferLength,
MEM_COMMIT,
PAGE_READWRITE);
//----------------------------------------------------------------------
// Initialize dwFlags and dwLoops to 0. This seems to be necesary according to the
// Microsoft Windows documentation
//----------------------------------------------------------------------
m_WaveHeader[0].dwFlags = m_WaveHeader[1].dwFlags = m_WaveHeader[2].dwFlags = 0L;
m_WaveHeader[0].dwLoops = m_WaveHeader[1].dwLoops = m_WaveHeader[2].dwFlags = 0L;
//----------------------------------------------------------------------
// Initialize the headers
//----------------------------------------------------------------------
if ((m_err = waveInPrepareHeader(m_WaveInHandle, &m_WaveHeader[0], sizeof(WAVEHDR))))
printf("yarpsounddriver: Error preparing WAVEHDR -- %08X\n", m_err);
if ((m_err = waveInPrepareHeader(m_WaveInHandle, &m_WaveHeader[1], sizeof(WAVEHDR))))
printf("yarpsounddriver: Error preparing WAVEHDR -- %08X\n", m_err);
if ((m_err = waveInPrepareHeader(m_WaveInHandle, &m_WaveHeader[2], sizeof(WAVEHDR))))
printf("yarpsounddriver: Error preparing WAVEHDR -- %08X\n", m_err);
//----------------------------------------------------------------------
// It is necessary to queue the two buffers.
//----------------------------------------------------------------------
if ((m_err = waveInAddBuffer(m_WaveInHandle, &m_WaveHeader[0], sizeof(WAVEHDR))))
printf("yarpsounddriver: Error queueing WAVEHDR 1! -- %08X\n", m_err);
if ((m_err = waveInAddBuffer(m_WaveInHandle, &m_WaveHeader[1], sizeof(WAVEHDR))))
printf("yarpsounddriver: Error queueing WAVEHDR 2! -- %08X\n", m_err);
if ((m_err = waveInAddBuffer(m_WaveInHandle, &m_WaveHeader[2], sizeof(WAVEHDR))))
printf("yarpsounddriver: Error queueing WAVEHDR 2! -- %08X\n", m_err);
}
static bool_t getbuffer(WAVEHDR *pwh) {
GDataBuffer *paud;
// Get the next data block to send
gfxSystemLock();
paud = gaudioRecordGetFreeBlockI();
if (!paud && !nQueuedBuffers)
gaudioRecordDoneI();
gfxSystemUnlock();
if (!paud)
return FALSE;
// Prepare the wave header for Windows
pwh->dwUser = (DWORD_PTR)paud;
pwh->lpData = (LPSTR)(paud+1); // The data is on the end of the structure
pwh->dwBufferLength = paud->size;
pwh->dwFlags = 0;
if (waveInPrepareHeader(ah, pwh, sizeof(WAVEHDR))) {
fprintf(stderr, "GAUDIO: Failed to prepare a record buffer");
exit(-1);
}
// Send it to windows
if (waveInAddBuffer(ah, pwh, sizeof(WAVEHDR))) {
fprintf(stderr, "GAUDIO: Failed to add the record buffer");
exit(-1);
}
nQueuedBuffers++;
return TRUE;
}
BOOL RUIAudio::RecAddBuffer(RUIBuffer* pRUIBuffer)
{
if (pRUIBuffer == NULL)
{
ASSERT(FALSE);
return FALSE;
}
BYTE* pBufferRec = pRUIBuffer->GetBuffer();
WAVEHDR* pWaveHdr = (WAVEHDR*) pBufferRec;
pWaveHdr->lpData = (LPSTR) (pBufferRec + sizeof(WAVEHDR));
pWaveHdr->dwBufferLength = pRUIBuffer->GetBufferSize() - sizeof(WAVEHDR);
pWaveHdr->dwFlags = 0;
pWaveHdr->dwUser = 0;
if (waveInPrepareHeader(m_hWaveIn, pWaveHdr, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
ASSERT(FALSE);
return FALSE;
}
if (waveInAddBuffer(m_hWaveIn, pWaveHdr, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
ASSERT(FALSE);
return FALSE;
}
return TRUE;
}
//为录音分配一组内存
BOOL CAudioRec::AllocBuffer()
{
BOOL bRet=FALSE;
UINT i;
m_pHdr=new WAVEHDR[NUM_BUF];
//为了使录音连续，采用多个缓冲区
for(i=0;i<NUM_BUF;i++)
{
ZeroMemory(&m_pHdr[i],sizeof(WAVEHDR));
m_pHdr[i].lpData=new char[m_nBufSize];
m_pHdr[i].dwBufferLength=m_nBufSize;
m_mmr=waveInPrepareHeader(m_hIn,&m_pHdr[i],sizeof(WAVEHDR));
if(m_mmr)
goto RET;
m_mmr=waveInAddBuffer(m_hIn,&m_pHdr[i],sizeof(WAVEHDR));
if(m_mmr)
goto RET;
}
bRet=TRUE;
RET:
return bRet;
}
static void nt_resyncaudio(void)
{
UINT mmresult;
int nad, nda, count;
if (nt_resync_cancelled)
return;
/* for each open input device, eat all buffers which are marked
ready. The next one will thus be "busy". */
post("resyncing audio");
for (nad = 0; nad < nt_nwavein; nad++)
{
int phase = ntsnd_inphase[nad];
for (count = 0; count < MAXRESYNC; count++)
{
WAVEHDR *inwavehdr = ntsnd_invec[nad][phase].lpWaveHdr;
if (!(inwavehdr->dwFlags & WHDR_DONE)) break;
if (inwavehdr->dwFlags & WHDR_PREPARED)
waveInUnprepareHeader(ntsnd_indev[nad],
inwavehdr, sizeof(WAVEHDR));
inwavehdr->dwFlags = 0L;
waveInPrepareHeader(ntsnd_indev[nad], inwavehdr, sizeof(WAVEHDR));
mmresult = waveInAddBuffer(ntsnd_indev[nad], inwavehdr,
sizeof(WAVEHDR));
if (mmresult != MMSYSERR_NOERROR)
nt_waveinerror("waveInAddBuffer: %s\n", mmresult);
ntsnd_inphase[nad] = phase = WRAPFWD(phase + 1);
}
if (count == MAXRESYNC) post("resync error 1");
}
/* Each output buffer which is "ready" is filled with zeros and
queued. */
for (nda = 0; nda < nt_nwaveout; nda++)
{
int phase = ntsnd_outphase[nda];
for (count = 0; count < MAXRESYNC; count++)
{
WAVEHDR *outwavehdr = ntsnd_outvec[nda][phase].lpWaveHdr;
if (!(outwavehdr->dwFlags & WHDR_DONE)) break;
if (outwavehdr->dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(ntsnd_outdev[nda],
outwavehdr, sizeof(WAVEHDR));
outwavehdr->dwFlags = 0L;
memset((char *)(ntsnd_outvec[nda][phase].lpData),
0, (CHANNELS_PER_DEVICE * SAMPSIZE * nt_realdacblksize));
waveOutPrepareHeader(ntsnd_outdev[nda], outwavehdr,
sizeof(WAVEHDR));
mmresult = waveOutWrite(ntsnd_outdev[nda], outwavehdr,
sizeof(WAVEHDR));
if (mmresult != MMSYSERR_NOERROR)
nt_waveouterror("waveOutAddBuffer: %s\n", mmresult);
ntsnd_outphase[nda] = phase = WRAPFWD(phase + 1);
}
if (count == MAXRESYNC) post("resync error 2");
}
#ifdef MIDI_TIMESTAMP
nt_resetmidisync();
#endif
}
int openMicAndStartRecording(DWORD threadId)
{
int i;
WAVEFORMATEX m_WaveFormatEx = getDefaultFormat();
if( MMSYSERR_NOERROR != waveInOpen(&g_recordHandler,WAVE_MAPPER,&m_WaveFormatEx,threadId,0,CALLBACK_THREAD)){
printf("ER1!\n");
return -1;
}
for(i=0; i<MAXRECBUFFER; i++){
rechead[i]=CreateWaveHeader();
if(MMSYSERR_NOERROR != waveInPrepareHeader(g_recordHandler,rechead[i], sizeof(WAVEHDR)) ){
printf("ER2! i=%d\n", i);
return -1;
}
if(MMSYSERR_NOERROR != waveInAddBuffer(g_recordHandler, rechead[i], sizeof(WAVEHDR))){
printf("ER3!\n");
return -1;
}
if(MMSYSERR_NOERROR != waveInStart(g_recordHandler)){
printf("ER4!\n");
return -1;
}
}
printf("Start recording OK!\n");
return 0;
}
DWORD CWaveBuffer::m_dwPrepare(HWAVEIN hWaveIn)
{
m_vPrepareCommon(m_iSize);
m_hWaveIn = hWaveIn;
return waveInPrepareHeader(m_hWaveIn, &m_header, sizeof(m_header));
}
void RUIAudio::On_WIM_DATA(WAVEHDR* pWaveHdr)
{
if (m_hWaveIn != NULL && pWaveHdr != NULL && m_pRUIBufferListPCM != NULL && pWaveHdr->dwBytesRecorded > 0)
{
DWORD dwCurrTick = GetTickCount();
#ifdef _USE_AAC_CODEC
// [neuromos] !아래 코드는 TCP만 지원함
RUIBuffer* pRUIBufferPCM = m_pRUIBufferListPCM->AddBuffer((BYTE*) (pWaveHdr->lpData), pWaveHdr->dwBytesRecorded, dwCurrTick);
#else
if (m_nCodec != PCM_16)
{
DWORD dwFrameSizeEnc = EncodeVoicePCM(m_nCodec, (void*) (pWaveHdr->lpData), pWaveHdr->dwBytesRecorded, (void*) m_pFrameRecEnc, WAVE_FRAME_SIZE);
m_pRUIBufferListSend->AddUDPFrame(m_nFrameType, 0, m_dwFrameKey, dwFrameSizeEnc , dwCurrTick, (BYTE*) m_pFrameRecEnc , dwFrameSizeEnc , 0);
}
else
m_pRUIBufferListSend->AddUDPFrame(m_nFrameType, 0, m_dwFrameKey, pWaveHdr->dwBytesRecorded, dwCurrTick, (BYTE*) (pWaveHdr->lpData), pWaveHdr->dwBytesRecorded, 0);
#endif
m_dwFrameKey++;
if (waveInPrepareHeader(m_hWaveIn, pWaveHdr, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
ASSERT(FALSE);
return;
}
if( waveInAddBuffer (m_hWaveIn, pWaveHdr, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
ASSERT(FALSE);
return;
}
}
}
int main()
{
HWAVEIN inStream;
HWAVEOUT outStream;
WAVEFORMATEX waveFormat;
WAVEHDR buffer[4]; // pingpong buffers
waveFormat.wFormatTag = WAVE_FORMAT_PCM; // PCM audio
waveFormat.nSamplesPerSec = 22050; // really 22050 frames/sec
waveFormat.nChannels = 2; // stereo
waveFormat.wBitsPerSample = 16; // 16bits per sample
waveFormat.cbSize = 0; // no extra data
waveFormat.nBlockAlign =
waveFormat.nChannels * waveFormat.wBitsPerSample / 2;
waveFormat.nAvgBytesPerSec =
waveFormat.nBlockAlign * waveFormat.nSamplesPerSec;
// Event: default security descriptor, Manual Reset, initial non-signaled
HANDLE event = CreateEvent(NULL, TRUE, FALSE, "waveout event");
waveInOpen( &inStream, WAVE_MAPPER, &waveFormat, (unsigned long)event,
0, CALLBACK_EVENT);
waveOutOpen(&outStream, WAVE_MAPPER, &waveFormat, (unsigned long)event,
0, CALLBACK_EVENT);
// initialize the input and output PingPong buffers
int index;
for(index = 0; index < 4; index++) {
buffer[index].dwBufferLength = NUM_FRAMES * waveFormat.nBlockAlign;
buffer[index].lpData =
(void *)malloc(NUM_FRAMES * waveFormat.nBlockAlign);
buffer[index].dwFlags = 0;
waveInPrepareHeader( inStream, &buffer[index], sizeof(WAVEHDR));
}
ResetEvent(event);
for(index= 0; index < 4; index++) // queue all buffers for input
waveInAddBuffer(inStream, &buffer[index], sizeof(WAVEHDR));
waveInStart(inStream);
while(!( buffer[1].dwFlags & WHDR_DONE)); // poll(!) for 2 full input buffers
// move the two full buffers to output
waveOutWrite(outStream, &buffer[0], sizeof(WAVEHDR));
waveOutWrite(outStream, &buffer[1], sizeof(WAVEHDR));
int inIndex = 2, outIndex = 0; // the next input and output to watch
while(1) { // poll for completed input and output buffers
if(buffer[inIndex].dwFlags & WHDR_DONE) { // input buffer complete?
waveInAddBuffer( inStream, &buffer[inIndex], sizeof(WAVEHDR));
inIndex = (inIndex+1)%4; // next buffer to watch for full
}
if(buffer[outIndex].dwFlags & WHDR_DONE) { // output buffer complete?
waveOutWrite( outStream, &buffer[outIndex], sizeof(WAVEHDR));
outIndex = (outIndex+1)%4; // next buffer to watch for empty
}
}
}
void WaveInStart(WaveIn *waveIn, BOOL prep)
{
MMRESULT res;
res = waveInReset(waveIn->handler);
if(res) {
return;
}
// prepare header an add the buffer
waveIn->header.lpData = (char *) waveIn->data;
waveIn->header.dwBufferLength = waveIn->n * 2;
waveIn->header.dwBytesRecorded = 0;
waveIn->header.dwFlags = 0L;
waveIn->header.dwLoops = 0L;
waveIn->header.dwUser = 0L;
waveInPrepareHeader(waveIn->handler, &waveIn->header, sizeof(WAVEHDR));
res = waveInAddBuffer(waveIn->handler, &waveIn->header, sizeof(WAVEHDR));
if(res) {
return;
}
res = waveInStart(waveIn->handler);
if(res) {
return;
}
}
bool CAudio::InitializeWaveIn()
{
if (!waveInGetNumDevs())
return false;
MMRESULT mmResult;
DWORD dwThreadID = 0;
m_hThreadCallBack = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)waveInCallBack, (LPVOID)this, CREATE_SUSPENDED, &dwThreadID);
mmResult = waveInOpen(&m_hWaveIn, (WORD)WAVE_MAPPER, &(m_GSMWavefmt.wfx), (LONG)dwThreadID, (LONG)0, CALLBACK_THREAD);
if (mmResult != MMSYSERR_NOERROR)
return false;
for (int i = 0; i < 2; i++)
{
m_lpInAudioHdr[i]->lpData = (LPSTR)m_lpInAudioData[i];
m_lpInAudioHdr[i]->dwBufferLength = m_nBufferLength;
m_lpInAudioHdr[i]->dwFlags = 0;
m_lpInAudioHdr[i]->dwLoops = 0;
waveInPrepareHeader(m_hWaveIn, m_lpInAudioHdr[i], sizeof(WAVEHDR));
}
waveInAddBuffer(m_hWaveIn, m_lpInAudioHdr[m_nWaveInIndex], sizeof(WAVEHDR));
ResumeThread(m_hThreadCallBack);
waveInStart(m_hWaveIn);
m_bIsWaveInUsed = true;
return true;
}
WAVEHDR* QAudioInputPrivate::allocateBlocks(int size, int count)
{
int i;
unsigned char* buffer;
WAVEHDR* blocks;
DWORD totalBufferSize = (size + sizeof(WAVEHDR))*count;
if((buffer=(unsigned char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
totalBufferSize)) == 0) {
qWarning("QAudioInput: Memory allocation error");
return 0;
}
blocks = (WAVEHDR*)buffer;
buffer += sizeof(WAVEHDR)*count;
for(i = 0; i < count; i++) {
blocks[i].dwBufferLength = size;
blocks[i].lpData = (LPSTR)buffer;
blocks[i].dwBytesRecorded=0;
blocks[i].dwUser = 0L;
blocks[i].dwFlags = 0L;
blocks[i].dwLoops = 0L;
result = waveInPrepareHeader(hWaveIn,&blocks[i], sizeof(WAVEHDR));
if(result != MMSYSERR_NOERROR) {
qWarning("QAudioInput: Can't prepare block %d",i);
return 0;
}
buffer += size;
}
return blocks;
}
/**
* WAV録音準備
* @param filename 保存ファイル名
* @param channel チャンネル
* @param rate レート
* @param bits ビット数
* @param interval 取得タイミング
*/
void openWAV(const tjs_char *filename, int channel, int rate, int bits, int interval) {
closeWAV();
// ファイルを開く
wvout = TVPCreateIStream(filename, TJS_BS_WRITE);
// フォーマットを指定
WAVEFORMATEX waveForm;
waveForm.wFormatTag = WAVE_FORMAT_PCM;
waveForm.nChannels = channel;
waveForm.nSamplesPerSec = rate;
waveForm.wBitsPerSample = bits;
waveForm.nBlockAlign = waveForm.nChannels * waveForm.wBitsPerSample / 8;
waveForm.nAvgBytesPerSec = waveForm.nSamplesPerSec * waveForm.nBlockAlign;
// waveIn を開く
if (waveInOpen(&hwi, WAVE_MAPPER, &waveForm, (DWORD)waveInProc, (DWORD)this, CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {
TVPThrowExceptionMessage(L"waveInOpen");
}
/* キャプチャバッファ確保 */
int length = waveForm.nAvgBytesPerSec * interval / 1000;
wvhdr.lpData = new char[length];
wvhdr.dwBufferLength = length;
wvhdr.dwFlags = 0;
wvhdr.reserved = 0;
// バッファを設定
waveInPrepareHeader(hwi, &wvhdr, sizeof(wvhdr));
waveInAddBuffer(hwi, &wvhdr, sizeof(wvhdr));
}
static int add_wave_in(struct ausrc_st *st)
{
struct dspbuf *db = &st->bufs[st->pos];
WAVEHDR *wh = &db->wh;
MMRESULT res;
wh->lpData = (LPSTR)db->mb->buf;
wh->dwBufferLength = db->mb->size;
wh->dwBytesRecorded = 0;
wh->dwFlags = 0;
wh->dwUser = (DWORD_PTR)db->mb;
waveInPrepareHeader(st->wavein, wh, sizeof(*wh));
res = waveInAddBuffer(st->wavein, wh, sizeof(*wh));
if (res != MMSYSERR_NOERROR) {
warning("winwave: add_wave_in: waveInAddBuffer fail: %08x\n",
res);
return ENOMEM;
}
INC_RPOS(st->pos);
st->inuse++;
return 0;
}
//分配内存
BOOL CWaveIn::PerPareBuffer()
{
//已经分配内存
if (m_bAllocBuffer)
{
//返回
return FALSE;
}
//重置录音设备
m_mmr = waveInReset(m_hIn);
//出错
if (m_mmr)
{
//返回
return FALSE;
}
//循环变量
UINT i;
//新建WAVEHDR结构
m_pHdr = new WAVEHDR[NUM_BUF];
for (i = 0; i < NUM_BUF; i++)
{
//初始化
ZeroMemory(&m_pHdr[i], sizeof(WAVEHDR));
//波形缓存
m_pHdr[i].lpData = new char[SIZE_AUDIO_FRAME];
//缓存大小
m_pHdr[i].dwBufferLength = SIZE_AUDIO_FRAME;
m_pHdr[i].dwFlags = WHDR_BEGINLOOP | WHDR_ENDLOOP;
m_pHdr[i].dwLoops = 1;
//准备缓存
m_mmr = waveInPrepareHeader(m_hIn, &m_pHdr[i], sizeof(WAVEHDR));
//出错
if (m_mmr)
{
//返回
return FALSE;
}
//添加缓存到录音设备
m_mmr = waveInAddBuffer(m_hIn, &m_pHdr[i], sizeof(WAVEHDR));
//出错
if (m_mmr)
{
//返回
return FALSE;
}
}
//设置内存分配标记
m_bAllocBuffer = TRUE;
//返回
return TRUE;
}
/*------------------------------------------------------------------------------*/
static void WaveOutSync( void )
{
MMRESULT mmRes;
switch ( WaveOutStep ){
case -1:
dprintf( 0, 7, "WaveOut Error%d (0x%08X)", WaveOutErrorStep, (int)WaveOutErrorRes );
break;
case 0:
if ( SettingData.WAVOut != 0 ){ WaveOutStep = 1; }
break;
case 1:
mmRes = waveOutOpen( &HdWaveOut, WaveOutUse, &WaveFormat, (DWORD)WaveOutProc, 0, CALLBACK_FUNCTION );
if ( WaveOutErrorCheck( mmRes ) != FALSE ){ return; }
WaveOutStep = 2;
break;
case 2:
if ( WaveInStep != 4 ){ break; }
if ( WaveOutStatus == WAVEOUTSTATUS_OPEN ){ WaveOutStep = 3; }
break;
case 3:
if ( SettingData.WAVOut == 0 ){ WaveOutStep = 4; break; }
while ( WaveBuff[WaveOutNextNo].dwUser & 0x0001 ){
mmRes = waveInUnprepareHeader( HdWaveIn, &WaveBuff[WaveOutNextNo], sizeof(WAVEHDR) );
if ( WaveOutFlag != 0 ){
mmioWrite( hWaveRec, (char *)WaveBuff[WaveOutNextNo].lpData,
WaveBuff[WaveOutNextNo].dwBufferLength );
}
int diff = (WaveOutNextNo+WAVEBUFFNUM - WaveOutLastNo)%WAVEBUFFNUM;
if ( diff <= WAVEBUFFNUM/2 ){
mmRes = waveOutPrepareHeader( HdWaveOut, &WaveBuff[WaveOutNextNo], sizeof(WAVEHDR) );
mmRes = waveOutWrite( HdWaveOut, &WaveBuff[WaveOutNextNo], sizeof(WAVEHDR) );
WaveBuff[WaveOutNextNo].dwUser |= 0x0020;
} else {
WaveBuff[WaveOutNextNo].dwUser |= 0x0010;
}
WaveBuff[WaveOutNextNo].dwUser &= ~0x0001;
WaveOutNextNo = (WaveOutNextNo + 1 ) % WAVEBUFFNUM;
}
while ( WaveBuff[WaveOutLastNo].dwUser & 0x0010 ){
if ( WaveBuff[WaveOutNextNo].dwUser & 0x0020 ){
mmRes = waveOutUnprepareHeader( HdWaveOut, &WaveBuff[WaveOutLastNo], sizeof(WAVEHDR) );
}
mmRes = waveInPrepareHeader( HdWaveIn, &WaveBuff[WaveOutLastNo], sizeof(WAVEHDR) );
mmRes = waveInAddBuffer( HdWaveIn, &WaveBuff[WaveOutLastNo], sizeof(WAVEHDR) );
WaveBuff[WaveOutLastNo].dwUser &= ~0x0030;
WaveOutLastNo = (WaveOutLastNo + 1 ) % WAVEBUFFNUM;
}
break;
case 4:
waveOutReset( HdWaveOut );
for ( int i=0; i<WAVEBUFFNUM; i++ ){
waveOutUnprepareHeader( HdWaveOut, &WaveBuff[i], sizeof(WAVEHDR) );
}
waveOutClose( HdWaveOut );
WaveOutStep = 0;
break;
}
}
/**
* win32ai_open(int sample_rate)
* Setup audio for input at specified rate.
* returns -1 on error, 0 on happy.
*/
int win32ai_open(int sample_rate) {
WAVEFORMATEX waveFormat;
MMRESULT res;
int i;
// create an event by which audio driver will notify us
whinEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
// populate whinFormat struct
waveFormat.wFormatTag = WAVE_FORMAT_PCM;
waveFormat.nChannels = 1;
waveFormat.nSamplesPerSec = sample_rate;
waveFormat.nAvgBytesPerSec = sample_rate * SAMPLE_BITS / 8;
waveFormat.nBlockAlign = SAMPLE_BITS / 8;
waveFormat.wBitsPerSample = SAMPLE_BITS;
waveFormat.cbSize = 0;
whinBufNo = 0;
whinBufIndex = 0;
// open audio device
res = waveInOpen(&wavein, WAVE_MAPPER, &waveFormat,
(DWORD) whinEvent, (DWORD) 0, CALLBACK_EVENT);
if (checkWaveInResult(wavein, res, "waveInOpen"))
return -1;
// create buffers
for (i = 0; i < WaveBuf_N; ++i) {
// allocate buffer header
whin[i] = (WAVEHDR*) calloc(1, sizeof(WAVEHDR));
if (whin[i] == NULL) {
perror("malloc WAVEHDR");
return -1; /* need to cleanup XXX */
}
// allocate buffer
whin[i]->lpData = malloc(WaveBuf_SIZE);
if (whin[i]->lpData == NULL) {
perror("new char[WaveBuf_SIZE]");
return -1; /* need to cleanup XXX */
}
whin[i]->dwBufferLength = WaveBuf_SIZE;
// prepare buffer
res = waveInPrepareHeader(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInPrepareHeader"))
return -1;
// give buffer to driver
res = waveInAddBuffer(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInAddBuffer"))
return -1; /* need to cleanup XXX */
}
// start device, yeeeeeee haw!
res = waveInStart(wavein);
if (checkWaveInResult(wavein, res, "waveInStart"))
return -1; /* need to cleanup XXX */
return 0;
}
/*
* Class: com_ibm_media_protocol_device_DevicePushSourceStream
* Method: read
* Signature: ([BII)I
*/
JNIEXPORT jint JNICALL Java_com_ibm_media_protocol_device_DevicePushSourceStream_read
(JNIEnv* env, jobject obj, jbyteArray arr, jint offset, jint length) {
MMRESULT result;
jclass cls;
jmethodID mid;
jsize len = (*env)->GetArrayLength(env, arr);
jbyte* body = (*env)->GetByteArrayElements(env, arr, JNI_FALSE);
/* fill the buffer struct */
waveHeader.lpData = &body[offset];
waveHeader.dwBufferLength = length;
waveHeader.dwBytesRecorded = 0;
waveHeader.dwUser = NULL;
waveHeader.dwFlags = NULL;
waveHeader.dwLoops = NULL;
waveHeader.lpNext = NULL;
waveHeader.reserved = NULL;
isBufferFilled = FALSE;
/* preper the buffer */
result = waveInPrepareHeader(hwi, &waveHeader, sizeof(WAVEHDR));
/* DEBUG */
if (result != MMSYSERR_NOERROR)
printf("ERROR while adding buffer to device !\n %d\n", result);
/* end DEBUG */
result = waveInAddBuffer(hwi, &waveHeader, sizeof(WAVEHDR));
/* DEBUG */
if (result != MMSYSERR_NOERROR)
printf("ERROR while adding buffer to device !\n %d\n", result);
/* end DEBUG */
if (!isStarted)
startDevice();
/* wait until buffer was filled */
while (!isBufferFilled)
Sleep(10);
(*env)->ReleaseByteArrayElements(env, arr, body, 0);
/* notify DevicePushSourceStream it can generate another transferData call */
if (isStarted) {
cls = (*env)->GetObjectClass(env, obj);
mid = (*env)->GetMethodID(env, cls, "notify", "()V");
if (mid == 0) {
printf("Error indentifying native method\n");
return;
}
(*env)->CallVoidMethod(env, obj, mid);
}
return waveHeader.dwBytesRecorded;
}
void CAudioInput::OpenMic()
{
SetWaveHDRInit();
SetWaveInitFormat();
waveInOpen(&h_input, 0, &my_wave_format, (DWORD)waveInProc, 0, CALLBACK_FUNCTION);
waveInPrepareHeader(h_input, mp_wave_header, sizeof(WAVEHDR));
waveInAddBuffer(h_input, mp_wave_header, sizeof(WAVEHDR));
waveInStart(h_input);
}
// Define: _start(WORD, DWORD, DWORD) (real)
DWORD waveCapture::_start(const WORD uDevice, const DWORD dwBufferLength, const DWORD dwNumBuffers)
{
// only one start per session is permitted
if(_recording)
return ERR_ALREADYSTARTED;
// I need dwNumBuffers in stop() as well so I'll set __dwNumBuffers under the counter
__dwNumBuffers = dwNumBuffers;
// Define WAVEFORMATEX Structure (WAVEFORMATEX wf):
wf.wFormatTag = WAVE_FORMAT_PCM;
wf.wBitsPerSample = _wBitsPerSample;
wf.nChannels = _nChannels;
wf.nSamplesPerSec = _dwSamplePerSec;
wf.nBlockAlign = (wf.nChannels * wf.wBitsPerSample) / 8;
wf.nAvgBytesPerSec = (wf.nSamplesPerSec * wf.nBlockAlign);
wf.cbSize = 0;
// Create event:
hevent = CreateEvent(NULL,FALSE,FALSE,NULL);
if(hevent == NULL)
return ERR_EVENTNULL;
// WaveInOpen
if(waveInOpen(&hwi,uDevice,(LPWAVEFORMATEX)&wf,(DWORD)hevent,0,CALLBACK_EVENT) != MMSYSERR_NOERROR)
return ERR_WAVEINOPEN;
// Define WAVEHDR Structure:
buff = new WAVEHDR*[dwNumBuffers];
for (int i = 0; i<(int)dwNumBuffers; i++)
{
buff[i] = new WAVEHDR;
ZeroMemory(buff[i],sizeof(WAVEHDR));
buff[i]->lpData = (char*) malloc(dwBufferLength);
buff[i]->dwBufferLength = dwBufferLength;
buff[i]->dwBytesRecorded = 0;
buff[i]->dwUser = 0;
buff[i]->dwFlags = 0;
buff[i]->dwLoops = 0;
if(waveInPrepareHeader(hwi, buff[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
return ERR_WAVEINPREPAREHEADER;
if(waveInAddBuffer(hwi, buff[i], sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
return ERR_WAVEINADDBUFFER;
}
// Start capturing...
if(waveInStart(hwi) != MMSYSERR_NOERROR)
return ERR_WAVEINSTART;
_dwBufferCount = 0;
dwTotalBufferLength = 0;
_recording = true;
return ERR_NOERROR;
}
/**
* win32ai_read(buf, size)
* Read stuff and return count of what was read.
* Return -1 on error.
*/
int win32ai_read(unsigned char *buf, unsigned bufsiz) {
unsigned char *bufptr = buf;
unsigned char *bufend = buf + bufsiz;
MMRESULT res;
int i, n;
// rumage through buffers looking for data
for (i = whinBufNo; bufptr < bufend; i = (i + 1) % WaveBuf_N) {
// wait for buffer if necessary
while ((whin[i]->dwFlags & WHDR_DONE) == 0) {
// buffer not ready, wait, try again
WaitForSingleObject(whinEvent, INFINITE);
}
// unprepare buffer (no op if already unprepared)
if (whin[i]->dwUser == 0) {
whin[i]->dwUser = 1;
res = waveInUnprepareHeader(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInUnprepareHeader"))
return -1;
}
// do something with data, dwBytesRecorded
n = whin[i]->dwBytesRecorded;
if (bufptr + n > bufend)
n = bufend - bufptr;
memcpy(bufptr, whin[i]->lpData + WaveBuf_SIZE
- whin[i]->dwBytesRecorded, n);
bufptr += n;
whin[i]->dwBytesRecorded -= n;
if (whin[i]->dwBytesRecorded == 0) {
// initialization
whin[i]->dwUser = 0;
whin[i]->dwFlags = 0;
whin[i]->dwBufferLength = WaveBuf_SIZE;
// prepare buffer
res = waveInPrepareHeader(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInPrepareHeader"))
return -1;
// give buffer back to driver
res = waveInAddBuffer(wavein, whin[i], sizeof(WAVEHDR));
if (checkWaveInResult(wavein, res, "waveInAddBuffer"))
return -1;
// done with this buffer, point to the next one
whinBufNo = (whinBufNo + 1) % WaveBuf_N;
}
}
return bufptr - buf;
}
void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg, DWORD dwInstance,
DWORD dwParam1, DWORD dwParam2){
switch(uMsg){
case WIM_DATA:
pTemp->GetBufferData();
waveInUnprepareHeader(pTemp->h_input, pTemp->mp_wave_header, sizeof(WAVEHDR));
waveInPrepareHeader(pTemp->h_input, pTemp->mp_wave_header, sizeof(WAVEHDR));
waveInAddBuffer(pTemp->h_input, pTemp->mp_wave_header, sizeof(WAVEHDR));
break;
}
}
static void do_read(struct userdata *u) {
uint32_t free_frags;
pa_memchunk memchunk;
WAVEHDR *hdr;
MMRESULT res;
void *p;
if (!u->source)
return;
if (!PA_SOURCE_IS_LINKED(u->source->state))
return;
EnterCriticalSection(&u->crit);
free_frags = u->free_ifrags;
u->free_ifrags = 0;
LeaveCriticalSection(&u->crit);
if (free_frags == u->fragments)
pa_log_debug("WaveIn overflow!");
while (free_frags) {
hdr = &u->ihdrs[u->cur_ihdr];
if (hdr->dwFlags & WHDR_PREPARED)
waveInUnprepareHeader(u->hwi, hdr, sizeof(WAVEHDR));
if (hdr->dwBytesRecorded) {
memchunk.memblock = pa_memblock_new(u->core->mempool, hdr->dwBytesRecorded);
pa_assert(memchunk.memblock);
p = pa_memblock_acquire(memchunk.memblock);
memcpy((char*) p, hdr->lpData, hdr->dwBytesRecorded);
pa_memblock_release(memchunk.memblock);
memchunk.length = hdr->dwBytesRecorded;
memchunk.index = 0;
pa_source_post(u->source, &memchunk);
pa_memblock_unref(memchunk.memblock);
}
res = waveInPrepareHeader(u->hwi, hdr, sizeof(WAVEHDR));
if (res != MMSYSERR_NOERROR)
pa_log_error("Unable to prepare waveIn block: %d", res);
res = waveInAddBuffer(u->hwi, hdr, sizeof(WAVEHDR));
if (res != MMSYSERR_NOERROR)
pa_log_error("Unable to add waveIn block: %d", res);
free_frags--;
u->cur_ihdr++;
u->cur_ihdr %= u->fragments;
}
}
void CALLBACK WWaveIn::_WaveInProc(HWAVEIN hwi, UINT uMsg, DWORD dwInstance,DWORD dwParam1, DWORD dwParam2)
{
WWaveIn *instance = (WWaveIn*) dwInstance;
switch(uMsg)
{
case MM_WIM_OPEN:
break;
case MM_WIM_CLOSE:
break;
case MM_WIM_DATA:
{
if(instance->c_fWorking == 0)
break;
// add data to queue
WAVEHDR* header = (WAVEHDR *) dwParam1;
unsigned int nHaveRecorded = header->dwBytesRecorded;
EnterCriticalSection(&instance->cs);
// add new data to buffer
if(nHaveRecorded)
instance->c_Queue.PushLast(header->lpData, nHaveRecorded);
unsigned int nHaveInQueue = instance->c_Queue.GetSizeSum();
if(nHaveInQueue > instance->c_nMaxQueueSizeInBytes)
{
// need to cut
instance->c_Queue.CutDataFifo(nHaveInQueue - instance->c_nMaxQueueSizeInBytes);
}
LeaveCriticalSection(&instance->cs);
waveInUnprepareHeader(hwi, header, sizeof(WAVEHDR));
header->dwFlags = 0;
waveInPrepareHeader(hwi, header, sizeof(WAVEHDR));
waveInAddBuffer(hwi, header, sizeof(WAVEHDR));
}
break;
}
}
/**
* Add input buffer to WAV recorder
* Input buffer will be used for WAV recording
*/
static javacall_result add_input_buffer(recorder_handle* hRecord,
WAVEFORMATEX* pFormat)
{
#define BUFFER_SIZE (2048)
char* pBuffer = NULL;
long bufSize = 0;
MMRESULT mmReturn = 0;
/* if there is no header, create it */
if (NULL == hRecord->pHdr) {
hRecord->pHdr = (LPWAVEHDR)LocalAlloc(LPTR, sizeof(WAVEHDR));
if (NULL == hRecord->pHdr) return JAVACALL_FAIL;
}
/* if there is no buffer, create it */
if (NULL == hRecord->pHdr->lpData) {
bufSize = pFormat->nBlockAlign * BUFFER_SIZE;
hRecord->pHdr->lpData = (char*)LocalAlloc(LPTR, bufSize);
if (NULL == hRecord->pHdr->lpData) {
LocalFree((HLOCAL)hRecord->pHdr);
return JAVACALL_FAIL;
}
}
/* Initialize buffer length */
hRecord->pHdr->dwBufferLength = bufSize;
/* prepare it */
mmReturn = waveInPrepareHeader(hRecord->hWAVEIN, hRecord->pHdr, sizeof(WAVEHDR));
if (MMSYSERR_NOERROR != mmReturn) {
LocalFree((HLOCAL)hRecord->pHdr->lpData);
hRecord->pHdr->lpData = NULL;
LocalFree((HLOCAL)hRecord->pHdr);
hRecord->pHdr = NULL;
return JAVACALL_FAIL;
}
/* add the input buffer to the queue */
mmReturn = waveInAddBuffer(hRecord->hWAVEIN, hRecord->pHdr, sizeof(WAVEHDR));
if (MMSYSERR_NOERROR != mmReturn) {
waveInUnprepareHeader(hRecord->hWAVEIN, hRecord->pHdr, sizeof(WAVEHDR));
LocalFree((HLOCAL)hRecord->pHdr->lpData);
hRecord->pHdr->lpData = NULL;
LocalFree((HLOCAL)hRecord->pHdr);
hRecord->pHdr = NULL;
return JAVACALL_FAIL;
}
return JAVACALL_OK;
}
/**
* Wave In Callback
* Call back by Windows
*/
static void CALLBACK waveInProc(HWAVEIN hwi, UINT uMsg,
DWORD dwInstance, DWORD dwParam1, DWORD dwParam2)
{
MMRESULT mmReturn = 0;
recorder_handle* hRecord = (recorder_handle*)dwInstance;
DWORD recorded;
if ((NULL == hRecord) || (NULL == hRecord->pHdr))
return;
JAVA_DEBUG_PRINT1("[record] waveInProc %d\n", hRecord->isRecording);
if (uMsg != WIM_DATA)
return;
if (hRecord->hWAVEIN && hRecord->pHdr) {
mmReturn =
waveInUnprepareHeader(hRecord->hWAVEIN, hRecord->pHdr, sizeof(WAVEHDR));
if (MMSYSERR_NOERROR != mmReturn)
return;
}
if (hRecord->isRecording) {
/* Write to file */
recorded = hRecord->pHdr->dwBytesRecorded;
if (recorded) {
write_wav_file(hRecord, hRecord->pHdr->lpData, recorded);
}
/* Reuse input buffer */
mmReturn =
waveInPrepareHeader(hRecord->hWAVEIN, hRecord->pHdr, sizeof(WAVEHDR));
if (MMSYSERR_NOERROR == mmReturn) {
mmReturn =
waveInAddBuffer(hRecord->hWAVEIN, hRecord->pHdr, sizeof(WAVEHDR));
}
if (MMSYSERR_NOERROR != mmReturn) {
JAVA_DEBUG_PRINT("[record] Can't reuse input buffer\n");
}
return;
}
LocalFree(hRecord->pHdr->lpData);
hRecord->pHdr->lpData = NULL;
LocalFree(hRecord->pHdr);
hRecord->pHdr = NULL;
}
static int32 wavein_enqueue_buf (HWAVEIN h, LPWAVEHDR whdr)
{
int32 st;
if ((st = waveInPrepareHeader (h, whdr, sizeof(WAVEHDR))) != 0) {
wavein_error("waveInPrepareHeader", st);
return -1;
}
if ((st = waveInAddBuffer (h, whdr, sizeof(WAVEHDR))) != 0) {
wavein_error("waveInAddBuffer", st);
return -1;
}
return 0;
}
BOOL Mic_Init_Physical()
{
if (Mic_Inited)
return TRUE;
Mic_Inited = FALSE;
HRESULT hr;
WAVEFORMATEX wfx;
memset(Mic_TempBuf, 0x80, MIC_BUFSIZE);
memset(Mic_Buffer[0], 0x80, MIC_BUFSIZE);
memset(Mic_Buffer[1], 0x80, MIC_BUFSIZE);
Mic_BufPos = 0;
Mic_WriteBuf = 0;
Mic_PlayBuf = 1;
memset(&wfx, 0, sizeof(wfx));
wfx.cbSize = 0;
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 1;
wfx.nSamplesPerSec = 16000;
wfx.nBlockAlign = 1;
wfx.nAvgBytesPerSec = 16000;
wfx.wBitsPerSample = 8;
hr = waveInOpen(&waveIn, WAVE_MAPPER, &wfx, (DWORD_PTR)waveInProc, 0, CALLBACK_FUNCTION);
MIC_CHECKERR(hr)
memset(&waveHdr, 0, sizeof(waveHdr));
waveHdr.lpData = (LPSTR)Mic_TempBuf;
waveHdr.dwBufferLength = MIC_BUFSIZE;
hr = waveInPrepareHeader(waveIn, &waveHdr, sizeof(WAVEHDR));
MIC_CHECKERR(hr)
hr = waveInAddBuffer(waveIn, &waveHdr, sizeof(WAVEHDR));
MIC_CHECKERR(hr)
hr = waveInStart(waveIn);
MIC_CHECKERR(hr)
Mic_Inited = TRUE;
INFO("win32 microphone init OK\n");
return TRUE;
}
LRESULT CChatDlg::onWaveInData(WPARAM wParam, LPARAM lParam)
{
HWAVEIN hwi = (HWAVEIN) wParam;
LPWAVEHDR pwh = (LPWAVEHDR) lParam;
waveInUnprepareHeader(hwi, pwh, sizeof(WAVEHDR));
short val = *(short *) pwh->lpData;
m_sendVol.SetPos(abs(val));
session->sendSpeechData(pwh->lpData, pwh->dwBytesRecorded);
waveInPrepareHeader(hwi, pwh, sizeof(WAVEHDR));
waveInAddBuffer(hwi, pwh, sizeof(WAVEHDR));
return 0;
}
BOOL WaveIn::addBuffer(DWORD size)
{
WAVEHDR *pwh = new WAVEHDR;
pwh->dwFlags = 0;
pwh->dwBufferLength = size;
pwh->lpData = new char[size];
waveHeaders.AddTail(pwh);
if (waveInPrepareHeader(hWaveIn, pwh, sizeof(WAVEHDR)) ||
waveInAddBuffer(hWaveIn, pwh, sizeof(WAVEHDR))) {
close();
return FALSE;
}
return TRUE;
}
