seal 0.1.0

data/src/seal/rvb.c

@@ -0,0 +1,368 @@
+#include <al/al.h>
+#include <al/efx.h>
+#include <al/efx-presets.h>
+#include <seal/rvb.h>
+#include <seal/core.h>
+#include <seal/err.h>
+
+static
+void
+load_properties(seal_rvb_t* rvb, EFXEAXREVERBPROPERTIES properties)
+{
+    seal_set_rvb_density(rvb, properties.flDensity);
+    seal_set_rvb_diffusion(rvb, properties.flDiffusion);
+    seal_set_rvb_gain(rvb, properties.flGain);
+    seal_set_rvb_hfgain(rvb, properties.flGainHF);
+    seal_set_rvb_decay_time(rvb, properties.flDecayTime);
+    seal_set_rvb_hfdecay_ratio(rvb, properties.flDecayHFRatio);
+    seal_set_rvb_reflections_gain(rvb, properties.flReflectionsGain);
+    seal_set_rvb_reflections_delay(rvb, properties.flReflectionsDelay);
+    seal_set_rvb_late_gain(rvb, properties.flLateReverbGain);
+    seal_set_rvb_late_delay(rvb, properties.flLateReverbDelay);
+    seal_set_rvb_air_absorbtion_hfgain(rvb, properties.flAirAbsorptionGainHF);
+    seal_set_rvb_room_rolloff_factor(rvb, properties.flRoomRolloffFactor);
+    seal_set_rvb_hfdecay_limited(rvb, properties.iDecayHFLimit);
+}
+
+seal_err_t
+seal_init_rvb(seal_rvb_t* rvb)
+{
+    seal_err_t err;
+
+    if ((err = _seal_init_obj(rvb, alGenEffects)) != SEAL_OK)
+        return err;
+    alEffecti(rvb->id, AL_EFFECT_TYPE, AL_EFFECT_REVERB);
+
+    return _seal_get_openal_err();
+}
+
+seal_err_t
+seal_destroy_rvb(seal_rvb_t* rvb)
+{
+    return _seal_destroy_obj(rvb, alDeleteEffects, alIsEffect);
+}
+
+/* A macro tied very closely to `seal_load_rvb'. */
+#define CASE_LOAD(rvb, preset)                                              \
+    case SEAL_##preset##_REVERB:                                            \
+    {                                                                       \
+        EFXEAXREVERBPROPERTIES __properties__ = EFX_REVERB_PRESET_##preset; \
+        load_properties(rvb, __properties__);                               \
+        break;                                                              \
+    }
+
+seal_err_t
+seal_load_rvb(seal_rvb_t* rvb, seal_rvb_preset_t preset)
+{
+    switch (preset) {
+        /* Default presets */
+        CASE_LOAD(rvb, GENERIC)
+        CASE_LOAD(rvb, PADDEDCELL)
+        CASE_LOAD(rvb, ROOM)
+        CASE_LOAD(rvb, BATHROOM)
+        CASE_LOAD(rvb, LIVINGROOM)
+        CASE_LOAD(rvb, STONEROOM)
+        CASE_LOAD(rvb, AUDITORIUM)
+        CASE_LOAD(rvb, CONCERTHALL)
+        CASE_LOAD(rvb, CAVE)
+        CASE_LOAD(rvb, ARENA)
+        CASE_LOAD(rvb, HANGAR)
+        CASE_LOAD(rvb, CARPETEDHALLWAY)
+        CASE_LOAD(rvb, HALLWAY)
+        CASE_LOAD(rvb, STONECORRIDOR)
+        CASE_LOAD(rvb, ALLEY)
+        CASE_LOAD(rvb, FOREST)
+        CASE_LOAD(rvb, CITY)
+        CASE_LOAD(rvb, MOUNTAINS)
+        CASE_LOAD(rvb, QUARRY)
+        CASE_LOAD(rvb, PLAIN)
+        CASE_LOAD(rvb, PARKINGLOT)
+        CASE_LOAD(rvb, SEWERPIPE)
+        CASE_LOAD(rvb, UNDERWATER)
+        CASE_LOAD(rvb, DRUGGED)
+        CASE_LOAD(rvb, DIZZY)
+        CASE_LOAD(rvb, PSYCHOTIC)
+
+        /* Castle presets */
+        CASE_LOAD(rvb, CASTLE_SMALLROOM)
+        CASE_LOAD(rvb, CASTLE_SHORTPASSAGE)
+        CASE_LOAD(rvb, CASTLE_MEDIUMROOM)
+        CASE_LOAD(rvb, CASTLE_LARGEROOM)
+        CASE_LOAD(rvb, CASTLE_LONGPASSAGE)
+        CASE_LOAD(rvb, CASTLE_HALL)
+        CASE_LOAD(rvb, CASTLE_CUPBOARD)
+        CASE_LOAD(rvb, CASTLE_COURTYARD)
+        CASE_LOAD(rvb, CASTLE_ALCOVE)
+
+        /* Factory presets */
+        CASE_LOAD(rvb, FACTORY_SMALLROOM)
+        CASE_LOAD(rvb, FACTORY_SHORTPASSAGE)
+        CASE_LOAD(rvb, FACTORY_MEDIUMROOM)
+        CASE_LOAD(rvb, FACTORY_LARGEROOM)
+        CASE_LOAD(rvb, FACTORY_LONGPASSAGE)
+        CASE_LOAD(rvb, FACTORY_HALL)
+        CASE_LOAD(rvb, FACTORY_CUPBOARD)
+        CASE_LOAD(rvb, FACTORY_COURTYARD)
+        CASE_LOAD(rvb, FACTORY_ALCOVE)
+
+        /* Ice palace presets */
+        CASE_LOAD(rvb, ICEPALACE_SMALLROOM)
+        CASE_LOAD(rvb, ICEPALACE_SHORTPASSAGE)
+        CASE_LOAD(rvb, ICEPALACE_MEDIUMROOM)
+        CASE_LOAD(rvb, ICEPALACE_LARGEROOM)
+        CASE_LOAD(rvb, ICEPALACE_LONGPASSAGE)
+        CASE_LOAD(rvb, ICEPALACE_HALL)
+        CASE_LOAD(rvb, ICEPALACE_CUPBOARD)
+        CASE_LOAD(rvb, ICEPALACE_COURTYARD)
+        CASE_LOAD(rvb, ICEPALACE_ALCOVE)
+
+        /* Space station presets */
+        CASE_LOAD(rvb, SPACESTATION_SMALLROOM)
+        CASE_LOAD(rvb, SPACESTATION_SHORTPASSAGE)
+        CASE_LOAD(rvb, SPACESTATION_MEDIUMROOM)
+        CASE_LOAD(rvb, SPACESTATION_LARGEROOM)
+        CASE_LOAD(rvb, SPACESTATION_LONGPASSAGE)
+        CASE_LOAD(rvb, SPACESTATION_HALL)
+        CASE_LOAD(rvb, SPACESTATION_CUPBOARD)
+        CASE_LOAD(rvb, SPACESTATION_ALCOVE)
+
+        /* Wooden Galleon presets */
+        CASE_LOAD(rvb, WOODEN_SMALLROOM)
+        CASE_LOAD(rvb, WOODEN_SHORTPASSAGE)
+        CASE_LOAD(rvb, WOODEN_MEDIUMROOM)
+        CASE_LOAD(rvb, WOODEN_LARGEROOM)
+        CASE_LOAD(rvb, WOODEN_LONGPASSAGE)
+        CASE_LOAD(rvb, WOODEN_HALL)
+        CASE_LOAD(rvb, WOODEN_CUPBOARD)
+        CASE_LOAD(rvb, WOODEN_COURTYARD)
+        CASE_LOAD(rvb, WOODEN_ALCOVE)
+
+        /* Sports presets */
+        CASE_LOAD(rvb, SPORT_EMPTYSTADIUM)
+        CASE_LOAD(rvb, SPORT_SQUASHCOURT)
+        CASE_LOAD(rvb, SPORT_SMALLSWIMMINGPOOL)
+        CASE_LOAD(rvb, SPORT_LARGESWIMMINGPOOL)
+        CASE_LOAD(rvb, SPORT_GYMNASIUM)
+        CASE_LOAD(rvb, SPORT_FULLSTADIUM)
+        CASE_LOAD(rvb, SPORT_STADIUMTANNOY)
+
+        /* Prefab presets */
+        CASE_LOAD(rvb, PREFAB_WORKSHOP)
+        CASE_LOAD(rvb, PREFAB_SCHOOLROOM)
+        CASE_LOAD(rvb, PREFAB_PRACTISEROOM)
+        CASE_LOAD(rvb, PREFAB_OUTHOUSE)
+        CASE_LOAD(rvb, PREFAB_CARAVAN)
+
+        /* Dome presets */
+        CASE_LOAD(rvb, DOME_TOMB)
+        CASE_LOAD(rvb, DOME_SAINTPAULS)
+
+        /* Pipe presets. */
+        CASE_LOAD(rvb, PIPE_SMALL)
+        CASE_LOAD(rvb, PIPE_LONGTHIN)
+        CASE_LOAD(rvb, PIPE_LARGE)
+        CASE_LOAD(rvb, PIPE_RESONANT)
+
+        /* Outdoors presets */
+        CASE_LOAD(rvb, OUTDOORS_BACKYARD)
+        CASE_LOAD(rvb, OUTDOORS_ROLLINGPLAINS)
+        CASE_LOAD(rvb, OUTDOORS_DEEPCANYON)
+        CASE_LOAD(rvb, OUTDOORS_CREEK)
+        CASE_LOAD(rvb, OUTDOORS_VALLEY)
+
+        /* Mood presets */
+        CASE_LOAD(rvb, MOOD_HEAVEN)
+        CASE_LOAD(rvb, MOOD_HELL)
+        CASE_LOAD(rvb, MOOD_MEMORY)
+
+        /* Driving presets */
+        CASE_LOAD(rvb, DRIVING_COMMENTATOR)
+        CASE_LOAD(rvb, DRIVING_PITGARAGE)
+        CASE_LOAD(rvb, DRIVING_INCAR_RACER)
+        CASE_LOAD(rvb, DRIVING_INCAR_SPORTS)
+        CASE_LOAD(rvb, DRIVING_INCAR_LUXURY)
+        CASE_LOAD(rvb, DRIVING_FULLGRANDSTAND)
+        CASE_LOAD(rvb, DRIVING_EMPTYGRANDSTAND)
+        CASE_LOAD(rvb, DRIVING_TUNNEL)
+
+        /* City presets */
+        CASE_LOAD(rvb, CITY_STREETS)
+        CASE_LOAD(rvb, CITY_SUBWAY)
+        CASE_LOAD(rvb, CITY_MUSEUM)
+        CASE_LOAD(rvb, CITY_LIBRARY)
+        CASE_LOAD(rvb, CITY_UNDERPASS)
+        CASE_LOAD(rvb, CITY_ABANDONED)
+
+        /* Misc. presets */
+        CASE_LOAD(rvb, DUSTYROOM)
+        CASE_LOAD(rvb, CHAPEL)
+        CASE_LOAD(rvb, SMALLWATERROOM)
+        default:
+            return SEAL_BAD_PRESET;
+    }
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_set_rvb_density(seal_rvb_t* rvb, float density)
+{
+    return _seal_setf(rvb, AL_REVERB_DENSITY, density, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_diffusion(seal_rvb_t* rvb, float diffusion)
+{
+    return _seal_setf(rvb, AL_REVERB_DIFFUSION, diffusion, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_gain(seal_rvb_t* rvb, float gain)
+{
+    return _seal_setf(rvb, AL_REVERB_GAIN, gain, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_hfgain(seal_rvb_t* rvb, float hfgain)
+{
+    return _seal_setf(rvb, AL_REVERB_GAINHF, hfgain, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_decay_time(seal_rvb_t* rvb, float time)
+{
+    return _seal_setf(rvb, AL_REVERB_DECAY_TIME, time, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_hfdecay_ratio(seal_rvb_t* rvb, float ratio)
+{
+    return _seal_setf(rvb, AL_REVERB_DECAY_HFRATIO, ratio, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_reflections_gain(seal_rvb_t* rvb, float gain)
+{
+    return _seal_setf(rvb, AL_REVERB_REFLECTIONS_GAIN, gain, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_reflections_delay(seal_rvb_t* rvb, float delay)
+{
+    return _seal_setf(rvb, AL_REVERB_REFLECTIONS_DELAY, delay, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_late_gain(seal_rvb_t* rvb, float gain)
+{
+    return _seal_setf(rvb, AL_REVERB_LATE_REVERB_GAIN, gain, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_late_delay(seal_rvb_t* rvb, float delay)
+{
+    return _seal_setf(rvb, AL_REVERB_LATE_REVERB_DELAY, delay, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_air_absorbtion_hfgain(seal_rvb_t* rvb, float hfgain)
+{
+    return _seal_setf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, hfgain,
+                      alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_room_rolloff_factor(seal_rvb_t* rvb, float factor)
+{
+    return _seal_setf(rvb, AL_REVERB_ROOM_ROLLOFF_FACTOR, factor, alEffectf);
+}
+
+seal_err_t
+seal_set_rvb_hfdecay_limited(seal_rvb_t* rvb, char limited)
+{
+    return _seal_seti(rvb, AL_REVERB_DECAY_HFLIMIT, limited, alEffecti);
+}
+
+seal_err_t
+seal_get_rvb_density(seal_rvb_t* rvb, float* pdensity)
+{
+    return _seal_getf(rvb, AL_REVERB_DENSITY, pdensity, alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_diffusion(seal_rvb_t* rvb, float* pdiffusion)
+{
+    return _seal_getf(rvb,  AL_REVERB_DIFFUSION, pdiffusion, alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_gain(seal_rvb_t* rvb, float* pgain)
+{
+    return _seal_getf(rvb,  AL_REVERB_GAIN, pgain, alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_hfgain(seal_rvb_t* rvb, float* phfgain)
+{
+    return _seal_getf(rvb,  AL_REVERB_GAINHF, phfgain, alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_decay_time(seal_rvb_t* rvb, float* ptime)
+{
+    return _seal_getf(rvb,  AL_REVERB_DECAY_TIME, ptime, alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_hfdecay_ratio(seal_rvb_t* rvb, float* pratio)
+{
+    return _seal_getf(rvb,  AL_REVERB_DECAY_HFRATIO, pratio, alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_reflections_gain(seal_rvb_t* rvb, float* pgain)
+{
+    return _seal_getf(rvb,  AL_REVERB_REFLECTIONS_GAIN, pgain,
+                      alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_reflections_delay(seal_rvb_t* rvb, float* pdelay)
+{
+    return _seal_getf(rvb,  AL_REVERB_REFLECTIONS_DELAY, pdelay,
+                      alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_late_gain(seal_rvb_t* rvb, float* pgain)
+{
+    return _seal_getf(rvb,  AL_REVERB_LATE_REVERB_GAIN, pgain,
+                      alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_late_delay(seal_rvb_t* rvb, float* pdelay)
+{
+    return _seal_getf(rvb,  AL_REVERB_LATE_REVERB_DELAY, pdelay,
+                      alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_air_absorbtion_hfgain(seal_rvb_t* rvb, float* phfgain)
+{
+    return _seal_getf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, phfgain,
+                      alGetEffectf);
+}
+
+seal_err_t
+seal_get_rvb_room_rolloff_factor(seal_rvb_t* rvb, float* pfactor)
+{
+    return _seal_getf(rvb, AL_REVERB_ROOM_ROLLOFF_FACTOR, pfactor,
+                      alGetEffectf);
+}
+
+seal_err_t
+seal_is_rvb_hfdecay_limited(seal_rvb_t* rvb, char* plimited)
+{
+    return _seal_getb(rvb, AL_REVERB_DECAY_HFLIMIT, plimited,
+                      alGetEffecti);
+}

data/src/seal/src.c

@@ -0,0 +1,654 @@
+/*
+ * src.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 <string.h>
+#include <stdlib.h>
+#include <al/al.h>
+#include <al/efx.h>
+#include <seal/src.h>
+#include <seal/core.h>
+#include <seal/buf.h>
+#include <seal/stream.h>
+#include <seal/efs.h>
+#include <seal/err.h>
+#include "threading.h"
+
+typedef void queue_op_t(unsigned int, int, unsigned int*);
+
+enum
+{
+    /* 2^24=16777216. */
+    CHUNK_STORAGE_CAP = 16777216,
+    /* LCM(36, 1024)=9216. */
+    MIN_CHUNK_SIZE = 9216
+};
+
+static const size_t MIN_QUEUE_SIZE     = 2;
+static const size_t MAX_QUEUE_SIZE     = 63;
+static const size_t DEFAULT_QUEUE_SIZE = 3;
+static const size_t DEFAULT_CHUNK_SIZE = MIN_CHUNK_SIZE << 2;
+static const size_t MAX_CHUNK_SIZE     = CHUNK_STORAGE_CAP -
+                                         CHUNK_STORAGE_CAP % MIN_CHUNK_SIZE;
+
+static
+seal_err_t
+check_val_limit(int val, int lower_bound, int upper_bound)
+{
+    if (val < lower_bound)
+        return SEAL_BAD_VAL;
+    else if (val > upper_bound)
+        return SEAL_BAD_VAL;
+    else
+        return SEAL_OK;
+}
+
+static
+seal_err_t
+operate(seal_src_t* src, void (*op)(unsigned int))
+{
+    op(src->id);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+set3f(seal_src_t* src, int key, float x, float y, float z)
+{
+    alSource3f(src->id, key, x, y, z);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+get3f(seal_src_t* src, int key, float* px, float* py, float* pz)
+{
+    alGetSource3f(src->id, key, px, py, pz);
+
+    return _seal_get_openal_err();
+}
+
+static
+void
+wait4updater(seal_src_t* src)
+{
+    if (src->updater != 0) {
+        _seal_join_thread(src->updater);
+        src->updater = 0;
+    }
+}
+
+static
+void*
+update(void* args)
+{
+    seal_src_t* src = args;
+    seal_err_t err = SEAL_OK;
+
+    while (alIsSource(src->id)) {
+        seal_src_state_t state;
+        err = seal_get_src_state(src, &state);
+        if (err != SEAL_OK || state != SEAL_PLAYING)
+            break;
+        if ((err = seal_update_src(src)) != SEAL_OK)
+            break;
+        _seal_sleep(50);
+    }
+
+    return (void*) err;
+}
+
+static
+seal_err_t
+queue_op(seal_src_t* src, int nbufs, unsigned int* bufs, queue_op_t* op)
+{
+    op(src->id, nbufs, bufs);
+
+    return _seal_get_openal_err();
+}
+
+static
+seal_err_t
+queue_bufs(seal_src_t* src, int nbufs, unsigned int* bufs)
+{
+    return queue_op(src, nbufs, bufs, (queue_op_t*) alSourceQueueBuffers);
+}
+
+static
+seal_err_t
+unqueue_bufs(seal_src_t* src, int nbufs, unsigned int* bufs)
+{
+    return queue_op(src, nbufs, bufs, alSourceUnqueueBuffers);
+}
+
+static
+seal_err_t
+clean_queue(seal_src_t* src)
+{
+    int nbufs_processed;
+    unsigned int* bufs;
+    seal_err_t err;
+
+    /* Do not let the updater touch anything when cleaning the queue. */
+    wait4updater(src);
+    err = _seal_geti(src, AL_BUFFERS_PROCESSED, &nbufs_processed,
+                     alGetSourcei);
+    if (err != SEAL_OK)
+        return err;
+
+    bufs = malloc(sizeof (unsigned int) * nbufs_processed);
+    if (bufs == 0)
+        return SEAL_CANNOT_ALLOC_MEM;
+
+    if ((err = unqueue_bufs(src, nbufs_processed, bufs)) == SEAL_OK)
+        err = _seal_delete_objs(nbufs_processed, bufs, alDeleteBuffers);
+
+    free(bufs);
+
+    return err;
+}
+
+/*
+ * Stopping a source will mark all the buffers in its queue processed so that
+ * they can be unqueued.
+ */
+static
+seal_err_t
+stop_then_clean_queue(seal_src_t* src)
+{
+    seal_err_t err;
+
+    if ((err = operate(src, alSourceStop)) != SEAL_OK)
+        return err;
+
+    return clean_queue(src);
+}
+
+static
+seal_err_t
+restart_queuing(seal_src_t* src)
+{
+    seal_err_t err;
+
+    if ((err = stop_then_clean_queue(src)) != SEAL_OK)
+        return err;
+
+    return seal_rewind_stream(src->stream);
+}
+
+static
+seal_err_t
+empty_queue(seal_src_t* src)
+{
+    seal_err_t err;
+
+    /* Need to be playing first in order to become stopped. */
+    if ((err = operate(src, alSourcePlay)) != SEAL_OK)
+        return err;
+
+    return stop_then_clean_queue(src);
+}
+
+static
+seal_err_t
+ensure_queue_empty(seal_src_t* src)
+{
+    if (src->stream != 0)
+        return empty_queue(src);
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_init_src(seal_src_t* src)
+{
+    seal_err_t err = _seal_init_obj(src, alGenSources);
+
+    if (err == SEAL_OK) {
+        src->buf = 0;
+        src->stream = 0;
+        src->updater = 0;
+        src->chunk_size = DEFAULT_CHUNK_SIZE;
+        src->queue_size = DEFAULT_QUEUE_SIZE;
+        src->looping = 0;
+        src->automatic = 1;
+    }
+
+    return err;
+}
+
+seal_err_t
+seal_destroy_src(seal_src_t* src)
+{
+    seal_err_t err;
+
+    if (alIsSource(src->id)) {
+        if ((err = ensure_queue_empty(src)) != SEAL_OK)
+            return err;
+        err = _seal_delete_objs(1, &src->id, alDeleteSources);
+        if (err != SEAL_OK)
+            return err;
+    }
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_play_src(seal_src_t* src)
+{
+    if (src->stream != 0) {
+        seal_src_state_t state;
+        seal_err_t err = seal_get_src_state(src, &state);
+        if (err != SEAL_OK)
+            return err;
+        if (state == SEAL_PLAYING) {
+            /* Source and its updater will be stopped after this. */
+            if ((err = restart_queuing(src)) != SEAL_OK)
+                return err;
+        } else {
+            /* In case the old updater is not done. */
+            wait4updater(src);
+        }
+        /* Stream some data so plackback can start immediately. */
+        if ((err = seal_update_src(src)) != SEAL_OK)
+            return err;
+        if (src->automatic)
+            src->updater = _seal_create_thread(update, src);
+    }
+
+    return operate(src, alSourcePlay);
+}
+
+seal_err_t
+seal_pause_src(seal_src_t* src)
+{
+    return operate(src, alSourcePause);
+}
+
+seal_err_t
+seal_stop_src(seal_src_t* src)
+{
+    seal_err_t err;
+
+    if ((err = operate(src, alSourceStop)) == SEAL_OK && src->stream != 0)
+        /* Already stopped so all buffers are proccessed. */
+        if ((err = clean_queue(src)) == SEAL_OK)
+            err = seal_rewind_stream(src->stream);
+
+    return err;
+}
+
+seal_err_t
+seal_rewind_src(seal_src_t* src)
+{
+    if (src->stream != 0) {
+        seal_src_state_t state;
+        seal_err_t err = seal_get_src_state(src, &state);
+        if (err != SEAL_OK)
+            return err;
+        if (state == SEAL_PLAYING || state == SEAL_PAUSED)
+            if ((err = restart_queuing(src)) != SEAL_OK)
+                return err;
+    }
+
+    return operate(src, alSourceRewind);
+}
+
+seal_err_t
+seal_detach_src_audio(seal_src_t* src)
+{
+    seal_err_t err;
+
+    if ((err = ensure_queue_empty(src)) != SEAL_OK)
+        return err;
+
+    /* Sets the state to `SEAL_INITIAL' for consistency. */
+    if ((err = operate(src, alSourceRewind)) != SEAL_OK)
+        return err;
+
+    if ((err = _seal_seti(src, AL_BUFFER, AL_NONE, alSourcei)) == SEAL_OK) {
+        src->buf = 0;
+        src->stream = 0;
+    }
+
+    return err;
+}
+
+seal_err_t
+seal_set_src_buf(seal_src_t* src, seal_buf_t* buf)
+{
+    seal_err_t err;
+
+    /* Make sure `src' is not currently a streaming source. */
+    if (src->stream != 0)
+        return SEAL_MIXING_SRC_TYPE;
+
+    /* Carry the previous looping state over for static sources. */
+    err = _seal_seti(src, AL_LOOPING, src->looping, alSourcei);
+    if (err != SEAL_OK)
+        return err;
+
+    if ((err = _seal_seti(src, AL_BUFFER, buf->id, alSourcei)) == SEAL_OK)
+        src->buf = buf;
+
+    return err;
+}
+
+seal_err_t
+seal_set_src_stream(seal_src_t* src, seal_stream_t* stream)
+{
+    seal_err_t err;
+
+    if (stream == src->stream)
+        return SEAL_OK;
+    /* Make sure `src' is not currently a static source. */
+    if (src->buf != 0)
+        return SEAL_MIXING_SRC_TYPE;
+    /* Cannot associate an unopened stream. */
+    if (stream->id == 0)
+        return SEAL_STREAM_UNOPENED;
+    /* Cannot associate a stream with a different audio format. */
+    if (src->stream != 0 && memcmp(&stream->attr, &src->stream->attr,
+                                   sizeof (seal_raw_attr_t)) != 0)
+        return SEAL_MIXING_STREAM_FMT;
+
+    /* Never use AL_LOOPING for streaming sources. */
+    if ((err = _seal_seti(src, AL_LOOPING, 0, alSourcei)) != SEAL_OK)
+        return err;
+
+    src->stream = stream;
+
+    /* Immediately update the queue to become `AL_STREAMING'. */
+    return seal_update_src(src);
+}
+
+seal_err_t
+seal_update_src(seal_src_t* src)
+{
+    unsigned int buf;
+    size_t nbytes_streamed;
+    seal_raw_t raw;
+    seal_err_t err;
+
+    if (!alIsSource(src->id))
+        return SEAL_OK;
+
+    if (src->stream == 0)
+        return SEAL_OK;
+    /* If another updater is running. */
+    if (src->updater != 0 && !_seal_calling_thread_is(src->updater))
+        return SEAL_OK;
+
+    /* Set the desired size of each chunk. */
+    raw.size = src->chunk_size;
+
+    for (;;) {
+        int nqueued, nprocessed;
+
+        err = _seal_geti(src, AL_BUFFERS_QUEUED, &nqueued, alGetSourcei);
+        if (err != SEAL_OK)
+            return err;
+        err = _seal_geti(src, AL_BUFFERS_PROCESSED, &nprocessed,
+                         alGetSourcei);
+        if (err != SEAL_OK)
+            return err;
+
+        /* Remove processed buffers from the queue if possible. */
+        if (nprocessed > 0) {
+            if ((err = unqueue_bufs(src, 1, &buf)) != SEAL_OK)
+                return err;
+            /* The queue is full even after the removal. */
+            if ((size_t) nqueued >= src->queue_size) {
+                err = _seal_delete_objs(1, &buf, alDeleteBuffers);
+                if (err != SEAL_OK)
+                    return err;
+                continue;
+            }
+        /* The queue is too short. */
+        } else if ((size_t) nqueued < src->queue_size) {
+            if ((err = _seal_gen_objs(1, &buf, alGenBuffers)) != SEAL_OK)
+                return err;
+        /* The queue is full and nothing is processed. */
+        } else {
+            return SEAL_OK;
+        }
+
+start_streaming:
+        err = seal_stream(src->stream, &raw, &nbytes_streamed);
+        if (err != SEAL_OK)
+            break;
+        if (nbytes_streamed > 0) {
+            /* Fill or refill the current buffer. */
+            err = _seal_raw2buf(buf, &raw);
+            free(raw.data);
+            if (err != SEAL_OK)
+                break;
+            if ((err = queue_bufs(src, 1, &buf)) != SEAL_OK)
+                break;
+        /* Rewind the stream if looping. */
+        } else if (src->looping) {
+            seal_rewind_stream(src->stream);
+            raw.size = src->chunk_size;
+            goto start_streaming;
+        /* End of stream reached. */
+        } else {
+            break;
+        }
+    } /* for (;;) */
+
+    if (err == SEAL_OK)
+        return _seal_delete_objs(1, &buf, alDeleteBuffers);
+    else {
+        _seal_delete_objs(1, &buf, alDeleteBuffers);
+        return err;
+    }
+}
+
+seal_err_t
+seal_set_src_queue_size(seal_src_t* src, size_t size)
+{
+    seal_err_t err;
+
+    err = check_val_limit(size, MIN_QUEUE_SIZE, MAX_QUEUE_SIZE);
+    if (err == SEAL_OK)
+        src->queue_size = size;
+
+    return err;
+}
+
+seal_err_t
+seal_set_src_chunk_size(seal_src_t* src, size_t size)
+{
+    seal_err_t err;
+
+    err = check_val_limit(size, MIN_CHUNK_SIZE, MAX_CHUNK_SIZE);
+    if (err == SEAL_OK)
+        src->chunk_size = size / MIN_CHUNK_SIZE * MIN_CHUNK_SIZE;
+
+    return err;
+}
+
+seal_err_t
+seal_set_src_pos(seal_src_t* src, float x, float y, float z)
+{
+    return set3f(src, AL_POSITION, x, y, z);
+}
+
+seal_err_t
+seal_set_src_vel(seal_src_t* src, float x, float y, float z)
+{
+    return set3f(src, AL_VELOCITY, x, y, z);
+}
+
+seal_err_t
+seal_set_src_pitch(seal_src_t* src, float pitch)
+{
+    return _seal_setf(src, AL_PITCH, pitch, alSourcef);
+}
+
+seal_err_t
+seal_set_src_gain(seal_src_t* src, float gain)
+{
+    return _seal_setf(src, AL_GAIN, gain, alSourcef);
+}
+
+seal_err_t
+seal_set_src_auto(seal_src_t* src, char automatic)
+{
+    src->automatic = automatic != 0;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_set_src_relative(seal_src_t* src, char relative)
+{
+    return _seal_seti(src, AL_SOURCE_RELATIVE, relative != 0, alSourcei);
+}
+
+seal_err_t
+seal_set_src_looping(seal_src_t* src, char looping)
+{
+    looping = looping != 0;
+    /*
+     * Streaming does not work with OpenAL's looping as the queuing buffers
+     * will never become `processed' when `AL_LOOPING' is true, so set
+     * `AL_LOOPING' only for static sources.
+     */
+    if (src->stream == 0) {
+        seal_err_t err = _seal_seti(src, AL_LOOPING, looping, alSourcei);
+        if (err != SEAL_OK)
+            return err;
+    }
+
+    src->looping = looping;
+
+    return SEAL_OK;
+}
+
+seal_buf_t*
+seal_get_src_buf(seal_src_t* src)
+{
+    return src->buf;
+}
+
+seal_stream_t*
+seal_get_src_stream(seal_src_t* src)
+{
+    return src->stream;
+}
+
+seal_err_t
+seal_get_src_queue_size(seal_src_t* src, size_t* psize)
+{
+    *psize = src->queue_size;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_get_src_chunk_size(seal_src_t* src, size_t* psize)
+{
+    *psize = src->chunk_size;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_get_src_pos(seal_src_t* src, float* px, float* py, float* pz)
+{
+    return get3f(src, AL_POSITION, px, py, pz);
+}
+
+seal_err_t
+seal_get_src_vel(seal_src_t* src, float* px, float* py, float* pz)
+{
+    return get3f(src, AL_VELOCITY, px, py, pz);
+}
+
+seal_err_t
+seal_get_src_pitch(seal_src_t* src, float* ppitch)
+{
+    return _seal_getf(src, AL_PITCH, ppitch, alGetSourcef);
+}
+
+seal_err_t
+seal_get_src_gain(seal_src_t* src, float* pgain)
+{
+    return _seal_getf(src, AL_GAIN, pgain, alGetSourcef);
+}
+
+seal_err_t
+seal_is_src_auto(seal_src_t* src, char* pauto)
+{
+    *pauto = src->automatic;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_is_src_relative(seal_src_t* src, char* prelative)
+{
+    return _seal_getb(src, AL_SOURCE_RELATIVE, prelative, alGetSourcei);
+}
+
+seal_err_t
+seal_is_src_looping(seal_src_t* src, char* plooping)
+{
+    *plooping = src->looping;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+seal_get_src_type(seal_src_t* src, seal_src_type_t* ptype)
+{
+    int type;
+    seal_err_t err;
+
+    err = _seal_geti(src, AL_SOURCE_TYPE, &type, alGetSourcei);
+    if (err == SEAL_OK) {
+        switch (type) {
+        case AL_STATIC:
+            *ptype = SEAL_STATIC;
+            break;
+        case AL_STREAMING:
+            *ptype = SEAL_STREAMING;
+            break;
+        default:
+            *ptype = SEAL_UNDETERMINED;
+        }
+    }
+
+    return err;
+}
+
+seal_err_t
+seal_get_src_state(seal_src_t* src, seal_src_state_t* pstate)
+{
+    int state;
+    seal_err_t err;
+
+    err = _seal_geti(src, AL_SOURCE_STATE, &state, alGetSourcei);
+    if (err == SEAL_OK) {
+        switch (state) {
+        case AL_PLAYING:
+            *pstate = SEAL_PLAYING;
+            break;
+        case AL_PAUSED:
+            *pstate = SEAL_PAUSED;
+            break;
+        case AL_STOPPED:
+            *pstate = SEAL_STOPPED;
+            break;
+        default:
+            *pstate = SEAL_INITIAL;
+        }
+    }
+
+    return err;
+}