/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

//

//  W A R N I N G

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

//

// This file is not part of the Qt API.  It exists for the convenience

// of other Qt classes.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "qaudiooutput_win32_p.h"

#ifndef SPEAKER_FRONT_LEFT

    #define SPEAKER_FRONT_LEFT            0x00000001

    #define SPEAKER_FRONT_RIGHT           0x00000002

    #define SPEAKER_FRONT_CENTER          0x00000004

    #define SPEAKER_LOW_FREQUENCY         0x00000008

    #define SPEAKER_BACK_LEFT             0x00000010

    #define SPEAKER_BACK_RIGHT            0x00000020

    #define SPEAKER_FRONT_LEFT_OF_CENTER  0x00000040

    #define SPEAKER_FRONT_RIGHT_OF_CENTER 0x00000080

    #define SPEAKER_BACK_CENTER           0x00000100

    #define SPEAKER_SIDE_LEFT             0x00000200

    #define SPEAKER_SIDE_RIGHT            0x00000400

    #define SPEAKER_TOP_CENTER            0x00000800

    #define SPEAKER_TOP_FRONT_LEFT        0x00001000

    #define SPEAKER_TOP_FRONT_CENTER      0x00002000

    #define SPEAKER_TOP_FRONT_RIGHT       0x00004000

    #define SPEAKER_TOP_BACK_LEFT         0x00008000

    #define SPEAKER_TOP_BACK_CENTER       0x00010000

    #define SPEAKER_TOP_BACK_RIGHT        0x00020000

    #define SPEAKER_RESERVED              0x7FFC0000

    #define SPEAKER_ALL                   0x80000000

#endif

#ifndef _WAVEFORMATEXTENSIBLE_

    #define _WAVEFORMATEXTENSIBLE_

    typedef struct

    {

        WAVEFORMATEX Format;          // Base WAVEFORMATEX data

        union

        {

            WORD wValidBitsPerSample; // Valid bits in each sample container

            WORD wSamplesPerBlock;    // Samples per block of audio data; valid

                                      // if wBitsPerSample=0 (but rarely used).

            WORD wReserved;           // Zero if neither case above applies.

        } Samples;

        DWORD dwChannelMask;          // Positions of the audio channels

        GUID SubFormat;               // Format identifier GUID

    } WAVEFORMATEXTENSIBLE, *PWAVEFORMATEXTENSIBLE, *LPPWAVEFORMATEXTENSIBLE;

    typedef const WAVEFORMATEXTENSIBLE* LPCWAVEFORMATEXTENSIBLE;

#endif

#if !defined(WAVE_FORMAT_EXTENSIBLE)

#define WAVE_FORMAT_EXTENSIBLE 0xFFFE

#endif

//#define DEBUG_AUDIO 1

QT_BEGIN_NAMESPACE

QAudioOutputPrivate::QAudioOutputPrivate(const QByteArray &device)

{

    bytesAvailable = 0;

    buffer_size = 0;

    period_size = 0;

    m_device = device;

    totalTimeValue = 0;

    intervalTime = 1000;

    audioBuffer = 0;

    errorState = QAudio::NoError;

    deviceState = QAudio::StoppedState;

    audioSource = 0;

    pullMode = true;

    finished = false;

}

QAudioOutputPrivate::~QAudioOutputPrivate()

{

    mutex.lock();

    finished = true;

    mutex.unlock();

    close();

}

void CALLBACK QAudioOutputPrivate::waveOutProc( HWAVEOUT hWaveOut, UINT uMsg,

        DWORD dwInstance, DWORD dwParam1, DWORD dwParam2 )

{

    Q_UNUSED(dwParam1)

    Q_UNUSED(dwParam2)

    Q_UNUSED(hWaveOut)

    QAudioOutputPrivate* qAudio;

    qAudio = (QAudioOutputPrivate*)(dwInstance);

    if(!qAudio)

        return;

    QMutexLocker(&qAudio->mutex);

    switch(uMsg) {

        case WOM_OPEN:

            qAudio->feedback();

            break;

        case WOM_CLOSE:

            return;

        case WOM_DONE:

            if(qAudio->finished || qAudio->buffer_size == 0 || qAudio->period_size == 0) {

                return;

	    }

            qAudio->waveFreeBlockCount++;

            if(qAudio->waveFreeBlockCount >= qAudio->buffer_size/qAudio->period_size)

                qAudio->waveFreeBlockCount = qAudio->buffer_size/qAudio->period_size;

            qAudio->feedback();

            break;

        default:

            return;

    }

}

WAVEHDR* QAudioOutputPrivate::allocateBlocks(int size, int count)

{

    int i;

    unsigned char* buffer;

    WAVEHDR* blocks;

    DWORD totalBufferSize = (size + sizeof(WAVEHDR))*count;

    if((buffer=(unsigned char*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,

                    totalBufferSize)) == 0) {

        qWarning("QAudioOutput: Memory allocation error");

        return 0;

    }

    blocks = (WAVEHDR*)buffer;

    buffer += sizeof(WAVEHDR)*count;

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

        blocks[i].dwBufferLength = size;

        blocks[i].lpData = (LPSTR)buffer;

        buffer += size;

    }

    return blocks;

}

void QAudioOutputPrivate::freeBlocks(WAVEHDR* blockArray)

{

    WAVEHDR* blocks = blockArray;

    int count = buffer_size/period_size;

    for(int i = 0; i < count; i++) {

        waveOutUnprepareHeader(hWaveOut,blocks, sizeof(WAVEHDR));

        blocks++;

    }

    HeapFree(GetProcessHeap(), 0, blockArray);

}

QAudioFormat QAudioOutputPrivate::format() const

{

    return settings;

}

void QAudioOutputPrivate::setFormat(const QAudioFormat& fmt)

{

    if (deviceState == QAudio::StoppedState)

        settings = fmt;

}

void QAudioOutputPrivate::start(QIODevice* device)

{

    if(deviceState != QAudio::StoppedState)

        close();

    if(!pullMode && audioSource)

        delete audioSource;

    pullMode = true;

    audioSource = device;

    deviceState = QAudio::ActiveState;

    if(!open())

        return;

    emit stateChanged(deviceState);

}

QIODevice* QAudioOutputPrivate::start()

{

    if(deviceState != QAudio::StoppedState)

        close();

    if(!pullMode && audioSource)

        delete audioSource;

    pullMode = false;

    audioSource = new OutputPrivate(this);

    audioSource->open(QIODevice::WriteOnly|QIODevice::Unbuffered);

    deviceState = QAudio::IdleState;

    if(!open())

        return 0;

    emit stateChanged(deviceState);

    return audioSource;

}

void QAudioOutputPrivate::stop()

{

    if(deviceState == QAudio::StoppedState)

        return;

    close();

    if(!pullMode && audioSource) {

        delete audioSource;

        audioSource = 0;

    }

    emit stateChanged(deviceState);

}

bool QAudioOutputPrivate::open()

{

#ifdef DEBUG_AUDIO

    QTime now(QTime::currentTime());

    qDebug()<<now.second()<<"s "<<now.msec()<<"ms :open()";

#endif

    if (!(settings.frequency() >= 8000 && settings.frequency() <= 48000)) {

        errorState = QAudio::OpenError;

        deviceState = QAudio::StoppedState;

        emit stateChanged(deviceState);

        qWarning("QAudioOutput: open error, frequency out of range.");

        return false;

    }

    if(buffer_size == 0) {

        // Default buffer size, 200ms, default period size is 40ms

        buffer_size = settings.frequency()*settings.channels()*(settings.sampleSize()/8)*0.2;

	period_size = buffer_size/5;

    } else {

        period_size = buffer_size/5;

    }

    waveBlocks = allocateBlocks(period_size, buffer_size/period_size);

    mutex.lock();

    waveFreeBlockCount = buffer_size/period_size;

    mutex.unlock();

    waveCurrentBlock = 0;

    if(audioBuffer == 0)

        audioBuffer = new char[buffer_size];

    timeStamp.restart();

    elapsedTimeOffset = 0;

    wfx.nSamplesPerSec = settings.frequency();

    wfx.wBitsPerSample = settings.sampleSize();

    wfx.nChannels = settings.channels();

    wfx.cbSize = 0;

    bool surround = false;

    if (settings.channels() > 2)

        surround = true;

    wfx.wFormatTag = WAVE_FORMAT_PCM;

    wfx.nBlockAlign = (wfx.wBitsPerSample >> 3) * wfx.nChannels;

    wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;

    UINT_PTR devId = WAVE_MAPPER;

    WAVEOUTCAPS woc;

    unsigned long iNumDevs,ii;

    iNumDevs = waveOutGetNumDevs();

    for(ii=0;ii<iNumDevs;ii++) {

        if(waveOutGetDevCaps(ii, &woc, sizeof(WAVEOUTCAPS))

	    == MMSYSERR_NOERROR) {

	    QString tmp;

            tmp = QString::fromWCharArray(woc.szPname);

            if(tmp.compare(QLatin1String(m_device)) == 0) {

	        devId = ii;

		break;

	    }

	}

    }

    if (!surround) {

        if(waveOutOpen(&hWaveOut, devId, &wfx,

                    (DWORD_PTR)&waveOutProc,

                    (DWORD_PTR) this,

                    CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {

            errorState = QAudio::OpenError;

            deviceState = QAudio::StoppedState;

            emit stateChanged(deviceState);

            qWarning("QAudioOutput: open error");

            return false;

        }

    } else {

        WAVEFORMATEXTENSIBLE wfex;

        wfex.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;

        wfex.Format.nChannels = settings.channels();

        wfex.Format.wBitsPerSample = settings.sampleSize();

        wfex.Format.nSamplesPerSec = settings.frequency();

        wfex.Format.nBlockAlign = wfex.Format.nChannels*wfex.Format.wBitsPerSample/8;

        wfex.Format.nAvgBytesPerSec=wfex.Format.nSamplesPerSec*wfex.Format.nBlockAlign;

        wfex.Samples.wValidBitsPerSample=wfex.Format.wBitsPerSample;

        static const GUID _KSDATAFORMAT_SUBTYPE_PCM = {

             0x00000001, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};

        wfex.SubFormat=_KSDATAFORMAT_SUBTYPE_PCM;

        wfex.Format.cbSize=22;

        wfex.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;

        if (settings.channels() >= 4)

            wfex.dwChannelMask |= SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT;

        if (settings.channels() >= 6)

            wfex.dwChannelMask |= SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY;

        if (settings.channels() == 8)

            wfex.dwChannelMask |= SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT;

        if(waveOutOpen(&hWaveOut, devId, &wfex.Format,

                    (DWORD_PTR)&waveOutProc,

                    (DWORD_PTR) this,

                    CALLBACK_FUNCTION) != MMSYSERR_NOERROR) {

            errorState = QAudio::OpenError;

            deviceState = QAudio::StoppedState;

            emit stateChanged(deviceState);

            qWarning("QAudioOutput: open error");

            return false;

        }

    }

    totalTimeValue = 0;

    timeStampOpened.restart();

    elapsedTimeOffset = 0;

    errorState = QAudio::NoError;

    if(pullMode) {

        deviceState = QAudio::ActiveState;

        QTimer::singleShot(10, this, SLOT(feedback()));

    } else

        deviceState = QAudio::IdleState;

    return true;

}

void QAudioOutputPrivate::close()

{

    if(deviceState == QAudio::StoppedState)

        return;

    deviceState = QAudio::StoppedState;

    errorState = QAudio::NoError;

    int delay = (buffer_size-bytesFree())*1000/(settings.frequency()

                  *settings.channels()*(settings.sampleSize()/8));

    waveOutReset(hWaveOut);

    Sleep(delay+10);

    freeBlocks(waveBlocks);

    waveOutClose(hWaveOut);

    delete [] audioBuffer;

    audioBuffer = 0;

    buffer_size = 0;

}

int QAudioOutputPrivate::bytesFree() const

{

    int buf;

    buf = waveFreeBlockCount*period_size;

    return buf;

}

int QAudioOutputPrivate::periodSize() const

{

    return period_size;

}

void QAudioOutputPrivate::setBufferSize(int value)

{

    if(deviceState == QAudio::StoppedState)

        buffer_size = value;

}

int QAudioOutputPrivate::bufferSize() const

{

    return buffer_size;

}

void QAudioOutputPrivate::setNotifyInterval(int ms)

{

    intervalTime = qMax(0, ms);

}

int QAudioOutputPrivate::notifyInterval() const

{

    return intervalTime;

}

qint64 QAudioOutputPrivate::processedUSecs() const

{

    if (deviceState == QAudio::StoppedState)

        return 0;

    qint64 result = qint64(1000000) * totalTimeValue /

        (settings.channels()*(settings.sampleSize()/8)) /

        settings.frequency();

    return result;

}

qint64 QAudioOutputPrivate::write( const char *data, qint64 len )

{

    // Write out some audio data

    if (deviceState != QAudio::ActiveState && deviceState != QAudio::IdleState)

        return 0;

    char* p = (char*)data;

    int l = (int)len;

    WAVEHDR* current;

    int remain;

    current = &waveBlocks[waveCurrentBlock];

    while(l > 0) {

        mutex.lock();

        if(waveFreeBlockCount==0) {

            mutex.unlock();

            break;

        }

        mutex.unlock();

        if(current->dwFlags & WHDR_PREPARED)

            waveOutUnprepareHeader(hWaveOut, current, sizeof(WAVEHDR));

        if(l < period_size)

            remain = l;

        else

            remain = period_size;

        memcpy(current->lpData, p, remain);

        l -= remain;

        p += remain;

        current->dwBufferLength = remain;

        waveOutPrepareHeader(hWaveOut, current, sizeof(WAVEHDR));

        waveOutWrite(hWaveOut, current, sizeof(WAVEHDR));

        mutex.lock();

        waveFreeBlockCount--;

#ifdef DEBUG_AUDIO

        qDebug("write out l=%d, waveFreeBlockCount=%d",

                current->dwBufferLength,waveFreeBlockCount);

#endif

        mutex.unlock();

        totalTimeValue += current->dwBufferLength;

        waveCurrentBlock++;

        waveCurrentBlock %= buffer_size/period_size;

        current = &waveBlocks[waveCurrentBlock];

        current->dwUser = 0;

        errorState = QAudio::NoError;

        if (deviceState != QAudio::ActiveState) {

            deviceState = QAudio::ActiveState;

            emit stateChanged(deviceState);

        }

    }

    return (len-l);

}

void QAudioOutputPrivate::resume()

{

    if(deviceState == QAudio::SuspendedState) {

        deviceState = QAudio::ActiveState;

        errorState = QAudio::NoError;

        waveOutRestart(hWaveOut);

        QTimer::singleShot(10, this, SLOT(feedback()));

        emit stateChanged(deviceState);

    }

}

void QAudioOutputPrivate::suspend()

{

    if(deviceState == QAudio::ActiveState || deviceState == QAudio::IdleState) {

        int delay = (buffer_size-bytesFree())*1000/(settings.frequency()

                *settings.channels()*(settings.sampleSize()/8));

        waveOutPause(hWaveOut);

        Sleep(delay+10);

        deviceState = QAudio::SuspendedState;

        errorState = QAudio::NoError;