/**
* \brief - open system default WAVE device
* \param s - sydney audio stream handle
* \return - completion status
*/
int openAudio(sa_stream_t *s) {
int status;
WAVEFORMATEX wfx;
UINT supported = FALSE;
status = allocateBlocks(s->blockSize, BLOCK_COUNT, &(s->waveBlocks));
HANDLE_WAVE_ERROR(status, "allocating audio buffer blocks");
s->waveFreeBlockCount = BLOCK_COUNT;
s->waveCurrentBlock = 0;
wfx.nSamplesPerSec = (DWORD)s->rate; /* sample rate */
wfx.wBitsPerSample = 16; /* sample size */
wfx.nChannels = s->channels; /* channels */
wfx.cbSize = 0; /* size of _extra_ info */
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nBlockAlign = (wfx.wBitsPerSample * wfx.nChannels) >> 3;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
supported = waveOutOpen(NULL, WAVE_MAPPER, &wfx, (DWORD_PTR)0, (DWORD_PTR)0,
WAVE_FORMAT_QUERY);
if (supported == MMSYSERR_NOERROR) { // audio device opened sucessfully
status = waveOutOpen((LPHWAVEOUT)&(s->hWaveOut), WAVE_MAPPER, &wfx,
(DWORD_PTR)waveOutProc, (DWORD_PTR)s, CALLBACK_FUNCTION);
if (status != MMSYSERR_NOERROR) {
freeBlocks(s->waveBlocks);
s->waveBlocks = NULL;
HANDLE_WAVE_ERROR(status, "opening audio device for playback");
}
}
else if (supported == WAVERR_BADFORMAT) {
printf("Requested format not supported.\n");
// clean up the memory
freeBlocks(s->waveBlocks);
s->waveBlocks = NULL;
return SA_ERROR_NOT_SUPPORTED;
}
else {
printf("Error opening default audio device.\n");
// clean up the memory
freeBlocks(s->waveBlocks);
s->waveBlocks = NULL;
return SA_ERROR_SYSTEM;
}
// create notification for data written to a device
s->callbackEvent = CreateEvent(0, FALSE, FALSE, 0);
// initialise critical section for operations on waveFreeBlockCound variable
InitializeCriticalSection(&(s->waveCriticalSection));
return SA_SUCCESS;
}
/*-----------------------------------------------------------------------------
-- FUNCTION: allocateBlocks
--
-- DATE: 2009-04-06
--
-- REVISIONS:
--
-- DESIGNER(S): David Overton
-- PROGRAMMER(S): David Overton, Steffen L. Norgren
--
-- INTERFACE: allocateBlocks(int size, int count)
-- int size: The size of each block
-- int count: The amount of blocks
--
-- RETURNS: WAVEHDR *: Pointer to the allocated blocks.
--
-- NOTES: Allocates a buffer to receive data in.
-----------------------------------------------------------------------------*/
WAVEHDR* allocateBlocks(int size, int count)
{
unsigned char* buffer;
int i;
WAVEHDR* blocks;
DWORD totalBufferSize = (size + sizeof(WAVEHDR)) * count;
/* Free any current memory blocks */
freeBlocks(waveBlocks);
/* allocate memory for the entire set in one go */
if((buffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, totalBufferSize)) == NULL)
{
MessageBox(ghWndMain, (LPCSTR)"Memory allocation error.",
(LPCSTR)"Error!", MB_OK | MB_ICONSTOP);
ExitProcess(1);
}
/* and set up the pointers to each bit */
blocks = (WAVEHDR*)buffer;
buffer += sizeof(WAVEHDR) * count;
for(i = 0; i < count; i++)
{
blocks[i].dwBufferLength = size;
blocks[i].lpData = buffer;
buffer += size;
}
return blocks;
}
bool CWavePlay::CloseDevice()
{
ZeroMemory(&m_wavformex,sizeof(WAVEFORMATEX));
while(_nWaveFreeBlockCount != 0 && _nWaveFreeBlockCount < BLOCK_COUNT)
Sleep(10);
/*
* unprepare any blocks that are still prepared
*/
for(int i = 0; i < _nWaveFreeBlockCount; i++)
{
if(_waveBlocks && _waveBlocks[i].dwFlags & WHDR_PREPARED)
{
waveOutUnprepareHeader(m_hWaveOut, &_waveBlocks[i], sizeof(WAVEHDR));
}
}
if(_waveBlocks)
{
freeBlocks(_waveBlocks);
_waveBlocks = NULL;
}
waveOutClose(m_hWaveOut);
m_bPalyState = false;
return true;
}
//------------------------------------------------------------------------------
void freeCode(int handle)
{
codeHandleType *h = (codeHandleType *)handle;
if (h != NULL)
{
g_evallib_stats[0]-=h->code_stats[0];
g_evallib_stats[1]-=h->code_stats[1];
g_evallib_stats[2]-=h->code_stats[2];
g_evallib_stats[3]-=h->code_stats[3];
g_evallib_stats[4]--;
freeBlocks(h->blocks);
}
}
WavePlayer::~WavePlayer(void)
{
UnInit();
// 释放播放缓存
freeBlocks(m_wBlock.pWaveHdr);
memset(&m_wBlock, 0, sizeof(WaveBlock));
if (m_hEventDecode)
{
CloseHandle(m_hEventDecode);
m_hEventDecode = NULL;
}
// 销毁临界区
DeleteCriticalSection(&m_cs);
}
void QAudioOutputPrivate::close()
{
if(deviceState == QAudio::StoppedState)
return;
deviceState = QAudio::StoppedState;
errorState = QAudio::NoError;
int delay = (buffer_size-bytesFree())*1000/(settings.frequency()
*settings.channels()*(settings.sampleSize()/8));
waveOutReset(hWaveOut);
Sleep(delay+10);
freeBlocks(waveBlocks);
waveOutClose(hWaveOut);
delete [] audioBuffer;
audioBuffer = 0;
buffer_size = 0;
}
void MarkedSpace::shrink()
{
// We record a temporary list of empties to avoid modifying m_blocks while iterating it.
DoublyLinkedList<MarkedBlock> empties;
BlockIterator end = m_blocks.end();
for (BlockIterator it = m_blocks.begin(); it != end; ++it) {
MarkedBlock* block = *it;
if (block->isEmpty()) {
SizeClass& sizeClass = sizeClassFor(block->cellSize());
sizeClass.blockList.remove(block);
sizeClass.nextBlock = sizeClass.blockList.head();
empties.append(block);
}
}
freeBlocks(empties);
ASSERT(empties.isEmpty());
}
/**
* \brief - closes opened audio device handle
* \param s - sydney audio stream handle
* \return - completion status
*/
int closeAudio(sa_stream_t * s) {
int status, i, result;
result = SA_SUCCESS;
// reseting audio device and flushing buffers
status = waveOutReset(s->hWaveOut);
if (status != MMSYSERR_NOERROR) {
result = getSAErrorCode(status);
}
if (s->waveBlocks) {
/* wait for all blocks to complete */
while(s->waveFreeBlockCount < BLOCK_COUNT) {
Sleep(10);
}
/* unprepare any blocks that are still prepared */
for(i = 0; i < s->waveFreeBlockCount; i++) {
if(s->waveBlocks[i].dwFlags & WHDR_PREPARED) {
status = waveOutUnprepareHeader(s->hWaveOut, &(s->waveBlocks[i]), sizeof(WAVEHDR));
if (status != MMSYSERR_NOERROR) {
result = getSAErrorCode(status);
}
}
}
freeBlocks(s->waveBlocks);
s->waveBlocks = NULL;
}
status = waveOutClose(s->hWaveOut);
if (status != MMSYSERR_NOERROR) {
result = getSAErrorCode(status);
}
s->playing = 0;
DeleteCriticalSection(&(s->waveCriticalSection));
CloseHandle(s->callbackEvent);
return result;
}
void QAudioInputPrivate::close()
{
if(deviceState == QAudio::StoppedState)
return;
deviceState = QAudio::StoppedState;
waveInReset(hWaveIn);
waveInClose(hWaveIn);
int count = 0;
while(!finished && count < 500) {
count++;
Sleep(10);
}
mutex.lock();
for(int i=0; i<waveFreeBlockCount; i++)
waveInUnprepareHeader(hWaveIn,&waveBlocks[i],sizeof(WAVEHDR));
freeBlocks(waveBlocks);
mutex.unlock();
}
void HeapPage::defragment() {
if (releasedBlocks.size() == 0) return;
// Go trough the heap starting from the beginning and
// look for released blocks.
std::list<HeapBlock> newReleasedBlocks;
std::list<HeapBlock> newBlocks;
// Join released blocks together that are aligned next
// to each other.
joinBlocks(newReleasedBlocks, newBlocks);
// See if we can join some blocks to the main memory region
// where the page pointer is pointing to.
freeBlocks(newBlocks, newReleasedBlocks);
// Generate new released priority queue.
generateNewReleasedQueue(newReleasedBlocks);
fragmentation = 0.0f;
missedBytes = 0;
}
void QAudioInputPrivate::close()
{
if(deviceState == QAudio::StoppedState)
return;
deviceState = QAudio::StoppedState;
waveInReset(hWaveIn);
waveInClose(hWaveIn);
int count = 0;
while(!finished && count < 500) {
count++;
Sleep(10);
}
EnterCriticalSection(&waveInCriticalSection);
for(int i=0; i<waveFreeBlockCount; i++) {
if(waveBlocks[i].dwFlags & WHDR_PREPARED)
waveInUnprepareHeader(hWaveIn,&waveBlocks[i],sizeof(WAVEHDR));
}
LeaveCriticalSection(&waveInCriticalSection);
freeBlocks(waveBlocks);
}
void MarkedSpace::shrink()
{
// We record a temporary list of empties to avoid modifying m_blocks while iterating it.
TakeIfUnmarked takeIfUnmarked(this);
freeBlocks(forEachBlock(takeIfUnmarked));
}
void UDPread(UDPinfo *UI, int filesize)
{
WSABUF UDPread;
int bytesRecv = 0;
DWORD flags = 0;
int err;
WAVEHDR* waveBlocks;
FILE *fp;
WAVEFORMATEX wfx;
wavheader WH;
HWAVEOUT hWaveOut;
char data[BUFSIZE];
int i = 0;
UDPread.buf = (char *) malloc (BUFSIZE);
UDPread.len = BUFSIZE;
waveBlocks = allocateBlocks(BLOCK_SIZE, BLOCK_COUNT);
waveFreeBlockCount = BLOCK_COUNT;
waveCurrentBlock = 0;
InitializeCriticalSection(&waveCriticalSection);
fp = wavOpen(&WH);
wfx.nSamplesPerSec = WH.sampleRate;
wfx.wBitsPerSample = 16;
wfx.nChannels = 2;
wfx.cbSize = 0;
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nBlockAlign = (wfx.wBitsPerSample * wfx.nChannels) >> 3;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
if((err = waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx,(DWORD_PTR)waveOutProc, (DWORD_PTR)&waveFreeBlockCount, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
{
fprintf(stdout, "unable to open wave mapper device");
fprintf(stdout, "%d", err);
ExitProcess(1);
}
while(bytesRecv < filesize)
{
if(recvfrom(UI->sd, UDPread.buf, BUFSIZE, flags,NULL,NULL) == SOCKET_ERROR)
{
err = WSAGetLastError();
if(err != ERROR_IO_PENDING)
{
// error during read
}
}
memcpy(data,UDPread.buf, BUFSIZE);
writeAudio(hWaveOut, data, BUFSIZE, waveBlocks, waveCriticalSection);
bytesRecv += BUFSIZE;
}
/*
* unprepare any blocks that are still prepared
*/
for(i = 0; i < waveFreeBlockCount; i++)
{
if(waveBlocks[i].dwFlags & WHDR_PREPARED)
{
waveOutUnprepareHeader(hWaveOut, &waveBlocks[i], sizeof(WAVEHDR));
}
}
DeleteCriticalSection(&waveCriticalSection);
freeBlocks(waveBlocks);
waveOutClose(hWaveOut);
}
void Heap::shrink()
{
// We record a temporary list of empties to avoid modifying m_blocks while iterating it.
TakeIfEmpty takeIfEmpty(&m_newSpace);
freeBlocks(forEachBlock(takeIfEmpty));
}
//------------------------------------------------------------------------------
int compileCode(char *_expression)
{
char *expression,*expression_start;
int computable_size=0;
codeHandleType *handle;
startPtr *scode=NULL;
startPtr *startpts=NULL;
if (!_expression || !*_expression) return 0;
if (!varTable) return 0;
#ifdef NSEEL_USE_CRITICAL_SECTION
EnterCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
#endif
blocks_head=0;
tmpblocks_head=0;
memset(l_stats,0,sizeof(l_stats));
handle = (codeHandleType*)newBlock(sizeof(codeHandleType));
if (!handle)
{
#ifdef NSEEL_USE_CRITICAL_SECTION
LeaveCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
#endif
return 0;
}
memset(handle,0,sizeof(codeHandleType));
expression_start=expression=preprocessCode(_expression);
while (*expression)
{
startPtr *tmp;
char *expr;
colCount=0;
// single out segment
while (*expression == ';' || *expression == ' ') expression++;
if (!*expression) break;
expr=expression;
while (*expression && *expression != ';') expression++;
if (*expression) *expression++ = 0;
// parse
tmp=(startPtr*) newTmpBlock(sizeof(startPtr));
if (!tmp) break;
g_evallib_computTableTop=0;
tmp->startptr=compileExpression(expr);
if (computable_size < g_evallib_computTableTop)
{
computable_size=g_evallib_computTableTop;
}
if (g_evallib_computTableTop > NSEEL_MAX_TEMPSPACE_ENTRIES-32)
{
tmp->startptr=0; // overflow in this mode
}
if (!tmp->startptr)
{
if (g_log_errors)
{
int l=strlen(expr);
if (l > 512) l=512;
movestringover(last_error_string,l+2);
memcpy(last_error_string,expr,l);
last_error_string[l]='\r';
last_error_string[l+1]='\n';
}
scode=NULL;
break;
}
tmp->next=NULL;
if (!scode) scode=startpts=tmp;
else
{
scode->next=tmp;
scode=tmp;
}
}
// check to see if failed on the first startingCode
if (!scode)
{
freeBlocks(blocks_head); // free blocks
handle=NULL; // return NULL (after resetting blocks_head)
}
else
{
// now we build one big code segment out of our list of them, inserting a mov esi, computable before each item
unsigned char *writeptr;
int size=1; // for ret at end :)
startPtr *p;
p=startpts;
while (p)
{
size+=2; // mov esi, edi
size+=*(int *)p->startptr;
p=p->next;
}
handle->code = newBlock(size);
if (handle->code)
{
writeptr=(unsigned char *)handle->code;
p=startpts;
while (p)
{
int thissize=*(int *)p->startptr;
*(unsigned short *)writeptr= X86_MOV_ESI_EDI;
writeptr+=2;
memcpy(writeptr,(char*)p->startptr + 4,thissize);
writeptr += thissize;
p=p->next;
}
*writeptr=X86_RET; // ret
l_stats[1]=size;
}
handle->blocks = blocks_head;
handle->workTablePtr_size=(computable_size+4) * sizeof(double);
}
freeBlocks(tmpblocks_head); // free blocks
tmpblocks_head=0;
blocks_head=0;
if (handle)
{
memcpy(handle->code_stats,l_stats,sizeof(l_stats));
g_evallib_stats[0]+=l_stats[0];
g_evallib_stats[1]+=l_stats[1];
g_evallib_stats[2]+=l_stats[2];
g_evallib_stats[3]+=l_stats[3];
g_evallib_stats[4]++;
}
memset(l_stats,0,sizeof(l_stats));
#ifdef NSEEL_USE_CRITICAL_SECTION
LeaveCriticalSection(& NSEEL_USE_CRITICAL_SECTION);
#endif
free(expression_start);
return (int)handle;
}
void unprepareMicPlay()
{
DeleteCriticalSection(&waveCriticalSection);
freeBlocks(waveBlocks);
waveOutClose(hWaveOut);
}
DataChunker::~DataChunker()
{
freeBlocks();
}
/*-----------------------------------------------------------------------------
-- FUNCTION: receiveStream
--
-- DATE: 2009-04-06
--
-- REVISIONS: 2009-04-06 - Jaymz, Took out the TCP connection stuff since
-- we already have that at this point. Also added
-- a parameter WPARAM sd, which is the socket
-- from which we are receiving the data.
-- - Jaymz, Miscellaneous code touch-ups (mainly
-- formatting and removing of test printf()'s)
--
-- DESIGNER(S): David Overton
-- PROGRAMMER(S): David Overton, Jaymz Boilard, Steffen L. Norgren
--
-- INTERFACE: receiveStream(LPVOID iValue)
--
-- RETURNS: void
--
-- NOTES: The main function to receive a UDP stream of data and process
-- that information.
-----------------------------------------------------------------------------*/
DWORD WINAPI receiveStream(LPVOID iValue)
{
WAVEFORMATEX wfx;
char buffer[BLOCK_SIZE]; /* intermediate buffer for reading */
int i, n, remote_len;
DWORD outBytes = 0;
char * play_byte = "1";
BOOL firstRun = TRUE;
remote_len = sizeof(udp_remote);
/* initialise the module variables */
waveBlocks = allocateBlocks(BLOCK_SIZE, BLOCK_COUNT);
waveFreeBlockCount = BLOCK_COUNT;
waveCurrentBlock = 0;
InitializeCriticalSection(&waveCriticalSection);
/* playback loop - read from socket */
while (TRUE)
{
if (ci.request != MULTI_STREAM) {
/* send play signal */
sendto(ci.udpSocket, play_byte, sizeof(play_byte), 0, (struct sockaddr *)&udp_remote, remote_len);
}
if ((n = recvfrom(ci.udpSocket, buffer, sizeof(buffer), 0, (struct sockaddr *)&udp_remote, &remote_len)) <= 0)
{
waveOutClose(hWaveOut);
ExitThread(0);
}
/* first 4 bytes in a file, so set the header information */
if(strncmp(buffer, "RIFF", 4) == 0)
{
memcpy(&wfx, buffer+20, sizeof(wfx));
if (ci.request != MULTI_STREAM || firstRun == TRUE) {
waveOutClose(hWaveOut);
if(waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, (DWORD_PTR)waveOutProc,
(DWORD_PTR)&waveFreeBlockCount, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
{
MessageBox(NULL, "Unable to open mapper device.", "Error", MB_OK);
ExitProcess(1);
}
firstRun = FALSE;
}
}
if(n == 0)
break;
else if(n < sizeof(buffer) && n != WAVE_HEAD_SIZE)
{
memset(buffer + n, 0, sizeof(buffer) - n);
writeAudio(buffer, n);
break;
}
writeAudio(buffer, n);
}
/* wait for all blocks to complete */
while(waveFreeBlockCount < BLOCK_COUNT)
Sleep(10);
/* unprepare any blocks that are still prepared */
for(i = 0; i < waveFreeBlockCount; i++)
{
if(waveBlocks[i].dwFlags & WHDR_PREPARED)
waveOutUnprepareHeader(hWaveOut, &waveBlocks[i], sizeof(WAVEHDR));
}
DeleteCriticalSection(&waveCriticalSection);
freeBlocks(waveBlocks);
waveOutClose(hWaveOut);
streamInProgress = FALSE;
ExitThread(0);
}
