icanhasaudio 0.0.3 → 0.1.0

data/History.txt

@@ -1,3 +1,8 @@
+== 0.1.0
+
+* 1 major enhancement
+  * Added MPEG Encoder
+
 == 0.0.3
 * 1 minor enhancement
   * Fixed extconf to be a little more smart.

data/Manifest.txt

@@ -4,6 +4,7 @@ Manifest.txt
 README.txt
 Rakefile
 examples/decoder.rb
+examples/encoder.rb
 examples/kexp.rb
 ext/decoder.c
 ext/decoder.h
@@ -11,10 +12,16 @@ 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
 lib/icanhasaudio/mpeg.rb
+lib/icanhasaudio/mpeg/encoder.rb
 lib/icanhasaudio/ogg.rb
+test/assets/testcase.wav
+test/test_mpeg_encoder.rb

data/README.txt

@@ -5,7 +5,8 @@
 == DESCRIPTION.  LULZ
 
 Hai! icanhasaudio? is an interface to lame for decoding ur MP3s.  I iz in ur
-computer. Decodin ur mp3s.  Whatevs!  I also decodin ur OGGz!
+computer. Decodin ur mp3s.  Whatevs!  I also decodin ur OGGz!  I kin also
+encodin' ur WAV and AIFF to mp3z!
 
 == SYNOPSYS ROFLOL
 
@@ -23,15 +24,27 @@ Or even smaller:
   reader = Audio::OGG::Decoder.new
   reader.decode(File.open(ARGV[0], 'rb'), File.open(ARGV[1], 'wb'))
 
+Encoder!!!!!! LOL
+
+  writer = Audio::MPEG::Encoder.new
+  File.open(ARGV[0]), 'rb') { |wav_lol|
+    File.open(ARGV[1]), 'wb+') { |mp3_lol|
+      writer.encode(wav_lol, mp3_lol)
+    }
+  }
+
 == PROBLEMS
 
-Currently only decodes MP3/OGG data.  Plus many other problems....  YMMV. LOL.
+Currently only decodes MP3/OGG data.  Also encodes WAV/AIFF to mp3. Plus many
+other problems....  YMMV. LOL.
 Not laugh plz!
 
 == DEPENDENSEEZ
 
 Make sure lame is installed on ur 'puter.  Also ogg and vorbisfile!
 
+  # port install libvorbis vorbis-tools lame
+
 == CREDITZ
 
 Thanx Ryan for mah name!  Also, most of this code was taken from the lame

data/Rakefile

@@ -2,7 +2,9 @@ require 'hoe'
 
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), "lib")
 
-Hoe.new('icanhasaudio', '0.0.3') do |p|
+kind = Config::CONFIG["DLEXT"]
+
+Hoe.new('icanhasaudio', '0.1.0') do |p|
   p.rubyforge_name  = 'seattlerb'
   p.author          = 'Aaron Patterson'
   p.email           = 'aaronp@rubyforge.org'
@@ -11,5 +13,18 @@ Hoe.new('icanhasaudio', '0.0.3') do |p|
   p.url             = p.paragraphs_of('README.txt', 1).first.strip
   p.changes         = p.paragraphs_of('History.txt', 0..2).join("\n\n")
   p.spec_extras     = { :extensions => ['ext/extconf.rb'] }
+  p.clean_globs     = ["ext/Makefile", "ext/*.{o,so,bundle,log}"]
+end
+
+Rake::Task[:test].prerequisites << :extension
+
+desc "I can haz binary"
+task :extension => ["ext/icanhasaudio.#{kind}"]
+
+file "ext/Makefile" => "ext/extconf.rb" do
+  Dir.chdir("ext") { ruby "extconf.rb" }
 end
 
+file "ext/icanhasaudio.#{kind}" => FileList["ext/Makefile", "ext/*.{c,h}"] do
+  Dir.chdir("ext") { sh "make" }
+end

data/examples/encoder.rb

@@ -0,0 +1,28 @@
+require 'icanhasaudio'
+
+include Audio::MPEG
+
+writer = Encoder.new
+
+### NOTE:  All of these settings are optional ###
+# The default setup is 128kbps minimum plus VBR.
+
+# Set up the encoder to be 128kbps, NON-VBR
+writer.bitrate  = 128
+writer.vbr_type = Encoder::VBR_OFF
+
+# Set the ID3 tags
+writer.title  = 'tenderlovemaking.com'
+writer.artist = 'Aaron Patterson'
+writer.album  = 'ICANHASAUDIO'
+writer.year   = 2008
+writer.track  = 1
+writer.genre  = 'Porn Groove'
+
+# Make sure to open your outfile as read and write.  Writing VBR tags requires
+# seeking through the file.
+File.open(ARGV[1], 'wb+') { |outfile|
+  File.open(ARGV[0], 'rb') { |infile|
+    writer.encode(infile, outfile)
+  }
+}

data/ext/extconf.rb

@@ -1,3 +1,5 @@
+ENV["ARCHFLAGS"] = "-arch #{`uname -p` =~ /powerpc/ ? 'ppc' : 'i386'}"
+
 require 'mkmf'
 
 def exit_failure(msg)

data/ext/get_audio.c

@@ -10,6 +10,10 @@ get_audio_common(VALUE self, VALUE musicin,
 		  int buffer[2][1152], short buffer16[2][1152],
       mp3data_struct * mp3data);
 
+int get_audio_pcm(VALUE self, VALUE musicin, int buffer[2][1152]) {
+  return 0;
+}
+
 static int
 read_samples_mp3(VALUE self, VALUE musicin,
     short int mpg123pcm[2][1152], int stereo, mp3data_struct * mp3data);

data/ext/get_audio.h

@@ -1,4 +1,11 @@
+#ifndef GET_AUDIO_H
+#define GET_AUDIO_H
+
 #define MAX_U_32_NUM 0xFFFFFFFF
 int
 get_audio16(VALUE self, VALUE musicin, short buffer[2][1152],
     mp3data_struct * mp3data);
+
+int get_audio_pcm(VALUE self, VALUE musicin, int buffer[2][1152]);
+
+#endif

data/ext/icanhasaudio.c

@@ -6,11 +6,10 @@
  *
  * Released under the GPL
  */
-#include <ruby.h>
-#include <lame/lame.h>
-#include <dlfcn.h>
+#include "icanhasaudio.h"
 #include "syncword.h"
 #include "decoder.h"
+#include "mpeg_encoder.h"
 #include "get_audio.h"
 
 static VALUE rb_mAudio;
@@ -164,8 +163,8 @@ void Init_icanhasaudio() {
   rb_mOgg = rb_define_module_under(rb_mAudio, "OGG");
   rb_cOggDecoder = rb_define_class_under(rb_mOgg, "Decoder", rb_cObject);
 
-  /* VERSION = '0.0.3' */
-  rb_define_const(rb_cDecoder, "VERSION", rb_str_new2("0.0.3"));
+  /* VERSION = '0.1.0' */
+  rb_define_const(rb_cDecoder, "VERSION", rb_str_new2("0.1.0"));
   rb_define_singleton_method(
       rb_cDecoder,
       "lame_version",
@@ -176,6 +175,8 @@ void Init_icanhasaudio() {
   rb_define_alloc_func(rb_cDecoder, reader_allocate);
   rb_define_method(rb_cDecoder, "decode", method_lame_decode, 2);
   rb_define_method(rb_cOggDecoder, "decode", method_ogg_decode, 2);
+
+  init_MpegEncoder(rb_mMpeg);
   rb_require("icanhasaudio/mpeg");
   rb_require("icanhasaudio/ogg");
 }

data/ext/icanhasaudio.h

@@ -0,0 +1,8 @@
+#ifndef ICANHASAUDIO_H
+#define ICANHASAUDIO_H
+
+#include <ruby.h>
+#include <lame/lame.h>
+#include <dlfcn.h>
+
+#endif

data/ext/mpeg_encoder.c

@@ -0,0 +1,528 @@
+#include "mpeg_encoder.h"
+#include <rubyio.h>
+
+static VALUE cMpegEncoder;
+
+static void encoder_free(lame_global_flags * gfp) {
+  lame_close(gfp);
+}
+
+/*
+ * call-seq:
+ *    Audio::MPEG::Encoder.new
+ *
+ * Returns a new MPEG Encoder object.
+ */
+static VALUE
+encoder_allocate(VALUE klass) {
+  lame_global_flags * gfp = lame_init();
+  id3tag_init(gfp);
+
+  return Data_Wrap_Struct(klass, NULL, encoder_free, gfp);
+}
+
+/* Public methods. */
+
+/*
+ * call-seq:
+ *    encoder.vbr_hard_min=
+ *
+ * Strictly enforce the vbr min bitrate.  Normally it will be violated for
+ * analog silence.
+ */
+static VALUE MpegEncoder_set_vbr_hard_min(VALUE self, VALUE boolean) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_VBR_hard_min(gfp, boolean == Qtrue ? 1 : 0);
+  return boolean;
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_hard_min?
+ *
+ *  Get the hard minimum flag. 
+ */
+static VALUE MpegEncoder_get_vbr_hard_min(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return lame_get_VBR_hard_min(gfp) == 0 ? Qfalse : Qtrue;
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_max_bitrate=
+ *
+ * Set the maximum vbr bitrate.
+ */
+static VALUE MpegEncoder_set_vbr_max_bitrate(VALUE self, VALUE brate) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_VBR_max_bitrate_kbps(gfp, NUM2INT(brate));
+  return brate;
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_max_bitrate
+ *
+ * Get the maximum vbr bitrate.
+ */
+static VALUE MpegEncoder_get_vbr_max_bitrate(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_VBR_max_bitrate_kbps(gfp));
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_min_bitrate=
+ *
+ * Set the minimum vbr bitrate.
+ */
+static VALUE MpegEncoder_set_vbr_min_bitrate(VALUE self, VALUE brate) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_VBR_min_bitrate_kbps(gfp, NUM2INT(brate));
+  return brate;
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_min_bitrate
+ *
+ * Get the minimum vbr bitrate.
+ */
+static VALUE MpegEncoder_get_vbr_min_bitrate(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_VBR_min_bitrate_kbps(gfp));
+}
+
+/*
+ * call-seq:
+ *    encoder.bitrate=
+ *
+ * Set the bitrate.
+ */
+static VALUE MpegEncoder_set_bitrate(VALUE self, VALUE brate) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_brate(gfp, NUM2INT(brate));
+  lame_set_VBR_min_bitrate_kbps(gfp, lame_get_brate(gfp));
+  return brate;
+}
+
+/*
+ * call-seq:
+ *    encoder.bitrate
+ *
+ * Get the bitrate.
+ */
+static VALUE MpegEncoder_get_bitrate(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_brate(gfp));
+}
+
+/*
+ * call-seq:
+ *    encoder.quality=
+ *
+ * Set the VBR quality. 0 = highest, 9 = lowest
+ */
+static VALUE MpegEncoder_set_vbr_quality(VALUE self, VALUE quality) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_VBR_q(gfp, NUM2INT(quality));
+  return quality;
+}
+
+/*
+ * call-seq:
+ *    encoder.quality
+ *
+ * Get the VBR quality. 0 = highest, 9 = lowest
+ */
+static VALUE MpegEncoder_get_vbr_quality(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_VBR_q(gfp));
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_type=
+ *
+ * Set the type of VBR. Must be VBR_OFF, VBR_NORMAL, or VBR_FAST
+ */
+static VALUE MpegEncoder_set_vbr_type(VALUE self, VALUE type) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_VBR(gfp, NUM2INT(type));
+  return type;
+}
+
+/*
+ * call-seq:
+ *    encoder.vbr_type
+ *
+ * Get the type of VBR.
+ */
+static VALUE MpegEncoder_get_vbr_type(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_VBR(gfp));
+}
+
+/*
+ * call-seq:
+ *    encoder.print_config
+ *
+ * Print the encoder configuration.
+ */
+static VALUE MpegEncoder_print_config(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_print_config(gfp);
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *    encoder.artist=
+ *
+ * Set the ID3 artist.
+ */
+static VALUE MpegEncoder_set_artist(VALUE self, VALUE artist) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  id3tag_set_artist(gfp, StringValuePtr(artist));
+  return artist;
+}
+
+/*
+ * call-seq:
+ *    encoder.title=
+ *
+ * Set the ID3 title.
+ */
+static VALUE MpegEncoder_set_title(VALUE self, VALUE title) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  id3tag_set_title(gfp, StringValuePtr(title));
+  return title;
+}
+
+/*
+ * call-seq:
+ *    encoder.album=
+ *
+ * Set the ID3 album.
+ */
+static VALUE MpegEncoder_set_album(VALUE self, VALUE album) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  id3tag_set_album(gfp, StringValuePtr(album));
+  return album;
+}
+
+/*
+ * call-seq:
+ *    encoder.year=
+ *
+ * Set the ID3 year.
+ */
+static VALUE MpegEncoder_set_year(VALUE self, VALUE year) {
+  lame_global_flags * gfp;
+  VALUE * year_string;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  year_string = rb_funcall(year, rb_intern("to_s"), 0);
+  id3tag_set_year(gfp, StringValuePtr(year_string));
+  return year;
+}
+
+/*
+ * call-seq:
+ *    encoder.track=
+ *
+ * Set the ID3 track.
+ */
+static VALUE MpegEncoder_set_track(VALUE self, VALUE track) {
+  lame_global_flags * gfp;
+  int track_number;
+  VALUE * track_string;
+
+  track_number = NUM2INT(track);
+  if(track < 0 || track > 255)
+    rb_raise(rb_eRuntimeError, "Track must be between 0 and 255.\n");
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  track_string = rb_funcall(track, rb_intern("to_s"), 0);
+  id3tag_set_track(gfp, StringValuePtr(track_string));
+  return track;
+}
+
+/*
+ * call-seq:
+ *    encoder.genre=
+ *
+ * Set the ID3 genre.
+ */
+static VALUE MpegEncoder_set_genre(VALUE self, VALUE genre) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  id3tag_set_genre(gfp, StringValuePtr(genre));
+  return genre;
+}
+
+/* Private methods. */
+
+static VALUE MpegEncoder_write_vbr_tag(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  if(lame_get_bWriteVbrTag(gfp))
+    return Qtrue;
+  return Qfalse;
+}
+
+static VALUE MpegEncoder_print_internals(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_print_internals(gfp);
+  return Qnil;
+}
+
+static VALUE MpegEncoder_get_mpeg_quality(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_quality(gfp));
+}
+
+static VALUE MpegEncoder_get_compression_ratio(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return rb_float_new(lame_get_compression_ratio(gfp));
+}
+
+static VALUE MpegEncoder_get_mpeg_version(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_version(gfp));
+}
+
+static VALUE MpegEncoder_get_mpeg_mode(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_mode(gfp));
+}
+
+static VALUE MpegEncoder_get_force_ms(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_force_ms(gfp));
+}
+
+static VALUE MpegEncoder_get_out_samplerate(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_out_samplerate(gfp));
+}
+
+static VALUE MpegEncoder_set_in_samplerate(VALUE self, VALUE samplerate) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_in_samplerate(gfp, NUM2INT(samplerate));
+  return samplerate;
+}
+
+static VALUE MpegEncoder_set_num_samples(VALUE self, VALUE num_samples) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_num_samples(gfp, NUM2ULONG(num_samples));
+  return num_samples;
+}
+
+static VALUE MpegEncoder_get_num_samples(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return ULONG2NUM(lame_get_num_samples(gfp));
+}
+
+static VALUE MpegEncoder_set_num_channels(VALUE self, VALUE num_channels) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_set_num_channels(gfp, NUM2INT(num_channels));
+  return num_channels;
+}
+
+static VALUE MpegEncoder_get_num_channels(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_num_channels(gfp));
+}
+
+static VALUE MpegEncoder_get_framesize(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  return INT2NUM(lame_get_framesize(gfp));
+}
+
+static VALUE MpegEncoder_encoder_buffer(VALUE self, VALUE left, VALUE right) {
+  unsigned char mp3buffer[LAME_MAXMP3BUFFER];
+  int * buffer_left;
+  int * buffer_right;
+  int length, i;
+  int imp3;
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+
+  length = NUM2INT(rb_funcall(left, rb_intern("length"), 0));
+  buffer_left = calloc(length, sizeof(int));
+  buffer_right = calloc(length, sizeof(int));
+
+  for(i = 0; i < length; i++) {
+    buffer_left[i] = NUM2UINT(rb_funcall(left, rb_intern("[]"), 1, INT2NUM(i)));
+    buffer_right[i] = NUM2UINT(rb_funcall(right, rb_intern("[]"), 1,INT2NUM(i)));
+  }
+
+  imp3 = lame_encode_buffer_int(gfp, buffer_left, buffer_right, length,
+    mp3buffer, sizeof(mp3buffer));
+
+  free(buffer_left);
+  free(buffer_right);
+
+  if(imp3 < 0) {
+    if(imp3 == -1)
+      rb_raise(rb_eRuntimeError, "Mp3 buffer is not big enough.\n");
+    else
+      rb_raise(rb_eRuntimeError, "internal error.\n");
+  }
+  return rb_str_new(mp3buffer, imp3);
+}
+
+static VALUE MpegEncoder_flush(VALUE self) {
+  unsigned char mp3buffer[LAME_MAXMP3BUFFER];
+  int imp3;
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  imp3 = lame_encode_flush(gfp, mp3buffer, sizeof(mp3buffer));
+  if(imp3 < 0) {
+    if(imp3 == -1)
+      rb_raise(rb_eRuntimeError, "Mp3 buffer is not big enough.\n");
+    else
+      rb_raise(rb_eRuntimeError, "internal error.\n");
+  }
+  return rb_str_new(mp3buffer, imp3);
+}
+
+static VALUE MpegEncoder_write_vbr_tags(VALUE self, VALUE outfile) {
+  OpenFile *fp;
+  lame_global_flags * gfp;
+
+  GetOpenFile(outfile, fp);
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  lame_mp3_tags_fid(gfp, fp->f);
+  return Qnil;
+}
+
+static VALUE MpegEncoder_init_params(VALUE self) {
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+
+  if(lame_init_params(gfp) < 0) {
+    rb_raise(rb_eRuntimeError, "Fatal error during initialization.\n");
+  }
+
+  return Qnil;
+}
+
+void init_MpegEncoder(VALUE rb_mMpeg) {
+  /*
+  rb_mAudio = rb_define_module("Audio");
+  rb_mMpeg = rb_define_module_under(rb_mAudio, "MPEG");
+  */
+  /*
+   * Encode mp3s
+   */
+  cMpegEncoder = rb_define_class_under(rb_mMpeg, "Encoder", rb_cObject);
+  rb_define_alloc_func(cMpegEncoder, encoder_allocate);
+
+  /* Public Methods */
+
+  rb_define_method(cMpegEncoder, "vbr_quality=",MpegEncoder_set_vbr_quality, 1);
+  rb_define_method(cMpegEncoder, "vbr_quality", MpegEncoder_get_vbr_quality, 0);
+  rb_define_method(cMpegEncoder, "vbr_type=", MpegEncoder_set_vbr_type, 1);
+  rb_define_method(cMpegEncoder, "vbr_type", MpegEncoder_get_vbr_type, 0);
+  rb_define_method(cMpegEncoder, "print_config", MpegEncoder_print_config, 0);
+  rb_define_method(cMpegEncoder, "title=", MpegEncoder_set_title, 1);
+  rb_define_method(cMpegEncoder, "artist=", MpegEncoder_set_artist, 1);
+  rb_define_method(cMpegEncoder, "album=", MpegEncoder_set_album, 1);
+  rb_define_method(cMpegEncoder, "year=", MpegEncoder_set_year, 1);
+  rb_define_method(cMpegEncoder, "track=", MpegEncoder_set_track, 1);
+  rb_define_method(cMpegEncoder, "genre=", MpegEncoder_set_genre, 1);
+  rb_define_method(cMpegEncoder, "bitrate=", MpegEncoder_set_bitrate, 1);
+  rb_define_method(cMpegEncoder, "bitrate", MpegEncoder_get_bitrate, 0);
+  rb_define_method(cMpegEncoder, "vbr_min_bitrate=", MpegEncoder_set_vbr_min_bitrate, 1);
+  rb_define_method(cMpegEncoder, "vbr_min_bitrate", MpegEncoder_get_vbr_min_bitrate, 0);
+  rb_define_method(cMpegEncoder, "vbr_max_bitrate=", MpegEncoder_set_vbr_max_bitrate, 1);
+  rb_define_method(cMpegEncoder, "vbr_max_bitrate", MpegEncoder_get_vbr_max_bitrate, 0);
+  rb_define_method(cMpegEncoder, "vbr_hard_min=", MpegEncoder_set_vbr_hard_min, 1);
+  rb_define_method(cMpegEncoder, "vbr_hard_min?", MpegEncoder_get_vbr_hard_min, 0);
+
+
+  rb_define_private_method(cMpegEncoder, "init_params", MpegEncoder_init_params, 0);
+  rb_define_private_method(cMpegEncoder, "num_channels=", MpegEncoder_set_num_channels, 1);
+  rb_define_private_method(cMpegEncoder, "num_channels", MpegEncoder_get_num_channels, 0);
+  rb_define_private_method(cMpegEncoder, "in_samplerate=", MpegEncoder_set_in_samplerate, 1);
+  rb_define_private_method(cMpegEncoder, "num_samples=", MpegEncoder_set_num_samples, 1);
+  rb_define_private_method(cMpegEncoder, "num_samples", MpegEncoder_get_num_samples, 0);
+  rb_define_private_method(cMpegEncoder, "out_samplerate", MpegEncoder_get_out_samplerate, 0);
+  rb_define_private_method(cMpegEncoder, "framesize", MpegEncoder_get_framesize, 0);
+  rb_define_private_method(cMpegEncoder, "encode_buffer", MpegEncoder_encoder_buffer, 2);
+  rb_define_private_method(cMpegEncoder, "flush", MpegEncoder_flush, 0);
+  rb_define_private_method(cMpegEncoder, "write_vbr_tags", MpegEncoder_write_vbr_tags, 1);
+  rb_define_private_method(cMpegEncoder, "force_ms", MpegEncoder_get_force_ms, 0);
+  rb_define_private_method(cMpegEncoder, "mpeg_mode", MpegEncoder_get_mpeg_mode, 0);
+  rb_define_private_method(cMpegEncoder, "mpeg_version", MpegEncoder_get_mpeg_version, 0);
+  rb_define_private_method(cMpegEncoder, "compression_ratio", MpegEncoder_get_compression_ratio, 0);
+  rb_define_private_method(cMpegEncoder, "mpeg_quality", MpegEncoder_get_mpeg_quality, 0);
+  rb_define_private_method(cMpegEncoder, "print_internals", MpegEncoder_print_internals, 0);
+  rb_define_private_method(cMpegEncoder, "write_vbr_tag?", MpegEncoder_write_vbr_tag, 0);
+}

data/ext/mpeg_encoder.h

@@ -0,0 +1,10 @@
+#ifndef MPEG_ENCODER_H
+#define MPEG_ENCODER_H
+
+#include "icanhasaudio.h"
+#include "get_audio.h"
+
+#define LAME_MAXMP3BUFFER 16384
+void init_MpegEncoder(VALUE mMpeg);
+
+#endif

data/lib/icanhasaudio/mpeg.rb

@@ -1,3 +1,5 @@
+require 'icanhasaudio/mpeg/encoder'
+
 class Audio::MPEG::Decoder
   attr_reader :stereo, :samplerate, :bitrate, :mode, :mode_ext, :framesize
 

data/lib/icanhasaudio/mpeg/encoder.rb

@@ -0,0 +1,241 @@
+module Audio
+  module MPEG
+    class Encoder
+      WAV_ID_RIFF = 0x52494646
+      WAV_ID_WAVE = 0x57415645 # "WAVE"
+      WAV_ID_FMT  = 0x666d7420 # "fmt "
+      WAV_ID_DATA = 0x64617461 # "data"
+
+      IFF_ID_FORM = 0x464f524d # "FORM"
+      IFF_ID_AIFF = 0x41494646 # "AIFF"
+      IFF_ID_AIFC = 0x41494643 # "AIFC"
+      IFF_ID_COMM = 0x434f4d4d # "COMM"
+      IFF_ID_SSND = 0x53534e44 # "SSND"
+
+      IFF_ID_NONE = 0x4e4f4e45 # "NONE" AIFF-C data format
+      IFF_ID_2CBE = 0x74776f73 # "twos" AIFF-C data format
+      IFF_ID_2CLE = 0x736f7774 # "sowt" AIFF-C data format
+      
+
+      VBR_OFF     = 0
+      VBR_NORMAL  = 2
+      VBR_FAST    = 4
+
+      MODE_NAMES = [
+        [ 'stereo', 'j-stereo', 'dual-ch', 'single-ch' ],
+        [ 'stereo', 'force-ms', 'dual-ch', 'single-ch' ],
+      ]
+
+      attr_accessor :pcmbitwidth
+      attr_accessor :logger
+      def initialize
+        @pcmbitwidth = 16
+        @logger = nil
+        self.vbr_quality = 2
+        self.vbr_type    = VBR_NORMAL
+      end
+
+      def encode(infile, outfile)
+        raise "Out file must be a FILE.  :-(" unless outfile.is_a?(File)
+
+        num_samples = 0xFFFFFFFF
+        parse_header(infile)
+        init_params
+
+        logger.debug(encoding_info) if logger
+
+        num_samples_read = 0
+
+        sw = case @pcmbitwidth
+             when 8
+               32 - 8
+             when 16
+               32 - 16
+             when 24
+               32 - 24
+             end
+        while !infile.eof?
+          tmp_num_samples = num_samples()
+          samples_to_read = framesize()
+          remaining = tmp_num_samples - [tmp_num_samples, num_samples_read].min
+          if remaining < framesize && 0 != tmp_num_samples
+            samples_to_read = remaining
+          end
+
+          read_size = num_channels * samples_to_read * (pcmbitwidth / 8)
+
+          samples = infile.read(read_size)
+          samples_read = samples.length / num_channels
+
+          buffers = [[], []]
+          samples.unpack('v*').each_with_index do |b,i|
+            (buffers[(i % 2)]) << (b << sw)
+          end
+          outfile.write(encode_buffer(buffers[0], buffers[1]))
+        end
+        outfile.write(flush())
+        write_vbr_tags(outfile) if write_vbr_tag?
+      end
+
+      private
+      def encoding_info
+        sprintf("Encoding as %g kHz ", 1e-3 * out_samplerate) +
+        sprintf("VBR(q=%i)", vbr_quality) +
+        sprintf(" %s MPEG-%u%s Layer III (%s%gx) qval=%i\n",
+               MODE_NAMES[force_ms][mpeg_mode],
+               2 - mpeg_version,
+               out_samplerate < 16000 ? ".5" : '',
+               '',
+               0.1 * (10.0 * compression_ratio + 0.5).to_i,
+               mpeg_quality)
+      end
+
+      def parse_header(file)
+        header = file.read(4).unpack('N').first
+        case header
+        when WAV_ID_RIFF # Wave file
+          parse_wave_header(file)
+        when IFF_ID_FORM # AIFF file
+          parse_aiff_header(file)
+        else
+          $stderr.puts "Assuming RAW PCM"
+          file.rewind
+        end
+      end
+
+      def parse_aiff_header(file)
+        chunk_size  = file.read(4).unpack('N').first
+        type_id     = file.read(4).unpack('N').first
+
+        raise unless [IFF_ID_AIFF, IFF_ID_AIFC].any? { |x| type_id == x }
+
+        sub_size = 0
+        sample_type = nil
+        sample_size = nil
+        num_channels = nil
+        block_size = nil
+        sample_rate = nil
+        is_aiff = false
+        while chunk_size > 0
+          type = file.read(4).unpack('N').first
+          chunk_size -= 4
+
+          case type
+          when IFF_ID_COMM
+            sub_size = file.read(4).unpack('N').first
+            chunk_size -= 4
+
+            num_channels = file.read(2).unpack('n').first
+            sub_size -= 2
+            num_sample_frames = file.read(4).unpack('N').first
+            sub_size -= 4
+            sample_size = file.read(2).unpack('n').first
+            sub_size -= 2
+            sample_rate = unpack_ieee(file.read(10))
+            sub_size -= 10
+
+            if type_id == IFF_ID_AIFC
+              data_type = file.read(4).unpack('N').first
+              sub_size -=4
+
+              raise unless [  IFF_ID_2CLE,
+                              IFF_ID_2CBE,
+                              IFF_ID_NONE,
+              ].any? { |x| data_type == x }
+
+              #if sample_size == 16
+              # swap bytes....
+            end
+
+            file.read(sub_size)
+          when IFF_ID_SSND
+            sub_size = file.read(4).unpack('N').first
+            chunk_size -= sub_size
+
+            block_offset = file.read(4).unpack('N').first
+            sub_size -= 4
+            block_size = file.read(4).unpack('N').first
+            sub_size -= 4
+
+            sample_type = IFF_ID_SSND
+            file.read(block_offset)
+            is_aiff = true
+            break
+          else
+            sub_size = file.read(4).unpack('N').first
+            chunk_size -= sub_size
+            file.read(sub_size)
+          end
+        end
+
+        # Validate the header
+        if is_aiff
+          raise "Sound data is not PCM" unless sample_type == IFF_ID_SSND
+          raise "Sound data is not 16 bits" unless sample_size == 16
+          unless num_channels == 1 || num_channels == 2
+            raise "Sound data is not mono or stereo" 
+          end
+          raise "Block size is not 0 bytes" unless block_size == 0
+        end
+
+        @pcmbitwidth = sample_size
+        self.num_channels = num_channels
+        self.in_samplerate = sample_rate.to_i
+        self.num_samples = num_sample_frames
+      end
+
+      def unpack_ieee(data)
+        (expon, hi_mant, lo_mant) = data.unpack('nNN')
+        expon -= 16383
+        hi_mant * (2 ** (expon -= 31)) + lo_mant * (2 ** (expon -= 32))
+      end
+
+      def parse_wave_header(file)
+        format_tag        = nil
+        channels          = nil
+        samples_per_sec   = nil
+        avg_bytes_per_sec = nil
+        block_align       = nil
+        bits_per_sample   = nil
+        is_wav            = false
+        data_length       = 0
+
+        file_length = file.read(4).unpack('N').first
+        raise "Corrupt wave" if file.read(4).unpack('N').first != WAV_ID_WAVE
+        20.times {
+          type = file.read(4).unpack('N').first
+          case type
+          when WAV_ID_FMT
+            sub_size = file.read(4).unpack('V').first
+            raise "Corrupt wave" if sub_size < 16
+
+            ( format_tag,
+              channels, 
+              samples_per_sec,
+              avg_bytes_per_sec,
+              block_align, bits_per_sample) = *(file.read(16).unpack('vvVVvv'))
+            sub_size -= 16
+
+            file.read(sub_size) if sub_size > 0
+          when WAV_ID_DATA
+            sub_size = file.read(4).unpack('V').first
+            data_length = sub_size
+            is_wav = true
+            break;
+          else
+            sub_size = file.read(4).unpack('V').first
+            file.read(sub_size)
+          end
+        }
+        raise "Unsupported format" unless format_tag == 1
+        raise unless is_wav
+
+        self.num_channels = channels
+        self.in_samplerate = samples_per_sec
+        self.num_samples = data_length / (channels * ((bits_per_sample+7)/8))
+        @pcmbitwidth = bits_per_sample
+        is_wav
+      end
+    end
+  end
+end

data/test/test_mpeg_encoder.rb

@@ -0,0 +1,120 @@
+require 'test/unit'
+require 'icanhasaudio'
+require 'tempfile'
+
+class MPEGEncoderTest < Test::Unit::TestCase
+  include Audio::MPEG
+
+  WAV_FILE = File.dirname(__FILE__) + "/assets/testcase.wav"
+  #AIFF_FILE = File.dirname(__FILE__) + "/assets/cow.aiff"
+
+  def setup
+    @encoder = Audio::MPEG::Encoder.new
+    assert File.exists?(WAV_FILE)
+    #assert File.exists?(AIFF_FILE)
+  end
+
+  def test_encoder_initialize
+    assert Audio::MPEG::Encoder.new
+  end
+  
+  def test_encode
+    File.open("#{Dir::tmpdir}/out.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_bitrate
+    @encoder.bitrate = 128
+    assert_equal(128, @encoder.bitrate)
+    assert_equal(128, @encoder.vbr_min_bitrate)
+  end
+
+  def test_vbr_type
+    @encoder.vbr_type = Encoder::VBR_OFF
+    assert_equal(Encoder::VBR_OFF, @encoder.vbr_type)
+    File.open("#{Dir::tmpdir}/no_vbr.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_min_vbr_bitrate
+    @encoder.vbr_min_bitrate = 128
+    assert_equal(128, @encoder.vbr_min_bitrate)
+  end
+
+  def test_set_vbr_max_bitrate
+    @encoder.vbr_max_bitrate = 128
+    assert_equal(128, @encoder.vbr_max_bitrate)
+    @encoder.vbr_max_bitrate = 256
+    assert_equal(256, @encoder.vbr_max_bitrate)
+  end
+
+  def test_set_vbr_hard_min
+    assert_equal(false, @encoder.vbr_hard_min?)
+    @encoder.vbr_hard_min = true
+    assert_equal(true, @encoder.vbr_hard_min?)
+    @encoder.vbr_hard_min = false
+    assert_equal(false, @encoder.vbr_hard_min?)
+  end
+
+  def test_set_title
+    @encoder.title = 'tenderlovemaking.com'
+
+    File.open("#{Dir::tmpdir}/title.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_artist
+    @encoder.artist = 'Aaron Patterson'
+
+    File.open("#{Dir::tmpdir}/artist.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_album
+    @encoder.album = 'Some Album'
+
+    File.open("#{Dir::tmpdir}/album.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_year
+    @encoder.year = 1999
+
+    File.open("#{Dir::tmpdir}/year.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_track
+    @encoder.track = 1
+
+    File.open("#{Dir::tmpdir}/track.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_genre
+    @encoder.genre = 'Porn Groove'
+
+    File.open("#{Dir::tmpdir}/genre.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+
+  def test_set_all
+    @encoder.title = 'tenderlovemaking.com'
+    @encoder.artist = 'Aaron Patterson'
+    @encoder.album = 'ICANHASAUDIO'
+    @encoder.year = 2008
+    @encoder.track = 1
+    @encoder.genre = 'Rock'
+    File.open("#{Dir::tmpdir}/all.mp3", 'wb+') { |outfile|
+      @encoder.encode(File.open(WAV_FILE, 'rb'), outfile)
+    }
+  end
+end

metadata

@@ -1,81 +1,92 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
-specification_version: 1
 name: icanhasaudio
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
-date: 2007-08-05 00:00:00 -07:00
-summary: icanhasaudio is a lame/vorbis wrapper for decoding ur mp3s and ur oggs.
-require_paths: 
-  - lib
-  - ext
-email: aaronp@rubyforge.org
-homepage: http://seattlerb.rubyforge.org/
-rubyforge_project: seattlerb
-description: "Hai! icanhasaudio? is an interface to lame for decoding ur MP3s.  I iz in ur
-  computer. Decodin ur mp3s.  Whatevs!  I also decodin ur OGGz!  == SYNOPSYS
-  ROFLOL  require 'icanhasaudio'  reader = Audio::MPEG::Decoder.new
-  File.open(ARGV[0], 'rb') { |input_lol| File.open(ARGV[1], 'wb') { |output_lol|
-  reader.decode(input_lol, output_lol) } }"
+  version: 0.1.0
+platform: ruby
+authors: 
+- Aaron Patterson
 autorequire: 
-default_executable: 
 bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-    - 
-      - ">"
+cert_chain: []
+
+date: 2008-02-15 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.0.0
-  version: 
-platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
-authors: 
-  - Aaron Patterson
-files: 
-  - History.txt
-  - LICENSE.txt
-  - Manifest.txt
-  - README.txt
-  - Rakefile
-  - examples/decoder.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/rb_ogg.c
-  - ext/rb_wav.c
-  - ext/rb_wav.h
-  - ext/syncword.c
-  - ext/syncword.h
-  - lib/icanhasaudio/mpeg.rb
-  - lib/icanhasaudio/ogg.rb
-test_files: []
-rdoc_options: 
-  - "--main"
-  - README.txt
-extra_rdoc_files: 
-  - History.txt
-  - LICENSE.txt
-  - Manifest.txt
-  - README.txt
+        version: 1.5.0
+    version: 
+description: Hai! icanhasaudio? is an interface to lame for decoding ur MP3s.  I iz in ur computer. Decodin ur mp3s.  Whatevs!  I also decodin ur OGGz!  I kin also encodin' ur WAV and AIFF to mp3z!  == SYNOPSYS ROFLOL  require 'icanhasaudio'  reader = Audio::MPEG::Decoder.new File.open(ARGV[0], 'rb') { |input_lol| File.open(ARGV[1], 'wb') { |output_lol| reader.decode(input_lol, output_lol) } }
+email: aaronp@rubyforge.org
 executables: []
+
 extensions: 
-  - ext/extconf.rb
+- ext/extconf.rb
+extra_rdoc_files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- LICENSE.txt
+- Manifest.txt
+- README.txt
+- 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
+- lib/icanhasaudio/mpeg.rb
+- lib/icanhasaudio/mpeg/encoder.rb
+- lib/icanhasaudio/ogg.rb
+- test/assets/testcase.wav
+- test/test_mpeg_encoder.rb
+has_rdoc: true
+homepage: http://seattlerb.rubyforge.org/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
-dependencies: 
-  - !ruby/object:Gem::Dependency 
-    name: hoe
-    version_requirement: 
-    version_requirements: !ruby/object:Gem::Version::Requirement 
-      requirements: 
-        - 
-          - ">="
-          - !ruby/object:Gem::Version 
-            version: 1.2.2
-      version: 
+
+rubyforge_project: seattlerb
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: icanhasaudio is a lame/vorbis wrapper for decoding ur mp3s and ur oggs.
+test_files: 
+- test/test_mpeg_encoder.rb