seal 0.1.0

data/src/seal/buf.c

@@ -0,0 +1,124 @@
+/*
+ * buf.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 <stdlib.h>
+#include <al/al.h>
+#include <seal/buf.h>
+#include <seal/core.h>
+#include <seal/raw.h>
+#include <seal/fmt.h>
+#include <seal/err.h>
+#include "ov.h"
+#include "mpg.h"
+#include "wav.h"
+
+seal_err_t
+seal_init_buf(seal_buf_t* buf)
+{
+    return _seal_init_obj(buf, alGenBuffers);
+}
+
+seal_err_t
+seal_destroy_buf(seal_buf_t* buf)
+{
+    return _seal_destroy_obj(buf, alDeleteBuffers, alIsBuffer);
+}
+
+seal_err_t
+seal_load2buf(seal_buf_t* buf, const char* filename, seal_fmt_t fmt)
+{
+    seal_raw_t raw;
+    seal_err_t err;
+
+    /* `raw.data' will be dynamically allocated by the callee. */
+    if ((err = seal_load(&raw, filename, fmt)) != SEAL_OK)
+        return err;
+
+    err = seal_raw2buf(buf, &raw);
+    free(raw.data);
+
+    return err;
+}
+
+seal_err_t
+seal_raw2buf(seal_buf_t* buf, seal_raw_t* raw)
+{
+    return _seal_raw2buf(buf->id, raw);
+}
+
+seal_err_t
+_seal_raw2buf(unsigned int buf, seal_raw_t* raw)
+{
+    alBufferData(buf, _seal_get_buf_fmt(raw->attr.nchannels,
+                                        raw->attr.bit_depth),
+                 raw->data, raw->size, raw->attr.freq);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+seal_get_buf_size(seal_buf_t* buf, int* psize)
+{
+    return _seal_geti(buf, AL_SIZE, psize, alGetBufferi);
+}
+
+seal_err_t
+seal_get_buf_freq(seal_buf_t* buf, int* pfreq)
+{
+    return _seal_geti(buf, AL_FREQUENCY, pfreq, alGetBufferi);
+}
+
+seal_err_t
+seal_get_buf_bps(seal_buf_t* buf, int* pbps)
+{
+    return _seal_geti(buf, AL_BITS, pbps, alGetBufferi);
+}
+
+seal_err_t
+seal_get_buf_nchannels(seal_buf_t* buf, int* pnchannels)
+{
+    return _seal_geti(buf, AL_CHANNELS, pnchannels, alGetBufferi);
+}
+
+seal_err_t
+seal_load(seal_raw_t* raw, const char* filename, seal_fmt_t fmt)
+{
+    seal_err_t err;
+
+    if ((err = seal_ensure_fmt_known(filename, &fmt)) != SEAL_OK)
+        return err;
+
+    switch (fmt) {
+    case SEAL_WAV_FMT:
+        return _seal_load_wav(raw, filename);
+    case SEAL_OV_FMT:
+        return _seal_load_ov(raw, filename);
+    case SEAL_MPG_FMT:
+        return _seal_load_mpg(raw, filename);
+    default:
+        return SEAL_BAD_AUDIO;
+    }
+}
+
+/* All argument will have a single evaluation here. */
+#define RETURN_FMT_CONST(bit_depth, type) do                                \
+{                                                                           \
+    switch (bit_depth) {                                                    \
+    case 8:                                                                 \
+        return AL_FORMAT_##type##8;                                         \
+    default:                                                                \
+        return AL_FORMAT_##type##16;                                        \
+    }                                                                       \
+} while (0)
+
+int
+_seal_get_buf_fmt(int nchannels, int bit_depth)
+{
+    if (nchannels == 1)
+        RETURN_FMT_CONST(bit_depth, MONO);
+    else
+        RETURN_FMT_CONST(bit_depth, STEREO);
+}

data/src/seal/core.c

@@ -0,0 +1,283 @@
+/*
+ * core.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 <stdlib.h>
+#include <stddef.h>
+#include <al/al.h>
+#include <al/alc.h>
+#include <al/efx.h>
+#include <mpg123/mpg123.h>
+#include <seal/core.h>
+#include <seal/err.h>
+
+static int per_src_effect_limit = -1;
+
+void _seal_nop() {}
+void* _seal_nop_func() { return 0; }
+
+_seal_openal_initializer_t* alGenEffects = (void*) _seal_nop;
+_seal_openal_destroyer_t* alDeleteEffects = (void*) _seal_nop;
+_seal_openal_validator_t* alIsEffect = (void*) _seal_nop_func;
+LPALEFFECTF alEffectf = (void*) _seal_nop;
+LPALEFFECTI alEffecti = (void*) _seal_nop;
+LPALGETEFFECTF alGetEffectf = (void*) _seal_nop;
+LPALGETEFFECTI alGetEffecti = (void*) _seal_nop;
+_seal_openal_initializer_t* alGenAuxiliaryEffectSlots = (void*) _seal_nop;
+_seal_openal_destroyer_t* alDeleteAuxiliaryEffectSlots = (void*) _seal_nop;
+_seal_openal_validator_t* alIsAuxiliaryEffectSlot = (void*) _seal_nop_func;
+LPALAUXILIARYEFFECTSLOTI alAuxiliaryEffectSloti = (void*) _seal_nop;
+LPALAUXILIARYEFFECTSLOTF alAuxiliaryEffectSlotf = (void*) _seal_nop;
+LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti = (void*) _seal_nop;
+LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf = (void*) _seal_nop;
+
+const char*
+seal_get_version(void)
+{
+    return "0.1.0";
+}
+
+static
+seal_err_t
+init_ext_proc(void)
+{
+    alGenEffects = alGetProcAddress("alGenEffects");
+    alDeleteEffects = alGetProcAddress("alDeleteEffects");
+    alIsEffect = alGetProcAddress("alIsEffect");
+    alEffectf = alGetProcAddress("alEffectf");
+    alEffecti = alGetProcAddress("alEffecti");
+    alGetEffectf = alGetProcAddress("alGetEffectf");
+    alGetEffecti = alGetProcAddress("alGetEffecti");
+    alGenAuxiliaryEffectSlots = alGetProcAddress("alGenAuxiliaryEffectSlots");
+    alDeleteAuxiliaryEffectSlots =
+        alGetProcAddress("alDeleteAuxiliaryEffectSlots");
+    alIsAuxiliaryEffectSlot = alGetProcAddress("alIsAuxiliaryEffectSlot");
+    alAuxiliaryEffectSloti = alGetProcAddress("alAuxiliaryEffectSloti");
+    alAuxiliaryEffectSlotf = alGetProcAddress("alAuxiliaryEffectSlotf");
+    alGetAuxiliaryEffectSloti = alGetProcAddress("alGetAuxiliaryEffectSloti");
+    alGetAuxiliaryEffectSlotf = alGetProcAddress("alGetAuxiliaryEffectSlotf");
+    if (alGenEffects && alDeleteEffects && alIsEffect && alGetEffectf
+        && alGetEffecti && alEffectf && alGenAuxiliaryEffectSlots
+        && alDeleteAuxiliaryEffectSlots && alIsAuxiliaryEffectSlot
+        && alAuxiliaryEffectSloti && alAuxiliaryEffectSlotf
+        && alGetAuxiliaryEffectSloti && alGetAuxiliaryEffectSlotf)
+        return SEAL_OK;
+    else
+        return SEAL_NO_EXT_FUNC;
+}
+
+static
+void
+reset_ext_proc(void)
+{
+    alGenEffects = (void*) _seal_nop;
+    alDeleteEffects = (void*) _seal_nop;
+    alIsEffect = (void*) _seal_nop_func;
+    alEffectf = (void*) _seal_nop;
+    alEffecti = (void*) _seal_nop;
+    alGetEffectf = (void*) _seal_nop;
+    alGetEffecti = (void*) _seal_nop;
+    alGenAuxiliaryEffectSlots = (void*) _seal_nop;
+    alDeleteAuxiliaryEffectSlots = (void*) _seal_nop;
+    alIsAuxiliaryEffectSlot = (void*) _seal_nop_func;
+    alAuxiliaryEffectSloti = (void*) _seal_nop;
+    alAuxiliaryEffectSlotf = (void*) _seal_nop;
+    alGetAuxiliaryEffectSloti = (void*) _seal_nop;
+    alGetAuxiliaryEffectSlotf = (void*) _seal_nop;
+}
+
+/*
+ * Initializes the specified device and creates a single context. SEAL
+ * currently does not make use of multiple contexts.
+ */
+seal_err_t
+seal_startup(const char* device_name)
+{
+    ALCdevice* device;
+    ALCcontext* context;
+    seal_err_t err;
+    ALint attr[] = { ALC_MAX_AUXILIARY_SENDS, 4, 0, 0 };
+
+    /* Initialize device. */
+    device = alcOpenDevice(device_name);
+    if (device == 0)
+        return SEAL_CANNOT_OPEN_DEVICE;
+    alcGetError(device);
+
+    /* Initialize extensions. */
+    if (!alcIsExtensionPresent(device, ALC_EXT_EFX_NAME)) {
+        err = SEAL_NO_EFX;
+        goto clean_device;
+    }
+
+    /* Initialize context. */
+    context = alcCreateContext(device, attr);
+    switch (alcGetError(device)) {
+    case ALC_INVALID_VALUE:
+        err = SEAL_CANNOT_CREATE_CONTEXT;
+        goto clean_device;
+    case ALC_INVALID_DEVICE:
+        err = SEAL_BAD_DEVICE;
+        goto clean_device;
+    }
+    alcMakeContextCurrent(context);
+
+    err = init_ext_proc();
+    if (err != SEAL_OK)
+        goto clean_all;
+
+    /* Initialize libmpg123 (thread-unsafe). */
+    if (mpg123_init() != MPG123_OK) {
+        err = SEAL_CANNOT_INIT_MPG;
+        goto clean_all;
+    }
+
+    /* Reset OpenAL's error state. */
+    alGetError();
+
+    alcGetIntegerv(device, ALC_MAX_AUXILIARY_SENDS, 1,&per_src_effect_limit);
+
+    return SEAL_OK;
+
+clean_all:
+    alcMakeContextCurrent(0);
+    alcDestroyContext(context);
+clean_device:
+    alcCloseDevice(device);
+
+    return err;
+}
+
+/* Finalizes the current device and context. */
+void
+seal_cleanup(void)
+{
+    ALCdevice* device;
+    ALCcontext* context;
+
+    mpg123_exit();
+
+    context = alcGetCurrentContext();
+    device = alcGetContextsDevice(context);
+    alcMakeContextCurrent(0);
+    alcDestroyContext(context);
+    alcCloseDevice(device);
+
+    reset_ext_proc();
+}
+
+int
+seal_get_per_src_effect_limit(void)
+{
+    return per_src_effect_limit;
+}
+
+unsigned int
+_seal_openal_id(void* obj)
+{
+    /* Hack: assuming the object id is always at offset 0. */
+    return *(unsigned int*) obj;
+}
+
+seal_err_t
+_seal_gen_objs(int n, unsigned int* objs,
+                          _seal_openal_initializer_t* generate)
+{
+    generate(n, objs);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+_seal_delete_objs(int n, const unsigned int* objs,
+                  _seal_openal_destroyer_t* destroy)
+{
+    destroy(n, objs);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+_seal_init_obj(void* obj, _seal_openal_initializer_t* allocate)
+{
+    return _seal_gen_objs(1, obj, allocate);
+}
+
+seal_err_t
+_seal_destroy_obj(void* obj, _seal_openal_destroyer_t* destroy,
+                  _seal_openal_validator_t* valid)
+{
+    if (valid(_seal_openal_id(obj)))
+        return _seal_delete_objs(1, obj, destroy);
+
+    return SEAL_OK;
+}
+
+seal_err_t
+_seal_setf(void* obj, int key, float val, _seal_openal_setterf* set)
+{
+    set(_seal_openal_id(obj), key, val);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+_seal_getf(void* obj, int key, float* pval, _seal_openal_getterf* get)
+{
+    get(_seal_openal_id(obj), key, pval);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+_seal_seti(void* obj, int key, int val, _seal_openal_setteri* set)
+{
+    set(_seal_openal_id(obj), key, val);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+_seal_geti(void* obj, int key, int* pval, _seal_openal_getteri* get)
+{
+    get(_seal_openal_id(obj), key, pval);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+_seal_getb(void* obj, int key, char* pval, _seal_openal_getteri* get)
+{
+    int val;
+    seal_err_t err;
+
+    err = _seal_geti(obj, key, &val, get);
+    if (err == SEAL_OK)
+        *pval = val;
+
+    return err;
+}
+
+#if defined (__unix__) || defined (__APPLE_CC__)
+
+#include <unistd.h>
+
+void
+_seal_sleep(unsigned int millisec)
+{
+    usleep(millisec * 1000);
+}
+
+#elif defined (_WIN32)
+
+#include <Windows.h>
+
+void
+_seal_sleep(unsigned int millisec)
+{
+    SleepEx(millisec, 0);
+}
+
+#endif /* __unix__, _WIN32 */

data/src/seal/efs.c

@@ -0,0 +1,74 @@
+#include <al/al.h>
+#include <al/efx.h>
+#include <seal/efs.h>
+#include <seal/core.h>
+#include <seal/err.h>
+
+seal_err_t
+seal_init_efs(seal_efs_t* slot)
+{
+    return _seal_init_obj(slot, alGenAuxiliaryEffectSlots);
+}
+
+seal_err_t
+seal_destroy_efs(seal_efs_t* slot)
+{
+    return _seal_destroy_obj(slot, alDeleteAuxiliaryEffectSlots,
+                             alIsAuxiliaryEffectSlot);
+}
+
+seal_err_t
+seal_set_efs_effect(seal_efs_t* slot, void* effect)
+{
+    seal_err_t err;
+
+    err = _seal_seti(slot, AL_EFFECTSLOT_EFFECT,
+                     effect == 0 ? AL_EFFECT_NULL : _seal_openal_id(effect),
+                     alAuxiliaryEffectSloti);
+    if (err == SEAL_OK)
+        slot->effect = effect;
+
+    return err;
+}
+
+seal_err_t
+seal_feed_efs(seal_efs_t* slot, int index, seal_src_t* src)
+{
+    alSource3i(src->id, AL_AUXILIARY_SEND_FILTER, slot->id, index,
+               AL_FILTER_NULL);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+seal_set_efs_gain(seal_efs_t* slot, float gain)
+{
+    return _seal_setf(slot, AL_EFFECTSLOT_GAIN, gain, alAuxiliaryEffectSlotf);
+}
+
+seal_err_t
+seal_set_efs_auto(seal_efs_t* slot, char automatic)
+{
+    return _seal_seti(slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, automatic,
+                      alAuxiliaryEffectSloti);
+}
+
+void*
+seal_get_efs_effect(seal_efs_t* slot)
+{
+    return slot->effect;
+}
+
+seal_err_t
+seal_get_efs_gain(seal_efs_t* slot, float* pgain)
+{
+    return _seal_getf(slot, AL_EFFECTSLOT_GAIN, pgain,
+                      alGetAuxiliaryEffectSlotf);
+}
+
+seal_err_t
+seal_is_efs_auto(seal_efs_t* slot, char* pauto)
+{
+    return _seal_getb(slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, pauto,
+                      alGetAuxiliaryEffectSloti);
+}