/*
    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_dx5audio.h"

/* Define this if you want to use DirectX 6 DirectSoundNotify interface */
//#define USE_POSITION_NOTIFY

/* DirectX function pointers for audio */
HRESULT (WINAPI * DSoundCreate) (LPGUID, LPDIRECTSOUND *, LPUNKNOWN);

/* Audio driver functions */
static int DX5_OpenAudio (_THIS, SDL_AudioSpec * spec);
static void DX5_ThreadInit (_THIS);
static void DX5_WaitAudio_BusyWait (_THIS);
#ifdef USE_POSITION_NOTIFY
static void DX6_WaitAudio_EventWait (_THIS);
#endif
static void DX5_PlayAudio (_THIS);
static Uint8 *DX5_GetAudioBuf (_THIS);
static void DX5_WaitDone (_THIS);
static void DX5_CloseAudio (_THIS);

/* Audio driver bootstrap functions */

static int
Audio_Available (void)
{
    HINSTANCE DSoundDLL;
    int dsound_ok;

    /* Version check DSOUND.DLL (Is DirectX okay?) */
    dsound_ok = 0;
    DSoundDLL = LoadLibrary (TEXT ("DSOUND.DLL"));
    if (DSoundDLL != NULL) {
        /* We just use basic DirectSound, we're okay */
        /* Yay! */
        /* Unfortunately, the sound drivers on NT have
           higher latencies than the audio buffers used
           by many SDL applications, so there are gaps
           in the audio - it sounds terrible.  Punt for now.
         */
        OSVERSIONINFO ver;
        ver.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
        GetVersionEx (&ver);
        switch (ver.dwPlatformId) {
        case VER_PLATFORM_WIN32_NT:
            if (ver.dwMajorVersion > 4) {
                /* Win2K */
                dsound_ok = 1;
            } else {
                /* WinNT */
                dsound_ok = 0;
            }
            break;
        default:
            /* Win95 or Win98 */
            dsound_ok = 1;
            break;
        }
        /* Now check for DirectX 5 or better - otherwise
         * we will fail later in DX5_OpenAudio without a chance
         * to fall back to the DIB driver. */
        if (dsound_ok) {
            /* DirectSoundCaptureCreate was added in DX5 */
            if (!GetProcAddress
                (DSoundDLL, TEXT ("DirectSoundCaptureCreate")))
                dsound_ok = 0;

        }
        /* Clean up.. */
        FreeLibrary (DSoundDLL);
    }
    return (dsound_ok);
}

/* Functions for loading the DirectX functions dynamically */
static HINSTANCE DSoundDLL = NULL;

static void
DX5_Unload (void)
{
    if (DSoundDLL != NULL) {
        FreeLibrary (DSoundDLL);
        DSoundCreate = NULL;
        DSoundDLL = NULL;
    }
}
static int
DX5_Load (void)
{
    int status;

    DX5_Unload ();
    DSoundDLL = LoadLibrary (TEXT ("DSOUND.DLL"));
    if (DSoundDLL != NULL) {
        DSoundCreate = (void *) GetProcAddress (DSoundDLL,
                                                TEXT ("DirectSoundCreate"));
    }
    if (DSoundDLL && DSoundCreate) {
        status = 0;
    } else {
        DX5_Unload ();
        status = -1;
    }
    return status;
}

static void
Audio_DeleteDevice (SDL_AudioDevice * device)
{
    DX5_Unload ();
    SDL_free (device->hidden);
    SDL_free (device);
}

static SDL_AudioDevice *
Audio_CreateDevice (int devindex)
{
    SDL_AudioDevice *this;

    /* Load DirectX */
    if (DX5_Load () < 0) {
        return (NULL);
    }

    /* 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 = DX5_OpenAudio;
    this->ThreadInit = DX5_ThreadInit;
    this->WaitAudio = DX5_WaitAudio_BusyWait;
    this->PlayAudio = DX5_PlayAudio;
    this->GetAudioBuf = DX5_GetAudioBuf;
    this->WaitDone = DX5_WaitDone;
    this->CloseAudio = DX5_CloseAudio;

    this->free = Audio_DeleteDevice;

    return this;
}

AudioBootStrap DSOUND_bootstrap = {
    "dsound", "Win95/98/2000 DirectSound",
    Audio_Available, Audio_CreateDevice
};

static void
SetDSerror (const char *function, int code)
{
    static const char *error;
    static char errbuf[1024];

    errbuf[0] = 0;
    switch (code) {
    case E_NOINTERFACE:
        error =
            "Unsupported interface\n-- Is DirectX 5.0 or later installed?";
        break;
    case DSERR_ALLOCATED:
        error = "Audio device in use";
        break;
    case DSERR_BADFORMAT:
        error = "Unsupported audio format";
        break;
    case DSERR_BUFFERLOST:
        error = "Mixing buffer was lost";
        break;
    case DSERR_CONTROLUNAVAIL:
        error = "Control requested is not available";
        break;
    case DSERR_INVALIDCALL:
        error = "Invalid call for the current state";
        break;
    case DSERR_INVALIDPARAM:
        error = "Invalid parameter";
        break;
    case DSERR_NODRIVER:
        error = "No audio device found";
        break;
    case DSERR_OUTOFMEMORY:
        error = "Out of memory";
        break;
    case DSERR_PRIOLEVELNEEDED:
        error = "Caller doesn't have priority";
        break;
    case DSERR_UNSUPPORTED:
        error = "Function not supported";
        break;
    default:
        SDL_snprintf (errbuf, SDL_arraysize (errbuf),
                      "%s: Unknown DirectSound error: 0x%x", function, code);
        break;
    }
    if (!errbuf[0]) {
        SDL_snprintf (errbuf, SDL_arraysize (errbuf), "%s: %s", function,
                      error);
    }
    SDL_SetError ("%s", errbuf);
    return;
}

/* DirectSound needs to be associated with a window */
static HWND mainwin = NULL;
/* */
void
DX5_SoundFocus (HWND hwnd)
{
    mainwin = hwnd;
}

static void
DX5_ThreadInit (_THIS)
{
    SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_HIGHEST);
}

static void
DX5_WaitAudio_BusyWait (_THIS)
{
    DWORD status;
    DWORD cursor, junk;
    HRESULT result;

    /* Semi-busy wait, since we have no way of getting play notification
       on a primary mixing buffer located in hardware (DirectX 5.0)
     */
    result = IDirectSoundBuffer_GetCurrentPosition (mixbuf, &cursor, &junk);
    if (result != DS_OK) {
        if (result == DSERR_BUFFERLOST) {
            IDirectSoundBuffer_Restore (mixbuf);
        }
#ifdef DEBUG_SOUND
        SetDSerror ("DirectSound GetCurrentPosition", result);
#endif
        return;
    }
    cursor /= mixlen;

    while (cursor == playing) {
        /* FIXME: find out how much time is left and sleep that long */
        SDL_Delay (10);

        /* Try to restore a lost sound buffer */
        IDirectSoundBuffer_GetStatus (mixbuf, &status);
        if ((status & DSBSTATUS_BUFFERLOST)) {
            IDirectSoundBuffer_Restore (mixbuf);
            IDirectSoundBuffer_GetStatus (mixbuf, &status);
            if ((status & DSBSTATUS_BUFFERLOST)) {
                break;
            }
        }
        if (!(status & DSBSTATUS_PLAYING)) {
            result = IDirectSoundBuffer_Play (mixbuf, 0, 0, DSBPLAY_LOOPING);
            if (result == DS_OK) {
                continue;
            }
#ifdef DEBUG_SOUND
            SetDSerror ("DirectSound Play", result);
#endif
            return;
        }

        /* Find out where we are playing */
        result = IDirectSoundBuffer_GetCurrentPosition (mixbuf,
                                                        &cursor, &junk);
        if (result != DS_OK) {
            SetDSerror ("DirectSound GetCurrentPosition", result);
            return;
        }
        cursor /= mixlen;
    }
}

#ifdef USE_POSITION_NOTIFY
static void
DX6_WaitAudio_EventWait (_THIS)
{
    DWORD status;
    HRESULT result;

    /* Try to restore a lost sound buffer */
    IDirectSoundBuffer_GetStatus (mixbuf, &status);
    if ((status & DSBSTATUS_BUFFERLOST)) {
        IDirectSoundBuffer_Restore (mixbuf);
        IDirectSoundBuffer_GetStatus (mixbuf, &status);
        if ((status & DSBSTATUS_BUFFERLOST)) {
            return;
        }
    }
    if (!(status & DSBSTATUS_PLAYING)) {
        result = IDirectSoundBuffer_Play (mixbuf, 0, 0, DSBPLAY_LOOPING);
        if (result != DS_OK) {
#ifdef DEBUG_SOUND
            SetDSerror ("DirectSound Play", result);
#endif
            return;
        }
    }
    WaitForSingleObject (audio_event, INFINITE);
}
#endif /* USE_POSITION_NOTIFY */

static void
DX5_PlayAudio (_THIS)
{
    /* Unlock the buffer, allowing it to play */
    if (locked_buf) {
        IDirectSoundBuffer_Unlock (mixbuf, locked_buf, mixlen, NULL, 0);
    }

}

static Uint8 *
DX5_GetAudioBuf (_THIS)
{
    DWORD cursor, junk;
    HRESULT result;
    DWORD rawlen;

    /* Figure out which blocks to fill next */
    locked_buf = NULL;
    result = IDirectSoundBuffer_GetCurrentPosition (mixbuf, &cursor, &junk);
    if (result == DSERR_BUFFERLOST) {
        IDirectSoundBuffer_Restore (mixbuf);
        result = IDirectSoundBuffer_GetCurrentPosition (mixbuf,
                                                        &cursor, &junk);
    }
    if (result != DS_OK) {
        SetDSerror ("DirectSound GetCurrentPosition", result);
        return (NULL);
    }
    cursor /= mixlen;
    playing = cursor;
    cursor = (cursor + 1) % NUM_BUFFERS;
    cursor *= mixlen;

    /* Lock the audio buffer */
    result = IDirectSoundBuffer_Lock (mixbuf, cursor, mixlen,
                                      (LPVOID *) & locked_buf, &rawlen, NULL,
                                      &junk, 0);
    if (result == DSERR_BUFFERLOST) {
        IDirectSoundBuffer_Restore (mixbuf);
        result = IDirectSoundBuffer_Lock (mixbuf, cursor, mixlen,
                                          (LPVOID *) & locked_buf, &rawlen,
                                          NULL, &junk, 0);
    }
    if (result != DS_OK) {
        SetDSerror ("DirectSound Lock", result);
        return (NULL);
    }
    return (locked_buf);
}

static void
DX5_WaitDone (_THIS)
{
    Uint8 *stream;

    /* Wait for the playing chunk to finish */
    stream = this->GetAudioBuf (this);
    if (stream != NULL) {
        SDL_memset (stream, silence, mixlen);
        this->PlayAudio (this);
    }
    this->WaitAudio (this);

    /* Stop the looping sound buffer */
    IDirectSoundBuffer_Stop (mixbuf);
}

static void
DX5_CloseAudio (_THIS)
{
    if (sound != NULL) {
        if (mixbuf != NULL) {
            /* Clean up the audio buffer */
            IDirectSoundBuffer_Release (mixbuf);
            mixbuf = NULL;
        }
        if (audio_event != NULL) {
            CloseHandle (audio_event);
            audio_event = NULL;
        }
        IDirectSound_Release (sound);
        sound = NULL;
    }
}

#ifdef USE_PRIMARY_BUFFER
/* This function tries to create a primary audio buffer, and returns the
   number of audio chunks available in the created buffer.
*/
static int
CreatePrimary (LPDIRECTSOUND sndObj, HWND focus,
               LPDIRECTSOUNDBUFFER * sndbuf, WAVEFORMATEX * wavefmt,
               Uint32 chunksize)
{
    HRESULT result;
    DSBUFFERDESC format;
    DSBCAPS caps;
    int numchunks;

    /* Try to set primary mixing privileges */
    result = IDirectSound_SetCooperativeLevel (sndObj, focus,
                                               DSSCL_WRITEPRIMARY);
    if (result != DS_OK) {
#ifdef DEBUG_SOUND
        SetDSerror ("DirectSound SetCooperativeLevel", result);
#endif
        return (-1);
    }

    /* Try to create the primary buffer */
    SDL_memset (&format, 0, sizeof (format));
    format.dwSize = sizeof (format);
    format.dwFlags = (DSBCAPS_PRIMARYBUFFER | DSBCAPS_GETCURRENTPOSITION2);
    format.dwFlags |= DSBCAPS_STICKYFOCUS;
#ifdef USE_POSITION_NOTIFY
    format.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
#endif
    result = IDirectSound_CreateSoundBuffer (sndObj, &format, sndbuf, NULL);
    if (result != DS_OK) {
#ifdef DEBUG_SOUND
        SetDSerror ("DirectSound CreateSoundBuffer", result);
#endif
        return (-1);
    }

    /* Check the size of the fragment buffer */
    SDL_memset (&caps, 0, sizeof (caps));
    caps.dwSize = sizeof (caps);
    result = IDirectSoundBuffer_GetCaps (*sndbuf, &caps);
    if (result != DS_OK) {
#ifdef DEBUG_SOUND
        SetDSerror ("DirectSound GetCaps", result);
#endif
        IDirectSoundBuffer_Release (*sndbuf);
        return (-1);
    }
    if ((chunksize > caps.dwBufferBytes) ||
        ((caps.dwBufferBytes % chunksize) != 0)) {
        /* The primary buffer size is not a multiple of 'chunksize'
           -- this hopefully doesn't happen when 'chunksize' is a 
           power of 2.
         */
        IDirectSoundBuffer_Release (*sndbuf);
        SDL_SetError
            ("Primary buffer size is: %d, cannot break it into chunks of %d bytes\n",
             caps.dwBufferBytes, chunksize);
        return (-1);
    }
    numchunks = (caps.dwBufferBytes / chunksize);

    /* Set the primary audio format */
    result = IDirectSoundBuffer_SetFormat (*sndbuf, wavefmt);
    if (result != DS_OK) {
#ifdef DEBUG_SOUND
        SetDSerror ("DirectSound SetFormat", result);
#endif
        IDirectSoundBuffer_Release (*sndbuf);
        return (-1);
    }
    return (numchunks);
}
#endif /* USE_PRIMARY_BUFFER */

/* This function tries to create a secondary audio buffer, and returns the
   number of audio chunks available in the created buffer.
*/
static int
CreateSecondary (LPDIRECTSOUND sndObj, HWND focus,
                 LPDIRECTSOUNDBUFFER * sndbuf, WAVEFORMATEX * wavefmt,
                 Uint32 chunksize)
{
    const int numchunks = 2;
    HRESULT result;
    DSBUFFERDESC format;
    LPVOID pvAudioPtr1, pvAudioPtr2;
    DWORD dwAudioBytes1, dwAudioBytes2;

    /* Try to set primary mixing privileges */
    if (focus) {
        result = IDirectSound_SetCooperativeLevel (sndObj,
                                                   focus, DSSCL_PRIORITY);
    } else {
        result = IDirectSound_SetCooperativeLevel (sndObj,
                                                   GetDesktopWindow (),
                                                   DSSCL_NORMAL);
    }
    if (result != DS_OK) {
#ifdef DEBUG_SOUND
        SetDSerror ("DirectSound SetCooperativeLevel", result);
#endif
        return (-1);
    }

    /* Try to create the secondary buffer */
    SDL_memset (&format, 0, sizeof (format));
    format.dwSize = sizeof (format);
    format.dwFlags = DSBCAPS_GETCURRENTPOSITION2;
#ifdef USE_POSITION_NOTIFY
    format.dwFlags |= DSBCAPS_CTRLPOSITIONNOTIFY;
#endif
    if (!focus) {
        format.dwFlags |= DSBCAPS_GLOBALFOCUS;
    } else {
        format.dwFlags |= DSBCAPS_STICKYFOCUS;
    }
    format.dwBufferBytes = numchunks * chunksize;
    if ((format.dwBufferBytes < DSBSIZE_MIN) ||
        (format.dwBufferBytes > DSBSIZE_MAX)) {
        SDL_SetError ("Sound buffer size must be between %d and %d",
                      DSBSIZE_MIN / numchunks, DSBSIZE_MAX / numchunks);
        return (-1);
    }
    format.dwReserved = 0;
    format.lpwfxFormat = wavefmt;
    result = IDirectSound_CreateSoundBuffer (sndObj, &format, sndbuf, NULL);
    if (result != DS_OK) {
        SetDSerror ("DirectSound CreateSoundBuffer", result);
        return (-1);
    }
    IDirectSoundBuffer_SetFormat (*sndbuf, wavefmt);

    /* Silence the initial audio buffer */
    result = IDirectSoundBuffer_Lock (*sndbuf, 0, format.dwBufferBytes,
                                      (LPVOID *) & pvAudioPtr1,
                                      &dwAudioBytes1,
                                      (LPVOID *) & pvAudioPtr2,
                                      &dwAudioBytes2, DSBLOCK_ENTIREBUFFER);
    if (result == DS_OK) {
        if (wavefmt->wBitsPerSample == 8) {
            SDL_memset (pvAudioPtr1, 0x80, dwAudioBytes1);
        } else {
            SDL_memset (pvAudioPtr1, 0x00, dwAudioBytes1);
        }
        IDirectSoundBuffer_Unlock (*sndbuf,
                                   (LPVOID) pvAudioPtr1, dwAudioBytes1,
                                   (LPVOID) pvAudioPtr2, dwAudioBytes2);
    }

    /* We're ready to go */
    return (numchunks);
}

/* This function tries to set position notify events on the mixing buffer */
#ifdef USE_POSITION_NOTIFY
static int
CreateAudioEvent (_THIS)
{
    LPDIRECTSOUNDNOTIFY notify;
    DSBPOSITIONNOTIFY *notify_positions;
    int i, retval;
    HRESULT result;

    /* Default to fail on exit */
    retval = -1;
    notify = NULL;

    /* Query for the interface */
    result = IDirectSoundBuffer_QueryInterface (mixbuf,
                                                &IID_IDirectSoundNotify,
                                                (void *) &notify);
    if (result != DS_OK) {
        goto done;
    }

    /* Allocate the notify structures */
    notify_positions = (DSBPOSITIONNOTIFY *) SDL_malloc (NUM_BUFFERS *
                                                         sizeof
                                                         (*notify_positions));
    if (notify_positions == NULL) {
        goto done;
    }

    /* Create the notify event */
    audio_event = CreateEvent (NULL, FALSE, FALSE, NULL);
    if (audio_event == NULL) {
        goto done;
    }

    /* Set up the notify structures */
    for (i = 0; i < NUM_BUFFERS; ++i) {
        notify_positions[i].dwOffset = i * mixlen;
        notify_positions[i].hEventNotify = audio_event;
    }
    result = IDirectSoundNotify_SetNotificationPositions (notify,
                                                          NUM_BUFFERS,
                                                          notify_positions);
    if (result == DS_OK) {
        retval = 0;
    }
  done:
    if (notify != NULL) {
        IDirectSoundNotify_Release (notify);
    }
    return (retval);
}
#endif /* USE_POSITION_NOTIFY */

static int
DX5_OpenAudio (_THIS, SDL_AudioSpec * spec)
{
    HRESULT result;
    WAVEFORMATEX waveformat;

    /* Set basic WAVE format parameters */
    SDL_memset (&waveformat, 0, sizeof (waveformat));
    waveformat.wFormatTag = WAVE_FORMAT_PCM;

    /* Determine the audio parameters from the AudioSpec */
    switch (spec->format & 0xFF) {
    case 8:
        /* Unsigned 8 bit audio data */
        spec->format = AUDIO_U8;
        silence = 0x80;
        waveformat.wBitsPerSample = 8;
        break;
    case 16:
        /* Signed 16 bit audio data */
        spec->format = AUDIO_S16;
        silence = 0x00;
        waveformat.wBitsPerSample = 16;
        break;
    default:
        SDL_SetError ("Unsupported audio format");
        return (-1);
    }
    waveformat.nChannels = spec->channels;
    waveformat.nSamplesPerSec = spec->freq;
    waveformat.nBlockAlign =
        waveformat.nChannels * (waveformat.wBitsPerSample / 8);
    waveformat.nAvgBytesPerSec =
        waveformat.nSamplesPerSec * waveformat.nBlockAlign;

    /* Update the fragment size as size in bytes */
    SDL_CalculateAudioSpec (spec);

    /* Open the audio device */
    result = DSoundCreate (NULL, &sound, NULL);
    if (result != DS_OK) {
        SetDSerror ("DirectSoundCreate", result);
        return (-1);
    }

    /* Create the audio buffer to which we write */
    NUM_BUFFERS = -1;
#ifdef USE_PRIMARY_BUFFER
    if (mainwin) {
        NUM_BUFFERS = CreatePrimary (sound, mainwin, &mixbuf,
                                     &waveformat, spec->size);
    }
#endif /* USE_PRIMARY_BUFFER */
    if (NUM_BUFFERS < 0) {
        NUM_BUFFERS = CreateSecondary (sound, mainwin, &mixbuf,
                                       &waveformat, spec->size);
        if (NUM_BUFFERS < 0) {
            return (-1);
        }
#ifdef DEBUG_SOUND
        fprintf (stderr, "Using secondary audio buffer\n");
#endif
    }
#ifdef DEBUG_SOUND
    else
        fprintf (stderr, "Using primary audio buffer\n");
#endif

    /* The buffer will auto-start playing in DX5_WaitAudio() */
    playing = 0;
    mixlen = spec->size;

#ifdef USE_POSITION_NOTIFY
    /* See if we can use DirectX 6 event notification */
    if (CreateAudioEvent (this) == 0) {
        this->WaitAudio = DX6_WaitAudio_EventWait;
    } else {
        this->WaitAudio = DX5_WaitAudio_BusyWait;
    }
#endif
    return (0);
}

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