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

**

** 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 QtGui 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 "qsound.h"

#ifndef QT_NO_SOUND

#include "qlist.h"

#include <private/qobject_p.h>

#include "qsound_p.h"

QT_BEGIN_NAMESPACE

static QList<QAuServer*> *servers=0;

QAuServer::QAuServer(QObject* parent)

    : QObject(parent)

{

    if (!servers)

        servers = new QList<QAuServer*>;

    servers->prepend(this);

}

QAuServer::~QAuServer()

{

    servers->removeAll(this);

    if (servers->count() == 0) {

        delete servers;

        servers = 0;

    }

}

void QAuServer::play(const QString& filename)

{

    QSound s(filename);

    play(&s);

}

extern QAuServer* qt_new_audio_server();

static QAuServer& server()

{

    if (!servers) qt_new_audio_server();

    return *servers->first();

}

class QSoundPrivate : public QObjectPrivate

{

public:

    QSoundPrivate(const QString& fname)

        : filename(fname), bucket(0), looprem(0), looptotal(1)

    {

    }

    ~QSoundPrivate()

    {

        delete bucket;

    }

    QString filename;

    QAuBucket* bucket;

    int looprem;

    int looptotal;

};

/*!

    \class QSound

    \brief The QSound class provides access to the platform audio facilities.

    \ingroup multimedia

    Qt provides the most commonly required audio operation in GUI

    applications: asynchronously playing a sound file. This is most

    easily accomplished using the static play() function:

    \snippet doc/src/snippets/code/src_gui_kernel_qsound.cpp 0

    Alternatively, create a QSound object from the sound file first

    and then call the play() slot:

    \snippet doc/src/snippets/code/src_gui_kernel_qsound.cpp 1

    Once created a QSound object can be queried for its fileName() and

    total number of loops() (i.e. the number of times the sound will

    play). The number of repetitions can be altered using the

    setLoops() function. While playing the sound, the loopsRemaining()

    function returns the remaining number of repetitions. Use the

    isFinished() function to determine whether the sound has finished

    playing.

    Sounds played using a QSound object may use more memory than the

    static play() function, but it may also play more immediately

    (depending on the underlying platform audio facilities). Use the

    static isAvailable() function to determine whether sound

    facilities exist on the platform. Which facilities that are

    actually used varies:

    \table

    \header \o Platform \o Audio Facility

    \row

    \o Microsoft Windows

    \o The underlying multimedia system is used; only WAVE format sound files

    are supported.

    \row

    \o X11

    \o The \l{ftp://ftp.x.org/contrib/audio/nas/}{Network Audio System}

    is used if available, otherwise all operations work silently. NAS

    supports WAVE and AU files.

    \row

    \o Mac OS X

    are supported by Qt for Mac OS X.

    \row

    \o Qt for Embedded Linux

    \o A built-in mixing sound server is used, accessing \c /dev/dsp

    directly. Only the WAVE format is supported.

    \o Symbian

    \o CMdaAudioPlayerUtility is used. All formats that Symbian OS or devices support

    are supported also by Qt.

    \endtable

    Note that QSound does not support \l{resources.html}{resources}.

    This might be fixed in a future Qt version.

*/

/*!

    Plays the sound stored in the file specified by the given \a filename.

    \sa stop(), loopsRemaining(), isFinished()

*/

void QSound::play(const QString& filename)

{

    server().play(filename);

}

/*!

    Constructs a QSound object from the file specified by the given \a

    filename and with the given \a parent.

    This may use more memory than the static play() function, but it

    may also play more immediately (depending on the underlying

    platform audio facilities).

    \sa play()

*/

QSound::QSound(const QString& filename, QObject* parent)

    : QObject(*new QSoundPrivate(filename), parent)

{

    server().init(this);

}

#ifdef QT3_SUPPORT

/*!

    \obsolete

    Constructs a QSound object from the file specified by the given \a

    filename and with the given \a parent and \a name. Use the

    QSound() construcor and QObject::setObjectName() instead.

    \oldcode

        QSound *mySound = new QSound(filename, parent, name);

    \newcode

        QSounc *mySound = new QSound(filename, parent);

        mySound->setObjectName(name);

    \endcode

*/

QSound::QSound(const QString& filename, QObject* parent, const char* name)

    : QObject(*new QSoundPrivate(filename), parent)

{

    setObjectName(QString::fromAscii(name));

    server().init(this);

}

#endif

/*!

    Destroys this sound object. If the sound is not finished playing,

    the stop() function is called before the sound object is

    destructed.

    \sa stop(), isFinished()

*/

QSound::~QSound()

{

    if (!isFinished())

        stop();

}

/*!

    Returns true if the sound has finished playing; otherwise returns false.

    \warning On Windows this function always returns true for unlooped sounds.

*/

bool QSound::isFinished() const

{

    Q_D(const QSound);

    return d->looprem == 0;

}

/*!

    \overload

    Starts playing the sound specified by this QSound object.

    The function returns immediately.  Depending on the platform audio

    facilities, other sounds may stop or be mixed with the new

    sound. The sound can be played again at any time, possibly mixing

    or replacing previous plays of the sound.

    \sa fileName()

*/

void QSound::play()

{

    Q_D(QSound);

    d->looprem = d->looptotal;

    server().play(this);

}

/*!

    Returns the number of times the sound will play.

    \sa loopsRemaining(), setLoops()

*/

int QSound::loops() const

{

    Q_D(const QSound);

    return d->looptotal;

}

/*!

    Returns the remaining number of times the sound will loop (this

    value decreases each time the sound is played).

    \sa loops(), isFinished()

*/

int QSound::loopsRemaining() const

{

    Q_D(const QSound);

    return d->looprem;

}

/*!

    \fn void QSound::setLoops(int number)

    Sets the sound to repeat the given \a number of times when it is

    played.

    Note that passing the value -1 will cause the sound to loop

    indefinitely.

    \sa loops()

*/

void QSound::setLoops(int n)

{

    Q_D(QSound);

    d->looptotal = n;

}

/*!

    Returns the filename associated with this QSound object.

    \sa QSound()

*/

QString QSound::fileName() const

{

    Q_D(const QSound);

    return d->filename;

}

/*!

    Stops the sound playing.

    Note that on Windows the current loop will finish if a sound is

    played in a loop.

    \sa play()

*/

void QSound::stop()

{

    Q_D(QSound);

    server().stop(this);

    d->looprem = 0;

}

/*!

    Returns true if sound facilities exist on the platform; otherwise

    returns false.

    If no sound is available, all QSound operations work silently and

    quickly. An application may choose either to notify the user if

    sound is crucial to the application or to operate silently without

    bothering the user.

    Note: On Windows this always returns true because some sound card

    drivers do not implement a way to find out whether it is available

    or not.

*/

bool QSound::isAvailable()

{

    return server().okay();

}

/*!

    Sets the internal bucket record of sound \a s to \a b, deleting

    any previous setting.

*/

void QAuServer::setBucket(QSound* s, QAuBucket* b)

{

    delete s->d_func()->bucket;

    s->d_func()->bucket = b;

}

/*!

    Returns the internal bucket record of sound \a s.

*/

QAuBucket* QAuServer::bucket(QSound* s)

{

    return s->d_func()->bucket;

}

/*!

    Decrements the QSound::loopRemaining() value for sound \a s,

    returning the result.

*/

int QAuServer::decLoop(QSound* s)

{

    if (s->d_func()->looprem > 0)

        --s->d_func()->looprem;

    return s->d_func()->looprem;

}

/*!

    Initializes the sound. The default implementation does nothing.

*/

void QAuServer::init(QSound*)

{

}

QAuBucket::~QAuBucket()

{

}

/*!

    \fn bool QSound::available()

    Use the isAvailable() function instead.

*/

QT_END_NAMESPACE

#endif // QT_NO_SOUND