seal 0.1.1 → 0.1.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/README.md +19 -0
- data/include/seal/buf.h +17 -9
- data/include/seal/core.h +14 -8
- data/include/seal/efs.h +8 -8
- data/include/seal/err.h +3 -1
- data/include/seal/fmt.h +4 -2
- data/include/seal/listener.h +32 -9
- data/include/seal/rvb.h +71 -31
- data/include/seal/src.h +65 -37
- data/include/seal/stream.h +12 -5
- data/mpg123/build/config.guess +0 -0
- data/mpg123/build/config.sub +0 -0
- data/mpg123/build/depcomp +0 -0
- data/mpg123/build/install-sh +0 -0
- data/mpg123/build/missing +0 -0
- data/mpg123/configure +0 -0
- data/mpg123/ports/MSVC++/2010/libmpg123/libmpg123.vcxproj +2 -2
- data/mpg123/ports/MSVC++/2010/libmpg123/yasm.exe +0 -0
- data/mpg123/scripts/benchmark-cpu.pl +0 -0
- data/mpg123/src/win32_net.c +0 -0
- data/mpg123/src/win32_support.c +0 -0
- data/mpg123/src/win32_support.h +0 -0
- data/mpg123/windows-builds.sh +0 -0
- data/spec/spec_helper.rb +16 -3
- data/spec/support/movable_object.rb +25 -11
- data/src/rubyext.c +30 -1
- data/src/seal/buf.c +16 -3
- data/src/seal/core.c +16 -7
- data/src/seal/efs.c +37 -11
- data/src/seal/err.c +1 -0
- data/src/seal/listener.c +30 -0
- data/src/seal/mpg.c +6 -2
- data/src/seal/ov.c +9 -2
- data/src/seal/rvb.c +52 -21
- data/src/seal/src.c +75 -6
- data/src/seal/stream.c +4 -0
- data/src/seal/threading.c +8 -2
- data/src/seal/wav.c +6 -2
- metadata +7 -7
data/src/rubyext.c
CHANGED
@@ -633,6 +633,25 @@ rewind_src(VALUE rsrc)
|
|
633
633
|
return src_op(rsrc, seal_rewind_src);
|
634
634
|
}
|
635
635
|
|
636
|
+
/*
|
637
|
+
* call-seq:
|
638
|
+
* source.move -> source
|
639
|
+
*
|
640
|
+
* Moves the source (changes the position) based on the source velocity. This
|
641
|
+
* is a syntactic sugar for adding the velocity vector and position vector:
|
642
|
+
*
|
643
|
+
* # Equivalent to `source.move`
|
644
|
+
* source.position = source.position.zip(source.velocity).map do |a, b|
|
645
|
+
* a + b
|
646
|
+
* end
|
647
|
+
*/
|
648
|
+
static
|
649
|
+
VALUE
|
650
|
+
move_src(VALUE rsrc, VALUE value)
|
651
|
+
{
|
652
|
+
return src_op(rsrc, seal_move_src);
|
653
|
+
}
|
654
|
+
|
636
655
|
/*
|
637
656
|
* call-seq:
|
638
657
|
* source.buffer = buffer -> buffer
|
@@ -798,7 +817,6 @@ get_src_pos(VALUE rsrc)
|
|
798
817
|
* Sets the velocity of _source_ in a right-handed Cartesian coordinate
|
799
818
|
* system. The velocity of the source does not affect its position but is a
|
800
819
|
* factor used during the Doppler effect emulation. Use of NaN is undefined.
|
801
|
-
*
|
802
820
|
*/
|
803
821
|
static
|
804
822
|
VALUE
|
@@ -1683,6 +1701,15 @@ get_listener()
|
|
1683
1701
|
return rb_const_get(mSeal, rb_intern("LISTENER"));
|
1684
1702
|
}
|
1685
1703
|
|
1704
|
+
static
|
1705
|
+
VALUE
|
1706
|
+
move_listener(VALUE rlistener)
|
1707
|
+
{
|
1708
|
+
check_seal_err(seal_move_listener());
|
1709
|
+
|
1710
|
+
return rlistener;
|
1711
|
+
}
|
1712
|
+
|
1686
1713
|
/*
|
1687
1714
|
* call-seq:
|
1688
1715
|
* Seal.listener.gain = flt -> [flt, flt, flt]
|
@@ -1975,6 +2002,7 @@ bind_src(void)
|
|
1975
2002
|
rb_define_method(cSource, "pause", pause_src, 0);
|
1976
2003
|
rb_define_method(cSource, "stop", stop_src, 0);
|
1977
2004
|
rb_define_method(cSource, "rewind", rewind_src, 0);
|
2005
|
+
rb_define_method(cSource, "move", move_src, 0);
|
1978
2006
|
rb_define_method(cSource, "buffer=", set_src_buf, 1);
|
1979
2007
|
rb_define_method(cSource, "buffer", get_src_buf, 0);
|
1980
2008
|
rb_define_method(cSource, "stream=", set_src_stream, 1);
|
@@ -2348,6 +2376,7 @@ bind_listener(void)
|
|
2348
2376
|
rb_define_const(mSeal, "LISTENER", listener);
|
2349
2377
|
rb_define_singleton_method(mSeal, "listener", get_listener, 0);
|
2350
2378
|
singletonify(cListener);
|
2379
|
+
rb_define_method(cListener, "move", move_listener, 0);
|
2351
2380
|
rb_define_method(cListener, "position=", set_listener_pos, 1);
|
2352
2381
|
rb_define_method(cListener, "position", get_listener_pos, 0);
|
2353
2382
|
rb_define_method(cListener, "velocity=", set_listener_vel, 1);
|
data/src/seal/buf.c
CHANGED
@@ -10,18 +10,21 @@
|
|
10
10
|
#include "wav.h"
|
11
11
|
|
12
12
|
seal_err_t
|
13
|
+
SEAL_API
|
13
14
|
seal_init_buf(seal_buf_t* buf)
|
14
15
|
{
|
15
16
|
return _seal_init_obj(buf, alGenBuffers);
|
16
17
|
}
|
17
18
|
|
18
19
|
seal_err_t
|
20
|
+
SEAL_API
|
19
21
|
seal_destroy_buf(seal_buf_t* buf)
|
20
22
|
{
|
21
23
|
return _seal_destroy_obj(buf, alDeleteBuffers, alIsBuffer);
|
22
24
|
}
|
23
25
|
|
24
26
|
seal_err_t
|
27
|
+
SEAL_API
|
25
28
|
seal_load2buf(seal_buf_t* buf, const char* filename, seal_fmt_t fmt)
|
26
29
|
{
|
27
30
|
seal_raw_t raw;
|
@@ -38,6 +41,7 @@ seal_load2buf(seal_buf_t* buf, const char* filename, seal_fmt_t fmt)
|
|
38
41
|
}
|
39
42
|
|
40
43
|
seal_err_t
|
44
|
+
SEAL_API
|
41
45
|
seal_raw2buf(seal_buf_t* buf, seal_raw_t* raw)
|
42
46
|
{
|
43
47
|
return _seal_raw2buf(buf->id, raw);
|
@@ -46,38 +50,47 @@ seal_raw2buf(seal_buf_t* buf, seal_raw_t* raw)
|
|
46
50
|
seal_err_t
|
47
51
|
_seal_raw2buf(unsigned int buf, seal_raw_t* raw)
|
48
52
|
{
|
49
|
-
alBufferData(
|
50
|
-
|
51
|
-
|
53
|
+
alBufferData(
|
54
|
+
buf,
|
55
|
+
_seal_get_buf_fmt(raw->attr.nchannels, raw->attr.bit_depth),
|
56
|
+
raw->data,
|
57
|
+
raw->size,
|
58
|
+
raw->attr.freq
|
59
|
+
);
|
52
60
|
|
53
61
|
return _seal_get_openal_err();
|
54
62
|
}
|
55
63
|
|
56
64
|
seal_err_t
|
65
|
+
SEAL_API
|
57
66
|
seal_get_buf_size(seal_buf_t* buf, int* psize)
|
58
67
|
{
|
59
68
|
return _seal_geti(buf, AL_SIZE, psize, alGetBufferi);
|
60
69
|
}
|
61
70
|
|
62
71
|
seal_err_t
|
72
|
+
SEAL_API
|
63
73
|
seal_get_buf_freq(seal_buf_t* buf, int* pfreq)
|
64
74
|
{
|
65
75
|
return _seal_geti(buf, AL_FREQUENCY, pfreq, alGetBufferi);
|
66
76
|
}
|
67
77
|
|
68
78
|
seal_err_t
|
79
|
+
SEAL_API
|
69
80
|
seal_get_buf_bps(seal_buf_t* buf, int* pbps)
|
70
81
|
{
|
71
82
|
return _seal_geti(buf, AL_BITS, pbps, alGetBufferi);
|
72
83
|
}
|
73
84
|
|
74
85
|
seal_err_t
|
86
|
+
SEAL_API
|
75
87
|
seal_get_buf_nchannels(seal_buf_t* buf, int* pnchannels)
|
76
88
|
{
|
77
89
|
return _seal_geti(buf, AL_CHANNELS, pnchannels, alGetBufferi);
|
78
90
|
}
|
79
91
|
|
80
92
|
seal_err_t
|
93
|
+
SEAL_API
|
81
94
|
seal_load(seal_raw_t* raw, const char* filename, seal_fmt_t fmt)
|
82
95
|
{
|
83
96
|
seal_err_t err;
|
data/src/seal/core.c
CHANGED
@@ -28,9 +28,10 @@ LPALGETAUXILIARYEFFECTSLOTI alGetAuxiliaryEffectSloti = (void*) _seal_nop;
|
|
28
28
|
LPALGETAUXILIARYEFFECTSLOTF alGetAuxiliaryEffectSlotf = (void*) _seal_nop;
|
29
29
|
|
30
30
|
const char*
|
31
|
+
SEAL_API
|
31
32
|
seal_get_version(void)
|
32
33
|
{
|
33
|
-
return "0.1.
|
34
|
+
return "0.1.2";
|
34
35
|
}
|
35
36
|
|
36
37
|
static
|
@@ -87,6 +88,7 @@ reset_ext_proc(void)
|
|
87
88
|
* currently does not make use of multiple contexts.
|
88
89
|
*/
|
89
90
|
seal_err_t
|
91
|
+
SEAL_API
|
90
92
|
seal_startup(const char* device_name)
|
91
93
|
{
|
92
94
|
ALCdevice* device;
|
@@ -146,6 +148,7 @@ clean_device:
|
|
146
148
|
|
147
149
|
/* Finalizes the current device and context. */
|
148
150
|
void
|
151
|
+
SEAL_API
|
149
152
|
seal_cleanup(void)
|
150
153
|
{
|
151
154
|
ALCdevice* device;
|
@@ -163,6 +166,7 @@ seal_cleanup(void)
|
|
163
166
|
}
|
164
167
|
|
165
168
|
int
|
169
|
+
SEAL_API
|
166
170
|
seal_get_per_src_effect_limit(void)
|
167
171
|
{
|
168
172
|
return per_src_effect_limit;
|
@@ -176,8 +180,7 @@ _seal_openal_id(void* obj)
|
|
176
180
|
}
|
177
181
|
|
178
182
|
seal_err_t
|
179
|
-
_seal_gen_objs(int n, unsigned int* objs,
|
180
|
-
_seal_openal_initializer_t* generate)
|
183
|
+
_seal_gen_objs(int n, unsigned int* objs, _seal_openal_initializer_t* generate)
|
181
184
|
{
|
182
185
|
generate(n, objs);
|
183
186
|
|
@@ -185,8 +188,11 @@ _seal_gen_objs(int n, unsigned int* objs,
|
|
185
188
|
}
|
186
189
|
|
187
190
|
seal_err_t
|
188
|
-
_seal_delete_objs(
|
189
|
-
|
191
|
+
_seal_delete_objs(
|
192
|
+
int n,
|
193
|
+
const unsigned int* objs,
|
194
|
+
_seal_openal_destroyer_t* destroy
|
195
|
+
)
|
190
196
|
{
|
191
197
|
destroy(n, objs);
|
192
198
|
|
@@ -200,8 +206,11 @@ _seal_init_obj(void* obj, _seal_openal_initializer_t* allocate)
|
|
200
206
|
}
|
201
207
|
|
202
208
|
seal_err_t
|
203
|
-
_seal_destroy_obj(
|
204
|
-
|
209
|
+
_seal_destroy_obj(
|
210
|
+
void* obj,
|
211
|
+
_seal_openal_destroyer_t* destroy,
|
212
|
+
_seal_openal_validator_t* valid
|
213
|
+
)
|
205
214
|
{
|
206
215
|
if (valid(_seal_openal_id(obj)))
|
207
216
|
return _seal_delete_objs(1, obj, destroy);
|
data/src/seal/efs.c
CHANGED
@@ -5,26 +5,35 @@
|
|
5
5
|
#include <seal/err.h>
|
6
6
|
|
7
7
|
seal_err_t
|
8
|
+
SEAL_API
|
8
9
|
seal_init_efs(seal_efs_t* slot)
|
9
10
|
{
|
10
11
|
return _seal_init_obj(slot, alGenAuxiliaryEffectSlots);
|
11
12
|
}
|
12
13
|
|
13
14
|
seal_err_t
|
15
|
+
SEAL_API
|
14
16
|
seal_destroy_efs(seal_efs_t* slot)
|
15
17
|
{
|
16
|
-
return _seal_destroy_obj(
|
17
|
-
|
18
|
+
return _seal_destroy_obj(
|
19
|
+
slot,
|
20
|
+
alDeleteAuxiliaryEffectSlots,
|
21
|
+
alIsAuxiliaryEffectSlot
|
22
|
+
);
|
18
23
|
}
|
19
24
|
|
20
25
|
seal_err_t
|
26
|
+
SEAL_API
|
21
27
|
seal_set_efs_effect(seal_efs_t* slot, void* effect)
|
22
28
|
{
|
23
29
|
seal_err_t err;
|
24
30
|
|
25
|
-
err = _seal_seti(
|
26
|
-
|
27
|
-
|
31
|
+
err = _seal_seti(
|
32
|
+
slot,
|
33
|
+
AL_EFFECTSLOT_EFFECT,
|
34
|
+
effect == 0 ? AL_EFFECT_NULL : _seal_openal_id(effect),
|
35
|
+
alAuxiliaryEffectSloti
|
36
|
+
);
|
28
37
|
if (err == SEAL_OK)
|
29
38
|
slot->effect = effect;
|
30
39
|
|
@@ -32,34 +41,51 @@ seal_set_efs_effect(seal_efs_t* slot, void* effect)
|
|
32
41
|
}
|
33
42
|
|
34
43
|
seal_err_t
|
44
|
+
SEAL_API
|
35
45
|
seal_set_efs_gain(seal_efs_t* slot, float gain)
|
36
46
|
{
|
37
47
|
return _seal_setf(slot, AL_EFFECTSLOT_GAIN, gain, alAuxiliaryEffectSlotf);
|
38
48
|
}
|
39
49
|
|
40
50
|
seal_err_t
|
51
|
+
SEAL_API
|
41
52
|
seal_set_efs_auto(seal_efs_t* slot, char automatic)
|
42
53
|
{
|
43
|
-
return _seal_seti(
|
44
|
-
|
54
|
+
return _seal_seti(
|
55
|
+
slot,
|
56
|
+
AL_EFFECTSLOT_AUXILIARY_SEND_AUTO,
|
57
|
+
automatic,
|
58
|
+
alAuxiliaryEffectSloti
|
59
|
+
);
|
45
60
|
}
|
46
61
|
|
47
62
|
void*
|
63
|
+
SEAL_API
|
48
64
|
seal_get_efs_effect(seal_efs_t* slot)
|
49
65
|
{
|
50
66
|
return slot->effect;
|
51
67
|
}
|
52
68
|
|
53
69
|
seal_err_t
|
70
|
+
SEAL_API
|
54
71
|
seal_get_efs_gain(seal_efs_t* slot, float* pgain)
|
55
72
|
{
|
56
|
-
return _seal_getf(
|
57
|
-
|
73
|
+
return _seal_getf(
|
74
|
+
slot,
|
75
|
+
AL_EFFECTSLOT_GAIN,
|
76
|
+
pgain,
|
77
|
+
alGetAuxiliaryEffectSlotf
|
78
|
+
);
|
58
79
|
}
|
59
80
|
|
60
81
|
seal_err_t
|
82
|
+
SEAL_API
|
61
83
|
seal_is_efs_auto(seal_efs_t* slot, char* pauto)
|
62
84
|
{
|
63
|
-
return _seal_getb(
|
64
|
-
|
85
|
+
return _seal_getb(
|
86
|
+
slot,
|
87
|
+
AL_EFFECTSLOT_AUXILIARY_SEND_AUTO,
|
88
|
+
pauto,
|
89
|
+
alGetAuxiliaryEffectSloti
|
90
|
+
);
|
65
91
|
}
|
data/src/seal/err.c
CHANGED
data/src/seal/listener.c
CHANGED
@@ -57,48 +57,78 @@ getfv(int key, float* vector)
|
|
57
57
|
}
|
58
58
|
|
59
59
|
seal_err_t
|
60
|
+
SEAL_API
|
61
|
+
seal_move_listener(void)
|
62
|
+
{
|
63
|
+
seal_err_t err;
|
64
|
+
float pos[3], vel[3];
|
65
|
+
|
66
|
+
if ((err = seal_get_listener_pos(pos, pos + 1, pos + 2)) != SEAL_OK)
|
67
|
+
return err;
|
68
|
+
if ((err = seal_get_listener_vel(vel, vel + 1, vel + 2)) != SEAL_OK)
|
69
|
+
return err;
|
70
|
+
err = seal_set_listener_pos(
|
71
|
+
pos[0] + vel[0],
|
72
|
+
pos[1] + vel[1],
|
73
|
+
pos[2] + vel[2]
|
74
|
+
);
|
75
|
+
if (err != SEAL_OK)
|
76
|
+
return err;
|
77
|
+
|
78
|
+
return SEAL_OK;
|
79
|
+
}
|
80
|
+
|
81
|
+
seal_err_t
|
82
|
+
SEAL_API
|
60
83
|
seal_set_listener_gain(float gain)
|
61
84
|
{
|
62
85
|
return setf(AL_GAIN, gain);
|
63
86
|
}
|
64
87
|
|
65
88
|
seal_err_t
|
89
|
+
SEAL_API
|
66
90
|
seal_set_listener_pos(float x, float y, float z)
|
67
91
|
{
|
68
92
|
return set3f(AL_POSITION, x, y, z);
|
69
93
|
}
|
70
94
|
|
71
95
|
seal_err_t
|
96
|
+
SEAL_API
|
72
97
|
seal_set_listener_vel(float x, float y, float z)
|
73
98
|
{
|
74
99
|
return set3f(AL_VELOCITY, x, y, z);
|
75
100
|
}
|
76
101
|
|
77
102
|
seal_err_t
|
103
|
+
SEAL_API
|
78
104
|
seal_set_listener_orien(float* orien)
|
79
105
|
{
|
80
106
|
return setfv(AL_ORIENTATION, orien);
|
81
107
|
}
|
82
108
|
|
83
109
|
seal_err_t
|
110
|
+
SEAL_API
|
84
111
|
seal_get_listener_gain(float* pgain)
|
85
112
|
{
|
86
113
|
return getf(AL_GAIN, pgain);
|
87
114
|
}
|
88
115
|
|
89
116
|
seal_err_t
|
117
|
+
SEAL_API
|
90
118
|
seal_get_listener_pos(float* px, float* py, float* pz)
|
91
119
|
{
|
92
120
|
return get3f(AL_POSITION, px, py, pz);
|
93
121
|
}
|
94
122
|
|
95
123
|
seal_err_t
|
124
|
+
SEAL_API
|
96
125
|
seal_get_listener_vel(float* px, float* py, float* pz)
|
97
126
|
{
|
98
127
|
return get3f(AL_VELOCITY, px, py, pz);
|
99
128
|
}
|
100
129
|
|
101
130
|
seal_err_t
|
131
|
+
SEAL_API
|
102
132
|
seal_get_listener_orien(float* orien)
|
103
133
|
{
|
104
134
|
return getfv(AL_ORIENTATION, orien);
|
data/src/seal/mpg.c
CHANGED
@@ -51,8 +51,12 @@ read(seal_raw_t* raw, size_t* nbytes_loaded, mpg123_handle* mh)
|
|
51
51
|
int err;
|
52
52
|
size_t nbytes_read = 0;
|
53
53
|
|
54
|
-
err = mpg123_read(
|
55
|
-
|
54
|
+
err = mpg123_read(
|
55
|
+
mh,
|
56
|
+
(unsigned char*) raw->data + *nbytes_loaded,
|
57
|
+
raw->size - *nbytes_loaded,
|
58
|
+
&nbytes_read
|
59
|
+
);
|
56
60
|
*nbytes_loaded += nbytes_read;
|
57
61
|
|
58
62
|
return err;
|
data/src/seal/ov.c
CHANGED
@@ -41,8 +41,15 @@ read(seal_raw_t* raw, unsigned long* nbytes_loaded, OggVorbis_File* ovf)
|
|
41
41
|
long nbytes_read;
|
42
42
|
int bitstream;
|
43
43
|
|
44
|
-
nbytes_read = ov_read(
|
45
|
-
|
44
|
+
nbytes_read = ov_read(
|
45
|
+
ovf,
|
46
|
+
(char*) raw->data + *nbytes_loaded,
|
47
|
+
raw->size - *nbytes_loaded,
|
48
|
+
0,
|
49
|
+
2,
|
50
|
+
1,
|
51
|
+
&bitstream
|
52
|
+
);
|
46
53
|
*nbytes_loaded += nbytes_read;
|
47
54
|
|
48
55
|
return nbytes_read;
|
data/src/seal/rvb.c
CHANGED
@@ -25,6 +25,7 @@ load_properties(seal_rvb_t* rvb, EFXEAXREVERBPROPERTIES properties)
|
|
25
25
|
}
|
26
26
|
|
27
27
|
seal_err_t
|
28
|
+
SEAL_API
|
28
29
|
seal_init_rvb(seal_rvb_t* rvb)
|
29
30
|
{
|
30
31
|
seal_err_t err;
|
@@ -37,6 +38,7 @@ seal_init_rvb(seal_rvb_t* rvb)
|
|
37
38
|
}
|
38
39
|
|
39
40
|
seal_err_t
|
41
|
+
SEAL_API
|
40
42
|
seal_destroy_rvb(seal_rvb_t* rvb)
|
41
43
|
{
|
42
44
|
return _seal_destroy_obj(rvb, alDeleteEffects, alIsEffect);
|
@@ -52,6 +54,7 @@ seal_destroy_rvb(seal_rvb_t* rvb)
|
|
52
54
|
}
|
53
55
|
|
54
56
|
seal_err_t
|
57
|
+
SEAL_API
|
55
58
|
seal_load_rvb(seal_rvb_t* rvb, seal_rvb_preset_t preset)
|
56
59
|
{
|
57
60
|
switch (preset) {
|
@@ -204,165 +207,193 @@ seal_load_rvb(seal_rvb_t* rvb, seal_rvb_preset_t preset)
|
|
204
207
|
}
|
205
208
|
|
206
209
|
seal_err_t
|
210
|
+
SEAL_API
|
207
211
|
seal_set_rvb_density(seal_rvb_t* rvb, float density)
|
208
212
|
{
|
209
213
|
return _seal_setf(rvb, AL_REVERB_DENSITY, density, alEffectf);
|
210
214
|
}
|
211
215
|
|
212
216
|
seal_err_t
|
217
|
+
SEAL_API
|
213
218
|
seal_set_rvb_diffusion(seal_rvb_t* rvb, float diffusion)
|
214
219
|
{
|
215
220
|
return _seal_setf(rvb, AL_REVERB_DIFFUSION, diffusion, alEffectf);
|
216
221
|
}
|
217
222
|
|
218
223
|
seal_err_t
|
224
|
+
SEAL_API
|
219
225
|
seal_set_rvb_gain(seal_rvb_t* rvb, float gain)
|
220
226
|
{
|
221
227
|
return _seal_setf(rvb, AL_REVERB_GAIN, gain, alEffectf);
|
222
228
|
}
|
223
229
|
|
224
230
|
seal_err_t
|
231
|
+
SEAL_API
|
225
232
|
seal_set_rvb_hfgain(seal_rvb_t* rvb, float hfgain)
|
226
233
|
{
|
227
234
|
return _seal_setf(rvb, AL_REVERB_GAINHF, hfgain, alEffectf);
|
228
235
|
}
|
229
236
|
|
230
237
|
seal_err_t
|
238
|
+
SEAL_API
|
231
239
|
seal_set_rvb_decay_time(seal_rvb_t* rvb, float time)
|
232
240
|
{
|
233
241
|
return _seal_setf(rvb, AL_REVERB_DECAY_TIME, time, alEffectf);
|
234
242
|
}
|
235
243
|
|
236
244
|
seal_err_t
|
245
|
+
SEAL_API
|
237
246
|
seal_set_rvb_hfdecay_ratio(seal_rvb_t* rvb, float ratio)
|
238
247
|
{
|
239
248
|
return _seal_setf(rvb, AL_REVERB_DECAY_HFRATIO, ratio, alEffectf);
|
240
249
|
}
|
241
250
|
|
242
251
|
seal_err_t
|
252
|
+
SEAL_API
|
243
253
|
seal_set_rvb_reflections_gain(seal_rvb_t* rvb, float gain)
|
244
254
|
{
|
245
255
|
return _seal_setf(rvb, AL_REVERB_REFLECTIONS_GAIN, gain, alEffectf);
|
246
256
|
}
|
247
257
|
|
248
258
|
seal_err_t
|
259
|
+
SEAL_API
|
249
260
|
seal_set_rvb_reflections_delay(seal_rvb_t* rvb, float delay)
|
250
261
|
{
|
251
262
|
return _seal_setf(rvb, AL_REVERB_REFLECTIONS_DELAY, delay, alEffectf);
|
252
263
|
}
|
253
264
|
|
254
265
|
seal_err_t
|
266
|
+
SEAL_API
|
255
267
|
seal_set_rvb_late_gain(seal_rvb_t* rvb, float gain)
|
256
268
|
{
|
257
269
|
return _seal_setf(rvb, AL_REVERB_LATE_REVERB_GAIN, gain, alEffectf);
|
258
270
|
}
|
259
271
|
|
260
272
|
seal_err_t
|
273
|
+
SEAL_API
|
261
274
|
seal_set_rvb_late_delay(seal_rvb_t* rvb, float delay)
|
262
275
|
{
|
263
276
|
return _seal_setf(rvb, AL_REVERB_LATE_REVERB_DELAY, delay, alEffectf);
|
264
277
|
}
|
265
278
|
|
266
279
|
seal_err_t
|
280
|
+
SEAL_API
|
267
281
|
seal_set_rvb_air_absorbtion_hfgain(seal_rvb_t* rvb, float hfgain)
|
268
282
|
{
|
269
|
-
return _seal_setf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, hfgain,
|
270
|
-
alEffectf);
|
283
|
+
return _seal_setf(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, hfgain, alEffectf);
|
271
284
|
}
|
272
285
|
|
273
286
|
seal_err_t
|
287
|
+
SEAL_API
|
274
288
|
seal_set_rvb_room_rolloff_factor(seal_rvb_t* rvb, float factor)
|
275
289
|
{
|
276
290
|
return _seal_setf(rvb, AL_REVERB_ROOM_ROLLOFF_FACTOR, factor, alEffectf);
|
277
291
|
}
|
278
292
|
|
279
293
|
seal_err_t
|
294
|
+
SEAL_API
|
280
295
|
seal_set_rvb_hfdecay_limited(seal_rvb_t* rvb, char limited)
|
281
296
|
{
|
282
297
|
return _seal_seti(rvb, AL_REVERB_DECAY_HFLIMIT, limited, alEffecti);
|
283
298
|
}
|
284
299
|
|
285
300
|
seal_err_t
|
301
|
+
SEAL_API
|
286
302
|
seal_get_rvb_density(seal_rvb_t* rvb, float* pdensity)
|
287
303
|
{
|
288
304
|
return _seal_getf(rvb, AL_REVERB_DENSITY, pdensity, alGetEffectf);
|
289
305
|
}
|
290
306
|
|
291
307
|
seal_err_t
|
308
|
+
SEAL_API
|
292
309
|
seal_get_rvb_diffusion(seal_rvb_t* rvb, float* pdiffusion)
|
293
310
|
{
|
294
|
-
return _seal_getf(rvb,
|
311
|
+
return _seal_getf(rvb, AL_REVERB_DIFFUSION, pdiffusion, alGetEffectf);
|
295
312
|
}
|
296
313
|
|
297
314
|
seal_err_t
|
315
|
+
SEAL_API
|
298
316
|
seal_get_rvb_gain(seal_rvb_t* rvb, float* pgain)
|
299
317
|
{
|
300
|
-
return _seal_getf(rvb,
|
318
|
+
return _seal_getf(rvb, AL_REVERB_GAIN, pgain, alGetEffectf);
|
301
319
|
}
|
302
320
|
|
303
321
|
seal_err_t
|
322
|
+
SEAL_API
|
304
323
|
seal_get_rvb_hfgain(seal_rvb_t* rvb, float* phfgain)
|
305
324
|
{
|
306
|
-
return _seal_getf(rvb,
|
325
|
+
return _seal_getf(rvb, AL_REVERB_GAINHF, phfgain, alGetEffectf);
|
307
326
|
}
|
308
327
|
|
309
328
|
seal_err_t
|
329
|
+
SEAL_API
|
310
330
|
seal_get_rvb_decay_time(seal_rvb_t* rvb, float* ptime)
|
311
331
|
{
|
312
|
-
return _seal_getf(rvb,
|
332
|
+
return _seal_getf(rvb, AL_REVERB_DECAY_TIME, ptime, alGetEffectf);
|
313
333
|
}
|
314
334
|
|
315
335
|
seal_err_t
|
336
|
+
SEAL_API
|
316
337
|
seal_get_rvb_hfdecay_ratio(seal_rvb_t* rvb, float* pratio)
|
317
338
|
{
|
318
|
-
return _seal_getf(rvb,
|
339
|
+
return _seal_getf(rvb, AL_REVERB_DECAY_HFRATIO, pratio, alGetEffectf);
|
319
340
|
}
|
320
341
|
|
321
342
|
seal_err_t
|
343
|
+
SEAL_API
|
322
344
|
seal_get_rvb_reflections_gain(seal_rvb_t* rvb, float* pgain)
|
323
345
|
{
|
324
|
-
return _seal_getf(rvb,
|
325
|
-
alGetEffectf);
|
346
|
+
return _seal_getf(rvb, AL_REVERB_REFLECTIONS_GAIN, pgain, alGetEffectf);
|
326
347
|
}
|
327
348
|
|
328
349
|
seal_err_t
|
350
|
+
SEAL_API
|
329
351
|
seal_get_rvb_reflections_delay(seal_rvb_t* rvb, float* pdelay)
|
330
352
|
{
|
331
|
-
return _seal_getf(rvb,
|
332
|
-
alGetEffectf);
|
353
|
+
return _seal_getf(rvb, AL_REVERB_REFLECTIONS_DELAY, pdelay, alGetEffectf);
|
333
354
|
}
|
334
355
|
|
335
356
|
seal_err_t
|
357
|
+
SEAL_API
|
336
358
|
seal_get_rvb_late_gain(seal_rvb_t* rvb, float* pgain)
|
337
359
|
{
|
338
|
-
return _seal_getf(rvb,
|
339
|
-
alGetEffectf);
|
360
|
+
return _seal_getf(rvb, AL_REVERB_LATE_REVERB_GAIN, pgain, alGetEffectf);
|
340
361
|
}
|
341
362
|
|
342
363
|
seal_err_t
|
364
|
+
SEAL_API
|
343
365
|
seal_get_rvb_late_delay(seal_rvb_t* rvb, float* pdelay)
|
344
366
|
{
|
345
|
-
return _seal_getf(rvb,
|
346
|
-
alGetEffectf);
|
367
|
+
return _seal_getf(rvb, AL_REVERB_LATE_REVERB_DELAY, pdelay, alGetEffectf);
|
347
368
|
}
|
348
369
|
|
349
370
|
seal_err_t
|
371
|
+
SEAL_API
|
350
372
|
seal_get_rvb_air_absorbtion_hfgain(seal_rvb_t* rvb, float* phfgain)
|
351
373
|
{
|
352
|
-
return _seal_getf(
|
353
|
-
|
374
|
+
return _seal_getf(
|
375
|
+
rvb,
|
376
|
+
AL_REVERB_AIR_ABSORPTION_GAINHF,
|
377
|
+
phfgain,
|
378
|
+
alGetEffectf
|
379
|
+
);
|
354
380
|
}
|
355
381
|
|
356
382
|
seal_err_t
|
383
|
+
SEAL_API
|
357
384
|
seal_get_rvb_room_rolloff_factor(seal_rvb_t* rvb, float* pfactor)
|
358
385
|
{
|
359
|
-
return _seal_getf(
|
360
|
-
|
386
|
+
return _seal_getf(
|
387
|
+
rvb,
|
388
|
+
AL_REVERB_ROOM_ROLLOFF_FACTOR,
|
389
|
+
pfactor,
|
390
|
+
alGetEffectf
|
391
|
+
);
|
361
392
|
}
|
362
393
|
|
363
394
|
seal_err_t
|
395
|
+
SEAL_API
|
364
396
|
seal_is_rvb_hfdecay_limited(seal_rvb_t* rvb, char* plimited)
|
365
397
|
{
|
366
|
-
return _seal_getb(rvb, AL_REVERB_DECAY_HFLIMIT, plimited,
|
367
|
-
alGetEffecti);
|
398
|
+
return _seal_getb(rvb, AL_REVERB_DECAY_HFLIMIT, plimited, alGetEffecti);
|
368
399
|
}
|