seal 0.1.1 → 0.1.2

data/src/rubyext.c

@@ -633,6 +633,25 @@ rewind_src(VALUE rsrc)
     return src_op(rsrc, seal_rewind_src);
 }
 
+/*
+ *  call-seq:
+ *      source.move ->  source
+ *
+ * Moves the source (changes the position) based on the source velocity. This
+ * is a syntactic sugar for adding the velocity vector and position vector:
+ *
+ *      # Equivalent to `source.move`
+ *      source.position = source.position.zip(source.velocity).map do |a, b|
+ *          a + b
+ *      end
+ */
+static
+VALUE
+move_src(VALUE rsrc, VALUE value)
+{
+    return src_op(rsrc, seal_move_src);
+}
+
 /*
  *  call-seq:
  *      source.buffer = buffer  -> buffer
@@ -798,7 +817,6 @@ get_src_pos(VALUE rsrc)
  * Sets the velocity of _source_ in a right-handed Cartesian coordinate
  * system. The velocity of the source does not affect its position but is a
  * factor used during the Doppler effect emulation. Use of NaN is undefined.
- *
  */
 static
 VALUE
@@ -1683,6 +1701,15 @@ get_listener()
     return rb_const_get(mSeal, rb_intern("LISTENER"));
 }
 
+static
+VALUE
+move_listener(VALUE rlistener)
+{
+    check_seal_err(seal_move_listener());
+
+    return rlistener;
+}
+
 /*
  *  call-seq:
  *      Seal.listener.gain = flt   -> [flt, flt, flt]
@@ -1975,6 +2002,7 @@ bind_src(void)
     rb_define_method(cSource, "pause", pause_src, 0);
     rb_define_method(cSource, "stop", stop_src, 0);
     rb_define_method(cSource, "rewind", rewind_src, 0);
+    rb_define_method(cSource, "move", move_src, 0);
     rb_define_method(cSource, "buffer=", set_src_buf, 1);
     rb_define_method(cSource, "buffer", get_src_buf, 0);
     rb_define_method(cSource, "stream=", set_src_stream, 1);
@@ -2348,6 +2376,7 @@ bind_listener(void)
     rb_define_const(mSeal, "LISTENER", listener);
     rb_define_singleton_method(mSeal, "listener", get_listener, 0);
     singletonify(cListener);
+    rb_define_method(cListener, "move", move_listener, 0);
     rb_define_method(cListener, "position=", set_listener_pos, 1);
     rb_define_method(cListener, "position", get_listener_pos, 0);
     rb_define_method(cListener, "velocity=", set_listener_vel, 1);

data/src/seal/buf.c

@@ -10,18 +10,21 @@
 #include "wav.h"
 
 seal_err_t
+SEAL_API
 seal_init_buf(seal_buf_t* buf)
 {
     return _seal_init_obj(buf, alGenBuffers);
 }
 
 seal_err_t
+SEAL_API
 seal_destroy_buf(seal_buf_t* buf)
 {
     return _seal_destroy_obj(buf, alDeleteBuffers, alIsBuffer);
 }
 
 seal_err_t
+SEAL_API
 seal_load2buf(seal_buf_t* buf, const char* filename, seal_fmt_t fmt)
 {
     seal_raw_t raw;
@@ -38,6 +41,7 @@ seal_load2buf(seal_buf_t* buf, const char* filename, seal_fmt_t fmt)
 }
 
 seal_err_t
+SEAL_API
 seal_raw2buf(seal_buf_t* buf, seal_raw_t* raw)
 {
     return _seal_raw2buf(buf->id, raw);
@@ -46,38 +50,47 @@ seal_raw2buf(seal_buf_t* buf, seal_raw_t* 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);
+    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_API
 seal_get_buf_size(seal_buf_t* buf, int* psize)
 {
     return _seal_geti(buf, AL_SIZE, psize, alGetBufferi);
 }
 
 seal_err_t
+SEAL_API
 seal_get_buf_freq(seal_buf_t* buf, int* pfreq)
 {
     return _seal_geti(buf, AL_FREQUENCY, pfreq, alGetBufferi);
 }
 
 seal_err_t
+SEAL_API
 seal_get_buf_bps(seal_buf_t* buf, int* pbps)
 {
     return _seal_geti(buf, AL_BITS, pbps, alGetBufferi);
 }
 
 seal_err_t
+SEAL_API
 seal_get_buf_nchannels(seal_buf_t* buf, int* pnchannels)
 {
     return _seal_geti(buf, AL_CHANNELS, pnchannels, alGetBufferi);
 }
 
 seal_err_t
+SEAL_API
 seal_load(seal_raw_t* raw, const char* filename, seal_fmt_t fmt)
 {
     seal_err_t err;

data/src/seal/core.c

@@ -28,9 +28,10 @@ LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti = (void*) _seal_nop;
 LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf = (void*) _seal_nop;
 
 const char*
+SEAL_API
 seal_get_version(void)
 {
-    return "0.1.0";
+    return "0.1.2";
 }
 
 static
@@ -87,6 +88,7 @@ reset_ext_proc(void)
  * currently does not make use of multiple contexts.
  */
 seal_err_t
+SEAL_API
 seal_startup(const char* device_name)
 {
     ALCdevice* device;
@@ -146,6 +148,7 @@ clean_device:
 
 /* Finalizes the current device and context. */
 void
+SEAL_API
 seal_cleanup(void)
 {
     ALCdevice* device;
@@ -163,6 +166,7 @@ seal_cleanup(void)
 }
 
 int
+SEAL_API
 seal_get_per_src_effect_limit(void)
 {
     return per_src_effect_limit;
@@ -176,8 +180,7 @@ _seal_openal_id(void* obj)
 }
 
 seal_err_t
-_seal_gen_objs(int n, unsigned int* objs,
-                          _seal_openal_initializer_t* generate)
+_seal_gen_objs(int n, unsigned int* objs, _seal_openal_initializer_t* generate)
 {
     generate(n, objs);
 
@@ -185,8 +188,11 @@ _seal_gen_objs(int n, unsigned int* objs,
 }
 
 seal_err_t
-_seal_delete_objs(int n, const unsigned int* objs,
-                  _seal_openal_destroyer_t* destroy)
+_seal_delete_objs(
+    int n,
+    const unsigned int* objs,
+    _seal_openal_destroyer_t* destroy
+)
 {
     destroy(n, objs);
 
@@ -200,8 +206,11 @@ _seal_init_obj(void* obj, _seal_openal_initializer_t* allocate)
 }
 
 seal_err_t
-_seal_destroy_obj(void* obj, _seal_openal_destroyer_t* destroy,
-                  _seal_openal_validator_t* valid)
+_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);

data/src/seal/efs.c

@@ -5,26 +5,35 @@
 #include <seal/err.h>
 
 seal_err_t
+SEAL_API
 seal_init_efs(seal_efs_t* slot)
 {
     return _seal_init_obj(slot, alGenAuxiliaryEffectSlots);
 }
 
 seal_err_t
+SEAL_API
 seal_destroy_efs(seal_efs_t* slot)
 {
-    return _seal_destroy_obj(slot, alDeleteAuxiliaryEffectSlots,
-                             alIsAuxiliaryEffectSlot);
+    return _seal_destroy_obj(
+        slot,
+        alDeleteAuxiliaryEffectSlots,
+        alIsAuxiliaryEffectSlot
+    );
 }
 
 seal_err_t
+SEAL_API
 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);
+    err = _seal_seti(
+        slot,
+        AL_EFFECTSLOT_EFFECT,
+        effect == 0 ? AL_EFFECT_NULL : _seal_openal_id(effect),
+        alAuxiliaryEffectSloti
+    );
     if (err == SEAL_OK)
         slot->effect = effect;
 
@@ -32,34 +41,51 @@ seal_set_efs_effect(seal_efs_t* slot, void* effect)
 }
 
 seal_err_t
+SEAL_API
 seal_set_efs_gain(seal_efs_t* slot, float gain)
 {
     return _seal_setf(slot, AL_EFFECTSLOT_GAIN, gain, alAuxiliaryEffectSlotf);
 }
 
 seal_err_t
+SEAL_API
 seal_set_efs_auto(seal_efs_t* slot, char automatic)
 {
-    return _seal_seti(slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, automatic,
-                      alAuxiliaryEffectSloti);
+    return _seal_seti(
+        slot,
+        AL_EFFECTSLOT_AUXILIARY_SEND_AUTO,
+        automatic,
+        alAuxiliaryEffectSloti
+    );
 }
 
 void*
+SEAL_API
 seal_get_efs_effect(seal_efs_t* slot)
 {
     return slot->effect;
 }
 
 seal_err_t
+SEAL_API
 seal_get_efs_gain(seal_efs_t* slot, float* pgain)
 {
-    return _seal_getf(slot, AL_EFFECTSLOT_GAIN, pgain,
-                      alGetAuxiliaryEffectSlotf);
+    return _seal_getf(
+        slot,
+        AL_EFFECTSLOT_GAIN,
+        pgain,
+        alGetAuxiliaryEffectSlotf
+    );
 }
 
 seal_err_t
+SEAL_API
 seal_is_efs_auto(seal_efs_t* slot, char* pauto)
 {
-    return _seal_getb(slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, pauto,
-                      alGetAuxiliaryEffectSloti);
+    return _seal_getb(
+        slot,
+        AL_EFFECTSLOT_AUXILIARY_SEND_AUTO,
+        pauto,
+        alGetAuxiliaryEffectSloti
+    );
 }

data/src/seal/err.c

@@ -2,6 +2,7 @@
 #include <seal/err.h>
 
 const char*
+SEAL_API
 seal_get_err_msg(seal_err_t err)
 {
     switch (err) {

data/src/seal/listener.c

@@ -57,48 +57,78 @@ getfv(int key, float* vector)
 }
 
 seal_err_t
+SEAL_API
+seal_move_listener(void)
+{
+    seal_err_t err;
+    float pos[3], vel[3];
+
+    if ((err = seal_get_listener_pos(pos, pos + 1, pos + 2)) != SEAL_OK)
+        return err;
+    if ((err = seal_get_listener_vel(vel, vel + 1, vel + 2)) != SEAL_OK)
+        return err;
+    err = seal_set_listener_pos(
+        pos[0] + vel[0],
+        pos[1] + vel[1],
+        pos[2] + vel[2]
+    );
+    if (err != SEAL_OK)
+        return err;
+
+    return SEAL_OK;
+}
+
+seal_err_t
+SEAL_API
 seal_set_listener_gain(float gain)
 {
     return setf(AL_GAIN, gain);
 }
 
 seal_err_t
+SEAL_API
 seal_set_listener_pos(float x, float y, float z)
 {
     return set3f(AL_POSITION, x, y, z);
 }
 
 seal_err_t
+SEAL_API
 seal_set_listener_vel(float x, float y, float z)
 {
     return set3f(AL_VELOCITY, x, y, z);
 }
 
 seal_err_t
+SEAL_API
 seal_set_listener_orien(float* orien)
 {
     return setfv(AL_ORIENTATION, orien);
 }
 
 seal_err_t
+SEAL_API
 seal_get_listener_gain(float* pgain)
 {
     return getf(AL_GAIN, pgain);
 }
 
 seal_err_t
+SEAL_API
 seal_get_listener_pos(float* px, float* py, float* pz)
 {
     return get3f(AL_POSITION, px, py, pz);
 }
 
 seal_err_t
+SEAL_API
 seal_get_listener_vel(float* px, float* py, float* pz)
 {
     return get3f(AL_VELOCITY, px, py, pz);
 }
 
 seal_err_t
+SEAL_API
 seal_get_listener_orien(float* orien)
 {
     return getfv(AL_ORIENTATION, orien);

data/src/seal/mpg.c

@@ -51,8 +51,12 @@ 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);
+    err = mpg123_read(
+        mh,
+        (unsigned char*) raw->data + *nbytes_loaded,
+        raw->size - *nbytes_loaded,
+        &nbytes_read
+    );
     *nbytes_loaded += nbytes_read;
 
     return err;

data/src/seal/ov.c

@@ -41,8 +41,15 @@ read(seal_raw_t* raw, unsigned long* nbytes_loaded, OggVorbis_File* ovf)
     long nbytes_read;
     int bitstream;
 
-    nbytes_read = ov_read(ovf, (char*) raw->data + *nbytes_loaded,
-                          raw->size - *nbytes_loaded, 0, 2, 1, &bitstream);
+    nbytes_read = ov_read(
+        ovf,
+        (char*) raw->data + *nbytes_loaded,
+        raw->size - *nbytes_loaded,
+        0,
+        2,
+        1,
+        &bitstream
+    );
     *nbytes_loaded += nbytes_read;
 
     return nbytes_read;

data/src/seal/rvb.c

@@ -25,6 +25,7 @@ load_properties(seal_rvb_t* rvb, EFXEAXREVERBPROPERTIES properties)
 }
 
 seal_err_t
+SEAL_API
 seal_init_rvb(seal_rvb_t* rvb)
 {
     seal_err_t err;
@@ -37,6 +38,7 @@ seal_init_rvb(seal_rvb_t* rvb)
 }
 
 seal_err_t
+SEAL_API
 seal_destroy_rvb(seal_rvb_t* rvb)
 {
     return _seal_destroy_obj(rvb, alDeleteEffects, alIsEffect);
@@ -52,6 +54,7 @@ seal_destroy_rvb(seal_rvb_t* rvb)
     }
 
 seal_err_t
+SEAL_API
 seal_load_rvb(seal_rvb_t* rvb, seal_rvb_preset_t preset)
 {
     switch (preset) {
@@ -204,165 +207,193 @@ seal_load_rvb(seal_rvb_t* rvb, seal_rvb_preset_t preset)
 }
 
 seal_err_t
+SEAL_API
 seal_set_rvb_density(seal_rvb_t* rvb, float density)
 {
     return _seal_setf(rvb, AL_REVERB_DENSITY, density, alEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_set_rvb_diffusion(seal_rvb_t* rvb, float diffusion)
 {
     return _seal_setf(rvb, AL_REVERB_DIFFUSION, diffusion, alEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_set_rvb_gain(seal_rvb_t* rvb, float gain)
 {
     return _seal_setf(rvb, AL_REVERB_GAIN, gain, alEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_set_rvb_hfgain(seal_rvb_t* rvb, float hfgain)
 {
     return _seal_setf(rvb, AL_REVERB_GAINHF, hfgain, alEffectf);
 }
 
 seal_err_t
+SEAL_API
 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_API
 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_API
 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_API
 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_API
 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_API
 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_API
 seal_set_rvb_air_absorbtion_hfgain(seal_rvb_t* rvb, float hfgain)
 {
-    return _seal_setf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, hfgain,
-                      alEffectf);
+    return _seal_setf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, hfgain, alEffectf);
 }
 
 seal_err_t
+SEAL_API
 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_API
 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_API
 seal_get_rvb_density(seal_rvb_t* rvb, float* pdensity)
 {
     return _seal_getf(rvb, AL_REVERB_DENSITY, pdensity, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_diffusion(seal_rvb_t* rvb, float* pdiffusion)
 {
-    return _seal_getf(rvb,  AL_REVERB_DIFFUSION, pdiffusion, alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_DIFFUSION, pdiffusion, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_gain(seal_rvb_t* rvb, float* pgain)
 {
-    return _seal_getf(rvb,  AL_REVERB_GAIN, pgain, alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_GAIN, pgain, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_hfgain(seal_rvb_t* rvb, float* phfgain)
 {
-    return _seal_getf(rvb,  AL_REVERB_GAINHF, phfgain, alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_GAINHF, phfgain, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_decay_time(seal_rvb_t* rvb, float* ptime)
 {
-    return _seal_getf(rvb,  AL_REVERB_DECAY_TIME, ptime, alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_DECAY_TIME, ptime, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_hfdecay_ratio(seal_rvb_t* rvb, float* pratio)
 {
-    return _seal_getf(rvb,  AL_REVERB_DECAY_HFRATIO, pratio, alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_DECAY_HFRATIO, pratio, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_reflections_gain(seal_rvb_t* rvb, float* pgain)
 {
-    return _seal_getf(rvb,  AL_REVERB_REFLECTIONS_GAIN, pgain,
-                      alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_REFLECTIONS_GAIN, pgain, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_reflections_delay(seal_rvb_t* rvb, float* pdelay)
 {
-    return _seal_getf(rvb,  AL_REVERB_REFLECTIONS_DELAY, pdelay,
-                      alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_REFLECTIONS_DELAY, pdelay, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_late_gain(seal_rvb_t* rvb, float* pgain)
 {
-    return _seal_getf(rvb,  AL_REVERB_LATE_REVERB_GAIN, pgain,
-                      alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_LATE_REVERB_GAIN, pgain, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_late_delay(seal_rvb_t* rvb, float* pdelay)
 {
-    return _seal_getf(rvb,  AL_REVERB_LATE_REVERB_DELAY, pdelay,
-                      alGetEffectf);
+    return _seal_getf(rvb, AL_REVERB_LATE_REVERB_DELAY, pdelay, alGetEffectf);
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_air_absorbtion_hfgain(seal_rvb_t* rvb, float* phfgain)
 {
-    return _seal_getf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, phfgain,
-                      alGetEffectf);
+    return _seal_getf(
+        rvb,
+        AL_REVERB_AIR_ABSORPTION_GAINHF,
+        phfgain,
+        alGetEffectf
+    );
 }
 
 seal_err_t
+SEAL_API
 seal_get_rvb_room_rolloff_factor(seal_rvb_t* rvb, float* pfactor)
 {
-    return _seal_getf(rvb, AL_REVERB_ROOM_ROLLOFF_FACTOR, pfactor,
-                      alGetEffectf);
+    return _seal_getf(
+        rvb,
+        AL_REVERB_ROOM_ROLLOFF_FACTOR,
+        pfactor,
+        alGetEffectf
+    );
 }
 
 seal_err_t
+SEAL_API
 seal_is_rvb_hfdecay_limited(seal_rvb_t* rvb, char* plimited)
 {
-    return _seal_getb(rvb, AL_REVERB_DECAY_HFLIMIT, plimited,
-                      alGetEffecti);
+    return _seal_getb(rvb, AL_REVERB_DECAY_HFLIMIT, plimited, alGetEffecti);
 }