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.
- data/TODO +160 -0
- data/ext/openal/MANIFEST +9 -0
- data/ext/openal/Makefile +149 -0
- data/ext/openal/extconf.rb +12 -0
- data/ext/openal/mkmf.log +66 -0
- data/ext/openal/openal.c +15 -0
- data/ext/openal/openal.h +50 -0
- data/ext/openal/openal.o +0 -0
- data/ext/openal/openal.so +0 -0
- data/ext/openal/openal_al.c +1406 -0
- data/ext/openal/openal_al.h +53 -0
- data/ext/openal/openal_al.o +0 -0
- data/ext/openal/openal_alc.c +416 -0
- data/ext/openal/openal_alc.h +44 -0
- data/ext/openal/openal_alc.o +0 -0
- data/ext/openal/openal_alut.c +181 -0
- data/ext/openal/openal_alut.h +49 -0
- data/ext/openal/openal_alut.o +0 -0
- data/ruby-openal.gemspec +30 -0
- data/setup.rb +1585 -0
- data/test/test_al.rb +67 -0
- data/test/test_al.rb~ +67 -0
- metadata +72 -0
@@ -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
|
+
}
|