path: root/src/audio/dart/SDL_dart.c

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

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