Add a not yet fully implemented QALSource class

Change-Id: I37eb58ba39fa1cfeb0a56d7df88bd8bf8de3d3e4
Reviewed-by: Laszlo Papp <lpapp@kde.org>

2 files changed, 502 insertions, 39 deletions

diff --git a/src/qalsource.cpp b/src/qalsource.cpp
index d4b9047..94a39ba 100644
--- a/src/qalsource.cpp
+++ b/src/qalsource.cpp
@@ -1,29 +1,379 @@
-/******************************************************************************
- * This file is part of the QtOpenAL project
- * Copyright (c) 2011 Laszlo Papp <lpapp@kde.org>
- *
- * 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 Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
+/****************************************************************************
+**
+** Copyright (C) 2012 Laszlo Papp <lpapp@kde.org>
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtAudio3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
 
 #include "qalsource.h"
 
-QALSource::QALSource()
+class QALSource::Private
 {
+    public:
+        Private()
+            : source(0)
+        {
+        }
+
+        ~Private()
+        {
+        }
+
+        ALuint source;
+};
+
+QALSource::QALSource(unsigned int source)
+    : d(new Private)
+{
+    d->source = source;
 }
 
 QALSource::~QALSource()
 {
 }
 
+float QALSource::minimumGain() const
+{
+    float minimumGain;
+    alGetSourcef(d->source, AL_MIN_GAIN, &minimumGain);
+
+    return minimumGain;
+}
+
+float QALSource::maximumGain() const
+{
+    float maximumGain;
+    alGetSourcef(d->source, AL_MAX_GAIN, &maximumGain);
+
+    return maximumGain;
+}
+
+float QALSource::gain() const
+{
+    float gain;
+    alGetSourcef(d->source, AL_GAIN, &gain);
+
+    return gain;
+}
+
+bool QALSource::isRelative() const
+{
+    ALint isRelative;
+    alGetSourcei(d->source, AL_SOURCE_RELATIVE, &isRelative);
+
+    return (isRelative == AL_TRUE) ? true : false;
+}
+
+QALSource::Type QALSource::type() const
+{
+    ALint type;
+    alGetSourcei(d->source, AL_SOURCE_TYPE, &type);
+
+    Type sourceType;
+
+    switch (type) {
+    case AL_STATIC:
+        sourceType = Static;
+        break;
+
+    case AL_STREAMING:
+        sourceType = Streaming;
+        break;
+
+    case AL_UNDETERMINED:
+        sourceType = Undetermined;
+        break;
+
+    default:
+        sourceType = Undetermined;
+        break;
+    }
+
+    return sourceType;
+}
+
+bool QALSource::isLooping() const
+{
+    ALint isLooping;
+    alGetSourcei(d->source, AL_LOOPING, &isLooping);
+
+    return (isLooping == AL_TRUE) ? true : false;
+}
+
+int QALSource::currentBuffer() const
+{
+    ALint currentBuffer;
+    alGetSourcei(d->source, AL_BUFFER, &currentBuffer);
+
+    return currentBuffer;
+}
+
+int QALSource::queuedBuffers() const
+{
+    ALint queuedBuffers;
+    alGetSourcei(d->source, AL_BUFFERS_QUEUED, &queuedBuffers);
+
+    return queuedBuffers;
+}
+
+int QALSource::processedBuffers() const
+{
+    ALint processedBuffers;
+    alGetSourcei(d->source, AL_BUFFERS_PROCESSED, &processedBuffers);
+
+    return processedBuffers;
+}
+
+float QALSource::referenceDistance() const
+{
+    float referenceDistance;
+    alGetSourcef(d->source, AL_REFERENCE_DISTANCE, &referenceDistance);
+
+    return referenceDistance;
+}
+
+float QALSource::maximumDistance() const
+{
+    float maximumDistance;
+    alGetSourcef(d->source, AL_MAX_DISTANCE, &maximumDistance);
+
+    return maximumDistance;
+}
+
+float QALSource::rollOffFactor() const
+{
+    float rollOffFactor;
+    alGetSourcef(d->source, AL_ROLLOFF_FACTOR, &rollOffFactor);
+
+    return rollOffFactor;
+}
+
+float QALSource::pitch() const
+{
+    float pitch;
+    alGetSourcef(d->source, AL_PITCH, &pitch);
+
+    return pitch;
+}
+
+float QALSource::coneInnerAngle() const
+{
+    float coneInnerAngle;
+    alGetSourcef(d->source, AL_CONE_INNER_ANGLE, &coneInnerAngle);
+
+    return coneInnerAngle;
+}
+
+float QALSource::coneOuterAngle() const
+{
+    float coneOuterAngle;
+    alGetSourcef(d->source, AL_CONE_OUTER_ANGLE, &coneOuterAngle);
+
+    return coneOuterAngle;
+}
+
+float QALSource::coneOuterGain() const
+{
+    float coneOuterGain;
+    alGetSourcef(d->source, AL_CONE_OUTER_GAIN, &coneOuterGain);
+
+    return coneOuterGain;
+}
+
+float QALSource::secondOffset() const
+{
+    float secondOffset;
+    alGetSourcef(d->source, AL_SEC_OFFSET, &secondOffset);
+
+    return secondOffset;
+}
+
+float QALSource::sampleOffset() const
+{
+    float sampleOffset;
+    alGetSourcef(d->source, AL_SAMPLE_OFFSET, &sampleOffset);
+
+    return sampleOffset;
+}
+
+float QALSource::byteOffset() const
+{
+    float byteOffset;
+    alGetSourcef(d->source, AL_BYTE_OFFSET, &byteOffset);
+
+    return byteOffset;
+}
+
+void QALSource::setPosition(int px, int py, int pz)
+{
+    alSource3i(d->source, AL_POSITION, px, py, pz);
+}
+
+void QALSource::setPosition(float px, float py, float pz)
+{
+    alSource3f(d->source, AL_POSITION, px, py, pz);
+}
+
+void QALSource::setVelocity(int vx, int vy, int vz)
+{
+    alSource3i(d->source, AL_VELOCITY, vx, vy, vz);
+}
+
+void QALSource::setVelocity(float vx, float vy, float vz)
+{
+    alSource3f(d->source, AL_VELOCITY, vx, vy, vz);
+}
+
+void QALSource::setMinimumGain(float minimumGain)
+{
+    alSourcef(d->source, AL_MIN_GAIN, minimumGain);
+}
+
+void QALSource::setMaximumGain(float maximumGain)
+{
+    alSourcef(d->source, AL_MAX_GAIN, maximumGain);
+}
+
+void QALSource::setGain(float gain)
+{
+    alSourcef(d->source, AL_GAIN, gain);
+}
+
+void QALSource::setRelative(bool relative)
+{
+    alSourcei(d->source, AL_SOURCE_RELATIVE, relative);
+}
+
+void QALSource::setLooping(bool looping)
+{
+    alSourcei(d->source, AL_LOOPING, looping);
+}
+
+void QALSource::setCurrentBuffer(int currentBuffer)
+{
+    alSourcei(d->source, AL_BUFFER, currentBuffer);
+}
+
+void QALSource::setReferenceDistance(int referenceDistance)
+{
+    alSourcei(d->source, AL_REFERENCE_DISTANCE, referenceDistance);
+}
+
+void QALSource::setReferenceDistance(float referenceDistance)
+{
+    alSourcef(d->source, AL_REFERENCE_DISTANCE, referenceDistance);
+}
+
+void QALSource::setMaximumDistance(int maximumDistance)
+{
+    alSourcei(d->source, AL_MAX_DISTANCE, maximumDistance);
+}
+
+void QALSource::setMaximumDistance(float maximumDistance)
+{
+    alSourcef(d->source, AL_MAX_DISTANCE, maximumDistance);
+}
+
+void QALSource::setRollOffFactor(int rollOffFactor)
+{
+    alSourcei(d->source, AL_ROLLOFF_FACTOR, rollOffFactor);
+}
+
+void QALSource::setRollOffFactor(float rollOffFactor)
+{
+    alSourcef(d->source, AL_ROLLOFF_FACTOR, rollOffFactor);
+}
+
+void QALSource::setPitch(float pitch)
+{
+    alSourcef(d->source, AL_PITCH, pitch);
+}
+
+void QALSource::setConeInnerAngle(int coneInnerAngle)
+{
+    alSourcei(d->source, AL_CONE_INNER_ANGLE, coneInnerAngle);
+}
+
+void QALSource::setConeInnerAngle(float coneInnerAngle)
+{
+    alSourcef(d->source, AL_CONE_INNER_ANGLE, coneInnerAngle);
+}
+
+void QALSource::setConeOuterAngle(int coneOuterAngle)
+{
+    alSourcei(d->source, AL_CONE_OUTER_ANGLE, coneOuterAngle);
+}
+
+void QALSource::setConeOuterAngle(float coneOuterAngle)
+{
+    alSourcef(d->source, AL_CONE_OUTER_ANGLE, coneOuterAngle);
+}
+
+void QALSource::setConeOuterGain(float coneOuterGain)
+{
+    alSourcef(d->source, AL_CONE_OUTER_GAIN, coneOuterGain);
+}
+
+void QALSource::setSecondOffset(int secondOffset)
+{
+    alSourcei(d->source, AL_SEC_OFFSET, secondOffset);
+}
+
+void QALSource::setSecondOffset(float secondOffset)
+{
+    alSourcef(d->source, AL_SEC_OFFSET, secondOffset);
+}
+
+void QALSource::setSampleOffset(int sampleOffset)
+{
+    alSourcei(d->source, AL_SAMPLE_OFFSET, sampleOffset);
+}
+
+void QALSource::setSampleOffset(float sampleOffset)
+{
+    alSourcef(d->source, AL_SAMPLE_OFFSET, sampleOffset);
+}
+
+void QALSource::setByteOffset(int byteOffset)
+{
+    alSourcei(d->source, AL_BYTE_OFFSET, byteOffset);
+}
+
+void QALSource::setByteOffset(float byteOffset)
+{
+    alSourcef(d->source, AL_BYTE_OFFSET, byteOffset);
+}
diff --git a/src/qalsource.h b/src/qalsource.h
index a5d8302..1c6be4f 100644
--- a/src/qalsource.h
+++ b/src/qalsource.h
@@ -1,21 +1,43 @@
-/******************************************************************************
- * This file is part of the QtOpenAL project
- * Copyright (c) 2011 Laszlo Papp <lpapp@kde.org>
- *
- * 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 Street, Fifth Floor, Boston, MA  02110-1301  USA
- */
+/****************************************************************************
+**
+** Copyright (C) 2012 Laszlo Papp <lpapp@kde.org>
+** Contact: http://www.qt-project.org/
+**
+** This file is part of the QtAudio3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** GNU Lesser General Public License Usage
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU General
+** Public License version 3.0 as published by the Free Software Foundation
+** and appearing in the file LICENSE.GPL included in the packaging of this
+** file. Please review the following information to ensure the GNU General
+** Public License version 3.0 requirements will be met:
+** http://www.gnu.org/copyleft/gpl.html.
+**
+** Other Usage
+** Alternatively, this file may be used in accordance with the terms and
+** conditions contained in a signed written agreement between you and Nokia.
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
 
 #ifndef QALSOURCE_H
 #define QALSOURCE_H
@@ -24,10 +46,101 @@
 
 class Q_OPENAL_EXPORT QALSource
 {
-    //Q_DECLARE_PRIVATE(QALSource)
 public:
-    QALSource();
+
+    enum Type {
+        Static,
+        Streaming,
+        Undetermined
+    };
+
+    QALSource(unsigned int source);
     virtual ~QALSource();
+
+    float minimumGain() const;
+    float maximumGain() const;
+
+    float gain() const;
+
+    bool isRelative() const;
+
+    Type type() const;
+
+    bool isLooping() const;
+
+    int currentBuffer() const;
+
+    int queuedBuffers() const;
+    int processedBuffers() const;
+
+    float referenceDistance() const;
+
+    float maximumDistance() const;
+
+    float rollOffFactor() const;
+
+    float pitch() const;
+
+    float coneInnerAngle() const;
+    float coneOuterAngle() const;
+
+    float coneOuterGain() const;
+
+    float secondOffset() const;
+    float sampleOffset() const;
+    float byteOffset() const;
+
+    void setPosition(int px, int py, int pz);
+    void setPosition(float px, float py, float pz);
+
+    void setVelocity(int vx, int vy, int vz);
+    void setVelocity(float vx, float vy, float vz);
+
+    void setMinimumGain(float minimumGain);
+    void setMaximumGain(float maximumGain);
+
+    void setGain(float gain);
+
+    void setRelative(bool relative);
+
+    void setLooping(bool looping);
+
+    void setCurrentBuffer(int currentBuffer);
+
+    void setReferenceDistance(int referenceDistance);
+    void setReferenceDistance(float referenceDistance);
+
+    void setMaximumDistance(int maximumDistance);
+    void setMaximumDistance(float maximumDistance);
+
+    void setRollOffFactor(int rollOffFactor);
+    void setRollOffFactor(float rollOffFactor);
+
+    void setPitch(float pitch);
+
+    void setDirection(int dx, int dy, int dz);
+    void setDirection(float dx, float dy, float dz);
+
+    void setConeInnerAngle(int coneInnerAngle);
+    void setConeInnerAngle(float coneInnerAngle);
+
+    void setConeOuterAngle(int coneOuterAngle);
+    void setConeOuterAngle(float coneOuterAngle);
+
+    void setConeOuterGain(float coneOuterGain);
+
+    void setSecondOffset(int secondOffset);
+    void setSecondOffset(float secondOffset);
+
+    void setSampleOffset(int sampleOffset);
+    void setSampleOffset(float sampleOffset);
+
+    void setByteOffset(int byteOffset);
+    void setByteOffset(float byteOffset);
+
+    private:
+        class Private;
+        Private *const d;
 };
 
 #endif