rubysdl 1.3.1 → 2.0

data/rubysdl_main.c

@@ -20,89 +20,45 @@
 
 #define DEF_GLOBAL
 #include "rubysdl.h"
-#include <signal.h>
-#include <stdio.h>
-
-/* declaration of initialize functions */
-void init_video();
-#ifdef HAVE_SGE
-void init_sge_video();
-#else
-void init_pixel();
-#endif
-#ifdef DEF_OPENGL
-void init_opengl();
-#ifdef INIT_OGLMODULE_FROM_SDL
-void Init_opengl();
-#endif
-#endif
-#ifdef HAVE_SDL_IMAGE
-void init_sdl_image();
-#endif
-void init_event();
-#ifdef DEF_EVENT2
-void init_event2();
-#endif
-void init_keyEvent();
-void init_mouse();
-void init_joystick();
-void init_cdrom();
-void init_time();
-void init_wm();
-void init_kanji(void);
-#ifdef HAVE_SDL_TTF
-void init_ttf();
-void quit_ttf();
-#endif
-#ifdef HAVE_SDL_MIXER
-void  init_mixer();
-void quit_mixer();
-#endif
-#ifdef HAVE_SMPEG
-void init_smpeg();
-#endif
-
-#ifdef HAVE_SDLSKK
-void init_sdlskk();
-#endif
-
-static void sdl_quit();
-static VALUE sdl_init(VALUE obj,VALUE flags)
+
+static VALUE sdl_s_init(VALUE mod, VALUE flags)
 {
-  Uint32 flag;
-  
   rb_secure(4);
-  flag= NUM2UINT(flags);
-  if( SDL_Init(flag) < 0 )
-    rb_raise(eSDLError,"Couldn't initialize SDL: %s",SDL_GetError());
+  if( SDL_Init(NUM2UINT(flags)) < 0 )
+    rb_raise(eSDLError, "Couldn't initialize SDL: %s", SDL_GetError());
   return Qnil;
 }
 
-static VALUE sdl_initSubSystem(VALUE obj,VALUE flags)
+static VALUE sdl_s_initSubSystem(VALUE mod, VALUE flags)
 {
   if( SDL_InitSubSystem(NUM2UINT(flags)) < 0 )
-    rb_raise(eSDLError,"Couldn't initialize SDL subsystem: %s",SDL_GetError());
+    rb_raise(eSDLError, "Couldn't initialize SDL subsystem: %s", SDL_GetError());
   return Qnil;
 }
 
-static VALUE sdl_wasInit(VALUE mod,VALUE flags)
+static VALUE sdl_s_inited_system(VALUE mod, VALUE flags)
 {
-  return UINT2NUM( SDL_WasInit(NUM2UINT(flags)) );
+  return UINT2NUM(SDL_WasInit(NUM2UINT(flags)));
 }
 
-static VALUE sdl_putenv(VALUE mod,VALUE var)
+static VALUE sdl_s_putenv(VALUE mod, VALUE var)
 {
-  if( putenv(GETCSTR(var)) < 0 ){
-    rb_raise(eSDLError,"Can't put environ variable: %s", GETCSTR(var));
+  rb_secure(4);
+  SafeStringValue(var);
+  
+  if( putenv(RSTRING_PTR(var)) < 0 ){
+    rb_raise(eSDLError, "Can't put environ variable: %s",  RSTRING_PTR(var));
   }
   return Qnil;
 }
 
-static VALUE sdl_getenv(VALUE mod,VALUE name)
+static VALUE sdl_s_getenv(VALUE mod, VALUE name)
 {
-  char* result = getenv(GETCSTR(name));
-  if( result == NULL ){
-    rb_raise(eSDLError,"Can't get environ variable: %s", GETCSTR(name));
+  char* result;
+  SafeStringValue(name);
+  result = getenv(RSTRING_PTR(name));
+  if(result == NULL){
+    rb_raise(eSDLError, "Can't get environ variable: %s",  RSTRING_PTR(name));
   }
   return rb_str_new2(result);
 }
@@ -112,91 +68,62 @@ int rubysdl_is_quit(void)
 {
   return is_quit;
 }
-static void sdl_quit()
+static void sdl_quit(VALUE v)
 {
-#ifdef HAVE_SDL_MIXER
-  quit_mixer();
-#endif
-#ifdef HAVE_SDL_TTF
-  quit_ttf();
-#endif
-  is_quit = 1;
+  if(rubysdl_is_quit())
+    return;
+  rubysdl_quit_Mixer();
+  rubysdl_quit_TTF();
   SDL_Quit();
-  return ;
+  is_quit = 1;
 }
 
-static VALUE sdl_rb_quit(VALUE obj)
+static VALUE sdl_s_quit(VALUE obj)
 {
-  sdl_quit();
+  sdl_quit(0);
   return Qnil;
 }
 
-static void defineConst()
-{
-  rb_define_const(mSDL,"INIT_TIMER",UINT2NUM(SDL_INIT_TIMER));
-  rb_define_const(mSDL,"INIT_AUDIO",UINT2NUM(SDL_INIT_AUDIO));
-  rb_define_const(mSDL,"INIT_VIDEO",UINT2NUM(SDL_INIT_VIDEO));
-  rb_define_const(mSDL,"INIT_CDROM",UINT2NUM(SDL_INIT_CDROM));
-  rb_define_const(mSDL,"INIT_JOYSTICK",UINT2NUM(SDL_INIT_JOYSTICK));
-  rb_define_const(mSDL,"INIT_NOPARACHUTE",UINT2NUM(SDL_INIT_NOPARACHUTE));
-  rb_define_const(mSDL,"INIT_EVENTTHREAD",UINT2NUM(SDL_INIT_EVENTTHREAD));
-  rb_define_const(mSDL,"INIT_EVERYTHING",UINT2NUM(SDL_INIT_EVERYTHING));
-}
-
-
 void Init_sdl()
 {
-  mSDL = rb_define_module("SDL");
-  eSDLError = rb_define_class_under(mSDL,"Error",rb_eStandardError);
-  rb_define_module_function(mSDL,"init",sdl_init,1);
-  rb_define_module_function(mSDL,"initedSystem",sdl_wasInit,1);
-  rb_define_module_function(mSDL,"initSubSystem",sdl_initSubSystem,1);
-  rb_define_module_function(mSDL,"quit",sdl_rb_quit,0);
-  rb_define_module_function(mSDL,"putenv",sdl_putenv,1);
-  rb_define_module_function(mSDL,"getenv",sdl_getenv,1);
+  VALUE mSDL = rb_define_module("SDL");
+  VALUE cSurface;
+  
+  eSDLError = rb_define_class_under(mSDL, "Error", rb_eStandardError);
+  rb_define_module_function(mSDL, "init", sdl_s_init, 1);
+  rb_define_module_function(mSDL, "initedSystem", sdl_s_inited_system, 1);
+  rb_define_module_function(mSDL, "initSubSystem", sdl_s_initSubSystem, 1);
+  rb_define_module_function(mSDL, "quit", sdl_s_quit, 0);
+  rb_define_module_function(mSDL, "putenv", sdl_s_putenv, 1);
+  rb_define_module_function(mSDL, "getenv", sdl_s_getenv, 1);
   
-  defineConst();
-
-
-  init_video();
-#ifdef HAVE_SGE
-  init_sge_video();
-#else
-  init_pixel();
-#endif
-#ifdef DEF_OPENGL
-  init_opengl();
-#ifdef INIT_OGLMODULE_FROM_SDL
-  Init_opengl();
-#endif
-#endif
-#ifdef HAVE_SDL_IMAGE
-  init_sdl_image();
-#endif
-  init_event();
-#ifdef DEF_EVENT2
-  init_event2();
-#endif
-  init_keyEvent();
-  init_mouse();
-  init_joystick();
-  init_cdrom();
-  init_time();
-  init_wm();
-  init_kanji();
-#ifdef HAVE_SDL_TTF
-  init_ttf();
-#endif
-#ifdef HAVE_SDL_MIXER
-  init_mixer();
-#endif
-#ifdef HAVE_SMPEG
-  init_smpeg();
-#endif
-#ifdef HAVE_SDLSKK
-  init_sdlskk();
-#endif
-  rb_set_end_proc(sdl_quit,0); 
+  rb_define_const(mSDL, "INIT_TIMER", UINT2NUM(SDL_INIT_TIMER));
+  rb_define_const(mSDL, "INIT_AUDIO", UINT2NUM(SDL_INIT_AUDIO));
+  rb_define_const(mSDL, "INIT_VIDEO", UINT2NUM(SDL_INIT_VIDEO));
+  rb_define_const(mSDL, "INIT_CDROM", UINT2NUM(SDL_INIT_CDROM));
+  rb_define_const(mSDL, "INIT_JOYSTICK", UINT2NUM(SDL_INIT_JOYSTICK));
+  rb_define_const(mSDL, "INIT_NOPARACHUTE", UINT2NUM(SDL_INIT_NOPARACHUTE));
+  rb_define_const(mSDL, "INIT_EVENTTHREAD", UINT2NUM(SDL_INIT_EVENTTHREAD));
+  rb_define_const(mSDL, "INIT_EVERYTHING", UINT2NUM(SDL_INIT_EVERYTHING));
+
+
+  cSurface = rubysdl_init_video(mSDL);
+  rubysdl_init_sge(mSDL, cSurface);
+  rubysdl_init_GL(mSDL);
+  rubysdl_init_image(mSDL, cSurface);
+  rubysdl_init_Event(mSDL);
+  rubysdl_init_Key(mSDL);
+  rubysdl_init_Mouse(mSDL);
+  rubysdl_init_Joystick(mSDL);
+  rubysdl_init_CD(mSDL);
+  rubysdl_init_time(mSDL);
+  rubysdl_init_WM(mSDL);
+  rubysdl_init_Kanji(mSDL);
+  rubysdl_init_TTF(mSDL);
+  rubysdl_init_Mixer(mSDL);
+  rubysdl_init_MPEG(mSDL);
+  rubysdl_init_SKK(mSDL);
+  rb_set_end_proc(sdl_quit, 0); 
 }
 
 

data/rubysdl_mixer.c

@@ -17,33 +17,86 @@
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
-#ifdef HAVE_SDL_MIXER
-
 #include "rubysdl.h"
+#ifdef HAVE_SDL_MIXER
 #define USE_RWOPS
 #include <SDL_mixer.h>
 
-static int mix_opened=0;
-static int mix_closed=0;
+static VALUE mMixer;
+static VALUE cWave;
+static VALUE cMusic;
 
 static VALUE playing_wave = Qnil;
-static VALUE playing_music=Qnil;
+static VALUE playing_music = Qnil;
 
-static void mix_FreeChunk(Mix_Chunk *chunk)
+static int Mix_opened(void)
 {
-  if( ! mix_closed ){
-    Mix_FreeChunk( chunk );
-  }
+  return Mix_QuerySpec(NULL, NULL, NULL);
 }
 
-static void mix_FreeMusic(Mix_Music *music)
+typedef struct {
+  Mix_Chunk* chunk;
+} Wave;
+
+typedef struct {
+  Mix_Music* music;
+} Music;
+
+DEFINE_GET_STRUCT(Wave, GetWave, cWave, "SDL::Mixer::Wave");
+static Mix_Chunk* Get_Mix_Chunk(VALUE obj)
 {
-  if( !mix_closed ){
-    Mix_FreeMusic( music );
-  }
+  Wave* wave = GetWave(obj);
+  if(wave->chunk == NULL)
+    rb_raise(eSDLError, "Wave data is already disposed");
+  return wave->chunk;
+}
+static void Wave_free(Wave* wave)
+{
+  if(Mix_opened() && wave->chunk)
+    Mix_FreeChunk(wave->chunk);
+  free(wave);
+}
+static VALUE Wave_s_alloc(VALUE klass)
+{
+  Wave* wave = ALLOC(Wave);
+  wave->chunk = NULL;
+  return Data_Wrap_Struct(klass, 0, Wave_free, wave);
+}
+static VALUE Wave_create(Mix_Chunk* chunk)
+{
+  VALUE newobj = Wave_s_alloc(cWave);
+  GetWave(newobj)->chunk = chunk;
+  return newobj;
 }
 
-static VALUE mix_audioDriverName(VALUE mod)
+DEFINE_GET_STRUCT(Music, GetMusic, cMusic, "SDL::Mixer::Music");
+static Mix_Music* Get_Mix_Music(VALUE obj)
+{
+  Music* mus = GetMusic(obj);
+  if(mus->music == NULL)
+    rb_raise(eSDLError, "Wave data is already disposed");
+  return mus->music;
+}
+static void Music_free(Music* mus)
+{
+  if(Mix_opened() && mus->music)
+    Mix_FreeMusic(mus->music);
+  free(mus);
+}
+static VALUE Music_s_alloc(VALUE klass)
+{
+  Music* mus = ALLOC(Music);
+  mus->music = NULL;
+  return Data_Wrap_Struct(klass, 0, Music_free, mus);
+}
+static VALUE Music_create(Mix_Music* music)
+{
+  VALUE newobj = Music_s_alloc(cMusic);
+  GetMusic(newobj)->music = music;
+  return newobj;
+}
+
+static VALUE Mixer_s_driverName(VALUE mod)
 {
   char driver_name[512];
   if(SDL_AudioDriverName(driver_name, sizeof(driver_name)) == NULL)
@@ -51,268 +104,314 @@ static VALUE mix_audioDriverName(VALUE mod)
   return rb_str_new2(driver_name);
 }
 
-static VALUE mix_openAudio(VALUE mod,VALUE frequency,VALUE format,
-			   VALUE channels,VALUE chunksize)
+static VALUE Mixer_s_open(VALUE mod, VALUE frequency, VALUE format,
+			   VALUE channels, VALUE chunksize)
 {
-  if( mix_opened ){
-    rb_raise(eSDLError,"already initialize SDL::Mixer");
+  rb_secure(4);
+  
+  if(Mix_opened()){
+    rb_raise(eSDLError, "already initialize SDL::Mixer");
   }
-  if( Mix_OpenAudio( NUM2INT(frequency),NUM2UINT(format),NUM2INT(channels),
-		     NUM2INT(chunksize) ) < 0 ){
-    rb_raise(eSDLError,"Couldn't open audio: %s",SDL_GetError());
+  if( Mix_OpenAudio(NUM2INT(frequency), NUM2UINT(format), NUM2INT(channels), 
+                    NUM2INT(chunksize)) < 0 ){
+    rb_raise(eSDLError, "Couldn't open audio: %s", SDL_GetError());
   }
 
-  mix_opened = 1;
   return Qnil;
 }
 
-static VALUE mix_querySpec(VALUE mod)
+static VALUE Mixer_s_close(VALUE mod)
+{
+  rb_secure(4);
+  Mix_CloseAudio();
+  return Qnil;
+}
+
+static VALUE Mixer_s_spec(VALUE mod)
 {
   int rate;
   Uint16 format;
   int channels;
 
-  if( !Mix_QuerySpec(&rate,&format,&channels) )
-    rb_raise(eSDLError,"audio have not been opened yet: %s", Mix_GetError());
-  return rb_ary_new3( 3,INT2NUM(rate),UINT2NUM(format),INT2NUM(channels) );
+  if( !Mix_QuerySpec(&rate, &format, &channels) )
+    rb_raise(eSDLError,"audio have not been opened yet: %s",
+             Mix_GetError());
+  return rb_ary_new3(3, INT2NUM(rate), UINT2NUM(format), INT2NUM(channels));
+
 }
 
-static VALUE mix_allocateChannels(VALUE mod,VALUE numchannels)
+static VALUE Mixer_s_allocateChannels(VALUE mod, VALUE numchannels)
 {
+  rb_secure(4);
   return INT2FIX( Mix_AllocateChannels(NUM2INT(numchannels)) );  
 }
 
 /* Returns which channel was used to play the sound. */
-static VALUE mix_playChannel(VALUE mod,VALUE channel,VALUE wave,VALUE loops)
+static VALUE Mixer_s_playChannel(VALUE mod, VALUE channel, VALUE wave, VALUE loops)
 {
-  Mix_Chunk *chunk;
-  int playing_channel;
+  int play_channel;
+  rb_secure(4);
+
+  play_channel = Mix_PlayChannel(NUM2INT(channel),
+                                 Get_Mix_Chunk(wave),
+                                 NUM2INT(loops));
+                            
+  if( play_channel == -1 )
+    rb_raise(eSDLError, "couldn't play wave: %s",
+             Mix_GetError());
   
-  if( ! rb_obj_is_kind_of(wave,cWave) )
-    rb_raise(rb_eArgError,"type mismatch: SDL::Mixer::Wave is expected");
-  Data_Get_Struct(wave,Mix_Chunk,chunk);
+  rb_ary_store(playing_wave, play_channel, wave);/* to avoid gc problem */
+  return INT2FIX(play_channel);
+}
   
-  playing_channel = Mix_PlayChannel(NUM2INT(channel),chunk,NUM2INT(loops) );
-  if( playing_channel == -1 ){
-    rb_raise( eSDLError, "couldn't play wave: %s", Mix_GetError() );
+static VALUE Mixer_s_playChannelTimed(VALUE mod,
+                                      VALUE channel,
+                                      VALUE wave,
+                                      VALUE loops,
+                                      VALUE ticks)
+{
+  int play_channel;
+  
+  play_channel = Mix_PlayChannelTimed(NUM2INT(channel),
+                                      Get_Mix_Chunk(wave),
+                                      NUM2INT(loops),
+                                      NUM2INT(ticks));
+  if( play_channel == -1 ){
+    rb_raise(eSDLError, "couldn't play wave: %s",
+             Mix_GetError());
   }
 
-  rb_ary_store(playing_wave,playing_channel,wave);/* to avoid gc problem */
-  return INT2FIX(playing_channel);
+  rb_ary_store(playing_wave, play_channel, wave);/* to avoid gc problem */
+  return INT2FIX(play_channel);
 }
 
-static VALUE mix_playChannelTimed(VALUE mod,VALUE channel,VALUE wave,VALUE loops,
-                                  VALUE ticks)
+static VALUE Mixer_s_fadeInChannel(VALUE mod,
+                                   VALUE channel,
+                                   VALUE wave,
+                                   VALUE loops,
+                                   VALUE ms)
 {
-  Mix_Chunk *chunk;
   int playing_channel;
   
-  if( ! rb_obj_is_kind_of(wave,cWave) )
-    rb_raise(rb_eArgError,"type mismatch: SDL::Mixer::Wave is expected");
-  Data_Get_Struct(wave,Mix_Chunk,chunk);
-  
-  playing_channel = Mix_PlayChannelTimed(NUM2INT(channel),chunk,NUM2INT(loops),
-                                         NUM2INT(ticks));
+  playing_channel = Mix_FadeInChannel(NUM2INT(channel),
+                                      Get_Mix_Chunk(wave),
+                                      NUM2INT(loops),
+                                      NUM2INT(ms));
   if( playing_channel == -1 ){
-    rb_raise( eSDLError, "couldn't play wave: %s", Mix_GetError() );
+    rb_raise(eSDLError, "couldn't play wave: %s",
+             Mix_GetError());
   }
-
-  rb_ary_store(playing_wave,playing_channel,wave);/* to avoid gc problem */
+  /* to avoid gc problem */
+  rb_ary_store(playing_wave, playing_channel, wave);
   return INT2FIX(playing_channel);
 }
 
-static VALUE mix_fadeInChannel(VALUE mod,VALUE channel,VALUE wave,VALUE loops,
-                               VALUE ms)
+static VALUE Mixer_s_fadeInChannelTimed(VALUE mod,
+                                        VALUE channel,
+                                        VALUE wave,
+                                        VALUE loops,
+                                        VALUE ms, VALUE ticks)
 {
-  Mix_Chunk *chunk;
   int playing_channel;
   
-  if( ! rb_obj_is_kind_of(wave,cWave) )
-    rb_raise(rb_eArgError,"type mismatch: SDL::Mixer::Wave is expected");
-  Data_Get_Struct(wave,Mix_Chunk,chunk);
-  
-  playing_channel = Mix_FadeInChannel(NUM2INT(channel),chunk,NUM2INT(loops),
-                                      NUM2INT(ms));
+  playing_channel = Mix_FadeInChannelTimed(NUM2INT(channel),
+                                           Get_Mix_Chunk(wave),
+                                           NUM2INT(loops),
+                                           NUM2INT(ms),
+                                           NUM2INT(ticks));
   if( playing_channel == -1 ){
-    rb_raise( eSDLError, "couldn't play wave: %s", Mix_GetError() );
+    rb_raise(eSDLError, "couldn't play wave: %s",
+             Mix_GetError());
   }
-
-  rb_ary_store(playing_wave,playing_channel,wave);/* to avoid gc problem */
+  /* to avoid gc problem */
+  rb_ary_store(playing_wave, playing_channel, wave);
   return INT2FIX(playing_channel);
 }
 
-static VALUE mix_fadeInChannelTimed(VALUE mod,VALUE channel,VALUE wave,VALUE loops,
-                                    VALUE ms, VALUE ticks)
+static VALUE Mixer_s_play_p(VALUE mod, VALUE channel)
 {
-  Mix_Chunk *chunk;
-  int playing_channel;
-  
-  if( ! rb_obj_is_kind_of(wave,cWave) )
-    rb_raise(rb_eArgError,"type mismatch: SDL::Mixer::Wave is expected");
-  Data_Get_Struct(wave,Mix_Chunk,chunk);
-  
-  playing_channel = Mix_FadeInChannelTimed(NUM2INT(channel),chunk,NUM2INT(loops),
-                                           NUM2INT(ms), NUM2INT(ticks));
-  if( playing_channel == -1 ){
-    rb_raise( eSDLError, "couldn't play wave: %s", Mix_GetError() );
-  }
+  return INT2BOOL(Mix_Playing(NUM2INT(channel)));
+}
 
-  rb_ary_store(playing_wave,playing_channel,wave);/* to avoid gc problem */
-  return INT2FIX(playing_channel);
+static VALUE Mixer_s_playing_channels(VALUE mod)
+{
+  return INT2NUM(Mix_Playing(-1));
 }
 
-static VALUE mix_playing(VALUE mod,VALUE channel)
+static VALUE Wave_s_load(VALUE class, VALUE filename)
 {
-  if( Mix_Playing( NUM2INT(channel) ) ){
-    return Qtrue;
-  }else{
-    return Qfalse;
+  Mix_Chunk *chunk;
+  
+  rb_secure(4);
+  SafeStringValue(filename);
+  
+  chunk = Mix_LoadWAV(RSTRING_PTR(filename));
+  if( chunk == NULL ){
+    rb_raise(eSDLError, "Couldn't load wave file %s: %s",
+             RSTRING_PTR(filename), SDL_GetError());
   }
+  return Wave_create(chunk);
 }
-  
-static VALUE mix_loadWav(VALUE class,VALUE filename)
+
+static VALUE Wave_s_loadFromIO(VALUE class, VALUE io)
 {
   Mix_Chunk *wave;
-  Check_Type(filename,T_STRING);
-  wave = Mix_LoadWAV( GETCSTR(filename) );
+  wave = Mix_LoadWAV_RW(rubysdl_RWops_from_ruby_obj(io), 1);
   if( wave == NULL ){
-    rb_raise( eSDLError,"Couldn't load wave file %s: %s",
-	      GETCSTR(filename), Mix_GetError() );
+    rb_raise(eSDLError, "Couldn't load wave file from IO: %s",
+             Mix_GetError());
   }
-  return Data_Wrap_Struct(class,0,mix_FreeChunk,wave);
+  return Wave_create(wave);
 }
 
-static VALUE mix_loadWavFromIO(VALUE class, VALUE io)
+static VALUE Wave_s_loadFromString(VALUE class, VALUE str)
 {
   Mix_Chunk *wave;
-  wave = Mix_LoadWAV_RW(rubysdl_RWops_from_ruby_obj(io), 1);
+  rb_secure(4);
+  SafeStringValue(str);
+  
+  wave = Mix_LoadWAV_RW(SDL_RWFromConstMem(RSTRING_PTR(str),
+                                           RSTRING_LEN(str)),
+                        1);
   if( wave == NULL ){
-    rb_raise(eSDLError,"Couldn't load wave file from IO: %s",
+    rb_raise(eSDLError, "Couldn't load wave file from String: %s",
              Mix_GetError());
   }
-  return Data_Wrap_Struct(class,0,mix_FreeChunk,wave);
+  return Wave_create(wave);
 }
- 
+
+
 /* Volume setting functions and methods : volume in 0..128 */
-static VALUE mix_volume(VALUE mod,VALUE channel,VALUE volume)
+static VALUE Mixer_s_setVolume(VALUE mod, VALUE channel, VALUE volume)
 {
-  return INT2FIX( Mix_Volume( NUM2INT(channel),NUM2INT(volume) ) );
+  rb_secure(4);
+  return INT2FIX(Mix_Volume(NUM2INT(channel), NUM2INT(volume)));
 }
-static VALUE mix_wave_volume(VALUE obj,VALUE volume)
+
+static VALUE Wave_s_setVolume(VALUE self, VALUE volume)
 {
-  Mix_Chunk *chunk;
-  Data_Get_Struct(obj,Mix_Chunk,chunk);
-  return INT2FIX( Mix_VolumeChunk( chunk,NUM2INT(volume) ) );
+  return INT2FIX(Mix_VolumeChunk(Get_Mix_Chunk(self), NUM2INT(volume)));
 }
 
 /* Halt,Pause function */
-static VALUE mix_halt(VALUE mod,VALUE channel)
+static VALUE Mixer_s_halt(VALUE mod, VALUE channel)
 {
+  rb_secure(4);
   Mix_HaltChannel(NUM2INT(channel));
   return Qnil;
 }
-static VALUE mix_pause(VALUE mod,VALUE channel)
+
+static VALUE Mixer_s_pause(VALUE mod, VALUE channel)
 {
+  rb_secure(4);
   Mix_Pause(NUM2INT(channel));
   return Qnil;
 }
-static VALUE mix_resume(VALUE mod,VALUE channel)
+
+static VALUE Mixer_s_resume(VALUE mod, VALUE channel)
 {
+  rb_secure(4);
   Mix_Resume(NUM2INT(channel));
   return Qnil;
 }
-static VALUE mix_paused(VALUE mod,VALUE channel)
+
+static VALUE Mixer_s_pause_p(VALUE mod, VALUE channel)
 {
+  rb_secure(4);
   return INT2FIX(Mix_Paused(NUM2INT(channel)));
 }
-static VALUE mix_fadeOut(VALUE mod,VALUE channel,VALUE ms)
+static VALUE Mixer_s_fadeOut(VALUE mod, VALUE channel, VALUE ms)
 {
   return INT2FIX(Mix_FadeOutChannel(NUM2INT(channel), NUM2INT(ms)));
 }
-static VALUE mix_expire(VALUE mod, VALUE channel, VALUE ticks)
+static VALUE Mixer_s_expire(VALUE mod, VALUE channel, VALUE ticks)
 {
   return INT2FIX(Mix_ExpireChannel(NUM2INT(channel),NUM2INT(ticks)));
 }
-static VALUE mix_fading(VALUE mod, VALUE which)
+static VALUE Mixer_s_fading(VALUE mod, VALUE which)
 {
   if( NUM2INT(which) < 0 || Mix_AllocateChannels(-1) <= NUM2INT(which))
     rb_raise(eSDLError, "channel %d out of range", NUM2INT(which));
-  return INT2FIX(Mix_FadingChannel(which));
+  return INT2FIX(Mix_FadingChannel(NUM2INT(which)));
 }
   
 /* music functions */
-#define MakeSimpleRubyFunc(rubyFunc,sdlFunc) \
+#define MakeSimpleRubyFunc(rubyFunc, sdlFunc) \
 static VALUE rubyFunc(VALUE mod) \
 { \
+  rb_secure(4); \
   sdlFunc(); \
   return Qnil; \
 } \
 
-static VALUE mix_playMusic(VALUE mod,VALUE music,VALUE loops)
+static VALUE Mixer_s_playMusic(VALUE mod, VALUE music, VALUE loops)
 {
-  Mix_Music *mus;
-  if( ! rb_obj_is_kind_of(music,cMusic) )
-    rb_raise(rb_eArgError,"type mismatch: SDL::Mixer::Music is expected");
-  Data_Get_Struct(music,Mix_Music,mus);
-  playing_music=music; /* to avoid gc problem */
-  Mix_PlayMusic(mus,NUM2INT(loops));
+  rb_secure(4);
+
+  Mix_PlayMusic(Get_Mix_Music(music), NUM2INT(loops));
+  playing_music = music; /* to avoid gc problem */
   return Qnil;
 }
 
-static VALUE mix_fadeInMusic(VALUE mod,VALUE music,VALUE loops,VALUE ms)
+static VALUE Mixer_s_fadeInMusic(VALUE mod, VALUE music, VALUE loops, VALUE ms)
 {
-  Mix_Music *mus;
-  if( ! rb_obj_is_kind_of(music,cMusic) )
-    rb_raise(rb_eArgError,"type mismatch: SDL::Mixer::Music is expected");
-  Data_Get_Struct(music,Mix_Music,mus);
-  Mix_FadeInMusic(mus,NUM2INT(loops),NUM2INT(ms));
+  rb_secure(4);
+  Mix_FadeInMusic(Get_Mix_Music(music), NUM2INT(loops), NUM2INT(ms));
+  playing_music = music; /* to avoid gc problem */
   return Qnil;
 }
 
-static VALUE mix_setVolumeMusic(VALUE mod,VALUE volume)
+static VALUE Mixer_s_setVolumeMusic(VALUE mod, VALUE volume)
 {
+  rb_secure(4);
   Mix_VolumeMusic( NUM2INT(volume) );
   return Qnil;
 }
 
-static VALUE mix_fadeOutMusic(VALUE mod,VALUE ms)
+static VALUE Mixer_s_fadeOutMusic(VALUE mod, VALUE ms)
 {
+  rb_secure(4);
   Mix_FadeOutMusic(NUM2INT(ms));
   return Qnil;
 }
 
-MakeSimpleRubyFunc(mix_haltMusic,Mix_HaltMusic)
-MakeSimpleRubyFunc(mix_pauseMusic,Mix_PauseMusic)
-MakeSimpleRubyFunc(mix_resumeMusic,Mix_ResumeMusic)
-MakeSimpleRubyFunc(mix_rewindMusic,Mix_RewindMusic)
+MakeSimpleRubyFunc(Mixer_s_haltMusic, Mix_HaltMusic)
+MakeSimpleRubyFunc(Mixer_s_pauseMusic, Mix_PauseMusic)
+MakeSimpleRubyFunc(Mixer_s_resumeMusic, Mix_ResumeMusic)
+MakeSimpleRubyFunc(Mixer_s_rewindMusic, Mix_RewindMusic)
 
-static VALUE mix_pausedMusic(VALUE mod)
+static VALUE Mixer_s_pauseMusic_p(VALUE mod)
 {
-  return BOOL(Mix_PausedMusic());
+  return INT2BOOL(Mix_PausedMusic());
 }
 
-static VALUE mix_playingMusic(VALUE mod)
+static VALUE Mixer_s_playMusic_p(VALUE mod)
 {
-  return BOOL(Mix_PlayingMusic());
+  return INT2BOOL(Mix_PlayingMusic());
 }
 
-static VALUE mix_fadingMusic(VALUE mod)
+static VALUE Mixer_s_fadingMusic(VALUE mod)
 {
   return INT2FIX(Mix_FadingMusic());
 }
 
-static VALUE mix_loadMus(VALUE class,VALUE filename)
+static VALUE Music_s_load(VALUE class, VALUE filename)
 {
   Mix_Music* music;
-  music = Mix_LoadMUS(GETCSTR(filename));
+  
+  rb_secure(4);
+  SafeStringValue(filename);
+  
+  music = Mix_LoadMUS(RSTRING_PTR(filename));
   if( music == NULL )
-    rb_raise(eSDLError,
-	     "Couldn't load %s: %s",GETCSTR(filename),SDL_GetError());
-  return Data_Wrap_Struct(class,0,mix_FreeMusic,music);
+        rb_raise(eSDLError, 
+                 "Couldn't load %s: %s", RSTRING_PTR(filename),
+                 SDL_GetError());
+  return Music_create(music);
 }
 
 #ifdef HAVE_MIX_LOADMUS_RW
-static VALUE mix_loadMusFromString(VALUE class,VALUE str)
+static VALUE Mixer_s_loadMusFromString(VALUE class, VALUE str)
 {
   Mix_Music* music;
   volatile VALUE result;
@@ -320,103 +419,129 @@ static VALUE mix_loadMusFromString(VALUE class,VALUE str)
   
   StringValue(str);
   buf = rb_str_dup(str);
-  music = Mix_LoadMUS_RW(SDL_RWFromConstMem(RSTRING(buf)->ptr,
-                                            RSTRING(buf)->len));
+  music = Mix_LoadMUS_RW(SDL_RWFromConstMem(RSTRING_PTR(buf),
+                                            RSTRING_LEN(buf)));
   
   if( music == NULL )
     rb_raise(eSDLError,
 	     "Couldn't load from String: %s",Mix_GetError());
   
-  result = Data_Wrap_Struct(class,0,mix_FreeMusic,music);
+  result = Music_create(music);
   rb_iv_set(result, "buf", buf);
   
   return result;
 }
 #endif
 
-static void defineConstForAudio()
-{
-  rb_define_const(mMixer,"FORMAT_U8",UINT2NUM(AUDIO_U8));
-  rb_define_const(mMixer,"FORMAT_S8",UINT2NUM(AUDIO_S8));
-  rb_define_const(mMixer,"FORMAT_U16LSB",UINT2NUM(AUDIO_U16LSB));
-  rb_define_const(mMixer,"FORMAT_S16LSB",UINT2NUM(AUDIO_S16LSB));
-  rb_define_const(mMixer,"FORMAT_U16MSB",UINT2NUM(AUDIO_U16MSB));
-  rb_define_const(mMixer,"FORMAT_S16MSB",UINT2NUM(AUDIO_S16MSB));
-  rb_define_const(mMixer,"FORMAT_U16",UINT2NUM(AUDIO_U16));
-  rb_define_const(mMixer,"FORMAT_S16",UINT2NUM(AUDIO_S16));
-
-  rb_define_const(mMixer,"FORMAT_U16SYS",UINT2NUM(AUDIO_U16SYS));
-  rb_define_const(mMixer,"FORMAT_S16SYS",UINT2NUM(AUDIO_S16SYS));
-
-  rb_define_const(mMixer,"CHANNELS",INT2NUM(MIX_CHANNELS));
-  rb_define_const(mMixer,"DEFAULT_FREQUENCY",INT2NUM(MIX_DEFAULT_FREQUENCY));
-  rb_define_const(mMixer,"DEFAULT_FORMAT",UINT2NUM(MIX_DEFAULT_FORMAT));
-  rb_define_const(mMixer,"DEFAULT_CHANNELS",UINT2NUM(MIX_DEFAULT_CHANNELS));
-  rb_define_const(mMixer,"MAX_VOLUME",INT2NUM(MIX_MAX_VOLUME));
-
-  rb_define_const(mMixer,"NO_FADING", INT2NUM(MIX_NO_FADING));
-  rb_define_const(mMixer,"FADING_OUT", INT2NUM(MIX_FADING_OUT));
-  rb_define_const(mMixer,"FADING_IN", INT2NUM(MIX_FADING_IN));
-}
-
-void init_mixer()
-{
-  mMixer = rb_define_module_under(mSDL,"Mixer");
-  rb_define_module_function(mMixer,"open",mix_openAudio,4);
-  rb_define_module_function(mMixer,"spec",mix_querySpec,0);
-  rb_define_module_function(mMixer,"driverName", mix_audioDriverName, 0); 
-  rb_define_module_function(mMixer,"playChannel",mix_playChannel,3);
-  rb_define_module_function(mMixer,"playChannelTimed", mix_playChannelTimed, 4);
-  rb_define_module_function(mMixer,"fadeInChannel", mix_fadeInChannel, 4);
-  rb_define_module_function(mMixer,"fadeInChannelTimed", mix_fadeInChannelTimed, 5);
-  rb_define_module_function(mMixer,"play?",mix_playing,1);
-  rb_define_module_function(mMixer,"setVolume",mix_volume,2);
-  rb_define_module_function(mMixer,"allocateChannels",mix_allocateChannels,1);
-  rb_define_module_function(mMixer,"halt",mix_halt,1);
-  rb_define_module_function(mMixer,"pause",mix_pause,1);
-  rb_define_module_function(mMixer,"resume",mix_resume,1);
-  rb_define_module_function(mMixer,"pause?",mix_paused,1);
-  rb_define_module_function(mMixer,"expire",mix_expire,2);
-  rb_define_module_function(mMixer,"fading",mix_fading,1);
-  rb_define_module_function(mMixer,"fadeOut",mix_fadeOut,2);
+static VALUE Wave_destroy(VALUE self)
+{
+  Wave* wave = GetWave(self);
+  if (wave->chunk) {
+    Mix_FreeChunk(wave->chunk);
+    wave->chunk = NULL;
+  }
+  return Qnil;
+}
+
+static VALUE Music_destroy(VALUE self)
+{
+  Music* mus = GetMusic(self);
+  if (mus->music) {
+    Mix_FreeMusic(mus->music);
+    mus->music = NULL;
+  }
+  return Qnil;
+}
+
+void rubysdl_init_Mixer(VALUE mSDL)
+{
+  mMixer = rb_define_module_under(mSDL, "Mixer");
+  rb_define_module_function(mMixer, "open", Mixer_s_open, 4);
+  rb_define_module_function(mMixer, "close", Mixer_s_close, 0);
+  rb_define_module_function(mMixer, "spec", Mixer_s_spec, 0);
+  rb_define_module_function(mMixer, "driverName", Mixer_s_driverName, 0);
+  rb_define_module_function(mMixer, "playChannel", Mixer_s_playChannel, 3);
+  rb_define_module_function(mMixer, "playChannelTimed", Mixer_s_playChannelTimed, 4);
+  rb_define_module_function(mMixer, "fadeInChannel", Mixer_s_playChannel, 4);
+  rb_define_module_function(mMixer, "fadeInChannelTimed", Mixer_s_fadeInChannelTimed, 5);
   
-  rb_define_module_function(mMixer,"playMusic",mix_playMusic,2);
-  rb_define_module_function(mMixer,"fadeInMusic",mix_fadeInMusic,3);
-  rb_define_module_function(mMixer,"setVolumeMusic",mix_setVolumeMusic,1);
-  rb_define_module_function(mMixer,"haltMusic",mix_haltMusic,0);
-  rb_define_module_function(mMixer,"fadeOutMusic",mix_fadeOutMusic,1);
-  rb_define_module_function(mMixer,"pauseMusic",mix_pauseMusic,0);
-  rb_define_module_function(mMixer,"resumeMusic",mix_resumeMusic,0);
-  rb_define_module_function(mMixer,"rewindMusic",mix_rewindMusic,0);
-  rb_define_module_function(mMixer,"pauseMusic?",mix_pausedMusic,0);
-  rb_define_module_function(mMixer,"playMusic?",mix_playingMusic,0);
-  rb_define_module_function(mMixer,"fadingMusic",mix_fadingMusic,0);
+  rb_define_module_function(mMixer, "play?", Mixer_s_play_p, 1);
+  rb_define_module_function(mMixer, "playingChannels", Mixer_s_playing_channels, 0);
+  rb_define_module_function(mMixer, "setVolume", Mixer_s_setVolume, 2);
+  rb_define_module_function(mMixer, "allocateChannels", Mixer_s_allocateChannels, 1);
   
-  cWave = rb_define_class_under(mMixer,"Wave",rb_cObject);
-  rb_define_singleton_method(cWave,"load",mix_loadWav,1);
-  rb_define_singleton_method(cWave,"loadFromIO",mix_loadWavFromIO,1);
-  rb_define_method(cWave,"setVolume",mix_wave_volume,1);
-
-  cMusic = rb_define_class_under(mMixer,"Music",rb_cObject);
-  rb_define_singleton_method(cMusic,"load",mix_loadMus,1);
+  rb_define_module_function(mMixer, "halt", Mixer_s_halt, 1);
+  rb_define_module_function(mMixer, "pause", Mixer_s_pause, 1);
+  rb_define_module_function(mMixer, "resume", Mixer_s_resume, 1);
+  rb_define_module_function(mMixer, "pause?", Mixer_s_pause_p, 1);
+  rb_define_module_function(mMixer, "expire", Mixer_s_expire, 2);
+  rb_define_module_function(mMixer, "fading", Mixer_s_fading, 1);
+  rb_define_module_function(mMixer, "fadeOut", Mixer_s_fadeOut, 2);
+  
+  rb_define_module_function(mMixer, "playMusic", Mixer_s_playMusic, 2);
+  rb_define_module_function(mMixer, "fadeInMusic", Mixer_s_fadeInMusic, 3);
+  rb_define_module_function(mMixer, "setVolumeMusic", Mixer_s_setVolumeMusic, 1);
+  rb_define_module_function(mMixer, "haltMusic", Mixer_s_haltMusic, 0);
+  rb_define_module_function(mMixer, "fadeOutMusic", Mixer_s_fadeOutMusic, 1);
+  rb_define_module_function(mMixer, "pauseMusic", Mixer_s_pauseMusic, 0);
+  rb_define_module_function(mMixer, "resumeMusic", Mixer_s_resumeMusic, 0);
+  rb_define_module_function(mMixer, "rewindMusic", Mixer_s_rewindMusic, 0);
+  rb_define_module_function(mMixer, "pauseMusic?", Mixer_s_pauseMusic_p, 0);
+  rb_define_module_function(mMixer, "playMusic?", Mixer_s_playMusic_p, 0);
+  rb_define_module_function(mMixer, "fadingMusic", Mixer_s_fadingMusic, 0);
+
+  cWave = rb_define_class_under(mMixer, "Wave", rb_cObject);
+  rb_define_singleton_method(cWave, "load", Wave_s_load, 1);
+  rb_define_singleton_method(cWave, "loadFromIO", Wave_s_loadFromIO,1);
+  rb_define_singleton_method(cWave, "loadFromString", Wave_s_loadFromString,1);
+  rb_define_method(cWave, "setVolume", Wave_s_setVolume, 1);
+  
+  cMusic = rb_define_class_under(mMixer, "Music", rb_cObject);
+  rb_define_singleton_method(cMusic, "load", Music_s_load, 1);
 #ifdef HAVE_MIX_LOADMUS_RW
-  rb_define_singleton_method(cMusic,"loadFromString",mix_loadMusFromString,1);
+  rb_define_singleton_method(cMusic, "loadFromString",
+                             Mixer_s_loadMusFromString,1);
 #endif
-  
+  rb_define_method(cWave, "destroy", Wave_destroy, 0);
+  rb_define_method(cMusic, "destroy", Music_destroy, 0);
+
   /* to avoid to do garbage collect when playing */
-  playing_wave = rb_ary_new();
   rb_global_variable( &playing_wave );
   rb_global_variable( &playing_music );
+  playing_wave = rb_ary_new();
+
+  rb_define_const(mMixer, "FORMAT_U8", UINT2NUM(AUDIO_U8));
+  rb_define_const(mMixer, "FORMAT_S8", UINT2NUM(AUDIO_S8));
+  rb_define_const(mMixer, "FORMAT_U16LSB", UINT2NUM(AUDIO_U16LSB));
+  rb_define_const(mMixer, "FORMAT_S16LSB", UINT2NUM(AUDIO_S16LSB));
+  rb_define_const(mMixer, "FORMAT_U16MSB", UINT2NUM(AUDIO_U16MSB));
+  rb_define_const(mMixer, "FORMAT_S16MSB", UINT2NUM(AUDIO_S16MSB));
+  rb_define_const(mMixer, "FORMAT_U16", UINT2NUM(AUDIO_U16));
+  rb_define_const(mMixer, "FORMAT_S16", UINT2NUM(AUDIO_S16));
 
-  defineConstForAudio();
-  return ;
+  rb_define_const(mMixer, "FORMAT_U16SYS", UINT2NUM(AUDIO_U16SYS));
+  rb_define_const(mMixer, "FORMAT_S16SYS", UINT2NUM(AUDIO_S16SYS));
+
+  rb_define_const(mMixer, "CHANNELS", INT2NUM(MIX_CHANNELS));
+  rb_define_const(mMixer, "DEFAULT_FREQUENCY", INT2NUM(MIX_DEFAULT_FREQUENCY));
+  rb_define_const(mMixer, "DEFAULT_FORMAT", UINT2NUM(MIX_DEFAULT_FORMAT));
+  rb_define_const(mMixer, "DEFAULT_CHANNELS", UINT2NUM(MIX_DEFAULT_CHANNELS));
+  rb_define_const(mMixer, "MAX_VOLUME", INT2NUM(MIX_MAX_VOLUME));
+
+  return;
 }
 
-void quit_mixer()
+void rubysdl_quit_Mixer(void)
 {
-  if( mix_opened ){
+  if(Mix_opened()){
     Mix_CloseAudio();
-    mix_closed = 1;
   }
 }
+#else /* HAVE_SDL_MIXER */
+void rubysdl_init_Mixer(VALUE mSDL)
+{
+}
+void rubysdl_quit_Mixer(void)
+{
+}
 #endif  /* HAVE_SDL_MIXER */