rubygame 2.2.0 → 2.3.0

data/ext/rubygame/rubygame_mixer.c

@@ -22,41 +22,45 @@
 
 #include "rubygame_shared.h"
 #include "rubygame_mixer.h"
+#include "rubygame_sound.h"
+#include "rubygame_music.h"
+
 
-void Init_rubygame_mixer();
 VALUE mMixer;
+VALUE cSample;
+VALUE cOldMusic;
 
-VALUE rbgm_mixer_openaudio(int, VALUE*, VALUE);
-VALUE rbgm_mixer_closeaudio(VALUE);
-VALUE rbgm_mixer_getmixchans();
-VALUE rbgm_mixer_setmixchans(VALUE, VALUE);
-VALUE rbgm_mixer_getdrivername(VALUE);
 
-VALUE cSample;
-VALUE rbgm_sample_new(VALUE, VALUE);
-VALUE rbgm_mixchan_play( VALUE, VALUE, VALUE, VALUE );
-VALUE rbgm_mixchan_stop( VALUE, VALUE );
-VALUE rbgm_mixchan_pause( VALUE, VALUE );
-VALUE rbgm_mixchan_resume( VALUE, VALUE );
-
-VALUE cMusic;
-VALUE rbgm_mixmusic_setcommand(VALUE, VALUE); 
-VALUE rbgm_mixmusic_new(VALUE, VALUE);
-
-VALUE rbgm_mixmusic_play(int, VALUE*, VALUE);
-VALUE rbgm_mixmusic_stop(VALUE);
-VALUE rbgm_mixmusic_resume(VALUE);
-VALUE rbgm_mixmusic_pause(VALUE);
-VALUE rbgm_mixmusic_rewind(VALUE);
-VALUE rbgm_mixmusic_jump(VALUE, VALUE);
-VALUE rbgm_mixmusic_paused(VALUE);
-VALUE rbgm_mixmusic_playing(VALUE);
-
-VALUE rbgm_mixmusic_getvolume(VALUE);
-VALUE rbgm_mixmusic_setvolume(VALUE, VALUE);
-VALUE rbgm_mixmusic_fadein(int, VALUE*, VALUE);
-VALUE rbgm_mixmusic_fadeout(VALUE, VALUE);
-VALUE rbgm_mixmusic_fading(int, VALUE*, VALUE);
+/* Return 1 if SDL_mixer audio is open, or 0 if it is not. */
+int audio_is_open()
+{
+  /* We don't actually care about these, but Mix_QuerySpec wants args. */
+  int frequency;  Uint16 format;  int channels;
+
+  int result = Mix_QuerySpec(&frequency, &format, &channels);
+
+  return ( (result > 0) ? 1 : 0 );
+}
+
+/*
+ * If SDL_mixer audio is not open, try to open it with the default
+ * arguments, and return the result. If it's already open, return 0
+ * without doing anything.
+ */
+int ensure_open_audio()
+{
+  if( audio_is_open() )
+  {
+    return 0;
+  }
+  else
+  {
+    return Mix_OpenAudio( MIX_DEFAULT_FREQUENCY, 
+                          MIX_DEFAULT_FORMAT,
+                          2, 
+                          1024 );
+  }
+}
 
 
 /* --
@@ -66,7 +70,10 @@ VALUE rbgm_mixmusic_fading(int, VALUE*, VALUE);
 
 /* call-seq:
  *  open_audio( frequency=nil, format=nil, channels=nil, buffer=nil)
- *  
+ *
+ *  **NOTE:** This method is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame.open_audio instead.
+ *
  *  Initializes the audio device. You must call this before using the other
  *  mixer functions. See also #close_audio().
  *
@@ -103,6 +110,10 @@ VALUE rbgm_mixmusic_fading(int, VALUE*, VALUE);
  */
 VALUE rbgm_mixer_openaudio(int argc, VALUE *argv, VALUE module)
 {
+
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer", "3.0");
+
   VALUE vfreq, vformat, vchannels, vbuffer;
   int freq = MIX_DEFAULT_FREQUENCY;
   Uint16 format = MIX_DEFAULT_FORMAT;
@@ -141,7 +152,10 @@ VALUE rbgm_mixer_openaudio(int argc, VALUE *argv, VALUE module)
 
 /* call-seq:
  *  close_audio()
- *  
+ *
+ *  **NOTE:** This method is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame.close_audio instead.
+ *
  *  Close the audio device being used by the mixer. You should not use any
  *  mixer functions after this function, unless you use #open_audio() to
  *  re-open the audio device. See also #open_audio().
@@ -150,18 +164,185 @@ VALUE rbgm_mixer_openaudio(int argc, VALUE *argv, VALUE module)
  */
 VALUE rbgm_mixer_closeaudio(VALUE module)
 {
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer", "3.0");
+
   Mix_CloseAudio();
   return Qnil;
 }
 
+
+
+/* call-seq:
+ *  open_audio( options={ :buffer => 1024, :channels => 2, :frequency => 22050 } )  ->  true or false
+ *
+ *  Initializes the audio device using the given settings.
+ *
+ *  NOTE: Audio will be automatically opened when Rubygame::Sound or
+ *  Rubygame::Music are first used. You only need to open audio
+ *  manually if you want settings different from the default, or if
+ *  you are using the older, deprecated Music and Sample classes from
+ *  the Rubygame::Mixer module.
+ *
+ *  If audio is already open, this method has no effect, and returns false.
+ *  If you want to change audio settings, you must #close_audio() and
+ *  then open it again.
+ *
+ *  options::    A Hash of any of the following options. (Hash, optional)
+ *
+ *     :frequency::  output sample rate in audio samples per second
+ *                   (Hz). Affects the quality of the sound output, at
+ *                   the expense of CPU usage. If omitted, the default
+ *                   (22050) is used. The default is recommended for
+ *                   most games.
+ *
+ *     :channels::   output sound channels. Use 2 for stereo, 1 for mono.
+ *                   If omitted, the default (2) is used.
+ *
+ *     :buffer::     size of the sound buffer, in bytes. Must be a
+ *                   power of 2 (e.g. 512, 1024, 2048). If omitted,
+ *                   the default (1024) is used. If your game is
+ *                   fast-paced, you may want to use a smaller value
+ *                   to reduce audio delay, the time between when you
+ *                   play a sound and when it is heard.
+ *
+ *  Returns::    true if the audio was newly opened by this action, or
+ *               false if it was already open before this action.
+ *
+ *  May raise::  SDLError, if initialization fails.
+ *               ArgumentError, if an invalid value is given for any option.
+ *
+ *
+ */
+VALUE rbgm_mixer_openaudio2(int argc, VALUE *argv, VALUE module)
+{
+  VALUE options;
+
+  int buffer = 1024;
+  int channels = 2;
+  int frequency = MIX_DEFAULT_FREQUENCY;
+
+  /* In general, format should always be the default. */
+  Uint16 format = MIX_DEFAULT_FORMAT;
+
+
+  /* Does nothing if audio is already open. */
+  if( audio_is_open() )
+  {
+    return Qfalse;
+  }
+
+
+  rb_scan_args(argc, argv, "01", &options);
+
+
+  if( RTEST(options) )
+  {
+    /* Make sure options is a Hash table */
+    if( TYPE(options) != T_HASH )
+    {
+      rb_raise(rb_eTypeError, "wrong argument type %s (expected Hash)",
+               rb_obj_classname(options));
+    }
+
+    VALUE temp;
+
+    /* Buffer size */
+    temp = rb_hash_aref(options, make_symbol("buffer"));
+    if( RTEST(temp) )
+    {
+      buffer = NUM2INT(temp);
+
+      if( buffer <= 0 )
+      {
+        rb_raise(rb_eArgError, "buffer size must be positive (got %d)", buffer);
+      }
+
+      /* Check to see if it's not a power of two */
+      if( buffer & (buffer - 1) != 0 )
+      {
+        rb_raise(rb_eArgError, "buffer size must be a power of 2 (e.g. 512, 1024) (got %d)", buffer);
+      }
+    }
+
+    /* Channels */
+    temp = rb_hash_aref(options, make_symbol("channels"));
+    if( RTEST(temp) )
+    {
+      channels = NUM2INT(temp);
+
+      if( channels != 1 && channels != 2 )
+      {
+        rb_raise(rb_eArgError, "channels must be 1 (mono) or 2 (stereo) (got %d)", channels);
+      }
+    }
+
+    /* Frequency */
+    temp = rb_hash_aref(options, make_symbol("frequency"));
+    if( RTEST(temp) )
+    {
+      frequency = NUM2INT(temp);
+
+      if( frequency <= 0 )
+      {
+        rb_raise(rb_eArgError, "frequency must be positive (got %d)", frequency);
+      }
+    }
+  }
+
+  int result = Mix_OpenAudio(frequency, format, channels, buffer);
+
+  if( result < 0 )
+  {
+    rb_raise(eSDLError, "Could not open audio: %s", Mix_GetError());
+  }
+
+  return Qtrue;
+}
+
+
+/* call-seq:
+ *  close_audio()  ->  true or false
+ *
+ *  Deinitializes and closes the audio device. If audio was not open,
+ *  this method does nothing, and returns false. See also #open_audio().
+ *
+ *  NOTE: The audio will be automatically closed when the program
+ *  exits. You only need to close audio manually if you want to
+ *  call #open_audio with different settings.
+ *
+ *  Returns::  true if the audio changed from open to closed, or
+ *             false if the audio was not open before this action.
+ */
+VALUE rbgm_mixer_closeaudio2(VALUE module)
+{
+  if( audio_is_open() )
+  {
+    Mix_CloseAudio();
+    return Qtrue;
+  }
+  else
+  {
+    return Qfalse;
+  }
+}
+
+
+
 /* call-seq:
  *  #mix_channels()  ->  integer
  *
+ *  **NOTE:** This method is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame::Sound class instead.
+ *
  *  Returns the number of mixing channels currently allocated.
  *  See also #mix_channels=().
  */
 VALUE rbgm_mixer_getmixchans(VALUE module)
 {
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer", "3.0");
+
   int result;
   result = Mix_AllocateChannels(-1);
 
@@ -171,6 +352,9 @@ VALUE rbgm_mixer_getmixchans(VALUE module)
 /* call-seq:
  *  #mix_channels = num_channels 
  *
+ *  **NOTE:** This method is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame::Sound class instead.
+ *
  *  Set the number of mixer channels, allocating or deallocating channels as
  *  needed. This can be called many times, even during audio playback. If this
  *  call reduces the number of channels allocated, the excess channels will
@@ -190,6 +374,9 @@ VALUE rbgm_mixer_getmixchans(VALUE module)
  */
 VALUE rbgm_mixer_setmixchans(VALUE module, VALUE channelsv)
 {
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer", "3.0");
+
   int desired;
   int allocated;
 
@@ -202,6 +389,9 @@ VALUE rbgm_mixer_setmixchans(VALUE module, VALUE channelsv)
 /* call-seq:
  *  driver_name -> string 
  *
+ *  **NOTE:** This method is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame.audio_driver instead.
+ *
  *  Returns the name of the audio driver that SDL is using.
  *
  *  May raise an SDLError if initialization fails.
@@ -209,10 +399,36 @@ VALUE rbgm_mixer_setmixchans(VALUE module, VALUE channelsv)
 
 VALUE rbgm_mixer_getdrivername(VALUE module)
 {
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer", "3.0");
+
+  char driver_name[1024];
+  if(SDL_AudioDriverName(driver_name, sizeof(driver_name)) == NULL)
+  {	
+    rb_raise(eSDLError, "Error fetching audio driver name: %s", SDL_GetError());
+  }
+  return rb_str_new2(driver_name);
+}
+
+/* call-seq:
+ *  audio_driver -> string 
+ *
+ *  Returns the name of the audio driver that SDL is using.
+ *
+ *  May raise an SDLError if initialization fails.
+ */
+
+VALUE rbgm_mixer_audiodriver(VALUE module)
+{
+  if( ensure_open_audio() != 0 )
+  {
+    rb_raise(eSDLError, "Could not initialize audio: %s", Mix_GetError());
+  }
+
   char driver_name[1024];
   if(SDL_AudioDriverName(driver_name, sizeof(driver_name)) == NULL)
   {	
-    rb_raise(eSDLError, "Error fetrching audio driver name: %s", SDL_GetError());
+    rb_raise(eSDLError, "Could not get audio driver name: %s", Mix_GetError());
   }
   return rb_str_new2(driver_name);
 }
@@ -227,6 +443,9 @@ VALUE rbgm_mixer_getdrivername(VALUE module)
 /* call-seq:
  *  load_audio( filename )  ->  Sample
  *
+ *  **NOTE:** Rubygame::Mixer::Sample is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame::Sound class instead.
+ *
  *  Load an audio sample (a "chunk", to use SDL_mixer's term) from a file.
  *  Only WAV files are supported at this time.
  *
@@ -234,6 +453,9 @@ VALUE rbgm_mixer_getdrivername(VALUE module)
  */
 VALUE rbgm_sample_new(VALUE class, VALUE filev)
 {
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer::Sample", "3.0");
+
   VALUE self;
   Mix_Chunk* sample;
 
@@ -254,6 +476,9 @@ VALUE rbgm_sample_new(VALUE class, VALUE filev)
 /* call-seq:
  *  play(sample, channel_num, repeats )  ->  integer
  *
+ *  **NOTE:** This method is DEPRECATED and will be removed in
+ *  Rubygame 3.0. Please use the Rubygame::Sound class instead.
+ *
  *  Play an audio Sample on a mixing channel, repeating a certain number
  *  of extra times. Returns the number of the channel that the sample
  *  is being played on.
@@ -269,6 +494,10 @@ VALUE rbgm_sample_new(VALUE class, VALUE filev)
  */
 VALUE rbgm_mixchan_play( VALUE self, VALUE samplev, VALUE chanv, VALUE loopsv )
 {
+
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer", "3.0");
+
   Mix_Chunk* sample;
   int loops, channel, result;
 
@@ -359,12 +588,19 @@ VALUE rbgm_mixmusic_setcommand(VALUE class, VALUE commandv)
 /* call-seq:
  *  load_audio( filename )  ->  Music
  *
+ *  **NOTE:** Rubygame::Mixer::Music is DEPRECATED and will be removed
+ *  in Rubygame 3.0. Please use the Rubygame::Music class instead.
+ *
  *  Load music from a file. Supports WAVE, MOD, MIDI, OGG, and MP3 formats.
  *
  *  Raises SDLError if the music could not be loaded.
  */
 VALUE rbgm_mixmusic_new(VALUE class, VALUE filev)
 {
+
+  /* This feature will be removed in Rubygame 3.0. */
+  rg_deprecated("Rubygame::Mixer::Music", "3.0");
+
   VALUE self;
   Mix_Music* music;
 
@@ -375,7 +611,7 @@ VALUE rbgm_mixmusic_new(VALUE class, VALUE filev)
     rb_raise(eSDLError, "Error loading audio music from file `%s': %s",
              StringValuePtr(filev), Mix_GetError());
   }
-	self = Data_Wrap_Struct( cMusic, 0, Mix_FreeMusic, music );
+	self = Data_Wrap_Struct( cOldMusic, 0, Mix_FreeMusic, music );
 
 	//rb_obj_call_init(self,argc,argv);
 
@@ -689,6 +925,9 @@ void Init_rubygame_mixer()
 
   Init_rubygame_shared();
 
+  Rubygame_Init_Sound();
+  Rubygame_Init_Music();
+
   rb_hash_aset(rb_ivar_get(mRubygame,rb_intern("VERSIONS")),
                ID2SYM(rb_intern("sdl_mixer")),
                rb_ary_new3(3,
@@ -696,14 +935,27 @@ void Init_rubygame_mixer()
                            INT2NUM(SDL_MIXER_MINOR_VERSION),
                            INT2NUM(SDL_MIXER_PATCHLEVEL)));
 
-	/*
-	 *  The Mixer module provides access to the SDL_mixer library for audio
-	 *  playback and mixing. This module is still very basic, but it is
-	 *  good enough to load and play WAV files on multiple mix channels.
-	 *
-	 *  See the Sample class for loading audio files.
-	 *  See the Music class for streaming music from a file.
-	 */
+  /*
+   * Moving these to be under Rubygame module instead of Mixer.
+   */
+  rb_define_module_function(mRubygame,"open_audio",  rbgm_mixer_openaudio2, -1);
+  rb_define_module_function(mRubygame,"close_audio", rbgm_mixer_closeaudio2, 0);
+  rb_define_module_function(mRubygame,"audio_driver",rbgm_mixer_audiodriver, 0);
+
+
+
+  /*
+   *  **NOTE:** This module is DEPRECATED and will be removed in Rubygame 3.0.
+   *  Please use Rubygame.open_audio, Rubygame.close_audio, Rubygame::Sound,
+   *  and Rubygame::Music instead.
+   *
+   *  The Mixer module provides access to the SDL_mixer library for audio
+   *  playback and mixing. This module is still very basic, but it is
+   *  good enough to load and play WAV files on multiple mix channels.
+   *
+   *  See the Sample class for loading audio files.
+   *  See the Music class for streaming music from a file.
+   */
   mMixer = rb_define_module_under(mRubygame, "Mixer");
 
   rb_define_const(mMixer,"AUDIO_U8", INT2NUM(AUDIO_U8));
@@ -718,8 +970,12 @@ void Init_rubygame_mixer()
   rb_define_module_function(mMixer,"driver_name", rbgm_mixer_getdrivername, 0);
 
 
-
-  /* Stores audio data to play with Mixer.play() */
+  /*
+   *  **NOTE:** This class is DEPRECATED and will be removed in Rubygame 3.0.
+   *  Please use the Rubygame::Sound class instead.
+   *
+   *  Stores audio data to play with Mixer.play() 
+   */
   cSample = rb_define_class_under(mMixer, "Sample", rb_cObject);
   rb_define_singleton_method(cSample, "load_audio", rbgm_sample_new, 1);
   rb_define_module_function(mMixer,"play", rbgm_mixchan_play, 3);
@@ -728,7 +984,11 @@ void Init_rubygame_mixer()
   rb_define_module_function(mMixer,"resume", rbgm_mixchan_resume, 1);
 
 
-/*  The Music class is used for playing music from a file. It supports
+/*
+ *  **NOTE:** This class is DEPRECATED and will be removed in Rubygame 3.0.
+ *  Please use the Rubygame::Music class instead.
+ *
+ *  The Music class is used for playing music from a file. It supports
  *  WAVE, MOD, MIDI, OGG, and MP3 files. There are two important differences
  *  between Music and Sample:
  *
@@ -740,25 +1000,25 @@ void Init_rubygame_mixer()
  *     be many Samples playing at once. If you play a second Music while one
  *     is already playing, the first one will be stopped. See #play.
  */
-  cMusic = rb_define_class_under(mMixer, "Music", rb_cObject);
-  rb_define_singleton_method(cMusic, "load_audio", rbgm_mixmusic_new, 1);
+  cOldMusic = rb_define_class_under(mMixer, "Music", rb_cObject);
+  rb_define_singleton_method(cOldMusic, "load_audio", rbgm_mixmusic_new, 1);
 
-  //rb_define_singleton_method(cMusic, "set_command", rbgm_mixmusic_setcommand, 1);
+  //rb_define_singleton_method(cOldMusic, "set_command", rbgm_mixmusic_setcommand, 1);
 	
-  rb_define_method(cMusic, "play",      rbgm_mixmusic_play,       -1);
-  rb_define_method(cMusic, "stop",      rbgm_mixmusic_stop,        0);
-  rb_define_method(cMusic, "pause",     rbgm_mixmusic_pause,       0);
-  rb_define_method(cMusic, "resume",    rbgm_mixmusic_resume,      0);
-  rb_define_method(cMusic, "rewind",    rbgm_mixmusic_rewind,      0);
-  rb_define_method(cMusic, "jump",      rbgm_mixmusic_jump,        1);
-  rb_define_method(cMusic, "paused?",   rbgm_mixmusic_paused,      0);
-  rb_define_method(cMusic, "playing?",  rbgm_mixmusic_playing,     0);
-
-  rb_define_method(cMusic, "volume",    rbgm_mixmusic_getvolume,   0);
-  rb_define_method(cMusic, "volume=",   rbgm_mixmusic_setvolume,   1);
-  rb_define_method(cMusic, "fade_in",   rbgm_mixmusic_fadein,     -1);
-  rb_define_method(cMusic, "fade_out",  rbgm_mixmusic_fadeout,     1);
-  rb_define_method(cMusic, "fading?",   rbgm_mixmusic_fading,     -1);
+  rb_define_method(cOldMusic, "play",      rbgm_mixmusic_play,       -1);
+  rb_define_method(cOldMusic, "stop",      rbgm_mixmusic_stop,        0);
+  rb_define_method(cOldMusic, "pause",     rbgm_mixmusic_pause,       0);
+  rb_define_method(cOldMusic, "resume",    rbgm_mixmusic_resume,      0);
+  rb_define_method(cOldMusic, "rewind",    rbgm_mixmusic_rewind,      0);
+  rb_define_method(cOldMusic, "jump",      rbgm_mixmusic_jump,        1);
+  rb_define_method(cOldMusic, "paused?",   rbgm_mixmusic_paused,      0);
+  rb_define_method(cOldMusic, "playing?",  rbgm_mixmusic_playing,     0);
+
+  rb_define_method(cOldMusic, "volume",    rbgm_mixmusic_getvolume,   0);
+  rb_define_method(cOldMusic, "volume=",   rbgm_mixmusic_setvolume,   1);
+  rb_define_method(cOldMusic, "fade_in",   rbgm_mixmusic_fadein,     -1);
+  rb_define_method(cOldMusic, "fade_out",  rbgm_mixmusic_fadeout,     1);
+  rb_define_method(cOldMusic, "fading?",   rbgm_mixmusic_fading,     -1);
 }
 
 

data/ext/rubygame/rubygame_mixer.h

@@ -24,39 +24,13 @@
 #include "SDL_audio.h"
 #include "SDL_mixer.h"
 
-extern void Init_rubygame_mixer();
-extern VALUE mMixer;
+extern int audio_is_open();
+extern int ensure_open_audio();
 
-extern VALUE rbgm_mixer_openaudio(int, VALUE*, VALUE);
-extern VALUE rbgm_mixer_closeaudio(VALUE);
-extern VALUE rbgm_mixer_getmixchans();
-extern VALUE rbgm_mixer_setmixchans(VALUE, VALUE);
-extern VALUE rbgm_mixer_getdrivername(VALUE);
+extern void Init_rubygame_mixer();
 
+extern VALUE mMixer;
 extern VALUE cSample;
-extern VALUE rbgm_sample_new(VALUE, VALUE);
-extern VALUE rbgm_mixchan_play( VALUE, VALUE, VALUE, VALUE );
-extern VALUE rbgm_mixchan_stop( VALUE, VALUE );
-extern VALUE rbgm_mixchan_pause( VALUE, VALUE );
-extern VALUE rbgm_mixchan_resume( VALUE, VALUE );
-
-extern VALUE cMusic;
-extern VALUE rbgm_mixmusic_setcommand(VALUE, VALUE); 
-extern VALUE rbgm_mixmusic_new(VALUE, VALUE);
-
-extern VALUE rbgm_mixmusic_play(int, VALUE*, VALUE);
-extern VALUE rbgm_mixmusic_stop(VALUE);
-extern VALUE rbgm_mixmusic_resume(VALUE);
-extern VALUE rbgm_mixmusic_pause(VALUE);
-extern VALUE rbgm_mixmusic_rewind(VALUE);
-extern VALUE rbgm_mixmusic_jump(VALUE, VALUE);
-extern VALUE rbgm_mixmusic_paused(VALUE);
-extern VALUE rbgm_mixmusic_playing(VALUE);
-
-extern VALUE rbgm_mixmusic_getvolume(VALUE);
-extern VALUE rbgm_mixmusic_setvolume(VALUE, VALUE);
-extern VALUE rbgm_mixmusic_fadein(int, VALUE*, VALUE);
-extern VALUE rbgm_mixmusic_fadeout(VALUE, VALUE);
-extern VALUE rbgm_mixmusic_fading(int, VALUE*, VALUE);
+extern VALUE cOldMusic;
 
 #endif