gme 0.0.13-x86-linux → 0.1.0-x86-linux

data/README.rdoc

@@ -1,25 +1,46 @@
-= GME: Game Music Emulator for Ruby
+= GME: Game Music Emu for Ruby
 
-This gem allows the use of the gme library (http://code.google.com/p/game-music-emu)
-by Blargg (http://www.fly.net/~ant/libs/audio.html) in Ruby programs.
+This gem allows the use of the {gme library}[http://code.google.com/p/game-music-emu]
+by {Blargg}[http://www.fly.net/~ant/libs/audio.html] in Ruby programs.
 
-At the moment, it implements just the basic functionality, and it's not suitable for production.
+Game Music Emu is a collection of video game music file emulators that support various formats and systems.
+
+At the moment, this gem implements just the basic functionality, and it's not suitable for production.
+
+== Installation
+Using Rubygems:
+
+   gem install gme
 
 == Example usage:
 
-This gem only outputs raw pcm data, and doesn't include options for handling multi track files.
+Note: This gem only outputs raw pcm data (16 bit samples, stereo).
 
+   require 'rubygems'
    require 'gme'
    
-   song = GME::Emulator.open('/path/to/file.ext', options = {}) # opens a music file and sets up an GME::Emulator object
+   song = GME::Emulator.open('/path/to/file.ext', options = {}) # opens a music file and sets up a GME::Emulator object
    # configuration options:
    # :sample_rate   - specifies the output sample rate
    # :buffer_length - specifies the internal buffer length to be used
 
-   puts song.info                     # prints the information about the first track
+   file = File.new('output.pcm', 'w') # opens a file for writing
+
+   song.start_track(1)                # starts the specified track (0 by default)
 
-   song.play_to_file(file)            # plays the first track of the song to a file
+   song.info                          # returns a hash with some information about the started track
 
-   song.start_track(track_number)     # starts the specified track (0 by default)
-   song.get_samples                   # gets a number of samples
+   song.play(file, :samples => 1024)  # writes the specified number of samples to a file
+
+   song.tell                          # returns the number of milliseconds played 
+                                      # since the beginning of the track
+
+   song.set_fade(2000)                # sets the number of milliseconds to start fading
+                                      # the track since the beginning of the track
+
+   song.play_silence(file, 2000)      # writes the specified milliseconds of silence to a file
    
+   song.play_to_file(file)            # completely plays the first track to a file
+
+   file.close                         # closes the ouput file
+   song.close                         # release the memory allocated for the emulator

data/VERSION

@@ -1 +1 @@
-0.0.13
+0.1.0

data/ext/gme/build/Makefile

@@ -87,8 +87,8 @@ extout_prefix =
 target_prefix = 
 LOCAL_LIBS = 
 LIBS = $(LIBRUBYARG_SHARED) -lgme  -lpthread -lrt -ldl -lcrypt -lm   -lc
-SRCS = gme_funcs.c gme.c util.c
-OBJS = gme_funcs.o gme.o util.o
+SRCS = gme.c util.c gme_funcs.c gme_helpers.c
+OBJS = gme.o util.o gme_funcs.o gme_helpers.o
 TARGET = gme_ext
 DLLIB = $(TARGET).so
 EXTSTATIC = 

data/ext/gme/gme.c

@@ -1,6 +1,7 @@
 #include <ruby.h>
-#include "gme_funcs.h"
 #include "util.h"
+#include "gme_helpers.h"
+#include "gme_funcs.h"
 
 // classes and modules representations
 VALUE mGME;
@@ -22,13 +23,14 @@ void Init_gme_ext()
     cEmulator = rb_define_class_under(mGME, "Emulator", rb_cObject);
     rb_funcall(cEmulator, rb_intern("attr_reader"), 1, ID2SYM(rb_intern("info")));
     rb_funcall(cEmulator, rb_intern("attr_reader"), 1, ID2SYM(rb_intern("track_count")));
+    rb_funcall(cEmulator, rb_intern("attr_reader"), 1, ID2SYM(rb_intern("sample_rate")));
 
     // for debugging
     rb_funcall(cEmulator, rb_intern("attr_reader"), 1, ID2SYM(rb_intern("internal_buffer")));
     rb_funcall(cEmulator, rb_intern("attr_reader"), 1, ID2SYM(rb_intern("internal_buffer_length")));
     // ---
 
-    /* rb_define_alloc_func(cEmulator, gme_alloc); */
+    // FIXME: open and play should have 1 mandatory parameter and the rest are optional (i.e.: -2 as parameter count)
     rb_define_singleton_method(cEmulator, "open", gme_ruby_open, -1);
     rb_define_method(cEmulator, "close", gme_ruby_close, 0);
     rb_define_method(cEmulator, "start_track", gme_ruby_start_track, -1);
@@ -38,4 +40,7 @@ void Init_gme_ext()
     rb_define_method(cEmulator, "tell", gme_ruby_tell, 0);
     rb_define_method(cEmulator, "track_ended?", gme_ruby_track_ended, 0);
     rb_define_method(cEmulator, "ignore_silence", gme_ruby_ignore_silence, 1);
+    rb_define_method(cEmulator, "set_fade", gme_ruby_set_fade, 1);
+    rb_define_method(cEmulator, "play", gme_ruby_play, -1);
+    rb_define_method(cEmulator, "play_silence", gme_ruby_play_silence, 2);
 }

data/ext/gme/gme_funcs.c

@@ -1,4 +1,5 @@
 #include "gme_funcs.h"
+#include "gme_helpers.h"
 #include "util.h"
 
 #include <rubyio.h>
@@ -8,19 +9,16 @@ extern VALUE eGenericException;
 extern VALUE eInvalidFile;
 extern VALUE eTrackNotStarted;
 
-void gme_ruby_emu_free(void* pointer);
-
 /*
- * Opens a new input file
- * Returns a new instance of GME::Emulator
+ * Opens a new input file.
+ * Returns a new instance of GME::Emulator.
+ * Accepts options in a hash (2nd argument).
  */
 VALUE gme_ruby_open(int argc, VALUE* argv, VALUE self)
 {
-    Music_Emu*  emulator;
-    int         c_sample_rate;
-    char*       c_path;
-    int         track = 0; // uses track 0 for getting info (FIXME)
-    gme_info_t* info;
+    Music_Emu* emulator;
+    int        c_sample_rate;
+    char*      c_path;
 
     // internal buffer
     short* buffer;
@@ -44,7 +42,7 @@ VALUE gme_ruby_open(int argc, VALUE* argv, VALUE self)
         options = rb_hash_new();
     }
 
-    // set sample rate
+    // set sample rate from options hash
     VALUE sample_rate = rb_hash_aref(options, ID2SYM(rb_intern("sample_rate")));
     if(!NIL_P(sample_rate)) {
         c_sample_rate = FIX2INT(sample_rate);
@@ -54,7 +52,7 @@ VALUE gme_ruby_open(int argc, VALUE* argv, VALUE self)
         c_sample_rate = 44100;
     }
 
-    // set buffer length
+    // set buffer length from options hash
     VALUE buffer_len = rb_hash_aref(options, ID2SYM(rb_intern("buffer_length")));
     if(!NIL_P(buffer_len)) {
         buffer_length = FIX2INT(buffer_len);
@@ -66,33 +64,18 @@ VALUE gme_ruby_open(int argc, VALUE* argv, VALUE self)
 
     // opens the specified file
     handle_error(gme_open_file(c_path, &emulator, c_sample_rate), eInvalidFile);
-    // and gets the info on the track
-    handle_error(gme_track_info(emulator, &info, track), eGenericException);
 
     // creates a new instance of GME::Emulator, as a wrapper around Music_Emu
     VALUE new_instance = Data_Wrap_Struct(cEmulator, 0, gme_ruby_emu_free, emulator);
 
     // allocates memory for the internal buffer
-    buffer = ALLOC_N(short, buffer_length);
-    // and saves a reference for later use (hack?)
+    buffer = (short*) malloc(sizeof(short) * buffer_length);
+    // and saves a reference for later use (HACK?)
     rb_iv_set(new_instance, "@internal_buffer", LONG2NUM((long)buffer));
     rb_iv_set(new_instance, "@internal_buffer_length", INT2NUM(buffer_length));
 
-    // Fills the info hash
-    VALUE info_hash = rb_hash_new();
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("play_length")), INT2FIX(info->play_length));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("length")), INT2FIX(info->length));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("intro_length")), INT2FIX(info->intro_length));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("loop_length")), INT2FIX(info->loop_length));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("system")), rb_str_new2(info->system));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("game")), rb_str_new2(info->game));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("song")), rb_str_new2(info->song));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("author")), rb_str_new2(info->author));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("copyright")), rb_str_new2(info->copyright));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("comment")), rb_str_new2(info->comment));
-    rb_hash_aset(info_hash, ID2SYM(rb_intern("dumper")), rb_str_new2(info->dumper));
-    rb_iv_set(new_instance, "@info", info_hash);
-    gme_free_info(info);
+    // saves the sample rate value for future reference
+    rb_iv_set(new_instance, "@sample_rate", INT2FIX(c_sample_rate));
 
     // sets the track count
     int track_count = gme_track_count(emulator);
@@ -106,21 +89,37 @@ VALUE gme_ruby_open(int argc, VALUE* argv, VALUE self)
 }
 
 /*
- * is this function really needed?
+ * Releases all the resources allocated in Emulator#open.
+ * The object is unusable after this call.
+ * TODO: mark valid and invalid objects and raise exceptions if appropiate
+ *       instead of simply failing or generating a segfault.
  */
 VALUE gme_ruby_close(VALUE self)
 {
-    return Qnil;    
+    Music_Emu* emulator;
+    short*     c_buffer;
+
+    Data_Get_Struct(self, Music_Emu, emulator);
+
+    // recovers a pointer to the internal buffer
+    c_buffer = (short*) NUM2LONG(rb_iv_get(self, "@internal_buffer"));
+
+    // releases the memory
+    if(c_buffer != NULL) free(c_buffer);
+
+    return Qnil;
 }
 
 /*
- * starts a track
- * if not specified, uses track number 0
+ * Starts a track.
+ * If a track is not specified, uses track number 0.
+ * Returns the number of the track started.
  */
 VALUE gme_ruby_start_track(int argc, VALUE* argv, VALUE self)
 {
-    Music_Emu* emulator;
-    int        c_track;
+    Music_Emu*  emulator;
+    int         c_track;
+    gme_info_t* info;
 
     Data_Get_Struct(self, Music_Emu, emulator);
 
@@ -133,6 +132,25 @@ VALUE gme_ruby_start_track(int argc, VALUE* argv, VALUE self)
         c_track = 0;
     }
 
+    // gets the info on the track
+    handle_error(gme_track_info(emulator, &info, c_track), eGenericException);
+
+    // Fills the info hash
+    VALUE info_hash = rb_hash_new();
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("play_length")), INT2FIX(info->play_length));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("length")), INT2FIX(info->length));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("intro_length")), INT2FIX(info->intro_length));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("loop_length")), INT2FIX(info->loop_length));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("system")), rb_str_new2(info->system));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("game")), rb_str_new2(info->game));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("song")), rb_str_new2(info->song));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("author")), rb_str_new2(info->author));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("copyright")), rb_str_new2(info->copyright));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("comment")), rb_str_new2(info->comment));
+    rb_hash_aset(info_hash, ID2SYM(rb_intern("dumper")), rb_str_new2(info->dumper));
+    rb_iv_set(self, "@info", info_hash);
+    gme_free_info(info);
+
     // starts the track
     handle_error(gme_start_track(emulator, c_track), eGenericException);
     
@@ -153,14 +171,11 @@ VALUE gme_ruby_get_samples(VALUE self)
     short*     c_buffer;
     int        c_buffer_len;
 
-    VALUE track_started = rb_iv_get(self, "@track_started");
-    if(!RTEST(track_started)) rb_raise(eTrackNotStarted, "you must start a track first");
+    raise_if_track_has_not_started(self);
 
     Data_Get_Struct(self, Music_Emu, emulator);
 
-    // recovers a pointer to the internal buffer
-    c_buffer = (short*) NUM2LONG(rb_iv_get(self, "@internal_buffer"));
-    c_buffer_len = NUM2INT(rb_iv_get(self, "@internal_buffer_length"));
+    get_internal_buffer(self, &c_buffer, &c_buffer_len);
 
     // plays the file, returning the specified number of samples
     handle_error(gme_play(emulator, c_buffer_len, c_buffer), eGenericException);
@@ -173,8 +188,8 @@ VALUE gme_ruby_get_samples(VALUE self)
 }
 
 /*
- * Plays the track 0 of the input file
- * and writes in the specified (ruby) output file
+ * Plays the track 0 of the input file,
+ * and writes in the specified (Ruby) output file.
  */
 VALUE gme_ruby_play_to_file(VALUE self, VALUE file)
 {
@@ -182,32 +197,22 @@ VALUE gme_ruby_play_to_file(VALUE self, VALUE file)
     short*     buffer;
     FILE*      stdio_file;
     Music_Emu* emulator;
-    int        track       = 0;    // plays track 0 (TODO?)
+    
+    // plays track 0
+    // TODO: receive the track to play as an argument
+    int track = 0;
 
-    // throws an exception if the file passed is not valid
-    // FIXME: currently it *requires* an object of class File
-    if(NIL_P(file) || TYPE(file) != T_FILE) {
-        rb_raise(eGenericException, "the file is not valid.");
-    }
+    raise_if_invalid_file(file);
+
+    stdio_file = get_stdio_pointer(file);
 
     // allocates memory for the buffer
     buffer = (short*) malloc(buffer_size * sizeof(short));
 
     Data_Get_Struct(self, Music_Emu, emulator);
     
-    // TODO: fix for ruby-1.9 (fptr->stdio_file)
-    stdio_file = RFILE(file)->fptr->f;
-
-    // if the stdio pointer couldn't be accesed, exit the program
-    if(stdio_file == NULL) {
-        rb_fatal("Couldn't access stdio FILE pointer");
-    }
-
-    // starts track 0
-    handle_error(gme_start_track(emulator, track), eGenericException);
-
-    // track 0 has been started
-    rb_iv_set(self, "@track_started", Qtrue);
+    // starts track
+    rb_funcall(self, rb_intern("start_track"), 1, INT2FIX(track));
 
     // gets the play length of the track from the info hash
     VALUE info_hash = rb_iv_get(self, "@info");
@@ -240,7 +245,7 @@ VALUE gme_ruby_track_started(VALUE self)
 }
 
 /*
- * Returns the number of milliseconds played since the start of the track
+ * Returns the number of milliseconds played since the start of the track.
  */
 VALUE gme_ruby_tell(VALUE self)
 {
@@ -255,7 +260,6 @@ VALUE gme_ruby_tell(VALUE self)
     return INT2FIX(milliseconds);
 }
 
-
 /*
  * Returns true if the track has ended
  * and false in other cases
@@ -264,9 +268,7 @@ VALUE gme_ruby_track_ended(VALUE self)
 {
     Music_Emu* emulator;
 
-    // throws an exception if a track hasn't been started
-    VALUE track_started = gme_ruby_track_started(self);
-    if(!RTEST(track_started)) rb_raise(eTrackNotStarted, "you have to start a track first");
+    raise_if_track_has_not_started(self);
 
     Data_Get_Struct(self, Music_Emu, emulator);
 
@@ -278,8 +280,8 @@ VALUE gme_ruby_track_ended(VALUE self)
 }
 
 /*
- * sets whether or not to disable automatic end of track detection
- * and skipping at the beginning
+ * Sets whether or not to disable automatic end of track detection
+ * and skipping at the beginning.
  */
 VALUE gme_ruby_ignore_silence(VALUE self, VALUE ignore)
 {
@@ -296,9 +298,109 @@ VALUE gme_ruby_ignore_silence(VALUE self, VALUE ignore)
 }
 
 /*
- * free function to the GME::Emulator wrapper for Music_Emu
+ * Sets the time in milliseconds to start fading the track.
  */
-void gme_ruby_emu_free(void* pointer)
+VALUE gme_ruby_set_fade(VALUE self, VALUE milliseconds)
 {
-    if(pointer != NULL) gme_delete(pointer);
+    Music_Emu* emulator;
+
+    Data_Get_Struct(self, Music_Emu, emulator);
+
+    gme_set_fade(emulator, FIX2INT(milliseconds));
+
+    return Qnil;
+}
+
+/*
+ * Plays the started track to the specified file.
+ * Optionally, one can indicate the number of samples to be played
+ * (given that the buffer allocated previuosly is long enough).
+ */
+VALUE gme_ruby_play(int argc, VALUE* argv, VALUE self)
+{
+    Music_Emu* emulator;
+    int        c_number_of_samples;
+    VALUE      options;         // options hash
+    VALUE      file;
+    FILE*      stdio_file;
+    short*     c_buffer;
+    int        c_buffer_len;
+
+    Data_Get_Struct(self, Music_Emu, emulator);
+
+    // file as the first argument
+    file = argv[0];
+
+    raise_if_invalid_file(file);
+
+    stdio_file = get_stdio_pointer(file);
+
+    raise_if_track_has_not_started(self);
+
+    // use the second argument, if present, as the options hash
+    VALUE temp;
+    if(argc >= 2){
+        temp = rb_check_convert_type(argv[1], T_HASH, "Hash", "to_hash");
+        if(!NIL_P(temp)) options = temp;
+        else options = rb_hash_new();
+    }
+    else {
+        options = rb_hash_new();
+    }
+   
+    get_internal_buffer(self, &c_buffer, &c_buffer_len);
+
+    // determine the maximum number of samples to play given the buffer size
+    // (recall that buffer was allocated as an array of short)
+    int max_samples = c_buffer_len;
+
+    // sets the number of samples to play
+    VALUE samples = rb_hash_aref(options, ID2SYM(rb_intern("samples")));
+    if(!NIL_P(samples) && FIX2INT(samples) > 0 && FIX2INT(samples) <= max_samples) {
+        c_number_of_samples = FIX2INT(samples);
+    }
+    else {
+        // default, the maximum number of samples permitted by the allocated buffer
+        c_number_of_samples = max_samples;
+    }
+
+    // plays the file, getting the specified number of samples
+    handle_error(gme_play(emulator, c_number_of_samples, c_buffer), eGenericException);
+
+    // writes the samples to the file
+    write_samples(stdio_file, c_number_of_samples, c_buffer);
+    fflush(stdio_file);
+
+    // returns the number of samples
+    return INT2FIX(c_number_of_samples);
+}
+
+/*
+ * Inserts the specified milliseconds of silence in a file.
+ */
+VALUE gme_ruby_play_silence(VALUE self, VALUE file, VALUE milliseconds)
+{
+    Music_Emu* emulator;
+    FILE*      stdio_file;
+    int        samples_to_write;
+
+    Data_Get_Struct(self, Music_Emu, emulator);
+
+    raise_if_invalid_file(file);
+
+    stdio_file = get_stdio_pointer(file);
+
+    // gets the original sample rate specified for the emulator
+    int sample_rate = FIX2INT(rb_iv_get(self, "@sample_rate"));
+    samples_to_write = sample_rate * (FIX2INT(milliseconds) / 1000);
+
+    // writes a number of 0's as silence
+    // (4 in the next calculation because samples are 2 bytes and there are 2 channels)
+    int i;
+    for(i=0; i <(samples_to_write * 4); i++) {
+        fputc(0, stdio_file);
+    }
+    fflush(stdio_file);
+
+    return Qnil;
 }

data/ext/gme/gme_funcs.h

@@ -13,5 +13,8 @@ VALUE gme_ruby_track_started(VALUE self);
 VALUE gme_ruby_tell(VALUE self);
 VALUE gme_ruby_track_ended(VALUE self);
 VALUE gme_ruby_ignore_silence(VALUE self, VALUE ignore);
+VALUE gme_ruby_set_fade(VALUE self, VALUE milliseconds);
+VALUE gme_ruby_play(int argc, VALUE* argv, VALUE self);
+VALUE gme_ruby_play_silence(VALUE self, VALUE file, VALUE milliseconds);
 
 #endif

data/ext/gme/gme_helpers.c

@@ -0,0 +1,59 @@
+#include "gme_helpers.h"
+
+/*
+ * free function to the GME::Emulator wrapper for Music_Emu
+ */
+void gme_ruby_emu_free(void* pointer)
+{
+    if(pointer != NULL) gme_delete(pointer);
+}
+
+/*
+ * Raises an exception if a track has not been started in the emulator.
+ */
+void raise_if_track_has_not_started(VALUE emulator)
+{
+    VALUE track_started = rb_iv_get(emulator, "@track_started");
+    if(!RTEST(track_started)) rb_raise(eTrackNotStarted, "you must start a track first");
+}
+
+/*
+ * Raises an exception the specified file is invalid.
+ * i.e. doesn't satisfy the required conditions.
+ */
+void raise_if_invalid_file(VALUE file)
+{
+    // FIXME: currently it *requires* an object of class File
+    if(NIL_P(file) || TYPE(file) != T_FILE) {
+        rb_raise(eGenericException, "the file is not valid.");
+    }
+
+    FILE* stdio_file = get_stdio_pointer(file);
+
+    // raises an exception if the stdio pointer couldn't be accesed
+    if(stdio_file == NULL) {
+        rb_raise(eGenericException, "couldn't access stdio FILE pointer of the specified file");
+    }
+}
+
+/*
+ * Recovers a pointer to the internal buffer of the emulator.
+ */
+void get_internal_buffer(VALUE emulator, short** buffer, int* buffer_len)
+{
+    *buffer = (short*) NUM2LONG(rb_iv_get(emulator, "@internal_buffer"));
+    *buffer_len = NUM2INT(rb_iv_get(emulator, "@internal_buffer_length"));
+}
+
+/*
+ * Gets the stdio pointer of the specified file.
+ */
+FILE* get_stdio_pointer(VALUE file)
+{
+    FILE* stdio_pointer = NULL;
+
+    // TODO: fix for ruby-1.9 (fptr->stdio_file)
+    stdio_pointer = RFILE(file)->fptr->f;
+
+    return stdio_pointer;
+}

data/ext/gme/gme_helpers.h

@@ -0,0 +1,17 @@
+#ifndef _GME_HELPERS_H
+#define _GME_HELPERS_H
+
+#include <ruby.h>
+#include <rubyio.h>
+
+extern VALUE eTrackNotStarted;
+extern VALUE eGenericException;
+
+void gme_ruby_emu_free(void* pointer);
+
+void  raise_if_track_has_not_started(VALUE emulator);
+void  raise_if_invalid_file(VALUE file);
+void  get_internal_buffer(VALUE emulator, short** buffer, int* buffer_len);
+FILE* get_stdio_pointer(VALUE file);
+
+#endif

data/spec/emulator_spec.rb

@@ -18,21 +18,8 @@ describe Emulator, "when first created" do
     @song.track_count.should == 1
   end
 
-  it "should respond to the message 'info' and return a non-empty container" do 
-    @song.info.should_not be_empty
-  end
-
-  it "should correctly return the metadata of track 0 in a hash" do 
-    @song.info[:game].should == "Super Castlevania 4"
-    @song.info[:song].should == "Stage Clear"
-    @song.info[:length].should == 4000
-    @song.info[:copyright].should == "1991 Konami"
-    @song.info[:author].should == "Masanori Adachi, Taro Kudou"
-    @song.info[:play_length].should == 4000
-    @song.info[:comment].should == ""
-    @song.info[:dumper].should == "Datschge"
-    @song.info[:system].should == "Super Nintendo"
-    @song.info[:loop_length].should == -1
+  it "should return nil when asked for info" do 
+    @song.info.should be_nil
   end
 
   it "should indicate that no track has been started" do 
@@ -77,7 +64,7 @@ describe Emulator, "when first created" do
         lambda { @song.play_to_file(@file) }.should_not raise_exception
         @song.close
         File.size("temp.out").should == 706560
-        Digest::SHA1.hexdigest(File.read("temp.out")).should == "5a557efdb64cb71baa953b7129663b1503f4a7d9"
+        # TODO: check correctness of the generated file
       end
 
       after(:each) do 
@@ -120,7 +107,26 @@ describe Emulator, "when first created" do
       @song.tell.should == 0
     end
 
-    # TODO: get_samples, open with options, etc.
+    it "should not return nil when asked for the info" do
+      @song.info.should_not be_nil
+    end
     
+    it "should correctly return the metadata of the started track in a hash" do
+      @song.info[:game].should == "Super Castlevania 4"
+      @song.info[:song].should == "Stage Clear"
+      @song.info[:length].should == 4000
+      @song.info[:copyright].should == "1991 Konami"
+      @song.info[:author].should == "Masanori Adachi, Taro Kudou"
+      @song.info[:play_length].should == 4000
+      @song.info[:comment].should == ""
+      @song.info[:dumper].should == "Datschge"
+      @song.info[:system].should == "Super Nintendo"
+      @song.info[:loop_length].should == -1
+    end
+
+    # TODO: complete examples for the methods:
+    # get_samples, set_fade, play_silence, play, close, tell, ignore_silence
+    # TODO: add examples for the open method with options
+    # :sample_rate, :buffer_length
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 1
   - 0
-  - 13
-  version: 0.0.13
+  version: 0.1.0
 platform: x86-linux
 authors: 
 - "Carlos Beltr\xC3\xA1n-Recabarren"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-30 00:00:00 -04:00
+date: 2010-05-14 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -36,12 +36,15 @@ files:
 - ext/gme/build/gme.o
 - ext/gme/build/gme_ext.so
 - ext/gme/build/gme_funcs.o
+- ext/gme/build/gme_helpers.o
 - ext/gme/build/mkmf.log
 - ext/gme/build/util.o
 - ext/gme/extconf.rb
 - ext/gme/gme.c
 - ext/gme/gme_funcs.c
 - ext/gme/gme_funcs.h
+- ext/gme/gme_helpers.c
+- ext/gme/gme_helpers.h
 - ext/gme/util.c
 - ext/gme/util.h
 - lib/gme.rb
@@ -79,5 +82,5 @@ signing_key:
 specification_version: 3
 summary: gme for Ruby
 test_files: 
-- spec/emulator_spec.rb
 - spec/spec_helper.rb
+- spec/emulator_spec.rb