/*

 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

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

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#define USE_ERROR

#define USE_TRACE

/* define this for the silencing/servicing code. Requires USE_TRACE */

//#define USE_DEBUG_SILENCING

#ifndef WIN32_EXTRA_LEAN

#define WIN32_EXTRA_LEAN

#endif

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <windows.h>

#include <mmsystem.h>

#include <string.h>

/* include DirectSound headers */

#include <dsound.h>

/* include Java Sound specific headers as C code */

#ifdef __cplusplus

extern "C" {

#endif

 #include "DirectAudio.h"

#ifdef __cplusplus

}

#endif

/* include to prevent charset problem */

#include "PLATFORM_API_WinOS_Charset_Util.h"

#ifdef USE_DEBUG_SILENCING

#define DEBUG_SILENCING0(p) TRACE0(p)

#define DEBUG_SILENCING1(p1,p2) TRACE1(p1,p2)

#define DEBUG_SILENCING2(p1,p2,p3) TRACE2(p1,p2,p3)

#else

#define DEBUG_SILENCING0(p)

#define DEBUG_SILENCING1(p1,p2)

#define DEBUG_SILENCING2(p1,p2,p3)

#endif

#if USE_DAUDIO == TRUE

/* half a minute to wait before device list is re-read */

#define WAIT_BETWEEN_CACHE_REFRESH_MILLIS 30000

/* maximum number of supported devices, playback+capture */

#define MAX_DS_DEVICES 60

typedef struct {

    INT32 mixerIndex;

    BOOL isSource;

    /* either LPDIRECTSOUND or LPDIRECTSOUNDCAPTURE */

    void* dev;

    /* how many instances use the dev */

    INT32 refCount;

    GUID guid;

} DS_AudioDeviceCache;

static DS_AudioDeviceCache g_audioDeviceCache[MAX_DS_DEVICES];

static INT32 g_cacheCount = 0;

static UINT64 g_lastCacheRefreshTime = 0;

static INT32 g_mixerCount = 0;

BOOL DS_lockCache() {

    /* dummy implementation for now, Java does locking */

    return TRUE;

}

void DS_unlockCache() {

    /* dummy implementation for now */

}

static GUID CLSID_DAUDIO_Zero = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

BOOL isEqualGUID(LPGUID lpGuid1, LPGUID lpGuid2) {

    if (lpGuid1 == NULL || lpGuid2 == NULL) {

        if (lpGuid1 == lpGuid2) {

            return TRUE;

        }

        if (lpGuid1 == NULL) {

            lpGuid1 = (LPGUID) (&CLSID_DAUDIO_Zero);

        } else {

            lpGuid2 = (LPGUID) (&CLSID_DAUDIO_Zero);

        }

    }

    return memcmp(lpGuid1, lpGuid2, sizeof(GUID)) == 0;

}

INT32 findCacheItemByGUID(LPGUID lpGuid, BOOL isSource) {

    int i;

    for (i = 0; i < g_cacheCount; i++) {

        if (isSource == g_audioDeviceCache[i].isSource

            && isEqualGUID(lpGuid, &(g_audioDeviceCache[i].guid))) {

            return i;

        }

    }

    return -1;

}

INT32 findCacheItemByMixerIndex(INT32 mixerIndex) {

    int i;

    for (i = 0; i < g_cacheCount; i++) {

        if (g_audioDeviceCache[i].mixerIndex == mixerIndex) {

            return i;

        }

    }

    return -1;

}

typedef struct {

    INT32 currMixerIndex;

    BOOL isSource;

} DS_RefreshCacheStruct;

BOOL CALLBACK DS_RefreshCacheEnum(LPGUID lpGuid,

                                  LPCSTR lpstrDescription,

                                  LPCSTR lpstrModule,

                                  DS_RefreshCacheStruct* rs) {

    INT32 cacheIndex = findCacheItemByGUID(lpGuid, rs->isSource);

    /*TRACE3("Enumerating %d: %s (%s)\n", cacheIndex, lpstrDescription, lpstrModule);*/

    if (cacheIndex == -1) {

        /* add this device */

        if (g_cacheCount < MAX_DS_DEVICES-1) {

            g_audioDeviceCache[g_cacheCount].mixerIndex = rs->currMixerIndex;

            g_audioDeviceCache[g_cacheCount].isSource = rs->isSource;

            g_audioDeviceCache[g_cacheCount].dev = NULL;

            g_audioDeviceCache[g_cacheCount].refCount = 0;

            if (lpGuid == NULL) {

                memset(&(g_audioDeviceCache[g_cacheCount].guid), 0, sizeof(GUID));

            } else {

                memcpy(&(g_audioDeviceCache[g_cacheCount].guid), lpGuid, sizeof(GUID));

            }

            g_cacheCount++;

            rs->currMixerIndex++;

        } else {

            /* failure case: more than MAX_DS_DEVICES available... */

        }

    } else {

        /* device already exists in cache... update mixer number */

        g_audioDeviceCache[cacheIndex].mixerIndex = rs->currMixerIndex;

        rs->currMixerIndex++;

    }

    /* continue enumeration */

    return TRUE;

}

///// implemented functions of DirectAudio.h

INT32 DAUDIO_GetDirectAudioDeviceCount() {

    DS_RefreshCacheStruct rs;

    INT32 oldCount;

    INT32 cacheIndex;

    if (!DS_lockCache()) {

        return 0;

    }

    if (g_lastCacheRefreshTime == 0

        || (UINT64) timeGetTime() > (UINT64) (g_lastCacheRefreshTime + WAIT_BETWEEN_CACHE_REFRESH_MILLIS)) {

        /* first, initialize any old cache items */

        for (cacheIndex = 0; cacheIndex < g_cacheCount; cacheIndex++) {

            g_audioDeviceCache[cacheIndex].mixerIndex = -1;

        }

        /* enumerate all devices and either add them to the device cache,

         * or refresh the mixer number

         */

        rs.currMixerIndex = 0;

        rs.isSource = TRUE;

        DirectSoundEnumerate((LPDSENUMCALLBACK) DS_RefreshCacheEnum, &rs);

        /* if we only got the Primary Sound Driver (GUID=NULL),

         * then there aren't any playback devices installed */

        if (rs.currMixerIndex == 1) {

            cacheIndex = findCacheItemByGUID(NULL, TRUE);

            if (cacheIndex == 0) {

                rs.currMixerIndex = 0;

                g_audioDeviceCache[0].mixerIndex = -1;

                TRACE0("Removing stale Primary Sound Driver from list.\n");

            }

        }

        oldCount = rs.currMixerIndex;

        rs.isSource = FALSE;

        DirectSoundCaptureEnumerate((LPDSENUMCALLBACK) DS_RefreshCacheEnum, &rs);

        /* if we only got the Primary Sound Capture Driver (GUID=NULL),

         * then there aren't any capture devices installed */

        if ((rs.currMixerIndex - oldCount) == 1) {

            cacheIndex = findCacheItemByGUID(NULL, FALSE);

            if (cacheIndex != -1) {

                rs.currMixerIndex = oldCount;

                g_audioDeviceCache[cacheIndex].mixerIndex = -1;

                TRACE0("Removing stale Primary Sound Capture Driver from list.\n");

            }

        }

        g_mixerCount = rs.currMixerIndex;

        g_lastCacheRefreshTime = (UINT64) timeGetTime();

    }

    DS_unlockCache();

    /*TRACE1("DirectSound: %d installed devices\n", g_mixerCount);*/

    return g_mixerCount;

}

BOOL CALLBACK DS_GetDescEnum(LPGUID lpGuid,

                             LPCWSTR lpstrDescription,

                             LPCWSTR lpstrModule,

                             DirectAudioDeviceDescription* desc) {

    INT32 cacheIndex = findCacheItemByGUID(lpGuid, g_audioDeviceCache[desc->deviceID].isSource);

    if (cacheIndex == desc->deviceID) {

        UnicodeToUTF8AndCopy(desc->name, lpstrDescription, DAUDIO_STRING_LENGTH);

        //strncpy(desc->description, lpstrModule, DAUDIO_STRING_LENGTH);

        desc->maxSimulLines = -1;

        /* do not continue enumeration */

        return FALSE;

    }

    return TRUE;

}

INT32 DAUDIO_GetDirectAudioDeviceDescription(INT32 mixerIndex, DirectAudioDeviceDescription* desc) {

    if (!DS_lockCache()) {

        return FALSE;

    }

    /* set the deviceID field to the cache index */

    desc->deviceID = findCacheItemByMixerIndex(mixerIndex);

    if (desc->deviceID < 0) {

        DS_unlockCache();

        return FALSE;

    }

    desc->maxSimulLines = 0;

    if (g_audioDeviceCache[desc->deviceID].isSource) {

        DirectSoundEnumerateW((LPDSENUMCALLBACKW) DS_GetDescEnum, desc);

        strncpy(desc->description, "DirectSound Playback", DAUDIO_STRING_LENGTH);

    } else {

        DirectSoundCaptureEnumerateW((LPDSENUMCALLBACKW) DS_GetDescEnum, desc);

        strncpy(desc->description, "DirectSound Capture", DAUDIO_STRING_LENGTH);

    }

    /*desc->vendor;

    desc->version;*/

    DS_unlockCache();

    return (desc->maxSimulLines == -1)?TRUE:FALSE;

}

/* multi-channel info: http://www.microsoft.com/whdc/hwdev/tech/audio/multichaud.mspx */

//static UINT32 sampleRateArray[] = { 8000, 11025, 16000, 22050, 32000, 44100, 48000, 56000, 88000, 96000, 172000, 192000 };

static INT32 sampleRateArray[] = { -1 };

static INT32 channelsArray[] = { 1, 2};

static INT32 bitsArray[] = { 8, 16};

#define SAMPLERATE_COUNT sizeof(sampleRateArray)/sizeof(INT32)

#define CHANNELS_COUNT sizeof(channelsArray)/sizeof(INT32)

#define BITS_COUNT sizeof(bitsArray)/sizeof(INT32)

void DAUDIO_GetFormats(INT32 mixerIndex, INT32 deviceID, int isSource, void* creator) {

    int rateIndex, channelIndex, bitIndex;

    /* no need to lock, since deviceID identifies the device sufficiently */

    /* sanity */

    if (deviceID >= g_cacheCount) {

        return;

    }

    if ((g_audioDeviceCache[deviceID].isSource && !isSource)

        || (!g_audioDeviceCache[deviceID].isSource && isSource)) {

        /* only support Playback or Capture */

        return;

    }

    for (rateIndex = 0; rateIndex < SAMPLERATE_COUNT; rateIndex++) {

        for (channelIndex = 0; channelIndex < CHANNELS_COUNT; channelIndex++) {

            for (bitIndex = 0; bitIndex < BITS_COUNT; bitIndex++) {

                DAUDIO_AddAudioFormat(creator, bitsArray[bitIndex],

                                      ((bitsArray[bitIndex] + 7) / 8) * channelsArray[channelIndex],

                                      channelsArray[channelIndex],

                                      (float) sampleRateArray[rateIndex],

                                      DAUDIO_PCM,

                                      (bitsArray[bitIndex]==8)?FALSE:TRUE,  /* signed */

                                      (bitsArray[bitIndex]==8)?FALSE:

#ifndef _LITTLE_ENDIAN

                                      TRUE /* big endian */

#else

                                      FALSE /* little endian */

#endif

                                      );

            }

        }

    }

}

typedef struct {

    int deviceID;

    /* for convenience */

    BOOL isSource;

    /* the secondary buffer (Playback) */

    LPDIRECTSOUNDBUFFER playBuffer;

    /* the secondary buffer (Capture) */

    LPDIRECTSOUNDCAPTUREBUFFER captureBuffer;

    /* size of the directsound buffer, usually 2 seconds */

    int dsBufferSizeInBytes;

    /* size of the read/write-ahead, as specified by Java */

    int bufferSizeInBytes;

    int bitsPerSample;

    int frameSize; // storage size in Bytes

    UINT64 framePos;

    /* where to write into the buffer.

     * -1 if at current position (Playback)

     * For Capture, this is the read position

     */

    int writePos;

    /* if start() had been called */

    BOOL started;

    /* how many bytes there is silence from current write position */

    int silencedBytes;

    BOOL underrun;

} DS_Info;

LPCSTR TranslateDSError(HRESULT hr) {

    switch(hr) {

        case DSERR_ALLOCATED:

            return "DSERR_ALLOCATED";

        case DSERR_CONTROLUNAVAIL:

            return "DSERR_CONTROLUNAVAIL";

        case DSERR_INVALIDPARAM:

            return "DSERR_INVALIDPARAM";

        case DSERR_INVALIDCALL:

            return "DSERR_INVALIDCALL";

        case DSERR_GENERIC:

            return "DSERR_GENERIC";

        case DSERR_PRIOLEVELNEEDED:

            return "DSERR_PRIOLEVELNEEDED";

        case DSERR_OUTOFMEMORY:

            return "DSERR_OUTOFMEMORY";

        case DSERR_BADFORMAT:

            return "DSERR_BADFORMAT";

        case DSERR_UNSUPPORTED:

            return "DSERR_UNSUPPORTED";

        case DSERR_NODRIVER:

            return "DSERR_NODRIVER";

        case DSERR_ALREADYINITIALIZED:

            return "DSERR_ALREADYINITIALIZED";

        case DSERR_NOAGGREGATION:

            return "DSERR_NOAGGREGATION";

        case DSERR_BUFFERLOST:

            return "DSERR_BUFFERLOST";

        case DSERR_OTHERAPPHASPRIO:

            return "DSERR_OTHERAPPHASPRIO";

        case DSERR_UNINITIALIZED:

            return "DSERR_UNINITIALIZED";

        default:

            return "Unknown HRESULT";

        }

}

/*

** data/routines for starting DS buffers by separate thread

** (joint into DS_StartBufferHelper class)

** see cr6372428: playback fails after exiting from thread that has started it

** due IDirectSoundBuffer8::Play() description:

** http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c

**       /directx/htm/idirectsoundbuffer8play.asp

** (remark section): If the application is multithreaded, the thread that plays

** the buffer must continue to exist as long as the buffer is playing.

** Buffers created on WDM drivers stop playing when the thread is terminated.

** IDirectSoundCaptureBuffer8::Start() has the same remark:

** http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/directx9_c

**       /directx/htm/idirectsoundcapturebuffer8start.asp

*/

class DS_StartBufferHelper {

public:

    /* starts DirectSound buffer (playback or capture) */

    static HRESULT StartBuffer(DS_Info* info);

    /* checks for initialization success */

    static inline BOOL isInitialized() { return data.threadHandle != NULL; }

protected:

    DS_StartBufferHelper() {}  // no need to create an instance

    /* data class */

    class Data {

    public:

        Data();

        ~Data();

        // public data to access from parent class

        CRITICAL_SECTION crit_sect;

        volatile HANDLE threadHandle;

        volatile HANDLE startEvent;

        volatile HANDLE startedEvent;

        volatile DS_Info* line2Start;

        volatile HRESULT startResult;

    } static data;

    /* StartThread function */

    static DWORD WINAPI __stdcall ThreadProc(void *param);

};

/* StartBufferHelper class implementation

*/

DS_StartBufferHelper::Data DS_StartBufferHelper::data;

DS_StartBufferHelper::Data::Data() {

    threadHandle = NULL;

    ::InitializeCriticalSection(&crit_sect);

    startEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);

    startedEvent = ::CreateEvent(NULL, FALSE, FALSE, NULL);

    if (startEvent != NULL && startedEvent != NULL)

        threadHandle = ::CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);

}

DS_StartBufferHelper::Data::~Data() {

    ::EnterCriticalSection(&crit_sect);

    if (threadHandle != NULL) {

        // terminate thread

        line2Start = NULL;

        ::SetEvent(startEvent);

        ::CloseHandle(threadHandle);

        threadHandle = NULL;

    }

    ::LeaveCriticalSection(&crit_sect);

    // won't delete startEvent/startedEvent/crit_sect

    // - Windows will do during process shutdown

}

DWORD WINAPI __stdcall DS_StartBufferHelper::ThreadProc(void *param)

{

    ::CoInitialize(NULL);

    while (1) {

        // wait for something to do

        ::WaitForSingleObject(data.startEvent, INFINITE);

        if (data.line2Start == NULL) {

            // (data.line2Start == NULL) is a signal to terminate thread

            break;

        }

        if (data.line2Start->isSource) {

            data.startResult =

                data.line2Start->playBuffer->Play(0, 0, DSBPLAY_LOOPING);

        } else {

            data.startResult =

                data.line2Start->captureBuffer->Start(DSCBSTART_LOOPING);

        }

        ::SetEvent(data.startedEvent);

    }

    ::CoUninitialize();

    return 0;

}

HRESULT DS_StartBufferHelper::StartBuffer(DS_Info* info) {

    HRESULT hr;

    ::EnterCriticalSection(&data.crit_sect);

    if (!isInitialized()) {

        ::LeaveCriticalSection(&data.crit_sect);

        return E_FAIL;

    }

    data.line2Start = info;

    ::SetEvent(data.startEvent);

    ::WaitForSingleObject(data.startedEvent, INFINITE);

    hr = data.startResult;

    ::LeaveCriticalSection(&data.crit_sect);

    return hr;

}

/* helper routines for DS buffer positions */

/* returns distance from pos1 to pos2

 */

inline int DS_getDistance(DS_Info* info, int pos1, int pos2) {

    int distance = pos2 - pos1;

    while (distance < 0)

        distance += info->dsBufferSizeInBytes;

    return distance;