/* RUDL - a C library wrapping SDL for use in Ruby. Copyright (C) 2001 Danny van Bruggen */ #include "rudl_audio.h" VALUE classSound; VALUE classChannel; VALUE classMixer; VALUE classMusic; VALUE classEndOfMusicEvent; #ifdef HAVE_SDL_MIXER_H #include "SDL_mixer.h" #ifndef MIX_MAJOR_VERSION Your SDL_mixer lib is too old #endif // Thanks to Ruby-SDL #define MAX_CHANNELS 256 /* should be more than enough */ static VALUE playing_wave[MAX_CHANNELS]; static VALUE playing_music=Qnil; void clearGCHack() { int i; for(i=0; iSDL_mixer. */ /** @class Channel A Channel is an interface object to one of the mixer's channels. It can be used for manipulating sound on a particular channel. */ /** @section Class Methods @method new( number ) Creates a Channel interface object for mixer channel @number. */ // Replaced by some evalled stuff /** @section Volume methods @method fade_out( milliseconds ) fade_out fades the channel to silence in @milliseconds milliseconds. */ /** @method volume @method volume=( loudness ) Get and set the volume of a @RUDL::Channel. Volumes range from 0.0 to 1.0. */ static VALUE channel_fade_out(VALUE self, VALUE milliseconds) { Mix_FadeOutChannel(retrieveChannelNumber(self), NUM2UINT(milliseconds)); return self; } static VALUE channel_get_volume(VALUE self, VALUE volume) { return DBL2NUM((Mix_Volume(retrieveChannelNumber(self), -1))/128.0); } static VALUE channel_set_volume(VALUE self, VALUE volume) { Mix_Volume(retrieveChannelNumber(self), (int)(NUM2DBL(volume)*128)); return self; } /** @section Play control @method busy => boolean @method pause => self @method unpause => self @method play( sound, loops, maxtime ) => self @method play( sound, loops ) => self @method play( sound ) => self @method stop => self */ /** @section Play control These are pretty self-explanatory. @play plays @Sound @sound 1 + @loops times, for a maximum time of @maxtime milliseconds. */ static VALUE channel_busy(VALUE self) { return Mix_Playing(retrieveChannelNumber(self)); } static VALUE channel_pause(VALUE self) { Mix_Pause(retrieveChannelNumber(self)); return self; } static VALUE channel_play(int argc, VALUE* argv, VALUE self) { int loops = 0, maxtime = -1, channelnum; VALUE sound=Qnil, loopsValue, maxtimeValue; Mix_Chunk* chunk=retrieveMixChunk(argv[0]); switch(rb_scan_args(argc, argv, "12", &sound, &loopsValue, &maxtimeValue)){ case 3: maxtime=NUM2INT(maxtimeValue); case 2: loops=NUM2INT(loopsValue); } channelnum = Mix_PlayChannelTimed(retrieveChannelNumber(self), chunk, loops, maxtime); if(channelnum != -1){ Mix_GroupChannel(channelnum, (int)chunk); } return self; } static VALUE channel_stop(VALUE self) { Mix_HaltChannel(retrieveChannelNumber(self)); return self; } static VALUE channel_unpause(VALUE self) { Mix_Resume(retrieveChannelNumber(self)); return self; } /** @section Positioning @method set_panning( left, right ) => self Set the panning of a channel. The left and right channels are specified as numbers between 0.0 and 1.0, quietest to loudest, respectively. Technically, this is just individual volume control for a sample with two (stereo) channels, so it can be used for more than just panning. If you want real panning, call it like this:

channel.set_panning(left, 1.0-left);

...which isn't so hard. */ static VALUE channel_set_panning(VALUE self, VALUE left, VALUE right) { double l=NUM2DBL(left); double r=NUM2DBL(right); RUDL_ASSERT(l<=1.0, "left volume too high"); RUDL_ASSERT(l>=0.0, "left volume too low"); RUDL_ASSERT(r<=1.0, "right volume too high"); RUDL_ASSERT(r>=0.0, "right volume too low"); SDL_VERIFY(Mix_SetPanning(retrieveChannelNumber(self), (Uint8)(l*255), (Uint8)(r*255))); return self; } /** @method set_position( angle, distance ) => self Set the position of a channel. @angle is an number from 0 to 360, that specifies the location of the sound in relation to the listener. @angle will be reduced as neccesary (540 becomes 180 degrees, -100 becomes 260). @Angle 0 is due north, and rotates clockwise as the value increases. For efficiency, the precision of this effect may be limited (angles 1 through 7 might all produce the same effect, 8 through 15 are equal, etc). @distance is a number between 0.0 and 1.0 that specifies the space between the sound and the listener. The larger the number, the further away the sound is. Using 1.0 does not guarantee that the channel will be culled from the mixing process or be completely silent. For efficiency, the precision of this effect may be limited (@distance 0 through 0.1 might all produce the same effect, 0.1 through 0.2 are equal, etc). Setting @angle and @distance to 0 unregisters this effect, since the data would be unchanged. */ static VALUE channel_set_position(VALUE self, VALUE angle, VALUE distance) { SDL_VERIFY(Mix_SetPosition(retrieveChannelNumber(self), (Sint16)NUM2INT(angle), (Sint8)(NUM2DBL(distance)*255))); return self; } /** @method set_distance( distance ) => self @Distance is a number between 0.0 and 1.0 that specifies the space between the sound and the listener. The larger the number, the further away the sound is. Using 1.0 does not guarantee that the channel will be culled from the mixing process or be completely silent. For efficiency, the precision of this effect may be limited (distance 0 through 0.1 might all produce the same effect, 0.1 through 0.2 are equal, etc). Setting @distance to 0 unregisters this effect, since the data would be unchanged. */ static VALUE channel_set_distance(VALUE self, VALUE distance) { SDL_VERIFY(Mix_SetDistance(retrieveChannelNumber(self), (Uint8)(NUM2DBL(distance)*255))); return self; } /** @method reverse_stereo( reverse ) => self Causes a channel to reverse its stereo. This is handy if the user has his speakers hooked up backwards, or you would like to have a minor bit of psychedelia in your sound code. :) Calling this function with @reverse set to true reverses the chunks's usual channels. If @reverse is false, the effect is unregistered. */ static VALUE channel_reverse_stereo(VALUE self, VALUE reverse) { SDL_VERIFY(Mix_SetReverseStereo(retrieveChannelNumber(self), NUM2BOOL(reverse))); return self; } /////////////// SOUND Mix_Chunk* retrieveMixChunk(VALUE self) { Mix_Chunk* chunk; Data_Get_Struct(self, Mix_Chunk, chunk); RUDL_ASSERT(chunk, "Retrieved NULL chunk"); return chunk; } /** @class Sound Sound is a single sample. It is loaded from a WAV file. */ /** @section Initializers @method new @method new( filename ) @method load_new( filename ) @section Initializers Creates a new @Sound object with the sound in file @filename. */ static VALUE sound_new(VALUE self, VALUE filename) { Mix_Chunk* chunk; VALUE newObject; initAudio(); chunk=Mix_LoadWAV(STR2CSTR(filename)); SDL_VERIFY(chunk); newObject=Data_Wrap_Struct(classSound, 0, SDL_FreeWAV, chunk); RUDL_VERIFY(newObject, "Sound.new misbehaved"); rb_obj_call_init(newObject, 0, NULL); return newObject; } /** @method import( sampledata ) This method imports raw sampledata. If it is not in the Mixer's format, use @Mixer@convert first. */ static VALUE sound_import(VALUE self, VALUE sampledata) { Mix_Chunk* chunk=(Mix_Chunk *)malloc(sizeof(Mix_Chunk)); VALUE newObject; initAudio(); Check_Type(sampledata, T_STRING); chunk->allocated = 0; chunk->alen = RSTRING(sampledata)->len; chunk->abuf = malloc(chunk->alen); chunk->volume = MIX_MAX_VOLUME; memcpy(chunk->abuf, RSTRING(sampledata)->ptr, chunk->alen); newObject=Data_Wrap_Struct(classSound, 0, SDL_FreeWAV, chunk); RUDL_VERIFY(newObject, "Sound.load_raw misbehaved"); rb_obj_call_init(newObject, 0, NULL); return newObject; } /* NOT IMPLEMENTED @method convert( sample, source_format, destination_format ) Returns a string with the string @sample with sampledata in it, assumed to be in @source_format, converted to the @destination_format. A format is an array with these contents: [frequency, format (like AUDIO_S8), channels]. */ static __inline__ void unpack_audio_format_array(VALUE array, int* rate, Uint16* format, int* channels) { *rate=NUM2INT(rb_ary_entry(array, 0)); *format=NUM2Uint16(rb_ary_entry(array, 1)); *channels=NUM2INT(rb_ary_entry(array, 2)); DEBUG_I(*format); DEBUG_I(*channels); DEBUG_I(*rate); } static __inline__ VALUE pack_audio_format_array(int rate, Uint16 format, int channels) { return rb_ary_new3(3, INT2NUM(rate), INT2NUM(format), INT2NUM(channels)); } static VALUE sound_convert(int argc, VALUE* argv, VALUE self) { int dest_rate; Uint16 dest_format; int dest_channels; Uint8* dest_memory; int dest_length; int src_rate; Uint16 src_format; int src_channels; VALUE src; Uint8* src_memory; int src_length; VALUE src_array, dest_array; switch(rb_scan_args(argc, argv, "21", &src, &src_array, &dest_array)){ case 2: { initAudio(); dest_array=mixer_get_format(0); break; } } src_memory=RSTRING(src)->ptr; src_length=RSTRING(src)->len; unpack_audio_format_array(src_array, &src_rate, &src_format, &src_channels); unpack_audio_format_array(dest_array, &dest_rate, &dest_format, &dest_channels); // call converter SDL_VERIFY( rudl_convert_audio( src_memory, src_length, &dest_memory, &dest_length, src_format, src_channels, src_rate, dest_format, dest_channels, dest_rate) !=-1); // wrap result in a string return rb_str_new(dest_memory, dest_length); } /* NOT IMPLEMENTED @method mix( destination, source ) @method mix( destination, source, max_volume ) */ /* __inline__ char* sound_pad(VALUE input, int to_length) { char* new_sound=(char*)calloc(to_length, sizeof(char)); memcpy(new_sound, RSTRING(input)->ptr, RSTRING(input)->len); return new_sound; } static VALUE sound_mix(int argc, VALUE* argv, VALUE self) { VALUE v_data1, v_data2, v_volume; double volume=1.0; char *data1, *data2; switch(rb_scan_args(argc, argv, "21", &v_data1, &v_data2, &v_volume)){ case 3: volume=NUM2DBL(v_volume); } Check_Type(v_data1, T_STRING); Check_Type(v_data2, T_STRING); *data1=RSTRING(v_data1)->len; *data2=RSTRING(v_data2)->len; if(RSTRING(v_data1)->len > RSTRING(v_data2)->len){ data2=sound_pad(v_data2, RSTRING(v_data1)->len); } if(RSTRING(v_data1)->len < RSTRING(v_data2)->len){ data1=sound_pad(v_data1, RSTRING(v_data2)->len); } Kopieer sdl_mixer.c SDL_MixAudio(data, Uint32 len, int volume); } */ /** @method String.to_sound Creates a new @RUDL::Sound object with the sound (in .WAV format) in the string. */ static VALUE string_to_sound(VALUE self) { Mix_Chunk* chunk; VALUE newObject; SDL_RWops* rwops; initAudio(); rwops=SDL_RWFromMem(RSTRING(self)->ptr, RSTRING(self)->len); chunk=Mix_LoadWAV_RW(rwops, 0); SDL_FreeRW(rwops); SDL_VERIFY(chunk); newObject=Data_Wrap_Struct(classSound, 0, SDL_FreeWAV, chunk); RUDL_VERIFY(newObject, "String.to_sound misbehaved"); rb_obj_call_init(newObject, 0, NULL); return newObject; } /** @section Volume methods @method fade_out( milliseconds ) @method volume @method volume=( loudness ) These are volume methods. */ /** @fade_out fades all instances of this sound that are playing to silence in @milliseconds milliseconds. @volume returns the current volume. @volume= sets the volume to loudness. Volumes range from 0.0 to 1.0. */ static VALUE sound_fade_out(VALUE self, VALUE time) { Mix_FadeOutGroup((int)retrieveMixChunk(self), NUM2UINT(time)); return self; } static VALUE sound_get_volume(VALUE self) { return DBL2NUM((Mix_VolumeChunk(retrieveMixChunk(self), -1))/128.0); } static VALUE sound_set_volume(VALUE self, VALUE volume) { Mix_VolumeChunk(retrieveMixChunk(self), (int)(NUM2DBL(volume)*128)); return self; } /** @method play( loops, maxtime ) => Channel or nil Starts playing a song on an available channel. If no channels are available, it will not play and return @nil. @Loops controls how many extra times the sound will play, a negative loop will play indefinitely, it defaults to 0. @Maxtime is the number of total milliseconds that the sound will play. It defaults to forever (-1). Returns a channel object for the channel that is selected to play the sound. Returns nil if for some reason no channel is found. */ static VALUE sound_play(int argc, VALUE* argv, VALUE self) { VALUE loopsValue, timeValue; int loops=0; int time=-1; int channelnum=-1; Mix_Chunk* chunk=retrieveMixChunk(self); switch(rb_scan_args(argc, argv, "02", &loopsValue, &timeValue)){ case 2: time=NUM2INT(timeValue); case 1: loops=NUM2INT(loopsValue); } channelnum = Mix_PlayChannelTimed(-1, chunk, loops, time); if(channelnum == -1) return Qnil; //make sure volume on this arbitrary channel is set to full Mix_Volume(channelnum, 128); Mix_GroupChannel(channelnum, (int)chunk); playing_wave[channelnum]=self; // to avoid gc problem return createChannelObject(channelnum); } /** @method stop => self Stops all channels playing this @Sound. */ static VALUE sound_stop(VALUE self) { Mix_HaltGroup((int)retrieveMixChunk(self)); return self; } static VALUE sound_get_num_channels(VALUE self) { return UINT2NUM(Mix_GroupCount((int)retrieveMixChunk(self))); } /** @method to_s => String Returns a string with the sampledata. */ static VALUE sound_export(VALUE self) { Mix_Chunk* chunk=retrieveMixChunk(self); return rb_str_new(chunk->abuf, chunk->alen); } /** @method format Returns the format of the @Sound, which is always the same as the Mixer's format. See @Mixer.format */ // This method is actually an alias for Mixer.format. /////////////// MIXER /** @class Mixer Mixer is the main sound class. All methods are available as class and instance methods. */ /** @section Initializers @method new => Mixer @method new( frequency ) => Mixer @method new( frequency, format ) => Mixer @method new( frequency, format, stereo ) => Mixer @method new( frequency, format, stereo, buffersize ) => Mixer Initializes the sound system. This call is not neccesary, the mixer will call @Mixer.new when it is needed. When you disagree with the defaults (at the time of writing: 16 bit, 22kHz, stereo, 4096) you can set them yourself, but do this before using any sound related method! @Mixer.new will return a @Mixer object, but if you don't want it, you can discard it and use class methods instead. */ static VALUE mixer_initialize(int argc, VALUE* argv, VALUE self) { int frequency = MIX_DEFAULT_FREQUENCY; Uint16 format = MIX_DEFAULT_FORMAT; int channels = MIX_DEFAULT_CHANNELS; int buffersize=4096; VALUE frequencyValue, sizeValue, stereoValue, bufferValue; switch(rb_scan_args(argc, argv, "04", &frequencyValue, &sizeValue, &stereoValue, &bufferValue)){ case 4: buffersize=NUM2INT(bufferValue); case 3: channels=NUM2INT(stereoValue); case 2: format=NUM2Uint16(sizeValue); case 1: frequency=NUM2INT(frequencyValue); } initSDL(); if(!SDL_WasInit(SDL_INIT_AUDIO)){ DEBUG_S("Starting audio subsystem"); SDL_VERIFY(!SDL_InitSubSystem(SDL_INIT_AUDIO)); } if(Mix_OpenAudio(frequency, format, channels, buffersize) == -1){ DEBUG_S("Stopping audio subsystem"); SDL_QuitSubSystem(SDL_INIT_AUDIO); SDL_RAISE; } return self; } /** @method destroy => self (was Mixer.quit) Uninitializes the Mixer. If you really want to do this, then be warned that all Music objects will be destroyed too! */ static VALUE mixer_destroy(VALUE self) { quitAudio(); return self; } /** @section Methods @method fade_out( millisecs ) Fades away all sound to silence in millisecs milliseconds. */ static VALUE mixer_fade_out(VALUE self, VALUE time) { initAudio(); Mix_FadeOutChannel(-1, NUM2INT(time)); return self; } /** @method find_free_channel => Channel or nil @method find_oldest_channel => Channel or nil Both functions search for a channel that can be used to play new sounds on. @find_free_channel finds a channel that is not playing anything and returns nil if there is no such channel. @find_oldest_channel finds the channel that has been playing for the longest time. */ static VALUE mixer_find_free_channel(VALUE self) { int channel; initAudio(); channel=Mix_GroupAvailable(-1); if(channel==-1){ return Qnil; } return createChannelObject(channel); } static VALUE mixer_find_oldest_channel(VALUE self) { initAudio(); return createChannelObject(Mix_GroupOldest(-1)); } /** @method busy? => boolean Returns the number of current active channels. This is not the total channels, but the number of channels that are currently playing sound. */ static VALUE mixer_get_busy(VALUE self) { if(!SDL_WasInit(SDL_INIT_AUDIO)){ return INT2NUM(0); } return INT2NUM(Mix_Playing(-1)); } /* @method num_channels => number_of_channels @method num_channels=( amount ) => number_of_channels Gets or sets the current number of channels available for the mixer. This value defaults to 8 when the mixer is first initialized. RUDL imposes a channel limit of 256. These channels are not the same thing as in @Mixer.init. */ static VALUE mixer_get_num_channels(VALUE self) { initAudio(); return INT2NUM(Mix_GroupCount(-1)); } static VALUE mixer_set_num_channels(VALUE self, VALUE channelsValue) { int channels=NUM2INT(channelsValue); initAudio(); RUDL_VERIFY(channels<=MAX_CHANNELS, "256 channels ought to be enough for anyone"); Mix_AllocateChannels(channels); return self; } /** @section Mass Channel Operations These work on all channels at once. */ /** @method pause @method unpause @method stop @section Methods */ static VALUE mixer_pause(VALUE self) { initAudio(); Mix_Pause(-1); return self; } static VALUE mixer_stop(VALUE self) { initAudio(); Mix_HaltChannel(-1); return self; } static VALUE mixer_unpause(VALUE self) { initAudio(); Mix_Resume(-1); return self; } /** @method reserved=( amount ) => self This sets aside the first ((|amount|)) channels. They can only be played on by directly creating a Channel object and playing on it. No other function will take these channels for playing. */ static VALUE mixer_set_reserved(VALUE self, VALUE amount) { initAudio(); Mix_ReserveChannels(NUM2INT(amount)); return self; } /** @method driver => String Returns the name of the driver doing the sound output. */ static VALUE mixer_driver(VALUE self) { int bufsize = 1024; char* name = ALLOCA_N(char, bufsize); char* result; initAudio(); result = SDL_AudioDriverName(name, bufsize); RUDL_ASSERT(result, "Audio not initialized yet"); return CSTR2STR(name); } /** @method format These get the parameters that Mixer is playing at. It returns an array of [format (like AUDIO_S8), channels, frequency]. See also @Mixer@init. */ static VALUE mixer_get_format(VALUE self) { int rate; Uint16 format; int channels; SDL_VERIFY( Mix_QuerySpec(&rate, &format, &channels) ==1); return pack_audio_format_array(rate, format, channels); } /////////////// MUSIC static bool endmusic_event=false; static void endmusic_callback(void) { if(endmusic_event && SDL_WasInit(SDL_INIT_VIDEO)){ SDL_Event e; memset(&e, 0, sizeof(e)); e.type = RUDL_ENDMUSICEVENT; SDL_PushEvent(&e); } } Mix_Music* retrieveMusicPointer(VALUE self) { Mix_Music* music; Data_Get_Struct(self, Mix_Music, music); return music; } void freemusic(Mix_Music* m) { if(m){ Mix_FreeMusic(m); // This is called multiple times, but it seems to work :) } } /** @class Music This encapsulates a song. For some reason, SDL will only play one song at a time, and even though most of the Music methods are instance methods, some will act on the playing Music only. */ /** @section Initializers @method new( filename ) Creates a new Music object from a MOD, XM, MIDI, MP3 or OGG file (I think.) */ static VALUE music_new(VALUE self, VALUE filename) { VALUE newObject; initAudio(); newObject=Data_Wrap_Struct(classMusic, 0, freemusic, Mix_LoadMUS(STR2CSTR(filename))); rb_obj_call_init(newObject, 0, NULL); return newObject; } /** @section Volume methods These methods work on the currently playing music. */ /** @method volume => Number @method volume=( loudness ) => self volume and volume= get and set the volume. Volume ranges from 0.0 to 1.0. */ /** @method fade_out( milliseconds ) fades out the currently playing music to silence in @milliseconds. */ static VALUE music_fade_out(VALUE self, VALUE time) { Mix_FadeOutMusic(NUM2INT(time)); return self; } static VALUE music_get_volume(VALUE self) { return DBL2NUM(Mix_VolumeMusic(-1)/127.0); } static VALUE music_set_volume(VALUE self, VALUE volume) { Mix_VolumeMusic((int)(NUM2DBL(volume)*127)); return self; } /** @section Play control All pretty straight forward, except that they all act on the playing music, not the current one. */ /** @method play @method play( loops ) Plays this piece of music, stopping the previously playing one. Plays the music one time, or @loops + 1 times if you pass @loops. */ static VALUE music_play(int argc, VALUE* argv, VALUE self) { int loops = 0; VALUE loopsValue; switch(rb_scan_args(argc, argv, "01", &loopsValue)){ case 1: loops=NUM2INT(loopsValue); } Mix_HookMusicFinished(endmusic_callback); playing_music=self; /* to avoid gc problem */ SDL_VERIFY(!(Mix_PlayMusic(retrieveMusicPointer(self), loops)==-1)); return self; } /** @method stop @method pause @method unpause @method busy? @method restart */ static VALUE music_stop(VALUE self) { Mix_HaltMusic(); return self; } static VALUE music_pause(VALUE self) { Mix_PauseMusic(); return self; } static VALUE music_unpause(VALUE self) { Mix_ResumeMusic(); return self; } static VALUE music_get_busy(VALUE self) { return INT2BOOL(Mix_PlayingMusic()); } static VALUE music_restart(VALUE self) { Mix_RewindMusic(); return self; } /** @section Methods @method post_end_event => boolean @method post_end_event=( on_or_off ) => self Returns, or sets whether an @EndOfMusicEvent will be posted when the current music stops playing. @on_or_off is true or false. */ static VALUE music_set_post_end_event(VALUE self, VALUE onOff) { endmusic_event=NUM2BOOL(onOff); return self; } static VALUE music_get_post_end_event(VALUE self) { return INT2BOOL(endmusic_event); } /** @section Initializers @method destroy Frees the music from memory, thereby rendering the music instance useless. Ruby will crash if you use it anyway. */ static VALUE music_destroy(VALUE self) { freemusic(retrieveMusicPointer(self)); DATA_PTR(self)=NULL; return self; } #endif /////////////// INIT void initAudioClasses() { #ifdef HAVE_SDL_MIXER_H classChannel=rb_define_class_under(moduleRUDL, "Channel", rb_cObject); //rb_define_singleton_method(classChannel, "new", channel_new, 1); rb_eval_string( "module RUDL class Channel \n" " def initialize(nr) \n" " @number=nr \n" " end end end \n" ); rb_define_method(classChannel, "fade_out", channel_fade_out, 1); rb_define_method(classChannel, "busy?", channel_busy, 0); rb_define_method(classChannel, "volume", channel_get_volume, 0); rb_define_method(classChannel, "volume=", channel_set_volume, 1); rb_define_method(classChannel, "play", channel_play, -1); rb_define_method(classChannel, "stop", channel_stop, 0); rb_define_method(classChannel, "pause", channel_pause, 0); rb_define_method(classChannel, "unpause", channel_unpause, 0); rb_define_method(classChannel, "set_panning", channel_set_panning, 2); rb_define_method(classChannel, "set_position", channel_set_position, 2); rb_define_method(classChannel, "distance=", channel_set_distance, 1); rb_define_method(classChannel, "reverse_stereo", channel_reverse_stereo, 2); classSound=rb_define_class_under(moduleRUDL, "Sound", rb_cObject); rb_define_singleton_method(classSound, "new", sound_new, 1); rb_define_singleton_method(classSound, "load_new", sound_new, 1); rb_define_singleton_method(classSound, "import", sound_import, 1); rb_define_singleton_method(classSound, "convert", sound_convert, -1); // rb_define_singleton_method(classSound, "mix", sound_mix, 3); - maybe in 0.8 rb_define_method(rb_cString, "to_sound", string_to_sound, 0); rb_define_method(classSound, "fade_out", sound_fade_out, 1); rb_define_method(classSound, "num_channels", sound_get_num_channels, 0); rb_define_method(classSound, "volume", sound_get_volume, 0); rb_define_method(classSound, "play", sound_play, -1); rb_define_method(classSound, "volume=", sound_set_volume, 1); rb_define_method(classSound, "stop", sound_stop, 0); rb_define_method(classSound, "export", sound_export, 0); rb_define_method(classSound, "format", mixer_get_format, 0); classMixer=rb_define_class_under(moduleRUDL, "Mixer", rb_cObject); rb_define_method(classMixer, "initialize", mixer_initialize, -1); rb_define_singleton_and_instance_method(classMixer, "destroy", mixer_destroy, 0); rb_define_singleton_and_instance_method(classMixer, "fade_out", mixer_fade_out, 1); rb_define_singleton_and_instance_method(classMixer, "find_free_channel", mixer_find_free_channel, 0); rb_define_singleton_and_instance_method(classMixer, "find_oldest_channel", mixer_find_oldest_channel, 0); rb_define_singleton_and_instance_method(classMixer, "busy?", mixer_get_busy, 0); rb_define_singleton_and_instance_method(classMixer, "num_channels", mixer_get_num_channels, 0); rb_define_singleton_and_instance_method(classMixer, "pause", mixer_pause, 0); rb_define_singleton_and_instance_method(classMixer, "num_channels=", mixer_set_num_channels, 1); rb_define_singleton_and_instance_method(classMixer, "reserved=", mixer_set_reserved, 1); rb_define_singleton_and_instance_method(classMixer, "stop", mixer_stop, 0); rb_define_singleton_and_instance_method(classMixer, "unpause", mixer_unpause, 0); rb_define_singleton_and_instance_method(classMixer, "driver", mixer_driver, 0); rb_define_singleton_and_instance_method(classMixer, "format", mixer_get_format, 0); classMusic=rb_define_class_under(moduleRUDL, "Music", rb_cObject); rb_define_singleton_method(classMusic, "new", music_new, 1); rb_define_method(classMusic, "busy?", music_get_busy, 0); rb_define_method(classMusic, "fade_out", music_fade_out, 1); rb_define_method(classMusic, "post_end_event=", music_set_post_end_event, 1); rb_define_method(classMusic, "post_end_event", music_get_post_end_event, 1); rb_define_method(classMusic, "volume", music_get_volume, 0); rb_define_method(classMusic, "volume=", music_set_volume, 1); rb_define_method(classMusic, "play", music_play, -1); rb_define_method(classMusic, "stop", music_stop, 0); rb_define_method(classMusic, "restart", music_restart, 0); rb_define_method(classMusic, "pause", music_pause, 0); rb_define_method(classMusic, "unpause", music_unpause, 0); rb_define_method(classMusic, "destroy", music_destroy, 0); // Backward compatibility rb_alias(classMusic, rb_intern("dealloc"), rb_intern("destroy")); rb_define_singleton_method(classMixer, "init", mixer_initialize, -1); /** #@file - need to fix Dokumentat for this @section Events @class EndOfMusicEvent This event is posted when the current music has ended. */ classEndOfMusicEvent=rb_define_class_under(moduleRUDL, "EndOfMusicEvent", rb_cObject); /** @section Constants #@file These are for indicating an audio format: AUDIO_U8, AUDIO_S8, AUDIO_U16LSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_S16MSB, AUDIO_U16, AUDIO_S16, AUDIO_U16SYS, AUDIO_S16SYS */ DEC_CONSTN(AUDIO_U8); DEC_CONSTN(AUDIO_S8); DEC_CONSTN(AUDIO_U16LSB); DEC_CONSTN(AUDIO_S16LSB); DEC_CONSTN(AUDIO_U16MSB); DEC_CONSTN(AUDIO_S16MSB); DEC_CONSTN(AUDIO_U16); DEC_CONSTN(AUDIO_S16); DEC_CONSTN(AUDIO_U16SYS); DEC_CONSTN(AUDIO_S16SYS); clearGCHack(); #endif }