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.
@@ -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);
@@ -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(buf, _seal_get_buf_fmt(raw->attr.nchannels,
50
- raw->attr.bit_depth),
51
- raw->data, raw->size, raw->attr.freq);
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;
@@ -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.0";
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(int n, const unsigned int* objs,
189
- _seal_openal_destroyer_t* destroy)
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(void* obj, _seal_openal_destroyer_t* destroy,
204
- _seal_openal_validator_t* valid)
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);
@@ -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(slot, alDeleteAuxiliaryEffectSlots,
17
- alIsAuxiliaryEffectSlot);
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(slot, AL_EFFECTSLOT_EFFECT,
26
- effect == 0 ? AL_EFFECT_NULL : _seal_openal_id(effect),
27
- alAuxiliaryEffectSloti);
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(slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, automatic,
44
- alAuxiliaryEffectSloti);
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(slot, AL_EFFECTSLOT_GAIN, pgain,
57
- alGetAuxiliaryEffectSlotf);
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(slot, AL_EFFECTSLOT_AUXILIARY_SEND_AUTO, pauto,
64
- alGetAuxiliaryEffectSloti);
85
+ return _seal_getb(
86
+ slot,
87
+ AL_EFFECTSLOT_AUXILIARY_SEND_AUTO,
88
+ pauto,
89
+ alGetAuxiliaryEffectSloti
90
+ );
65
91
  }
@@ -2,6 +2,7 @@
2
2
  #include <seal/err.h>
3
3
 
4
4
  const char*
5
+ SEAL_API
5
6
  seal_get_err_msg(seal_err_t err)
6
7
  {
7
8
  switch (err) {
@@ -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);
@@ -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(mh, (unsigned char*) raw->data + *nbytes_loaded,
55
- raw->size - *nbytes_loaded, &nbytes_read);
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;
@@ -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(ovf, (char*) raw->data + *nbytes_loaded,
45
- raw->size - *nbytes_loaded, 0, 2, 1, &bitstream);
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;
@@ -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, AL_REVERB_DIFFUSION, pdiffusion, alGetEffectf);
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, AL_REVERB_GAIN, pgain, alGetEffectf);
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, AL_REVERB_GAINHF, phfgain, alGetEffectf);
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, AL_REVERB_DECAY_TIME, ptime, alGetEffectf);
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, AL_REVERB_DECAY_HFRATIO, pratio, alGetEffectf);
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, AL_REVERB_REFLECTIONS_GAIN, pgain,
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, AL_REVERB_REFLECTIONS_DELAY, pdelay,
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, AL_REVERB_LATE_REVERB_GAIN, pgain,
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, AL_REVERB_LATE_REVERB_DELAY, pdelay,
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(rvb, AL_REVERB_AIR_ABSORPTION_GAINHF, phfgain,
353
- alGetEffectf);
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(rvb, AL_REVERB_ROOM_ROLLOFF_FACTOR, pfactor,
360
- alGetEffectf);
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
  }