ruby-openal 0.1

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.
@@ -0,0 +1,53 @@
1
+ #ifndef RUBY_OPENAL_AL_H
2
+ #define RUBY_OPENAL_AL_H
3
+
4
+ #ifdef __cplusplus
5
+ extern "C" {
6
+ #endif
7
+
8
+ /// module variable
9
+ extern VALUE vAL;
10
+
11
+ /// class variables
12
+ extern VALUE vAL_Listener;
13
+ extern VALUE vAL_SampleData;
14
+ extern VALUE vAL_Buffer;
15
+ extern VALUE vAL_Source;
16
+
17
+ /// AL module's constants
18
+ extern VALUE vAL_NO_ERROR; // errors
19
+ extern VALUE vAL_INVALID_NAME;
20
+ extern VALUE vAL_INVALID_ENUM;
21
+ extern VALUE vAL_INVALID_VALUE;
22
+ extern VALUE vAL_INVALID_OPERATION;
23
+ extern VALUE vAL_OUT_OF_MEMORY;
24
+ extern VALUE vAL_DOPPLER_FACTOR; // states
25
+ extern VALUE vAL_SPEED_OF_SOUND;
26
+ extern VALUE vAL_DISTANCE_MODEL;
27
+ extern VALUE vAL_VENDOR; // specs
28
+ extern VALUE vAL_VERSION;
29
+ extern VALUE vAL_RENDERER;
30
+ extern VALUE vAL_EXTENSIONS;
31
+ extern VALUE vAL_INVERSE_DISTANCE; // disance model
32
+ extern VALUE vAL_INVERSE_DISTANCE_CLAMPED;
33
+ extern VALUE vAL_LINEAR_DISTANCE;
34
+ extern VALUE vAL_LINEAR_DISTANCE_CLAMPED;
35
+ extern VALUE vAL_EXPONENT_DISTANCE;
36
+ extern VALUE vAL_EXPONENT_DISTANCE_CLAMPED;
37
+ extern VALUE vAL_NONE;
38
+ extern VALUE vAL_FORMAT_MONO8; // formats
39
+ extern VALUE vAL_FORMAT_MONO16;
40
+ extern VALUE vAL_FORMAT_STEREO8;
41
+ extern VALUE vAL_FORMAT_STEREO16;
42
+ extern VALUE vAL_UNDETERMINED; // source types
43
+ extern VALUE vAL_STATIC;
44
+ extern VALUE vAL_STREAMING;
45
+
46
+ extern void setup_module_AL();
47
+ extern VALUE AL_Buffer_from_albuf(const ALuint b);
48
+
49
+ #ifdef __cplusplus
50
+ }
51
+ #endif
52
+
53
+ #endif
Binary file
@@ -0,0 +1,416 @@
1
+ #include "ruby.h"
2
+ #include "openal.h"
3
+ #include "openal_al.h"
4
+ #include "AL/al.h"
5
+ #include "AL/alc.h"
6
+
7
+ /// module privates
8
+ static VALUE __arContextRegs;
9
+ static VALUE __arDeviceRegs;
10
+
11
+ /// module values
12
+ VALUE vALC;
13
+
14
+ /// class values
15
+ VALUE vALC_Device;
16
+ VALUE vALC_Context;
17
+ VALUE vALC_CaptureDevice;
18
+
19
+ /// ALC: error constants
20
+ VALUE vALC_NO_ERROR = INT2FIX(ALC_NO_ERROR);
21
+ VALUE vALC_INVALID_DEVICE = INT2FIX(ALC_INVALID_DEVICE);
22
+ VALUE vALC_INVALID_CONTEXT = INT2FIX(ALC_INVALID_CONTEXT);
23
+ VALUE vALC_INVALID_ENUM = INT2FIX(ALC_INVALID_ENUM);
24
+ VALUE vALC_INVALID_VALUE = INT2FIX(ALC_INVALID_VALUE);
25
+ VALUE vALC_OUT_OF_MEMORY = INT2FIX(ALC_OUT_OF_MEMORY);
26
+
27
+ static void define_ALC_error_consts() {
28
+ rb_define_const(vALC, "NO_ERROR", vALC_NO_ERROR);
29
+ rb_define_const(vALC, "INVALID_DEVICE", vALC_INVALID_DEVICE);
30
+ rb_define_const(vALC, "INVALID_CONTEXT", vALC_INVALID_CONTEXT);
31
+ rb_define_const(vALC, "INVALID_ENUM", vALC_INVALID_ENUM);
32
+ rb_define_const(vALC, "INVALID_VALUE", vALC_INVALID_VALUE);
33
+ rb_define_const(vALC, "OUT_OF_MEMORY", vALC_OUT_OF_MEMORY);
34
+ }
35
+
36
+ /// ALC: state constants
37
+ VALUE vALC_DEFAULT_DEVICE_SPECIFIER = INT2FIX(ALC_DEFAULT_DEVICE_SPECIFIER);
38
+ VALUE vALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER = INT2FIX(ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
39
+ VALUE vALC_DEVICE_SPECIFIER = INT2FIX(ALC_DEVICE_SPECIFIER);
40
+ VALUE vALC_CAPTURE_DEVICE_SPECIFIER = INT2FIX(ALC_CAPTURE_DEVICE_SPECIFIER);
41
+ VALUE vALC_EXTENSIONS = INT2FIX(ALC_EXTENSIONS);
42
+ VALUE vALC_MAJOR_VERSION = INT2FIX(ALC_MAJOR_VERSION);
43
+ VALUE vALC_MINOR_VERSION = INT2FIX(ALC_MINOR_VERSION);
44
+ VALUE vALC_ATTRIBUTES_SIZE = INT2FIX(ALC_ATTRIBUTES_SIZE);
45
+ VALUE vALC_ALL_ATTRIBUTES = INT2FIX(ALC_ALL_ATTRIBUTES);
46
+
47
+ static void define_ALC_state_consts() {
48
+ rb_define_const(vALC, "DEFAULT_DEVICE_SPECIFIER", vALC_DEFAULT_DEVICE_SPECIFIER);
49
+ rb_define_const(vALC, "CAPTURE_DEFAULT_DEVICE_SPECIFIER", vALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER);
50
+ rb_define_const(vALC, "DEVICE_SPECIFIER", vALC_DEVICE_SPECIFIER);
51
+ rb_define_const(vALC, "CAPTURE_DEVICE_SPECIFIER", vALC_CAPTURE_DEVICE_SPECIFIER);
52
+ rb_define_const(vALC, "EXTENSIONS", vALC_EXTENSIONS);
53
+ rb_define_const(vALC, "MAJOR_VERSION", vALC_MAJOR_VERSION);
54
+ rb_define_const(vALC, "MINOR_VERSION", vALC_MINOR_VERSION);
55
+ rb_define_const(vALC, "ATTRIBUTES_SIZE", vALC_ATTRIBUTES_SIZE);
56
+ rb_define_const(vALC, "ALL_ATTRIBUTES", vALC_ALL_ATTRIBUTES);
57
+ }
58
+
59
+ /// ALC: opts constants
60
+ VALUE vALC_FREQUENCY = INT2FIX(ALC_FREQUENCY);
61
+ VALUE vALC_SYNC = INT2FIX(ALC_SYNC);
62
+ VALUE vALC_REFRESH = INT2FIX(ALC_REFRESH);
63
+ VALUE vALC_MONO_SOURCES = INT2FIX(ALC_MONO_SOURCES);
64
+ VALUE vALC_STEREO_SOURCES = INT2FIX(ALC_STEREO_SOURCES);
65
+
66
+ static void define_ALC_opts_consts() {
67
+ rb_define_const(vALC, "FREQUENCY", vALC_FREQUENCY);
68
+ rb_define_const(vALC, "SYNC", vALC_SYNC);
69
+ rb_define_const(vALC, "REFRESH", vALC_REFRESH);
70
+ rb_define_const(vALC, "MONO_SOURCES", vALC_MONO_SOURCES);
71
+ rb_define_const(vALC, "STEREO_SOURCES", vALC_STEREO_SOURCES);
72
+ }
73
+
74
+ static void __ALC_Device_free(ALCdevice* device) {
75
+ alcCloseDevice(device);
76
+ }
77
+
78
+ /// ALC::Device#new
79
+ static VALUE ALC_Device_new(int argc, VALUE* argv, VALUE klass) {
80
+ VALUE self;
81
+ char* s = NULL;
82
+ //if (!NIL_P(argv[0])) s = RSTRING_PTR(argv[0]);
83
+ ALCdevice* device = alcOpenDevice(s);
84
+ if ( NULL == device ) return Qnil;
85
+ self = Data_Wrap_Struct(vALC_Device, 0, __ALC_Device_free, device);
86
+ rb_obj_call_init(self, argc, argv);
87
+ return self;
88
+ }
89
+
90
+ /// ALC::Device#initialize
91
+ static VALUE ALC_Device_initialize(int argc, VALUE* argv, VALUE self) {
92
+ rb_ary_push(__arDeviceRegs, self);
93
+ return self;
94
+ }
95
+
96
+ /// ALC::Device#extension_present?(extname)
97
+ static VALUE ALC_Device_extension_present_p(VALUE self, VALUE extname) {
98
+ ALboolean rslt;
99
+ const char* s = NULL;
100
+ ALCdevice* d = NULL;
101
+ // device
102
+ Data_Get_Struct(self, ALCdevice, d);
103
+ // extname
104
+ Check_Type(extname, T_STRING);
105
+ s = RSTRING_PTR(extname);
106
+ //
107
+ rslt = alcIsExtensionPresent(d, s);
108
+ return albool2rbbool(rslt);
109
+ }
110
+
111
+ /// ALC::Device#enum_value_of(enumname)
112
+ static VALUE ALC_Device_enum_value_of(VALUE self, VALUE enumname) {
113
+ const char* str = NULL;
114
+ ALCdevice* d = NULL;
115
+ // device
116
+ Data_Get_Struct(self, ALCdevice, d);
117
+ // enum-name
118
+ Check_Type(enumname, T_STRING);
119
+ str = RSTRING_PTR(enumname);
120
+ //
121
+ return INT2FIX(alcGetEnumValue(d, str));
122
+
123
+ }
124
+
125
+ /// ALC::Device#get_error
126
+ static VALUE ALC_Device_get_error(VALUE self) {
127
+ ALCdevice* d = NULL;
128
+ ALenum e;
129
+ Data_Get_Struct(self, ALCdevice, d);
130
+ e = alcGetError(d);
131
+ return INT2FIX(e);
132
+ }
133
+
134
+ /// ALC::Device#string(enum)
135
+ static VALUE ALC_Device_get_string(VALUE self, VALUE en) {
136
+ ALenum e;
137
+ ALCdevice* d = NULL;
138
+ // device
139
+ Data_Get_Struct(self, ALCdevice, d);
140
+ // enum
141
+ e = NUM2INT(en);
142
+ //
143
+ return rb_str_new2(alcGetString(d, e));
144
+ }
145
+
146
+ static VALUE ALC_Device_to_s(VALUE self) {
147
+ const long slen = 4096;
148
+ char s[4096];
149
+ ALCdevice* p;
150
+ Data_Get_Struct(self, ALCdevice, p);
151
+ snprintf(s, slen, "#<ALC::Device@%p>", p);
152
+ return rb_str_new2(s);
153
+ }
154
+
155
+ static void define_ALC_Device_methods() {
156
+ /// ALC::Device#new
157
+ rb_define_singleton_method(vALC_Device, "new", ALC_Device_new, -1);
158
+ /// ALC::Device#initialize
159
+ rb_define_method(vALC_Device, "initialize", ALC_Device_initialize, -1);
160
+
161
+ // error
162
+ /// ALC::device#get_error
163
+ rb_define_method(vALC_Device, "get_error", ALC_Device_get_error, 0);
164
+
165
+ // extensions
166
+ /// ALC::Device#extension_present?(extname)
167
+ rb_define_method(vALC_Device, "extension_present?", ALC_Device_extension_present_p, 1);
168
+ /// ALC::Device#enum_value_of(enumname)
169
+ rb_define_method(vALC_Device, "enum_value_of", ALC_Device_enum_value_of, 1);
170
+
171
+ // queries, states
172
+ /// ALC::Device#string(enumname)
173
+ rb_define_method(vALC_Device, "string", ALC_Device_get_string, 1);
174
+ ///FIXME: ALC::Device#integers(enumname)
175
+
176
+ // ALC::Device#to_s
177
+ rb_define_method(vALC_Device, "to_s", ALC_Device_to_s, 0);
178
+ }
179
+
180
+ static void setup_class_ALC_Device() {
181
+ __arDeviceRegs = rb_ary_new();
182
+ vALC_Device = rb_define_class_under(vALC, "Device", rb_cObject);
183
+ define_ALC_Device_methods();
184
+ }
185
+
186
+
187
+ static void __ALC_Context_free(ALCcontext* ctx) {
188
+ alcDestroyContext(ctx);
189
+ }
190
+
191
+ /// +ALC::Context#new
192
+ static VALUE ALC_Context_new(int argc, VALUE* argv, VALUE klass) {
193
+ VALUE self;
194
+ ALCcontext* ctx = NULL;
195
+ ALCdevice* dvc = NULL;
196
+ // device
197
+ Data_Get_Struct(argv[0], ALCdevice, dvc);
198
+ // FIXME: accept args for opts
199
+ ctx = alcCreateContext(dvc, NULL);
200
+ if ( NULL == ctx ) return Qnil;
201
+ self = Data_Wrap_Struct(vALC_Context, 0, __ALC_Context_free, ctx);
202
+ rb_obj_call_init(self, argc, argv);
203
+ return self;
204
+ }
205
+
206
+ /// ALC::Context#initialize
207
+ static VALUE ALC_Context_initialize(int argc, VALUE* argv, VALUE self) {
208
+ rb_ary_push(__arContextRegs, self);
209
+ return self;
210
+ }
211
+
212
+ /// +ALC::Context#current
213
+ static VALUE ALC_Context_get_current(VALUE self) {
214
+ ALCcontext* ctx = alcGetCurrentContext();
215
+ ALCcontext* ctx2;
216
+ long len = RARRAY_LEN(__arContextRegs);
217
+ long n;
218
+ VALUE v;
219
+ if ( NULL == ctx ) return Qnil;
220
+ for ( n = 0 ; n < len ; n ++ ) {
221
+ v = rb_ary_entry(__arContextRegs, n);
222
+ ctx2 = NULL;
223
+ Data_Get_Struct(v, ALCcontext, ctx2);
224
+ if ( ctx2 == ctx ) return v;
225
+ }
226
+ return Qnil;
227
+ }
228
+
229
+ /// +ALC::Context#current=(context)
230
+ static VALUE ALC_Context_set_current(VALUE self, VALUE context) {
231
+ ALCcontext* ctx;
232
+ ALCboolean b;
233
+ Data_Get_Struct(context, ALCcontext, ctx);
234
+ b = alcMakeContextCurrent(ctx);
235
+ return albool2rbbool(b);
236
+ }
237
+
238
+ /// ALC::Context#make_current
239
+ static VALUE ALC_Context_make_current(VALUE self) {
240
+ ALCcontext* ctx;
241
+ ALCboolean b;
242
+ Data_Get_Struct(self, ALCcontext, ctx);
243
+ b = alcMakeContextCurrent(ctx);
244
+ return albool2rbbool(b);
245
+ }
246
+
247
+ /// ALC::Context#device
248
+ static VALUE ALC_Context_get_device(VALUE self) {
249
+ ALCcontext* ctx;
250
+ ALCdevice* dvc;
251
+ ALCdevice* dvc2;
252
+ long len = RARRAY_LEN(__arDeviceRegs);
253
+ long n;
254
+ VALUE v;
255
+ // device?
256
+ Data_Get_Struct(self, ALCcontext, ctx);
257
+ dvc = alcGetContextsDevice(ctx);
258
+ if ( NULL == dvc ) return Qnil;
259
+ for ( n = 0 ; n < len ; n ++ ) {
260
+ v = rb_ary_entry(__arDeviceRegs, n);
261
+ dvc2 = NULL;
262
+ Data_Get_Struct(v, ALCdevice, dvc2);
263
+ if ( dvc2 == dvc ) return v;
264
+ }
265
+ return Qnil;
266
+ }
267
+
268
+ /// ALC::Context#process
269
+ static VALUE ALC_Context_process(VALUE self) {
270
+ ALCcontext* ctx;
271
+ Data_Get_Struct(self, ALCcontext, ctx);
272
+ alcProcessContext(ctx);
273
+ return Qnil;
274
+ }
275
+
276
+ /// ALC::Context#suspend
277
+ static VALUE ALC_Context_suspend(VALUE self) {
278
+ ALCcontext* ctx;
279
+ Data_Get_Struct(self, ALCcontext, ctx);
280
+ alcSuspendContext(ctx);
281
+ return Qnil;
282
+ }
283
+
284
+ /// ALC::Context#to_s
285
+ static VALUE ALC_Context_to_s(VALUE self) {
286
+ const long slen=4096;
287
+ char s[4096];
288
+ ALCcontext* p;
289
+ Data_Get_Struct(self, ALCcontext, p);
290
+ snprintf(s, slen, "#<ALC::Context@%p>", p);
291
+ return rb_str_new2(s);
292
+ }
293
+
294
+ static void define_ALC_Context_methods() {
295
+ /// +ALC::Context#new(device)
296
+ rb_define_singleton_method(vALC_Context, "new", ALC_Context_new, -1);
297
+ /// ALC::Context#initialize(device)
298
+ rb_define_method(vALC_Context, "initialize", ALC_Context_initialize, -1);
299
+ /// +ALC::Context#current=(context)
300
+ rb_define_singleton_method(vALC_Context, "current=", ALC_Context_set_current, 1);
301
+ /// +ALC::Context#current
302
+ rb_define_singleton_method(vALC_Context, "current", ALC_Context_get_current, 0);
303
+ /// ALC::Context#make_current
304
+ rb_define_method(vALC_Context, "make_current", ALC_Context_make_current, 0);
305
+ /// ALC::Context#process
306
+ rb_define_method(vALC_Context, "process", ALC_Context_process, 0);
307
+ /// ALC::Context#suspend
308
+ rb_define_method(vALC_Context, "suspend", ALC_Context_suspend, 0);
309
+ /// ALC::Context#device
310
+ rb_define_method(vALC_Context, "device", ALC_Context_get_device, 0);
311
+ ///FIXME: ALC::Context#destroy
312
+ // ALC::Context#to_s
313
+ rb_define_method(vALC_Context, "to_s", ALC_Context_to_s, 0);
314
+ }
315
+
316
+ static void setup_class_ALC_Context() {
317
+ __arContextRegs = rb_ary_new();
318
+ vALC_Context = rb_define_class_under(vALC, "Context", rb_cObject);
319
+ define_ALC_Context_methods();
320
+ }
321
+
322
+
323
+ static void __ALC_CaptureDevice_free(ALCdevice* dvc) {
324
+ alcCaptureCloseDevice(dvc);
325
+ }
326
+
327
+ /// - ALC::CaptureDevice#initialize
328
+ static VALUE ALC_CaptureDevice_initialize(VALUE self) {
329
+ return self;
330
+ }
331
+
332
+ /// + ALC::CaptureDeivce#new(device_name, frequency : Fixnum, format : ALenum, bufsize : Fixnum)
333
+ static VALUE ALC_CaptureDevice_new(VALUE klass, VALUE vDvcNm, VALUE vFreq, VALUE vFmt, VALUE vBufSize) {
334
+ VALUE self;
335
+ ALCdevice* dvc;
336
+ // params
337
+ const char* dvcnm = NULL;
338
+ if ( !NIL_P(vDvcNm) ) {
339
+ Check_Type(vDvcNm, T_STRING);
340
+ dvcnm = RSTRING_PTR(vDvcNm);
341
+ }
342
+ ALuint freq = NUM2UINT(vFreq);
343
+ ALenum fmt = NUM2INT(vFmt);
344
+ ALsizei bufsize = NUM2LONG(vBufSize);
345
+ // device
346
+ dvc = alcCaptureOpenDevice(dvcnm, freq, fmt, bufsize);
347
+ // device->val
348
+ if (NULL == dvc) return Qnil;
349
+ else {
350
+ self = Data_Wrap_Struct(vALC_CaptureDevice, 0, __ALC_CaptureDevice_free, dvc);
351
+ //rb_obj_call_init(self, argc, argv);
352
+ ALC_CaptureDevice_initialize(self);
353
+ return self;
354
+ }
355
+ }
356
+
357
+ /// - ALC::CaptureDevice#start
358
+ static VALUE ALC_CaptureDevice_start(VALUE self) {
359
+ ALCdevice* p;
360
+ Data_Get_Struct(self, ALCdevice, p);
361
+ alcCaptureStart(p);
362
+ return Qnil;
363
+ }
364
+
365
+ /// - ALC::CaptureDevice#stop
366
+ static VALUE ALC_CaptureDevice_stop(VALUE self) {
367
+ ALCdevice* p;
368
+ Data_Get_Struct(self, ALCdevice, p);
369
+ alcCaptureStop(p);
370
+ return Qnil;
371
+ }
372
+
373
+ /// - ALC::CaptureDevice#to_s
374
+ static VALUE ALC_CaptureDevice_to_s(VALUE self) {
375
+ const long slen=4096;
376
+ char s[4096];
377
+ ALCdevice* p;
378
+ Data_Get_Struct(self, ALCdevice, p);
379
+ snprintf(s, slen, "ALC::CaptureDevice@%p", p);
380
+ return rb_str_new2(s);
381
+ }
382
+
383
+
384
+ static void define_ALC_CaptureDevice_methods() {
385
+ /// + ALC::CaptureDeivce#new(device_name, frequency : Fixnum, format : ALenum, bufsize : Fixnum)
386
+ rb_define_singleton_method(vALC_CaptureDevice, "new", ALC_CaptureDevice_new, 4);
387
+ /// - ALC::CaptureDevice#initialize
388
+ rb_define_method(vALC_CaptureDevice, "initialize", ALC_CaptureDevice_initialize, 0);
389
+ /// - ALC::CaptureDevice#start
390
+ rb_define_method(vALC_CaptureDevice, "start", ALC_CaptureDevice_start, 0);
391
+ /// - ALC::CaptureDevice#stop
392
+ rb_define_method(vALC_CaptureDevice, "stop", ALC_CaptureDevice_stop, 0);
393
+ /// - ALC::CaptureDevice#to_s
394
+ rb_define_method(vALC_CaptureDevice, "to_s", ALC_CaptureDevice_to_s, 0);
395
+ //TODO: - ALC::CaptureDevice#retrive???
396
+ }
397
+
398
+ static void setup_class_ALC_CaptureDevice() {
399
+ vALC_CaptureDevice = rb_define_class_under(vALC, "CaptureDevice", rb_cObject);
400
+ define_ALC_CaptureDevice_methods();
401
+ }
402
+
403
+ void setup_module_ALC() {
404
+ vALC = rb_define_module("ALC");
405
+ // constants: ALC
406
+ define_ALC_error_consts();
407
+ define_ALC_state_consts();
408
+ define_ALC_opts_consts();
409
+ // module functions: ALC
410
+ // ALC::Device
411
+ setup_class_ALC_Device();
412
+ // ALC::Context
413
+ setup_class_ALC_Context();
414
+ // ALC::CaptureDevice
415
+ setup_class_ALC_CaptureDevice();
416
+ }