Added Sound without many changes made.

Now using std::vector instead of fixed size arrays.

include/Sound.h

@@ -0,0 +1,104 @@
+/*!
+ * \file include/Sound.h
+ * \brief This is the audio manager Header
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#ifndef _SOUND_H_
+#define _SOUND_H_
+
+#include <vector>
+
+/*!
+ * \brief This is the audio manager for OpenRaider
+ */
+class Sound {
+public:
+
+    typedef enum {
+        SoundFlagsNone = 0,       //!< No effect
+        SoundFlagsLoop = (1 << 0) //!< Enable looping during playback
+    } SoundFlags;
+
+    /*!
+     * \brief Constructs an object of Sound
+     */
+    Sound();
+
+    /*!
+     * \brief Deconstructs an object of Sound
+     */
+    ~Sound();
+
+    /*!
+     * \brief Initialize sound system
+     * \returns 0 on success or < 0 error flags
+     */
+    int init();
+
+    /*!
+     * \brief Get number of registered sources
+     * \returns number of registered sources
+     */
+    int registeredSources();
+
+    /*!
+     * \brief Move listener and repositions them
+     * \param pos New position for listener
+     * \param angle New orientation for listener
+     */
+    void listenAt(float pos[3], float angle[3]);
+
+    /*!
+     * \brief Move sound source to position
+     * \param source valid source id
+     * \param pos new position for source
+     */
+    void sourceAt(int source, float pos[3]);
+
+    /*!
+     * \brief Load wav file from disk
+     * \param filename not NULL!
+     * \param source not NULL! Returns new source ID or -1 on error.
+     * \param flags set options. Use SoundFlags enum bitwise OR-ed
+     * \returns 0 for no error or < 0 error flag
+     */
+    int addFile(const char *filename, int *source, unsigned int flags);
+
+    /*!
+     * \brief Load wav file from buffer
+     * \param wav not NULL! Is a valid waveform buffer!
+     * \param length length of wav buffer
+     * \param source not NULL! Returns new source ID or -1 on error.
+     * \param flags set options. Use SoundFlags enum bitwise OR-ed
+     * \returns 0 for no error or < 0 error flag
+     */
+    int addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags);
+
+    /*!
+     * \brief Remove all loaded sounds
+     */
+    void clear();
+
+    /*!
+     * \brief Play sound source
+     * \param source sound source to play
+     */
+    void play(int source);
+
+    /*!
+     * \brief Stop playing sound source
+     * \param source sound source to stop
+     */
+    void stop(int source);
+
+private:
+
+    bool mInit;                        //!< Guard to ensure ausio system is active
+    std::vector<unsigned int> mBuffer; //!< Audio buffer id list
+    std::vector<unsigned int> mSource; //!< Audio source id list
+};
+
+#endif

src/CMakeLists.txt

@@ -1,5 +1,6 @@
 # Set Source files
 set (SRCS ${SRCS} "main.cpp")
+set (SRCS ${SRCS} "Sound.cpp")
 
 #################################################################
 

src/Sound.cpp

@@ -0,0 +1,234 @@
+/*!
+ * \file src/Sound.cpp
+ * \brief This is the audio manager Implementation
+ *
+ * \author xythobuz
+ * \author Mongoose
+ */
+
+#ifdef __APPLE__
+#include <OpenAL/al.h>
+#else
+#include <AL/al.h>
+#endif
+
+#include <AL/alut.h>
+
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "Sound.h"
+
+Sound::Sound() {
+    mInit = false;
+}
+
+Sound::~Sound() {
+    if (mInit)
+        alutExit();
+}
+
+int Sound::init() {
+#ifndef __APPLE__
+    int fd;
+
+    fd = open("/dev/dsp", O_RDWR);
+
+    if (fd < 0) {
+        perror("Sound::Init> Could not open /dev/dsp : ");
+        return -1;
+    }
+
+    close(fd);
+#endif
+
+    ALCdevice *Device = alcOpenDevice("OSS");
+    ALCcontext *Context = alcCreateContext(Device, NULL);
+    alcMakeContextCurrent(Context);
+
+    if (alutInitWithoutContext(NULL, NULL) == AL_FALSE) {
+        printf("Sound::Init> Could not initialize alut (%s)\n", alutGetErrorString(alutGetError()));
+        return -2;
+    }
+
+    mInit = true;
+    printf("Created OpenAL Context\n");
+
+    return 0;
+}
+
+int Sound::registeredSources() {
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+
+    return mSource.size();
+}
+
+void Sound::listenAt(float pos[3], float angle[3]) {
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+    assert(pos != NULL);
+    assert(angle != NULL);
+
+    alListenerfv(AL_POSITION, pos);
+    alListenerfv(AL_ORIENTATION, angle);
+}
+
+void Sound::sourceAt(int source, float pos[3]) {
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+    assert(source >= 0);
+    assert(source < (int)mSource.size());
+    assert(pos != NULL);
+
+    alSourcefv(mSource[source], AL_POSITION, pos);
+}
+
+//! \fixme Seperate sourcing and buffering, Mongoose 2002.01.04
+int Sound::addFile(const char *filename, int *source, unsigned int flags)
+{
+    ALsizei size;
+    ALfloat freq;
+    ALenum format;
+    ALvoid *data;
+    int id;
+
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+    assert(filename != NULL);
+    assert(filename[0] != '\0');
+    assert(source != NULL);
+
+    *source = -1;
+    id = mSource.size();
+
+    alGetError();
+    alGenBuffers(1, &mBuffer[id]);
+    if (alGetError() != AL_NO_ERROR) {
+        fprintf(stderr, "Sound::AddFile> alGenBuffers call failed\n");
+        return -1;
+    }
+
+    alGetError();
+    alGenSources(1, &mSource[id]);
+    if (alGetError() != AL_NO_ERROR) {
+        fprintf(stderr, "Sound::AddFile> alGenSources call failed\n");
+        return -2;
+    }
+
+    // err = alutLoadWAV(filename, &data, &format, &size, &bits, &freq);
+    // is deprecated!
+    data = alutLoadMemoryFromFile(filename, &format, &size, &freq);
+    if (alutGetError() != ALUT_ERROR_NO_ERROR) {
+        fprintf(stderr, "Could not load %s\n", filename);
+        return -3;
+    }
+
+    alBufferData(mBuffer[id], format, data, size, static_cast<ALsizei>(freq));
+    alSourcei(mSource[id], AL_BUFFER, mBuffer[id]);
+
+    if (flags & SoundFlagsLoop) {
+        alSourcei(mSource[id], AL_LOOPING, 1);
+    }
+
+    *source = id;
+
+    return 0;
+}
+
+int Sound::addWave(unsigned char *wav, unsigned int length, int *source, unsigned int flags) {
+    ALsizei size;
+    ALfloat freq;
+    ALenum format;
+    ALvoid *data;
+    int error = 0;
+    int id;
+
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+    assert(wav != NULL);
+    assert(source != NULL);
+
+    *source = -1;
+    id = mSource.size();
+
+    data = wav;
+
+    alGetError();
+    alGenBuffers(1, &mBuffer[id]);
+    if (alGetError() != AL_NO_ERROR) {
+        fprintf(stderr, "Sound::AddWave> alGenBuffers call failed\n");
+        return -1;
+    }
+
+    alGetError();
+    alGenSources(1, &mSource[id]);
+    if (alGetError() != AL_NO_ERROR) {
+        fprintf(stderr, "Sound::AddWave> alGenSources call failed\n");
+        return -2;
+    }
+
+    //AL_FORMAT_WAVE_EXT does not exist on Mac!"
+    // alBufferData(mBuffer[id], AL_FORMAT_WAVE_EXT, data, size, freq);
+    // Idea: Fill Buffer with
+    // alutLoadMemoryFromFileImage
+    //     (const ALvoid *data, ALsizei length, ALenum *format, ALsizei *size, ALfloat *frequency)
+
+    data = alutLoadMemoryFromFileImage(wav, length, &format, &size, &freq);
+    if (((error = alutGetError()) != ALUT_ERROR_NO_ERROR) || (data == NULL)) {
+        fprintf(stderr, "Could not load wav buffer (%s)\n", alutGetErrorString(error));
+        return -3;
+    }
+
+    alBufferData(mBuffer[id], format, data, size, static_cast<ALsizei>(freq));
+    alSourcei(mSource[id], AL_BUFFER, mBuffer[id]);
+
+    if (flags & SoundFlagsLoop) {
+        alSourcei(mSource[id], AL_LOOPING, 1);
+    }
+
+    *source = id;
+
+    //! \fixme Should free alut buffer?
+
+    return 0;
+}
+
+void Sound::clear() {
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+
+    for (size_t i = 0; i < mSource.size(); i++) {
+        alDeleteSources(1, &mSource[i]);
+        alDeleteBuffers(1, &mBuffer[i]);
+    }
+
+    mSource.clear();
+    mBuffer.clear();
+}
+
+void Sound::play(int source) {
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+    assert(source >= 0);
+    assert(source < (int)mSource.size());
+
+    alSourcePlay(mSource[source]);
+}
+
+void Sound::stop(int source) {
+    assert(mInit == true);
+    assert(mSource.size() == mBuffer.size());
+    assert(source >= 0);
+    assert(source < (int)mSource.size());
+
+    alSourceStop(mSource[source]);
+}
+