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

**

** 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 QtMultimedia module of the Qt Toolkit.

**

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

**

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

#include "qaudiooutput_symbian_p.h"

QT_BEGIN_NAMESPACE

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

// Constants

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

const int UnderflowTimerInterval = 50; // ms

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

// Private class

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

SymbianAudioOutputPrivate::SymbianAudioOutputPrivate(

                               QAudioOutputPrivate *audioDevice)

    :   m_audioDevice(audioDevice)

{

}

SymbianAudioOutputPrivate::~SymbianAudioOutputPrivate()

{

}

qint64 SymbianAudioOutputPrivate::readData(char *data, qint64 len)

{

    Q_UNUSED(data)

    Q_UNUSED(len)

    return 0;

}

qint64 SymbianAudioOutputPrivate::writeData(const char *data, qint64 len)

{

    qint64 totalWritten = 0;

    if (m_audioDevice->state() == QAudio::ActiveState ||

        m_audioDevice->state() == QAudio::IdleState) {

        while (totalWritten < len) {

            const qint64 written = m_audioDevice->pushData(data + totalWritten,

                                                           len - totalWritten);

            if (written > 0)

                totalWritten += written;

            else

                break;

        }

    }

    return totalWritten;

}

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

// Public functions

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

QAudioOutputPrivate::QAudioOutputPrivate(const QByteArray &device,

                                       const QAudioFormat &format)

    :   m_device(device)

    ,   m_format(format)

    ,   m_clientBufferSize(SymbianAudio::DefaultBufferSize)

    ,   m_notifyInterval(SymbianAudio::DefaultNotifyInterval)

    ,   m_notifyTimer(new QTimer(this))

    ,   m_error(QAudio::NoError)

    ,   m_internalState(SymbianAudio::ClosedState)

    ,   m_externalState(QAudio::StoppedState)

    ,   m_pullMode(false)

    ,   m_source(0)

    ,   m_devSoundBuffer(0)

    ,   m_devSoundBufferSize(0)

    ,   m_bytesWritten(0)

    ,   m_pushDataReady(false)

    ,   m_bytesPadding(0)

    ,   m_underflow(false)

    ,   m_lastBuffer(false)

    ,   m_underflowTimer(new QTimer(this))

    ,   m_samplesPlayed(0)

    ,   m_totalSamplesPlayed(0)

{

    m_underflowTimer->setInterval(UnderflowTimerInterval);

    connect(m_underflowTimer.data(), SIGNAL(timeout()), this,

            SLOT(underflowTimerExpired()));

}

QAudioOutputPrivate::~QAudioOutputPrivate()

{

    close();

}

QIODevice* QAudioOutputPrivate::start(QIODevice *device)

{

    stop();

    if (device) {

        m_pullMode = true;

        m_source = device;

    }

    open();

    if (SymbianAudio::ClosedState != m_internalState) {

        if (device) {

            connect(m_source, SIGNAL(readyRead()), this, SLOT(dataReady()));

        } else {

            m_source = new SymbianAudioOutputPrivate(this);

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

        }

        m_elapsed.restart();

    }

    return m_source;

}

void QAudioOutputPrivate::stop()

{

    close();

}

void QAudioOutputPrivate::reset()

{

    m_totalSamplesPlayed += getSamplesPlayed();

    m_bytesPadding = 0;

    startPlayback();

}

void QAudioOutputPrivate::suspend()

{

    if (SymbianAudio::ActiveState == m_internalState

        || SymbianAudio::IdleState == m_internalState) {

        m_notifyTimer->stop();

        m_underflowTimer->stop();

        const qint64 samplesWritten = SymbianAudio::Utils::bytesToSamples(

                                          m_format, m_bytesWritten);

        const qint64 samplesPlayed = getSamplesPlayed();

        m_bytesWritten = 0;

        // CMMFDevSound::Pause() is not guaranteed to work correctly in all

        // implementations, for play-mode DevSound sessions.  We therefore

        // have to implement suspend() by calling CMMFDevSound::Stop().

        // Because this causes buffered data to be dropped, we replace the

        // lost data with silence following a call to resume(), in order to

        // ensure that processedUSecs() returns the correct value.

        m_totalSamplesPlayed += samplesPlayed;

        // Calculate the amount of data dropped

        const qint64 paddingSamples = samplesWritten - samplesPlayed;

        m_bytesPadding = SymbianAudio::Utils::samplesToBytes(m_format,

                                                             paddingSamples);

        setState(SymbianAudio::SuspendedState);

    }

}

void QAudioOutputPrivate::resume()

{

        startPlayback();

}

int QAudioOutputPrivate::bytesFree() const

{

    int result = 0;

    if (m_devSoundBuffer) {

        const TDes8 &outputBuffer = m_devSoundBuffer->Data();

        result = outputBuffer.MaxLength() - outputBuffer.Length();

    }

    return result;

}

int QAudioOutputPrivate::periodSize() const

{

    return bufferSize();

}

void QAudioOutputPrivate::setBufferSize(int value)

{

    // Note that DevSound does not allow its client to specify the buffer size.

    // This functionality is available via custom interfaces, but since these

    // cannot be guaranteed to work across all DevSound implementations, we

    // do not use them here.

    // In order to comply with the expected bevahiour of QAudioOutput, we store

    // the value and return it from bufferSize(), but the underlying DevSound

    // buffer size remains unchanged.

    if (value > 0)

        m_clientBufferSize = value;

}

int QAudioOutputPrivate::bufferSize() const

{

    return m_devSoundBufferSize ? m_devSoundBufferSize : m_clientBufferSize;

}

void QAudioOutputPrivate::setNotifyInterval(int ms)

{

        const int oldNotifyInterval = m_notifyInterval;

        m_notifyInterval = ms;

            m_notifyTimer->start(m_notifyInterval);

    }

}

int QAudioOutputPrivate::notifyInterval() const

{

    return m_notifyInterval;

}

qint64 QAudioOutputPrivate::processedUSecs() const

{

    int samplesPlayed = 0;

    if (m_devSound && SymbianAudio::SuspendedState != m_internalState)

        samplesPlayed = getSamplesPlayed();

    // Protect against division by zero

    Q_ASSERT_X(m_format.frequency() > 0, Q_FUNC_INFO, "Invalid frequency");

    const qint64 result = qint64(1000000) *

                          (samplesPlayed + m_totalSamplesPlayed)

                        / m_format.frequency();

    return result;

}

qint64 QAudioOutputPrivate::elapsedUSecs() const

{

    const qint64 result = (QAudio::StoppedState == state()) ?

                              0 : m_elapsed.elapsed() * 1000;

    return result;

}

QAudio::Error QAudioOutputPrivate::error() const

{

    return m_error;

}

QAudio::State QAudioOutputPrivate::state() const

{

    return m_externalState;

}

QAudioFormat QAudioOutputPrivate::format() const

{

    return m_format;

}

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

// Private functions

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

void QAudioOutputPrivate::dataReady()

{

    // Client-provided QIODevice has data ready to read.

    Q_ASSERT_X(m_source->bytesAvailable(), Q_FUNC_INFO,

        "readyRead signal received, but no data available");

    if (!m_bytesPadding)

        pullData();

}

void QAudioOutputPrivate::underflowTimerExpired()

{

    const TInt samplesPlayed = getSamplesPlayed();

    if (m_samplesPlayed && (samplesPlayed == m_samplesPlayed)) {

        setError(QAudio::UnderrunError);

    } else {

        m_samplesPlayed = samplesPlayed;

        m_underflowTimer->start();

    }

}

void QAudioOutputPrivate::open()

{

    Q_ASSERT_X(SymbianAudio::ClosedState == m_internalState,

        Q_FUNC_INFO, "DevSound already opened");

}

void QAudioOutputPrivate::startPlayback()

{

        if (isDataReady())

            setState(SymbianAudio::ActiveState);

        else

            setState(SymbianAudio::IdleState);

        m_underflow = false;

        writePaddingData();

        if (m_pullMode && m_source->bytesAvailable() && !m_bytesPadding)

            dataReady();

    } else {

        setError(QAudio::OpenError);

        close();

    }

}

void QAudioOutputPrivate::writePaddingData()

{

    // See comments in suspend()

    while (m_devSoundBuffer && m_bytesPadding) {

        if (SymbianAudio::IdleState == m_internalState)

            setState(SymbianAudio::ActiveState);

        TDes8 &outputBuffer = m_devSoundBuffer->Data();

        const qint64 outputBytes = bytesFree();

        const qint64 paddingBytes = outputBytes < m_bytesPadding ?

                                        outputBytes : m_bytesPadding;

        unsigned char *ptr = const_cast<unsigned char*>(outputBuffer.Ptr());

        Mem::FillZ(ptr, paddingBytes);

        outputBuffer.SetLength(outputBuffer.Length() + paddingBytes);

        m_bytesPadding -= paddingBytes;

        if (m_pullMode && m_source->atEnd())

            lastBufferFilled();

            bufferFilled();

    }

}

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

{

    // Data has been written to SymbianAudioOutputPrivate

    Q_ASSERT_X(!m_pullMode, Q_FUNC_INFO,

        "pushData called when in pull mode");

    const unsigned char *const inputPtr =

        reinterpret_cast<const unsigned char*>(data);

    qint64 bytesWritten = 0;

    if (SymbianAudio::IdleState == m_internalState)

        setState(SymbianAudio::ActiveState);

    while (m_devSoundBuffer && (bytesWritten < len)) {

        // writePaddingData() is called from BufferToBeFilled(), so we should

        // never have any padding data left at this point.

        Q_ASSERT_X(0 == m_bytesPadding, Q_FUNC_INFO,

            "Padding bytes remaining in pushData");

        TDes8 &outputBuffer = m_devSoundBuffer->Data();

        const qint64 outputBytes = bytesFree();

        const qint64 inputBytes = len - bytesWritten;

        const qint64 copyBytes = outputBytes < inputBytes ?

                                     outputBytes : inputBytes;

        outputBuffer.Append(inputPtr + bytesWritten, copyBytes);

        bytesWritten += copyBytes;

        bufferFilled();

    }

    m_pushDataReady = (bytesWritten < len);

    // If DevSound is still initializing (m_internalState == InitializingState),

    // we cannot transition m_internalState to ActiveState, but we must emit

    // an (external) state change from IdleState to ActiveState.  The following

    // call triggers this signal.

    setState(m_internalState);

    return bytesWritten;

}

void QAudioOutputPrivate::pullData()

{

    Q_ASSERT_X(m_pullMode, Q_FUNC_INFO,

        "pullData called when in push mode");

    // writePaddingData() is called by BufferToBeFilled() before pullData(),

    // so we should never have any padding data left at this point.

    Q_ASSERT_X(0 == m_bytesPadding, Q_FUNC_INFO,

        "Padding bytes remaining in pullData");

    qint64 inputBytes = m_source->bytesAvailable();

    while (m_devSoundBuffer && inputBytes) {

        if (SymbianAudio::IdleState == m_internalState)

            setState(SymbianAudio::ActiveState);

        TDes8 &outputBuffer = m_devSoundBuffer->Data();

        const qint64 outputBytes = bytesFree();

        const qint64 copyBytes = outputBytes < inputBytes ?

                                     outputBytes : inputBytes;

        char *outputPtr = (char*)(outputBuffer.Ptr() + outputBuffer.Length());

        const qint64 bytesCopied = m_source->read(outputPtr, copyBytes);

        Q_ASSERT(bytesCopied == copyBytes);

        outputBuffer.SetLength(outputBuffer.Length() + bytesCopied);