/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

/* Allow access to a raw mixing buffer */

#include "SDL_stdlib.h"

#include "SDL_string.h"

#include "SDL_types.h"

#include "SDL_error.h"

#include "SDL_timer.h"

#include "SDL_audio.h"

#include "SDL_audio_c.h"

#include "SDL_dart.h"

// Buffer states:

#define BUFFER_EMPTY 0

#define BUFFER_USED 1

typedef struct _tMixBufferDesc {

int iBufferUsage; // BUFFER_EMPTY or BUFFER_USED

SDL_AudioDevice *pSDLAudioDevice;

} tMixBufferDesc, *pMixBufferDesc;

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

// DARTEventFunc

//

// This function is called by DART, when an event occures, like end of

// playback of a buffer, etc...

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

LONG APIENTRY DARTEventFunc(ULONG ulStatus,

PMCI_MIX_BUFFER pBuffer,

ULONG ulFlags)

{

if (ulFlags && MIX_WRITE_COMPLETE)

{ // Playback of buffer completed!

// Get pointer to buffer description

pMixBufferDesc pBufDesc;

if (pBuffer)

{

pBufDesc = (pMixBufferDesc) (*pBuffer).ulUserParm;

if (pBufDesc)

{

SDL_AudioDevice *pSDLAudioDevice = pBufDesc->pSDLAudioDevice;

// Set the buffer to be empty

pBufDesc->iBufferUsage = BUFFER_EMPTY;

// And notify DART feeder thread that it will have to work a bit.

if (pSDLAudioDevice)

DosPostEventSem(pSDLAudioDevice->hidden->hevAudioBufferPlayed);

}

}

}

return TRUE;

}

int DART_OpenAudio(_THIS, SDL_AudioSpec *spec)

{

MCI_AMP_OPEN_PARMS AmpOpenParms;

MCI_GENERIC_PARMS GenericParms;

int iDeviceOrd = 0; // Default device to be used

int bOpenShared = 1; // Try opening it shared

int iBits = 16; // Default is 16 bits signed

int iFreq = 44100; // Default is 44KHz

int iChannels = 2; // Default is 2 channels (Stereo)

int iNumBufs = 2; // Number of audio buffers: 2

int iBufSize;

int iOpenMode;

int iSilence;

int rc;

// First thing is to try to open a given DART device!

// pszDeviceType should contain the device type in low word, and device ordinal in high word!

AmpOpenParms.pszDeviceType = (PSZ) (MCI_DEVTYPE_AUDIO_AMPMIX | (iDeviceOrd << 16));

iOpenMode = MCI_WAIT | MCI_OPEN_TYPE_ID;

if (bOpenShared) iOpenMode |= MCI_OPEN_SHAREABLE;

rc = mciSendCommand( 0, MCI_OPEN,

iOpenMode,

(PVOID) &AmpOpenParms, 0);

if (rc!=MCIERR_SUCCESS) // No audio available??

return (-1);

// Save the device ID we got from DART!

// We will use this in the next calls!

iDeviceOrd = AmpOpenParms.usDeviceID;

// Determine the audio parameters from the AudioSpec

switch ( spec->format & 0xFF )

{

case 8:

/* Unsigned 8 bit audio data */

spec->format = AUDIO_U8;

iSilence = 0x80;

iBits = 8;

break;

case 16:

/* Signed 16 bit audio data */

spec->format = AUDIO_S16;

iSilence = 0x00;

iBits = 16;

break;

default:

// Close DART, and exit with error code!

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("Unsupported audio format");

return(-1);

}

iFreq = spec->freq;

iChannels = spec->channels;

/* Update the fragment size as size in bytes */

SDL_CalculateAudioSpec(spec);

iBufSize = spec->size;

// Now query this device if it supports the given freq/bits/channels!

_this->hidden->MixSetupParms.ulBitsPerSample = iBits;

_this->hidden->MixSetupParms.ulFormatTag = MCI_WAVE_FORMAT_PCM;

_this->hidden->MixSetupParms.ulSamplesPerSec = iFreq;

_this->hidden->MixSetupParms.ulChannels = iChannels;

_this->hidden->MixSetupParms.ulFormatMode = MCI_PLAY;

_this->hidden->MixSetupParms.ulDeviceType = MCI_DEVTYPE_WAVEFORM_AUDIO;

_this->hidden->MixSetupParms.pmixEvent = DARTEventFunc;

rc = mciSendCommand (iDeviceOrd, MCI_MIXSETUP,

MCI_WAIT | MCI_MIXSETUP_QUERYMODE,

&(_this->hidden->MixSetupParms), 0);

if (rc!=MCIERR_SUCCESS)

{ // The device cannot handle this format!

// Close DART, and exit with error code!

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("Audio device doesn't support requested audio format");

return(-1);

}

// The device can handle this format, so initialize!

rc = mciSendCommand(iDeviceOrd, MCI_MIXSETUP,

MCI_WAIT | MCI_MIXSETUP_INIT,

&(_this->hidden->MixSetupParms), 0);

if (rc!=MCIERR_SUCCESS)

{ // The device could not be opened!

// Close DART, and exit with error code!

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("Audio device could not be set up");

return(-1);

}

// Ok, the device is initialized.

// Now we should allocate buffers. For this, we need a place where

// the buffer descriptors will be:

if (!(_this->hidden->pMixBuffers))

{ // Not enough memory!

// Close DART, and exit with error code!

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("Not enough memory for audio buffer descriptors");

return(-1);

}

// Now that we have the place for buffer list, we can ask DART for the

// buffers!

_this->hidden->BufferParms.ulNumBuffers = iNumBufs; // Number of buffers

_this->hidden->BufferParms.ulBufferSize = iBufSize; // each with this size

_this->hidden->BufferParms.pBufList = _this->hidden->pMixBuffers; // getting descriptorts into this list

// Allocate buffers!

rc = mciSendCommand(iDeviceOrd, MCI_BUFFER,

MCI_WAIT | MCI_ALLOCATE_MEMORY,

&(_this->hidden->BufferParms), 0);

if ((rc!=MCIERR_SUCCESS) || (iNumBufs != _this->hidden->BufferParms.ulNumBuffers) || (_this->hidden->BufferParms.ulBufferSize==0))

{ // Could not allocate memory!

// Close DART, and exit with error code!

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("DART could not allocate buffers");

return(-1);

}

// Ok, we have all the buffers allocated, let's mark them!

{

int i;

for (i=0; i<iNumBufs; i++)

{

// Check if this buffer was really allocated by DART

if ((!(_this->hidden->pMixBuffers[i].pBuffer)) || (!pBufferDesc))

{ // Wrong buffer!

// Close DART, and exit with error code!

// Free buffer descriptions

{ int j;

}

// and cleanup

mciSendCommand(iDeviceOrd, MCI_BUFFER, MCI_WAIT | MCI_DEALLOCATE_MEMORY, &(_this->hidden->BufferParms), 0);

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("Error at internal buffer check");

return(-1);

}

pBufferDesc->iBufferUsage = BUFFER_EMPTY;

pBufferDesc->pSDLAudioDevice = _this;

_this->hidden->pMixBuffers[i].ulBufferLength = _this->hidden->BufferParms.ulBufferSize;

_this->hidden->pMixBuffers[i].ulUserParm = (ULONG) pBufferDesc; // User parameter: Description of buffer

_this->hidden->pMixBuffers[i].ulFlags = 0; // Some stuff should be flagged here for DART, like end of

// audio data, but as we will continously send

// audio data, there will be no end.:)

}

}

_this->hidden->iNextFreeBuffer = 0;

_this->hidden->iLastPlayedBuf = -1;

// Create event semaphore

if (DosCreateEventSem(NULL, &(_this->hidden->hevAudioBufferPlayed), 0, FALSE)!=NO_ERROR)

{

// Could not create event semaphore!

{

int i;

}

mciSendCommand(iDeviceOrd, MCI_BUFFER, MCI_WAIT | MCI_DEALLOCATE_MEMORY, &(_this->hidden->BufferParms), 0);

mciSendCommand(iDeviceOrd, MCI_CLOSE, MCI_WAIT, &GenericParms, 0);

SDL_SetError("Could not create event semaphore");

return(-1);

}

// Store the new settings in global variables

_this->hidden->iCurrDeviceOrd = iDeviceOrd;

_this->hidden->iCurrFreq = iFreq;

_this->hidden->iCurrBits = iBits;

_this->hidden->iCurrChannels = iChannels;

_this->hidden->iCurrNumBufs = iNumBufs;

_this->hidden->iCurrBufSize = iBufSize;

return (0);

}

void DART_ThreadInit(_THIS)

{

return;

}

/* This function waits until it is possible to write a full sound buffer */

void DART_WaitAudio(_THIS)

{

int i;

pMixBufferDesc pBufDesc;

ULONG ulPostCount;

DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);

// If there is already an empty buffer, then return now!

for (i=0; i<_this->hidden->iCurrNumBufs; i++)

{

pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[i].ulUserParm;

if (pBufDesc->iBufferUsage == BUFFER_EMPTY)

return;

}

// If there is no empty buffer, wait for one to be empty!

DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // Wait max 1 sec!!! Important!

return;

}

void DART_PlayAudio(_THIS)

{

int iFreeBuf = _this->hidden->iNextFreeBuffer;

pMixBufferDesc pBufDesc;

pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].ulUserParm;

pBufDesc->iBufferUsage = BUFFER_USED;

// Send it to DART to be queued

_this->hidden->MixSetupParms.pmixWrite(_this->hidden->MixSetupParms.ulMixHandle,

&(_this->hidden->pMixBuffers[iFreeBuf]), 1);

_this->hidden->iLastPlayedBuf = iFreeBuf;

iFreeBuf = (iFreeBuf+1) % _this->hidden->iCurrNumBufs;

_this->hidden->iNextFreeBuffer = iFreeBuf;

}

Uint8 *DART_GetAudioBuf(_THIS)

{

int iFreeBuf;

Uint8 *pResult;

pMixBufferDesc pBufDesc;

if (_this)

{

if (_this->hidden)

{

iFreeBuf = _this->hidden->iNextFreeBuffer;

pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[iFreeBuf].ulUserParm;

if (pBufDesc)

{

if (pBufDesc->iBufferUsage == BUFFER_EMPTY)

{

pResult = _this->hidden->pMixBuffers[iFreeBuf].pBuffer;

return pResult;

}

} else

printf("[DART_GetAudioBuf] : ERROR! pBufDesc = %p\n", pBufDesc);

} else

printf("[DART_GetAudioBuf] : ERROR! _this->hidden = %p\n", _this->hidden);

} else

printf("[DART_GetAudioBuf] : ERROR! _this = %p\n", _this);

return NULL;

}

void DART_WaitDone(_THIS)

{

pMixBufferDesc pBufDesc;

ULONG ulPostCount;

APIRET rc;

pBufDesc = (pMixBufferDesc) _this->hidden->pMixBuffers[_this->hidden->iLastPlayedBuf].ulUserParm;

rc = NO_ERROR;

while ((pBufDesc->iBufferUsage != BUFFER_EMPTY) && (rc==NO_ERROR))

{

DosResetEventSem(_this->hidden->hevAudioBufferPlayed, &ulPostCount);

rc = DosWaitEventSem(_this->hidden->hevAudioBufferPlayed, 1000); // 1 sec timeout! Important!

}

}

void DART_CloseAudio(_THIS)

{

MCI_GENERIC_PARMS GenericParms;

int rc;

// Stop DART playback

rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_STOP, MCI_WAIT, &GenericParms, 0);

if (rc!=MCIERR_SUCCESS)

{

#ifdef SFX_DEBUG_BUILD

printf("Could not stop DART playback!\n");

fflush(stdout);

#endif

}

// Close event semaphore

DosCloseEventSem(_this->hidden->hevAudioBufferPlayed);

// Free memory of buffer descriptions

{

int i;

}

// Deallocate buffers

rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_BUFFER, MCI_WAIT | MCI_DEALLOCATE_MEMORY, &(_this->hidden->BufferParms), 0);

// Free bufferlist

// Close dart

rc = mciSendCommand(_this->hidden->iCurrDeviceOrd, MCI_CLOSE, MCI_WAIT, &(GenericParms), 0);

}

/* Audio driver bootstrap functions */

int Audio_Available(void)

{

return(1);

}

void Audio_DeleteDevice(SDL_AudioDevice *device)

{

SDL_free(device->hidden);

SDL_free(device);

}

SDL_AudioDevice *Audio_CreateDevice(int devindex)

{

SDL_AudioDevice *this;

/* Initialize all variables that we clean on shutdown */

if ( this )

{

}

if ( (this == NULL) || (this->hidden == NULL) )

{

SDL_OutOfMemory();

if ( this )

return(0);

}

/* Set the function pointers */

this->OpenAudio = DART_OpenAudio;

this->ThreadInit = DART_ThreadInit;

this->WaitAudio = DART_WaitAudio;

this->PlayAudio = DART_PlayAudio;

this->GetAudioBuf = DART_GetAudioBuf;

this->WaitDone = DART_WaitDone;

this->CloseAudio = DART_CloseAudio;

this->free = Audio_DeleteDevice;

return this;

}

AudioBootStrap DART_bootstrap = {

"dart", "OS/2 Direct Audio RouTines (DART)",

Audio_Available, Audio_CreateDevice

};