seal 0.1.0

data/src/seal/err.c

@@ -0,0 +1,118 @@
+/*
+ * err.c is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ */
+
+#include <al/al.h>
+#include <seal/err.h>
+
+const char*
+seal_get_err_msg(seal_err_t err)
+{
+    switch (err) {
+    case SEAL_OK:
+        return 0;
+
+    case SEAL_BAD_OBJ:
+        return "Invalid object";
+    case SEAL_BAD_ENUM:
+        return "Invalid token";
+    case SEAL_BAD_VAL:
+        return "Invalid parameter value";
+    case SEAL_BAD_OP:
+        return "Invalid operation";
+
+    case SEAL_CANNOT_OPEN_DEVICE:
+        return "Cannot open the specified device";
+    case SEAL_NO_EFX:
+        return "The effect module is not found";
+    case SEAL_NO_EXT_FUNC:
+        return "The required extension functions are not found";
+    case SEAL_BAD_DEVICE:
+        return "Invalid device";
+    case SEAL_CANNOT_CREATE_CONTEXT:
+        return "Cannot create an additional context for the device";
+
+    case SEAL_STREAM_UNOPENED:
+        return "Cannot use the uninitialized stream";
+    case SEAL_MIXING_STREAM_FMT:
+        return "Cannot attach a stream with a different audio format than "
+               "that of the currently attached stream";
+
+    case SEAL_MIXING_SRC_TYPE:
+        return "Cannot attach a stream to a static source or "
+               "attach a buffer to a streaming source";
+
+    case SEAL_CANNOT_OPEN_FILE:
+        return "Cannot open the specified file";
+    case SEAL_CANNOT_ALLOC_MEM:
+        return "Cannot allocate additional memory";
+
+    case SEAL_BAD_AUDIO:
+        return "The specified audio file format is unsupported";
+    case SEAL_BAD_PRESET:
+        return "The specified preset is invalid";
+
+    case SEAL_BAD_WAV_SUBTYPE:
+        return "The specified WAVE file has an unsupported subtype";
+    case SEAL_BAD_WAV_CHUNK:
+        return "The specified WAVE file has an invalid chunk";
+    case SEAL_BAD_WAV_CHUNK_SIZE:
+        return "The specified WAVE file has an invalid chunk size";
+    case SEAL_ABSENT_WAV_CHUNK:
+        return "The specified WAVE file is missing a required chunk";
+    case SEAL_BAD_WAV_BPS:
+        return "The specified WAVE file has an unsupported bit depth";
+    case SEAL_BAD_WAV_NCHANNELS:
+        return "The specified WAVE file has an invalid number of channels";
+    case FILE_BAD_WAV_FREQ:
+        return "The specified WAVE file has an invalid sample rate";
+    case SEAL_CANNOT_REWIND_WAV:
+        return "Failed rewinding the specified WAVE file";
+
+    case SEAL_CANNOT_OPEN_OV:
+        return "Failed openning the specified Ogg Vorbis file";
+    case SEAL_CANNOT_GET_OV_INFO:
+        return "Failed getting info from the specified Ogg Vorbis file";
+    case SEAL_CANNOT_READ_OV:
+        return "Failed reading the specified Ogg Vorbis file";
+    case SEAL_CANNOT_REWIND_OV:
+        return "Failed rewinding the specified Ogg Vorbis file";
+    case SEAL_CANNOT_CLOSE_OV:
+        return "Failed closing the specified Ogg Vorbis file";
+
+    case SEAL_CANNOT_INIT_MPG:
+        return "Failed initializing MPEG decoder";
+    case SEAL_CANNOT_GET_MPG_INFO:
+        return "Failed getting info from the specified MPEG file";
+    case SEAL_CANNOT_READ_MPG:
+        return "Failed reading the specified MPEG file";
+    case SEAL_CANNOT_REWIND_MPG:
+        return "Failed rewinding the specified MPEG file";
+    case SEAL_CANNOT_CLOSE_MPG:
+        return "Failed closing the specified MPEG file";
+
+    default:
+        return "Unkown error";
+    }
+}
+
+seal_err_t
+_seal_get_openal_err(void)
+{
+    switch (alGetError()) {
+    case AL_INVALID_NAME:
+        return SEAL_BAD_OBJ;
+    case AL_INVALID_ENUM:
+        return SEAL_BAD_ENUM;
+    case AL_INVALID_VALUE:
+        return SEAL_BAD_VAL;
+    case AL_INVALID_OPERATION:
+        return SEAL_BAD_OP;
+    case AL_OUT_OF_MEMORY:
+        return SEAL_CANNOT_ALLOC_MEM;
+    default:
+        return SEAL_OK;
+    }
+}

data/src/seal/fmt.c

@@ -0,0 +1,86 @@
+/*
+ * fmt.c is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ */
+
+#include <stdio.h>
+#include <stdint.h>
+#include <seal/fmt.h>
+#include <seal/err.h>
+#include "reader.h"
+
+enum
+{
+    RIFF = SEAL_MKTAG('R', 'I', 'F', 'F'),
+    WAVE = SEAL_MKTAG('W', 'A', 'V', 'E'),
+    OGGS = SEAL_MKTAG('O', 'g', 'g', 'S'),
+    /* APE tag identifier (splitted). */
+    APET = SEAL_MKTAG('A', 'P', 'E', 'T'),
+    AGEX = SEAL_MKTAG('A', 'G', 'E', 'X'),
+    /* Number of magic numbers needed to recognize the format. */
+    SAMPLE_SIZE = 3
+};
+
+/* ID3v1 tag identifier. */
+static const unsigned int TAG_ = SEAL_MKTAG('T', 'A', 'G', 0);
+/* ID3v2 tag identifier. */
+static const unsigned int ID3_ = SEAL_MKTAG('I', 'D', '3', 0);
+/* MP3 Sync identifier. */
+static const unsigned int SYNC = 0xf0ff;
+
+seal_err_t
+seal_recognize_fmt(const char* filename, seal_fmt_t* pfmt)
+{
+    FILE* audio;
+    uint32_t magic_nums[SAMPLE_SIZE];
+
+    audio = _seal_fopen(filename);
+    if (audio == 0)
+        return SEAL_CANNOT_OPEN_FILE;
+
+    /* Gets the magic numbers in little-endian. */
+    _seal_read_uint32le(magic_nums, SAMPLE_SIZE, audio);
+
+    _seal_fclose(audio);
+
+    switch (magic_nums[0]) {
+    case RIFF:
+        switch (magic_nums[2]) {
+        case WAVE:
+            *pfmt = SEAL_WAV_FMT;
+            return SEAL_OK;
+        }
+        break;
+    case OGGS:
+        *pfmt = SEAL_OV_FMT;
+        return SEAL_OK;
+    case APET:
+        switch (magic_nums[1]) {
+        case AGEX:
+            *pfmt = SEAL_MPG_FMT;
+            return SEAL_OK;
+        }
+        break;
+    }
+
+    if ((magic_nums[0] & TAG_) == TAG_ ||
+        (magic_nums[0] & ID3_) == ID3_ ||
+        (magic_nums[0] & SYNC) == SYNC) {
+        *pfmt = SEAL_MPG_FMT;
+        return SEAL_OK;
+    }
+
+    *pfmt = SEAL_UNKNOWN_FMT;
+
+    return SEAL_BAD_AUDIO;
+}
+
+seal_err_t
+seal_ensure_fmt_known(const char* filename, seal_fmt_t* pfmt)
+{
+    if (*pfmt == SEAL_UNKNOWN_FMT)
+        return seal_recognize_fmt(filename, pfmt);
+
+    return SEAL_OK;
+}

data/src/seal/listener.c

@@ -0,0 +1,111 @@
+/*
+ * listener.c is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ */
+
+#include <al/al.h>
+#include <seal/listener.h>
+#include <seal/err.h>
+
+static
+seal_err_t
+setf(int key, float val)
+{
+    alListenerf(key, val);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+set3f(int key, float x, float y, float z)
+{
+    alListener3f(key, x, y, z);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+setfv(int key, float* vector)
+{
+    alListenerfv(key, vector);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+getf(int key, float* pval)
+{
+    alGetListenerf(key, pval);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+get3f(int key, float* px, float* py, float* pz)
+{
+    alGetListener3f(key, px, py, pz);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+getfv(int key, float* vector)
+{
+    alGetListenerfv(key, vector);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+seal_set_listener_gain(float gain)
+{
+    return setf(AL_GAIN, gain);
+}
+
+seal_err_t
+seal_set_listener_pos(float x, float y, float z)
+{
+    return set3f(AL_POSITION, x, y, z);
+}
+
+seal_err_t
+seal_set_listener_vel(float x, float y, float z)
+{
+    return set3f(AL_VELOCITY, x, y, z);
+}
+
+seal_err_t
+seal_set_listener_orien(float* orien)
+{
+    return setfv(AL_ORIENTATION, orien);
+}
+
+seal_err_t
+seal_get_listener_gain(float* pgain)
+{
+    return getf(AL_GAIN, pgain);
+}
+
+seal_err_t
+seal_get_listener_pos(float* px, float* py, float* pz)
+{
+    return get3f(AL_POSITION, px, py, pz);
+}
+
+seal_err_t
+seal_get_listener_vel(float* px, float* py, float* pz)
+{
+    return get3f(AL_VELOCITY, px, py, pz);
+}
+
+seal_err_t
+seal_get_listener_orien(float* orien)
+{
+    return getfv(AL_ORIENTATION, orien);
+}

data/src/seal/mpg.c

@@ -0,0 +1,174 @@
+/*
+ * mpg.c is part of the Scorched End Audio Library (SEAL) and is licensed
+ * under the terms of the GNU Lesser General Public License. See COPYING
+ * attached with the library.
+ */
+
+#include <stdio.h>
+#include <stddef.h>
+#include <mpg123/mpg123.h>
+#include <seal/raw.h>
+#include <seal/stream.h>
+#include <seal/err.h>
+#include "mpg.h"
+
+/* Initial buffer size for loading. */
+static const int INITIAL_BUF_SIZE = 32768;
+
+
+static
+mpg123_handle*
+setup(seal_raw_attr_t* attr, const char* filename)
+{
+    mpg123_handle* mh;
+    long freq;
+    int encoding;
+
+    /* Use the default decoder. */
+    mh = mpg123_new(0, 0);
+    if (mh == 0)
+        return 0;
+
+    if (mpg123_open(mh, filename) != MPG123_OK)
+        goto cleanup;
+
+#ifndef NDEBUG
+    mpg123_param(mh, MPG123_FLAGS, MPG123_QUIET, 0);
+#endif
+
+    attr->bit_depth = 16;
+    /* Default encoding is MPG123_ENC_SIGNED_16. */
+    if (mpg123_getformat(mh, &freq, &attr->nchannels, &encoding) != MPG123_OK)
+        goto cleanup;
+    attr->freq = freq;
+
+    return mh;
+
+cleanup:
+    mpg123_close(mh);
+
+    return 0;
+}
+
+static
+int
+read(seal_raw_t* raw, size_t* nbytes_loaded, mpg123_handle* mh)
+{
+    int err;
+    size_t nbytes_read = 0;
+
+    err = mpg123_read(mh, (unsigned char*) raw->data + *nbytes_loaded,
+                      raw->size - *nbytes_loaded, &nbytes_read);
+    *nbytes_loaded += nbytes_read;
+
+    return err;
+}
+
+static
+seal_err_t
+load(seal_raw_t* raw, mpg123_handle* mh)
+{
+    size_t nbytes_loaded = 0;
+    seal_err_t err;
+
+    if ((err = seal_alloc_raw_data(raw, INITIAL_BUF_SIZE)) != SEAL_OK)
+        return err;
+
+    do {
+        if ((err = seal_ensure_raw_data_size(raw, nbytes_loaded)) != SEAL_OK)
+            goto cleanup;
+    } while (read(raw, &nbytes_loaded, mh) == MPG123_OK);
+
+    if (nbytes_loaded == 0) {
+        err = SEAL_CANNOT_READ_MPG;
+        goto cleanup;
+    }
+
+    raw->size = nbytes_loaded;
+
+    return SEAL_OK;
+
+cleanup:
+    seal_free_raw_data(raw);
+
+    return err;
+}
+
+seal_err_t
+_seal_load_mpg(seal_raw_t* raw, const char* filename)
+{
+    mpg123_handle* mh;
+    seal_raw_t tmp_raw;
+    seal_err_t err;
+
+    mh = setup(&tmp_raw.attr, filename);
+    if (mh == 0)
+        return SEAL_CANNOT_INIT_MPG;
+
+    if ((err = load(&tmp_raw, mh)) == SEAL_OK)
+        *raw = tmp_raw;
+
+    mpg123_close(mh);
+
+    return err;
+}
+
+seal_err_t
+_seal_init_mpg_stream(seal_stream_t* stream, const char* filename)
+{
+    mpg123_handle* mh;
+    seal_raw_attr_t tmp_attr;
+
+    mh = setup(&tmp_attr, filename);
+    if (mh == 0)
+        return SEAL_CANNOT_INIT_MPG;
+
+    stream->id = mh;
+    stream->fmt = SEAL_MPG_FMT;
+    stream->attr = tmp_attr;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_stream_mpg(seal_stream_t* stream, seal_raw_t* raw, size_t* psize)
+{
+    seal_raw_t tmp_raw;
+    int mpg123_err;
+    size_t nbytes_streamed = 0;
+    seal_err_t err;
+
+    if ((err = seal_alloc_raw_data(&tmp_raw, raw->size)) != SEAL_OK)
+        return err;
+
+    do mpg123_err = read(&tmp_raw, &nbytes_streamed, stream->id);
+    while (mpg123_err == MPG123_OK && nbytes_streamed < tmp_raw.size);
+
+    if (nbytes_streamed == 0 && mpg123_err != MPG123_DONE) {
+        seal_free_raw_data(&tmp_raw);
+        return SEAL_CANNOT_READ_MPG;
+    }
+
+    raw->data = tmp_raw.data;
+    raw->size = nbytes_streamed;
+    raw->attr = stream->attr;
+    *psize = nbytes_streamed;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_rewind_mpg_stream(seal_stream_t* stream)
+{
+    if (mpg123_seek(stream->id, 0, SEEK_SET) < 0)
+        return SEAL_CANNOT_REWIND_MPG;
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_close_mpg_stream(seal_stream_t* stream)
+{
+    if (mpg123_close(stream->id) != MPG123_OK)
+        return SEAL_CANNOT_CLOSE_MPG;
+    return SEAL_OK;
+}