icanhasaudio 0.1.1 → 0.1.2

data/History.txt

@@ -1,3 +1,9 @@
+=== 0.1.2
+
+* Bugfix
+  * Determining bitrate by filesize if not determined yet.
+  * Moving lots of C code to Ruby!
+
 === 0.1.1
 
 * 1 Bugfix

data/Manifest.txt

@@ -6,22 +6,32 @@ Rakefile
 examples/decoder.rb
 examples/encoder.rb
 examples/kexp.rb
-ext/decoder.c
-ext/decoder.h
-ext/extconf.rb
-ext/get_audio.c
-ext/get_audio.h
-ext/icanhasaudio.c
-ext/icanhasaudio.h
-ext/mpeg_encoder.c
-ext/mpeg_encoder.h
-ext/rb_ogg.c
-ext/rb_wav.c
-ext/rb_wav.h
-ext/syncword.c
-ext/syncword.h
+ext/icanhasaudio/audio_mpeg_decoder.c
+ext/icanhasaudio/audio_mpeg_decoder.h
+ext/icanhasaudio/audio_mpeg_decoder_mp3data.c
+ext/icanhasaudio/audio_mpeg_decoder_mp3data.h
+ext/icanhasaudio/audio_mpeg_encoder.c
+ext/icanhasaudio/audio_mpeg_encoder.h
+ext/icanhasaudio/audio_ogg_decoder.c
+ext/icanhasaudio/audio_ogg_decoder.h
+ext/icanhasaudio/extconf.rb
+ext/icanhasaudio/get_audio.c
+ext/icanhasaudio/get_audio.h
+ext/icanhasaudio/native.c
+ext/icanhasaudio/native.h
+ext/icanhasaudio/rb_wav.c
+ext/icanhasaudio/rb_wav.h
+lib/icanhasaudio.rb
 lib/icanhasaudio/mpeg.rb
+lib/icanhasaudio/mpeg/decoder.rb
 lib/icanhasaudio/mpeg/encoder.rb
 lib/icanhasaudio/ogg.rb
+lib/icanhasaudio/ogg/decoder.rb
+lib/icanhasaudio/version.rb
+lib/icanhasaudio/wav.rb
+lib/icanhasaudio/wav/file.rb
+test/assets/icha.mp3
 test/assets/testcase.wav
+test/helper.rb
+test/mpeg/test_decoder.rb
 test/test_mpeg_encoder.rb

data/README.txt

@@ -1,5 +1,7 @@
 = Audio::MPEG
 
+  http://icanhasaudio.com/
+  http://github.com/tenderlove/icanhasaudio/tree/master
   http://seattlerb.rubyforge.org/
 
 == DESCRIPTION.  LULZ

data/Rakefile

@@ -4,26 +4,33 @@ $LOAD_PATH.unshift File.join(File.dirname(__FILE__), "lib")
 
 kind = Config::CONFIG["DLEXT"]
 
-Hoe.new('icanhasaudio', '0.1.1') do |p|
+require 'icanhasaudio/version'
+
+Hoe.new('icanhasaudio', Audio::MPEG::Decoder::VERSION) do |p|
   p.rubyforge_name  = 'seattlerb'
   p.author          = 'Aaron Patterson'
   p.email           = 'aaronp@rubyforge.org'
   p.summary         = "icanhasaudio is a lame/vorbis wrapper for decoding ur mp3s and ur oggs."
   p.description     = p.paragraphs_of('README.txt', 3..6).join("\n\n")
   p.url             = p.paragraphs_of('README.txt', 1).first.strip
-  p.spec_extras     = { :extensions => ['ext/extconf.rb'] }
-  p.clean_globs     = ["ext/Makefile", "ext/*.{o,so,bundle,log}"]
+  p.spec_extras     = {
+    :extensions => ['ext/icanhasaudio/extconf.rb']
+  }
+  p.clean_globs     = [
+    "ext/icanhasaudio/Makefile",
+    "ext/icanhasaudio/*.{o,so,bundle,log}"
+  ]
 end
 
 Rake::Task[:test].prerequisites << :extension
 
 desc "I can haz binary"
-task :extension => ["ext/icanhasaudio.#{kind}"]
+task :extension => ["ext/icanhasaudio/native.#{kind}"]
 
-file "ext/Makefile" => "ext/extconf.rb" do
-  Dir.chdir("ext") { ruby "extconf.rb" }
+file "ext/icanhasaudio/Makefile" => "ext/icanhasaudio/extconf.rb" do
+  Dir.chdir("ext/icanhasaudio") { ruby "extconf.rb" }
 end
 
-file "ext/icanhasaudio.#{kind}" => FileList["ext/Makefile", "ext/*.{c,h}"] do
-  Dir.chdir("ext") { sh "make" }
+file "ext/icanhasaudio/native.#{kind}" => FileList["ext/icanhasaudio/Makefile", "ext/icanhasaudio/*.{c,h}"] do
+  Dir.chdir("ext/icanhasaudio") { sh "make" }
 end

data/ext/icanhasaudio/audio_mpeg_decoder.c

@@ -0,0 +1,220 @@
+/*
+ * Most of this code was take from the lame front end.  So thank you to the
+ * lame team!  The good parts are theirs, the bad parts are mine.
+ *
+ * The rest of it is (c) 2007 Aaron Patterson <aaronp@tenderlovemaking.com>
+ *
+ * Released under the GPL
+ */
+#include <audio_mpeg_decoder.h>
+
+static void reader_mark(lame_global_flags * lgf) {}
+static void reader_free(lame_global_flags * gfp) {
+  lame_close(gfp);
+}
+
+/*
+ * call-seq:
+ *    Audio::MPEG::Decoder.new
+ *
+ * Returns a new MPEG Decoder object.
+ */
+static VALUE
+reader_allocate(VALUE klass) {
+  int i = 0;
+  lame_global_flags * gfp = lame_init();
+  lame_set_decode_only(gfp, 1);
+  i = lame_init_params(gfp);
+
+  if(i < 0) {
+    rb_raise(rb_eRuntimeError, "Fatal error during initialization.\n");
+  }
+  lame_decode_init();
+  return Data_Wrap_Struct(klass, reader_mark, reader_free, gfp);
+}
+
+/*
+ * call-seq:
+ *    Audio::MPEG::Decoder.lame_version
+ *
+ * Returns the version of lame you are using.
+ */
+static VALUE method_lame_version(VALUE klass) {
+  const char * version = get_lame_version();
+  return rb_str_new(version, strlen(version));
+}
+
+/*
+ * call-seq:
+ *    decode_headers_for(buffer)
+ *
+ * Decode the mp3 headers for +buffer+.
+ */
+static VALUE decode_headers_for(VALUE self, VALUE rb_buffer)
+{
+  int enc_delay;
+  int enc_padding;
+  mp3data_struct * mp3data;
+
+  unsigned char * buf = (unsigned char *)StringValuePtr(rb_buffer);
+  int len = NUM2INT(rb_funcall(rb_buffer, rb_intern("length"), 0));
+  short int pcm_l[1152], pcm_r[1152];
+
+  VALUE rb_mp3data = rb_funcall(self, rb_intern("mp3data"), 0);
+  Data_Get_Struct(rb_mp3data, mp3data_struct, mp3data);
+
+  int ret = lame_decode1_headersB(buf,
+                                  len,
+                                  pcm_l,
+                                  pcm_r,
+                                  mp3data,
+                                  &enc_delay,
+                                  &enc_padding
+  );
+
+  if(ret == -1)
+    rb_raise(rb_eRuntimeError, "Decode headers failed.\n");
+
+  return rb_mp3data;
+}
+
+/*
+ * call-seq:
+ *    native_decode(input_io, output_io)
+ *
+ * Decode the input IO and write it to the output IO.
+ */
+static VALUE native_decode(VALUE self, VALUE infile, VALUE outf) {
+  lame_global_flags * gfp;
+  short int Buffer[2][1152];
+  int     iread;
+  double  wavsize;
+  int     i;
+  int tmp_num_channels;
+  int skip;
+  VALUE raw;
+  mp3data_struct * mp3data;
+
+  VALUE rb_mp3data = rb_funcall(self, rb_intern("mp3data"), 0);
+  Data_Get_Struct(rb_mp3data, mp3data_struct, mp3data);
+
+  raw = rb_iv_get(self, "@raw");
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  tmp_num_channels = lame_get_num_channels( gfp );
+  lame_set_num_samples(gfp, MAX_U_32_NUM);
+
+  skip = lame_get_encoder_delay(gfp)+528+1;
+
+  rb_iv_set(self, "@bits", INT2NUM(16));
+
+  wavsize = -skip;
+  if(lame_get_num_samples(gfp) == MAX_U_32_NUM) {
+    rb_funcall(self, rb_intern("determine_samples_for"), 1, infile);
+  }
+  mp3data->totalframes = mp3data->nsamp / mp3data->framesize;
+
+  assert(tmp_num_channels >= 1 && tmp_num_channels <= 2);
+
+  do {
+    char BitBuffer16[1152 * 4];
+    int bit_16_i = 0;
+    iread = get_audio16(self, infile, Buffer, mp3data);
+    mp3data->framenum += iread / mp3data->framesize;
+    wavsize += iread;
+
+    memset(&BitBuffer16, 0, 1152 * 4);
+
+    skip -= (i = skip < iread ? skip : iread); /* 'i' samples are to skip in this frame */
+
+    for (; i < iread; i++) {
+      /* Write the 0 channel */
+      BitBuffer16[bit_16_i] = Buffer[0][i] & 0xFF;
+      BitBuffer16[bit_16_i + 1] = ((Buffer[0][i] >> 8) & 0xFF);
+
+      if (tmp_num_channels == 2) {
+        BitBuffer16[bit_16_i + 2] = Buffer[1][i] & 0xFF;
+        BitBuffer16[bit_16_i + 3] = ((Buffer[1][i] >> 8) & 0xFF);
+        bit_16_i += 4;
+      } else {
+        bit_16_i += 2;
+      }
+    }
+    rb_funcall(outf, rb_intern("write"), 1, rb_str_new(BitBuffer16, bit_16_i));
+  } while (iread);
+
+  i = (16 / 8) * tmp_num_channels;
+  assert(i > 0);
+  if (wavsize <= 0) {
+      wavsize = 0;
+  }
+  else if (wavsize > 0xFFFFFFD0 / i) {
+      wavsize = 0xFFFFFFD0;
+  }
+  else {
+      wavsize *= i;
+  }
+
+  rb_iv_set(self, "@wavsize", INT2NUM(wavsize));
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *    num_channels
+ *
+ * Get the number of channels
+ */
+static VALUE get_num_channels(VALUE self)
+{
+  lame_global_flags * gfp;
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_num_channels(gfp));
+}
+
+/*
+ * call-seq:
+ *    num_samples=(number)
+ *
+ * Set the number of samples
+ */
+static VALUE set_num_samples(VALUE self, VALUE sample_count)
+{
+  lame_global_flags * gfp;
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_num_samples(gfp, NUM2INT(sample_count));
+  return sample_count;
+}
+
+/*
+ * call-seq:
+ *    in_samplerate
+ *
+ * Get the input samplerate
+ */
+static VALUE get_in_samplerate(VALUE self)
+{
+  lame_global_flags * gfp;
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_in_samplerate(gfp));
+}
+
+void init_audio_mpeg_decoder() {
+  VALUE rb_mAudio = rb_define_module("Audio");
+  VALUE rb_mMpeg = rb_define_module_under(rb_mAudio, "MPEG");
+  VALUE rb_cDecoder = rb_define_class_under(rb_mMpeg, "Decoder", rb_cObject);
+
+  rb_define_singleton_method(
+      rb_cDecoder,
+      "lame_version",
+      method_lame_version,
+      0
+  );
+
+  rb_define_alloc_func(rb_cDecoder, reader_allocate);
+  rb_define_method(rb_cDecoder, "num_samples=", set_num_samples, 1);
+  rb_define_method(rb_cDecoder, "in_samplerate", get_in_samplerate, 0);
+  rb_define_private_method(rb_cDecoder, "native_decode", native_decode, 2);
+  rb_define_private_method(rb_cDecoder, "decode_headers_for", decode_headers_for, 1);
+  rb_define_private_method(rb_cDecoder, "num_channels", get_num_channels, 0);
+}

data/ext/icanhasaudio/audio_mpeg_decoder.h

@@ -0,0 +1,8 @@
+#ifndef AUDIO_MPEG_DECODER_H
+#define AUDIO_MPEG_DECODER_H
+
+#include <native.h>
+
+void init_audio_mpeg_decoder();
+
+#endif

data/ext/icanhasaudio/audio_mpeg_decoder_mp3data.c

@@ -0,0 +1,96 @@
+#include <audio_mpeg_decoder_mp3data.h>
+
+/*
+ * call-seq:
+ *    header_parsed?
+ *
+ * Has the mp3 header been parsed yet?
+ */
+static VALUE header_parsed_eh(VALUE self)
+{
+  mp3data_struct * mp3data;
+  Data_Get_Struct(self, mp3data_struct, mp3data);
+
+  if(mp3data->header_parsed == 1) return Qtrue;
+  return Qfalse;
+}
+
+/*
+ * call-seq:
+ *    bitrate
+ *
+ * Get the bitrate
+ */
+static VALUE bitrate(VALUE self)
+{
+  mp3data_struct * mp3data;
+  Data_Get_Struct(self, mp3data_struct, mp3data);
+  return INT2NUM(mp3data->bitrate);
+}
+
+/*
+ * call-seq:
+ *    total_frames
+ *
+ * Get the total frames for this mp3
+ */
+static VALUE total_frames(VALUE self)
+{
+  mp3data_struct * mp3data;
+  Data_Get_Struct(self, mp3data_struct, mp3data);
+  return INT2NUM(mp3data->totalframes);
+}
+
+/*
+ * call-seq:
+ *    nsamp
+ *
+ * Get the number of samples
+ */
+static VALUE get_nsamp(VALUE self)
+{
+  mp3data_struct * mp3data;
+  Data_Get_Struct(self, mp3data_struct, mp3data);
+  return LONG2NUM(mp3data->nsamp);
+}
+
+/*
+ * call-seq:
+ *    nsamp=(num)
+ *
+ * Set the number of samples to +num+
+ */
+static VALUE set_nsamp(VALUE self, VALUE num)
+{
+  mp3data_struct * mp3data;
+  Data_Get_Struct(self, mp3data_struct, mp3data);
+  mp3data->nsamp = NUM2LONG(num);
+  return num;
+}
+
+static VALUE deallocate(mp3data_struct * mp3data)
+{
+  free(mp3data);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  mp3data_struct * mp3data = calloc(1, sizeof(mp3data_struct));
+  return Data_Wrap_Struct(klass, 0, deallocate, mp3data);
+}
+
+void init_audio_mpeg_decoder_mp3data()
+{
+  VALUE rb_mAudio = rb_define_module("Audio");
+  VALUE rb_mMpeg = rb_define_module_under(rb_mAudio, "MPEG");
+  VALUE rb_cDecoder = rb_define_class_under(rb_mMpeg, "Decoder", rb_cObject);
+  VALUE klass = rb_define_class_under(rb_cDecoder, "MP3Data", rb_cObject);
+
+  rb_const_set(klass, rb_intern("MAX_U_32_NUM"), INT2NUM(MAX_U_32_NUM));
+  rb_define_method(klass, "header_parsed?", header_parsed_eh, 0);
+  rb_define_method(klass, "bitrate", bitrate, 0);
+  rb_define_method(klass, "total_frames", total_frames, 0);
+  rb_define_method(klass, "nsamp", get_nsamp, 0);
+  rb_define_method(klass, "nsamp=", set_nsamp, 1);
+  rb_define_alloc_func(klass, allocate);
+}

data/ext/icanhasaudio/audio_mpeg_decoder_mp3data.h

@@ -0,0 +1,8 @@
+#ifndef AUDIO_MPEG_DECODER_MP3DATA
+#define AUDIO_MPEG_DECODER_MP3DATA
+
+#include <native.h>
+
+void init_audio_mpeg_decoder_mp3data();
+
+#endif