/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    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
    Lesser General Public License for more details.

    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
*/
#include "SDL_config.h"

/* Allow access to a raw mixing buffer */

#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!
    SDL_memset(&AmpOpenParms, 0, sizeof(MCI_AMP_OPEN_PARMS));
    // 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!
    SDL_memset(&(_this->hidden->MixSetupParms), 0,
               sizeof(MCI_MIXSETUP_PARMS));
    _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:
    _this->hidden->pMixBuffers =
        (MCI_MIX_BUFFER *) SDL_malloc(sizeof(MCI_MIX_BUFFER) * iNumBufs);
    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!
        SDL_free(_this->hidden->pMixBuffers);
        _this->hidden->pMixBuffers = NULL;
        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++) {
            pMixBufferDesc pBufferDesc =
                (pMixBufferDesc) SDL_malloc(sizeof(tMixBufferDesc));;
            // 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;
                    for (j = 0; j < i; j++)
                        SDL_free((void *) (_this->hidden->pMixBuffers[j].
                                           ulUserParm));
                }
                // and cleanup
                mciSendCommand(iDeviceOrd, MCI_BUFFER,
                               MCI_WAIT | MCI_DEALLOCATE_MEMORY,
                               &(_this->hidden->BufferParms), 0);
                SDL_free(_this->hidden->pMixBuffers);
                _this->hidden->pMixBuffers = NULL;
                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.:)
            SDL_memset(_this->hidden->pMixBuffers[i].pBuffer, iSilence,
                       iBufSize);
        }
    }
    _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;
            for (i = 0; i < iNumBufs; i++)
                SDL_free((void *) (_this->hidden->pMixBuffers[i].ulUserParm));
        }
        mciSendCommand(iDeviceOrd, MCI_BUFFER,
                       MCI_WAIT | MCI_DEALLOCATE_MEMORY,
                       &(_this->hidden->BufferParms), 0);
        SDL_free(_this->hidden->pMixBuffers);
        _this->hidden->pMixBuffers = NULL;
        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;
        for (i = 0; i < _this->hidden->iCurrNumBufs; i++)
            SDL_free((void *) (_this->hidden->pMixBuffers[i].ulUserParm));
    }

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

    // Free bufferlist
    SDL_free(_this->hidden->pMixBuffers);
    _this->hidden->pMixBuffers = NULL;

    // 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 */
    this = (SDL_AudioDevice *) SDL_malloc(sizeof(SDL_AudioDevice));
    if (this) {
        SDL_memset(this, 0, (sizeof *this));
        this->hidden = (struct SDL_PrivateAudioData *)
            SDL_malloc((sizeof *this->hidden));
    }
    if ((this == NULL) || (this->hidden == NULL)) {
        SDL_OutOfMemory();
        if (this)
            SDL_free(this);
        return (0);
    }
    SDL_memset(this->hidden, 0, (sizeof *this->hidden));

    /* 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
};

/* vi: set ts=4 sw=4 expandtab: */