icanhasaudio 0.0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.0.1 / 2007-07-10
+
+* 1 major enhancement
+  * I can has birfday!
+

data/LICENSE.txt

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+                       51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Library General
+Public License instead of this License.

data/Manifest.txt

@@ -0,0 +1,15 @@
+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/syncword.c
+ext/syncword.h

data/README.txt

@@ -0,0 +1,44 @@
+= Audio::MPEG
+
+  http://seattlerb.rubyforge.org/
+
+== DESCRIPTION.  LULZ
+
+Hai! icanhasaudio? is an interface to lame for decoding ur MP3s.  I iz in ur
+computer. Decodin ur mp3s.
+
+== 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)
+    }
+  }
+
+Or even smaller:
+
+  reader = Audio::MPEG::Decoder.new
+  reader.decode(File.open(ARGV[0], 'rb'), File.open(ARGV[1], 'wb'))
+
+== PROBLEMS
+
+Currently only decodes MP3 data.  Plus many other problems....  YYMV. LOL.
+Not laugh plz!
+
+== DEPENDENSEEZ
+
+Make sure lame is installed on ur 'puter.
+
+== CREDITZ
+
+Thanx Ryan for mah name!  Also, most of this code was taken from the lame
+front end.  So thank you to the lame team!
+
+== LICENSE
+
+GPL.  See LICENSE.txt
+
+KTHX BAI!

data/Rakefile

@@ -0,0 +1,15 @@
+require 'hoe'
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "lib")
+
+Hoe.new('icanhasaudio', '0.0.1') do |p|
+  p.rubyforge_name  = 'seattlerb'
+  p.author          = 'Aaron Patterson'
+  p.email           = 'aaronp@rubyforge.org'
+  p.summary         = "icanhasaudio is a wrappers lame for decoding ur mp3s."
+  p.description     = p.paragraphs_of('README.txt', 3..6).join("\n\n")
+  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'] }
+end
+

data/examples/decoder.rb

@@ -0,0 +1,8 @@
+require 'icanhasaudio'
+
+reader = Audio::MPEG::Decoder.new
+File.open(ARGV[0], 'rb') { |mp3|
+  File.open(ARGV[1], 'wb') { |out|
+    reader.decode(mp3, out);
+  }
+}

data/examples/kexp.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'raop'
+require 'icanhasaudio'
+require 'socket'
+
+rd, wr = IO.pipe
+puts Audio::MPEG::Decoder.lame_version
+
+decoder = Thread.new(rd, wr) { |read, write|
+  reader = Audio::MPEG::Decoder.new
+  socket = TCPSocket.new('kexp-mp3-128k.cac.washington.edu', '8000')
+  socket.puts("GET / HTTP/1.0\r\n\r\n")
+  until(socket.readline == "\r\n"); end
+  reader.decode(socket, write);
+  write.close
+}
+
+sleep 2
+
+raop = Net::RAOP::Client.new('192.168.1.173')
+raop.connect
+raop.play rd
+raop.disconnect
+rd.close
+
+decoder.join
+

data/ext/decoder.c

@@ -0,0 +1,105 @@
+#include <ruby.h>
+#include <lame/lame.h>
+#include <assert.h>
+#include "decoder.h"
+#include "get_audio.h"
+
+int
+lame_decoder(VALUE self, VALUE infile, VALUE outf, mp3data_struct * mp3data)
+{
+  lame_global_flags * gfp;
+  short int Buffer[2][1152];
+  int     iread;
+  double  wavsize;
+  int     i;
+  int tmp_num_channels;
+  int skip;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  tmp_num_channels = lame_get_num_channels( gfp );
+
+  skip = lame_get_encoder_delay(gfp)+528+1;
+
+  /* FIXME: Not sure if necessary
+  if ( 0 == disable_wav_header )
+  */
+  WriteWaveHeader(outf, 0x7FFFFFFF, lame_get_in_samplerate( gfp ),
+                        tmp_num_channels,
+                        16);
+
+    /* unknown size, so write maximum 32 bit signed value */
+
+  wavsize = -skip;
+  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;
+    int total = 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 */
+
+    //printf("Writing: %d\n", mp3data->framenum);
+    for (; i < iread; i++) {
+      /*
+      if ( disable_wav_header ) {
+          WriteFunction(outf, (char *) &Buffer[0][i], sizeof(short));
+          if (tmp_num_channels == 2)
+              WriteFunction(outf, (char *) &Buffer[1][i], sizeof(short));
+      }
+      else { */
+
+      /* 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;
+      }
+
+      /*
+      Write16BitsLowHigh(outf, Buffer[0][i]);
+      if (tmp_num_channels == 2)
+          Write16BitsLowHigh(outf, Buffer[1][i]);
+          */
+      /* } */
+    }
+    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;
+  }
+
+  if(rb_respond_to(outf, rb_intern("seek")) == Qtrue) {
+    rb_funcall( outf,
+                rb_intern("seek"),
+                2,
+                INT2NUM(0),
+                rb_const_get(rb_cIO, rb_intern("SEEK_SET")) );
+    WriteWaveHeader(outf, (int)wavsize, lame_get_in_samplerate(gfp),
+      tmp_num_channels, 16);
+  }
+
+  return 0;
+}
+

data/ext/decoder.h

@@ -0,0 +1,3 @@
+int
+lame_decoder(VALUE self, VALUE infile, VALUE outf, mp3data_struct * mp3data);
+

data/ext/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+have_header("lame/lame.h")
+have_library("mp3lame")
+dir_config('icanhasaudio')
+create_makefile('icanhasaudio')

data/ext/get_audio.c

@@ -0,0 +1,233 @@
+#include <ruby.h>
+#include <assert.h>
+#include <lame/lame.h>
+#include "get_audio.h"
+
+#define MAX_U_32_NUM 0xFFFFFFFF
+
+static int
+get_audio_common(VALUE self, VALUE musicin,
+		  int buffer[2][1152], short buffer16[2][1152],
+      mp3data_struct * mp3data);
+
+static int
+read_samples_mp3(VALUE self, VALUE musicin,
+    short int mpg123pcm[2][1152], int stereo, mp3data_struct * mp3data);
+
+int
+lame_decode_fromfile(VALUE file, short pcm_l[], short pcm_r[],
+                     mp3data_struct * mp3data);
+
+static void
+Write16BitsLowHigh(VALUE file, int i) {
+  rb_funcall(file, rb_intern("putc"), 1, INT2NUM(i & 0xFF));
+  rb_funcall(file, rb_intern("putc"), 1, INT2NUM((i >> 8) & 0xFF));
+}
+
+void
+Write32BitsLowHigh(VALUE fp, int i)
+{
+	Write16BitsLowHigh(fp,(int)(i&0xffffL));
+	Write16BitsLowHigh(fp,(int)((i>>16)&0xffffL));
+}
+
+/*
+  get_audio16 - behave as the original get_audio function, with a limited
+                16 bit per sample output
+*/
+int
+get_audio16(VALUE self, VALUE musicin, short buffer[2][1152],
+    mp3data_struct * mp3data)
+{
+    return( get_audio_common( self, musicin, NULL, buffer, mp3data ) );
+}
+
+/************************************************************************
+  get_audio_common - central functionality of get_audio*
+    in: gfp
+        buffer    output to the int buffer or 16-bit buffer
+   out: buffer    int output    (if buffer != NULL)
+        buffer16  16-bit output (if buffer == NULL) 
+returns: samples read
+note: either buffer or buffer16 must be allocated upon call
+*/
+static int
+get_audio_common(VALUE self, VALUE musicin,
+		  int buffer[2][1152], short buffer16[2][1152],
+      mp3data_struct * mp3data)
+{
+  lame_global_flags *gfp;
+  int     num_channels;
+  short   buf_tmp16[2][1152];
+  int     samples_read;
+  int     framesize;
+  int     samples_to_read;
+  unsigned int tmp_num_samples;
+  int     i;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+  num_channels = lame_get_num_channels( gfp );
+  
+  /* 
+   * NOTE: LAME can now handle arbritray size input data packets,
+   * so there is no reason to read the input data in chuncks of
+   * size "framesize".  EXCEPT:  the LAME graphical frame analyzer 
+   * will get out of sync if we read more than framesize worth of data.
+   */
+  
+  samples_to_read = framesize = lame_get_framesize(gfp);
+  assert(framesize <= 1152);
+  
+  /* get num_samples */
+  tmp_num_samples = lame_get_num_samples( gfp );
+  
+	if( buffer != NULL )
+	    samples_read = read_samples_mp3( self, musicin,
+					     buf_tmp16, num_channels, mp3data );
+	else
+	    samples_read = read_samples_mp3( self, musicin,
+					     buffer16, num_channels, mp3data );
+
+	if( buffer != NULL ) {
+	    for( i = samples_read; --i >= 0; )
+		buffer[0][i] = buf_tmp16[0][i] << (8 * sizeof(int) - 16);
+	    if( num_channels == 2 ) {
+		for( i = samples_read; --i >= 0; )
+		    buffer[1][i] = buf_tmp16[1][i] << (8 * sizeof(int) - 16);
+	    } else if( num_channels == 1 ) {
+		memset( buffer[1], 0, samples_read * sizeof(int) );
+	    } else
+		assert(0);
+	}
+
+
+    /* if num_samples = MAX_U_32_NUM, then it is considered infinitely long.
+       Don't count the samples */
+  /*
+    if ( tmp_num_samples != MAX_U_32_NUM )
+        num_samples_read += samples_read;
+        */
+
+    return samples_read;
+}
+
+static int
+read_samples_mp3(VALUE self, VALUE musicin,
+    short int mpg123pcm[2][1152], int stereo, mp3data_struct * mp3data)
+{
+  int     out;
+  lame_global_flags * gfp;
+
+  Data_Get_Struct(self, lame_global_flags, gfp);
+
+  out =
+      lame_decode_fromfile(musicin, mpg123pcm[0], mpg123pcm[1],
+                           mp3data);
+  /*
+   * out < 0:  error, probably EOF
+   * out = 0:  not possible with lame_decode_fromfile() ???
+   * out > 0:  number of output samples
+   */
+  if (out < 0) {
+      memset(mpg123pcm, 0, sizeof(**mpg123pcm) * 2 * 1152);
+      return 0;
+  }
+
+  if ( lame_get_num_channels( gfp ) != mp3data->stereo)
+      rb_raise(rb_eRuntimeError, "Error: number of channels has changed");
+
+    if ( lame_get_in_samplerate( gfp ) != mp3data->samplerate)
+      rb_raise(rb_eRuntimeError, "Error: sample frequency has changed");
+
+    return out;
+}
+
+
+void
+WriteWaveHeader(VALUE fp, const int pcmbytes,
+                const int freq, const int channels, const int bits)
+{
+  int     bytes = (bits + 7) / 8;
+  
+  /* quick and dirty, but documented */
+  rb_funcall(fp, rb_intern("write"), 1, rb_str_new2("RIFF"));
+  Write32BitsLowHigh(fp, pcmbytes + 44 - 8); /* length in bytes without header */
+  rb_funcall(fp, rb_intern("write"), 1, rb_str_new2("WAVEfmt "));
+  Write32BitsLowHigh(fp, 2 + 2 + 4 + 4 + 2 + 2); /* length of PCM format declaration area */
+  Write16BitsLowHigh(fp, 1); /* is PCM? */
+  Write16BitsLowHigh(fp, channels); /* number of channels */
+  Write32BitsLowHigh(fp, freq); /* sample frequency in [Hz] */
+  Write32BitsLowHigh(fp, freq * channels * bytes); /* bytes per second */
+  Write16BitsLowHigh(fp, channels * bytes); /* bytes per sample time */
+  Write16BitsLowHigh(fp, bits); /* bits per sample */
+  rb_funcall(fp, rb_intern("write"), 1, rb_str_new2("data"));
+  Write32BitsLowHigh(fp, pcmbytes); /* length in bytes of raw PCM data */
+}
+
+/*
+For lame_decode_fromfile:  return code
+  -1     error
+   n     number of samples output.  either 576 or 1152 depending on MP3 file.
+
+
+For lame_decode1_headers():  return code
+  -1     error
+   0     ok, but need more data before outputing any samples
+   n     number of samples output.  either 576 or 1152 depending on MP3 file.
+*/
+int
+lame_decode_fromfile(VALUE file, short pcm_l[], short pcm_r[],
+                     mp3data_struct * mp3data)
+{
+  int     ret = 0;
+  unsigned char buf[1024];
+  VALUE nread;
+  
+  memset(buf, 0, 1024);
+  /* first see if we still have data buffered in the decoder: */
+  ret = lame_decode1_headers(buf, 0, pcm_l, pcm_r, mp3data);
+
+  if (ret!=0) return ret;
+  
+  /* read until we get a valid output frame */
+  while (1) {
+    VALUE str = rb_funcall(file, rb_intern("read"), 1, INT2NUM(1024));
+
+
+  /*
+  printf("tell: %d\n", NUM2INT(rb_funcall(file, rb_intern("tell"), 0)));
+    */
+
+    if (str == Qnil) {
+      /* we are done reading the file, but check for buffered data */
+      /*
+  int j;
+  printf("####################################################\n");
+    for(j = 0; j < 1024; j++) {
+      printf("%d\n", buf[j]);
+    }
+  printf("####################################################\n");
+  printf("tell: %d\n", NUM2INT(rb_funcall(file, rb_intern("tell"), 0)));
+  */
+      ret = lame_decode1_headers(buf, 0, pcm_l, pcm_r, mp3data);
+      if (ret<=0) {
+        lame_decode_exit(); /* release mp3decoder memory */
+        return -1;  /* done with file */
+      }
+      break;
+    }
+
+    nread = rb_funcall(str, rb_intern("length"), 0);
+    memcpy(buf, StringValuePtr(str), NUM2INT(nread));
+
+    ret = lame_decode1_headers(buf, NUM2INT(nread), pcm_l, pcm_r, mp3data);
+    if (ret == -1) {
+      printf("oh shit 2\n");
+      lame_decode_exit();  /* release mp3decoder memory */
+      return -1;
+    }
+    if(ret > 0) break;
+  }
+  return ret;
+}
+

data/ext/get_audio.h

@@ -0,0 +1,8 @@
+#define MAX_U_32_NUM 0xFFFFFFFF
+int
+get_audio16(VALUE self, VALUE musicin, short buffer[2][1152],
+    mp3data_struct * mp3data);
+
+void
+WriteWaveHeader(VALUE fp, const int pcmbytes,
+                const int freq, const int channels, const int bits);

data/ext/icanhasaudio.c

@@ -0,0 +1,165 @@
+/*
+ * 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 <ruby.h>
+#include <lame/lame.h>
+#include <dlfcn.h>
+#include "syncword.h"
+#include "decoder.h"
+#include "get_audio.h"
+
+static VALUE rb_mAudio;
+static VALUE rb_mMpeg;
+static VALUE rb_cDecoder;
+
+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));
+}
+
+static int lame_decode_initfile(VALUE file, mp3data_struct * mp3data) {
+  unsigned char * buf;
+  VALUE str;
+  int len = 4;
+  int enc_delay;
+  int enc_padding;
+  int ret;
+  short int pcm_l[1152], pcm_r[1152];
+
+  str = rb_funcall(file, rb_intern("read"), 1, INT2NUM(len));
+  buf = StringValuePtr(str);
+  if(buf[0] == 'I' && buf[1] == 'D' && buf[2] == '3') {
+    len = 6;
+    str = rb_funcall(file, rb_intern("read"), 1, INT2NUM(len));
+    buf = StringValuePtr(str);
+
+    buf[2] &= 127; buf[3] &= 127; buf[4] &= 127; buf[5] &= 127;
+    len = (((((buf[2] << 7) + buf[3]) << 7) + buf[4]) << 7) + buf[5];
+
+    rb_funcall( file,
+                rb_intern("read"),
+                1,
+                INT2NUM(len));
+
+    len = 4;
+    str = rb_funcall(file, rb_intern("read"), 1, INT2NUM(len));
+    buf = StringValuePtr(str);
+
+    /* Check for Album ID */
+    if(0 == rb_str_cmp(str, rb_str_new2("AiD\1"))) {
+      /* FIXME */
+      rb_raise(rb_eRuntimeError, "Found Album ID.\n");
+    }
+
+    while (!is_syncword_mp123(buf)) {
+      int i;
+      for(i = 0; i < len - 1; i++) {
+        buf[i] = buf[i + 1];
+      }
+      buf[len - 1] = NUM2INT(rb_funcall(file, rb_intern("getc"), 0));
+    }
+
+    if ((buf[2] & 0xF0) == 0) {
+      printf("Input file is freeformat\n");
+    }
+
+    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");
+
+    while(!mp3data->header_parsed) {
+      str = rb_funcall(file, rb_intern("read"), 1, INT2NUM(100));
+      buf = StringValuePtr(str);
+      ret = lame_decode1_headersB(buf, 100, pcm_l, pcm_r, mp3data,&enc_delay,&enc_padding);
+      if(ret == -1)
+        rb_raise(rb_eRuntimeError, "Decode headers failed.\n");
+    }
+
+    if(mp3data->totalframes > 0) {
+    } else {
+      mp3data->nsamp = MAX_U_32_NUM;
+    }
+  }
+  return 0;
+}
+
+/*
+ * call-seq:
+ *    decoder.decode(input_io, output_io)
+ *
+ * Decode the input IO and write it to the output IO.
+ */
+static VALUE method_lame_decode(VALUE self, VALUE file, VALUE outf) {
+  mp3data_struct mp3data;
+  lame_global_flags * gfp;
+
+  memset(&mp3data, 0, sizeof(mp3data_struct));
+  lame_decode_initfile(file, &mp3data);
+
+  Data_Get_Struct (self, lame_global_flags, gfp);
+
+  rb_iv_set(self, "@stereo", INT2NUM(mp3data.stereo));
+  rb_iv_set(self, "@samplerate", INT2NUM(mp3data.samplerate));
+  rb_iv_set(self, "@bitrate", INT2NUM(mp3data.bitrate));
+  rb_iv_set(self, "@mode", INT2NUM(mp3data.mode));
+  rb_iv_set(self, "@mode_ext", INT2NUM(mp3data.mode_ext));
+  rb_iv_set(self, "@framesize", INT2NUM(mp3data.framesize));
+
+  lame_decoder(self, file, outf, &mp3data);
+
+  return Qnil;
+}
+
+void Init_icanhasaudio() {
+  rb_mAudio = rb_define_module("Audio");
+  rb_mMpeg = rb_define_module_under(rb_mAudio, "MPEG");
+  rb_cDecoder = rb_define_class_under(rb_mMpeg, "Decoder", rb_cObject);
+  /* VERSION = '0.0.1' */
+  rb_define_const(rb_cDecoder, "VERSION", rb_str_new2("0.0.1"));
+  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, "decode", method_lame_decode, 2);
+}
+

data/ext/syncword.c

@@ -0,0 +1,45 @@
+/*
+ * Taken from lame, get_audio.c
+ */
+
+int is_syncword_mp123(const void *const headerptr)
+{
+    const unsigned char *const p = headerptr;
+    static const char abl2[16] =
+        { 0, 7, 7, 7, 0, 7, 0, 0, 0, 0, 0, 8, 8, 8, 8, 8 };
+
+    if ((p[0] & 0xFF) != 0xFF)
+        return 0;       /* first 8 bits must be '1' */
+    if ((p[1] & 0xE0) != 0xE0)
+        return 0;       /* next 3 bits are also */
+    if ((p[1] & 0x18) == 0x08)
+        return 0;       /* no MPEG-1, -2 or -2.5 */        
+    if ((p[1] & 0x06) == 0x00)
+        return 0;       /* no Layer I, II and III */
+#ifndef USE_LAYER_1
+    if ((p[1] & 0x06) == 0x03*2)
+	return 0; /* layer1 is not supported */
+#endif
+#ifndef USE_LAYER_2
+    if ((p[1] & 0x06) == 0x02*2)
+	return 0; /* layer1 is not supported */
+#endif
+    /*
+    if (!(((p[1] & 0x06) == 0x03*2 && input_format == sf_mp1)
+	  || ((p[1] & 0x06) == 0x02*2 && input_format == sf_mp2)
+	  || ((p[1] & 0x06) == 0x01*2 && input_format == sf_mp3)))
+    */
+	  if(!(p[1] & 0x06) == 0x01*2)
+	return 0; /* imcompatible layer with input file format */
+    if ((p[2] & 0xF0) == 0xF0)
+        return 0;       /* bad bitrate */
+    if ((p[2] & 0x0C) == 0x0C)
+        return 0;       /* no sample frequency with (32,44.1,48)/(1,2,4)     */
+    if ((p[1] & 0x18) == 0x18 && (p[1] & 0x06) == 0x04
+	&& abl2[p[2] >> 4] & (1 << (p[3] >> 6)))
+	return 0;
+    if ((p[3] & 3) == 2)
+	return 0;       /* reserved enphasis mode */
+    return 1;
+}
+

data/ext/syncword.h

@@ -0,0 +1,3 @@
+
+int is_syncword_mp123(const void *const headerptr);
+

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: icanhasaudio
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-07-11 00:00:00 -07:00
+summary: icanhasaudio is a wrappers lame for decoding ur mp3s.
+require_paths: 
+  - 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.  == 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) }
+  }"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::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/syncword.c
+  - ext/syncword.h
+test_files: []
+rdoc_options: 
+  - "--main"
+  - README.txt
+extra_rdoc_files: 
+  - History.txt
+  - LICENSE.txt
+  - Manifest.txt
+  - README.txt
+executables: []
+extensions: 
+  - ext/extconf.rb
+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.1
+      version: