76 files changed, 17550 insertions, 0 deletions

diff --git a/songdbj/javazoom/jl/converter/Converter.java b/songdbj/javazoom/jl/converter/Converter.java
new file mode 100644
index 0000000000..845082e626
--- /dev/null
+++ b/songdbj/javazoom/jl/converter/Converter.java
@@ -0,0 +1,411 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 12/12/99 Original verion. mdm@techie.com.
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.converter;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.Header;
+import javazoom.jl.decoder.JavaLayerException;
+import javazoom.jl.decoder.Obuffer;
+
+/**
+ * The <code>Converter</code> class implements the conversion of
+ * an MPEG audio file to a .WAV file. To convert an MPEG audio stream,
+ * just create an instance of this class and call the convert()
+ * method, passing in the names of the input and output files. You can
+ * pass in optional <code>ProgressListener</code> and
+ * <code>Decoder.Params</code> objects also to customize the conversion.
+ *
+ * @author      MDM             12/12/99
+ * @since       0.0.7
+ */
+public class Converter
+{
+        /**
+         * Creates a new converter instance.
+         */
+        public Converter()
+        {
+        }
+
+        public synchronized void convert(String sourceName, String destName)
+                throws JavaLayerException
+        {
+                convert(sourceName, destName, null, null);
+        }
+
+        public synchronized void convert(String sourceName, String destName,
+                ProgressListener progressListener)
+                throws JavaLayerException
+        {
+                convert(sourceName, destName, progressListener, null);
+        }
+
+
+        public void convert(String sourceName, String destName,
+                ProgressListener progressListener, Decoder.Params decoderParams)
+                throws JavaLayerException
+        {
+                if (destName.length()==0)
+                        destName = null;
+                try {
+                        InputStream in = openInput(sourceName);
+                        convert(in, destName, progressListener, decoderParams);
+                        in.close();
+                } catch(IOException ioe) {
+                        throw new JavaLayerException(ioe.getLocalizedMessage(), ioe);
+                }
+        }
+
+        public synchronized void convert(InputStream sourceStream, String destName,
+                ProgressListener progressListener, Decoder.Params decoderParams)
+                throws JavaLayerException
+        {
+                if (progressListener==null)
+                        progressListener = PrintWriterProgressListener.newStdOut(
+                                        PrintWriterProgressListener.NO_DETAIL);
+                try {
+                        if (!(sourceStream instanceof BufferedInputStream))
+                                sourceStream = new BufferedInputStream(sourceStream);
+                        int frameCount = -1;
+                        if (sourceStream.markSupported()) {
+                                sourceStream.mark(-1);
+                                frameCount = countFrames(sourceStream);
+                                sourceStream.reset();
+                        }
+                        progressListener.converterUpdate(ProgressListener.UPDATE_FRAME_COUNT, frameCount, 0);
+
+
+                        Obuffer output = null;
+                        Decoder decoder = new Decoder(decoderParams);
+                        Bitstream stream = new Bitstream(sourceStream);
+
+                        if (frameCount==-1)
+                                frameCount = Integer.MAX_VALUE;
+
+                        int frame = 0;
+                        long startTime = System.currentTimeMillis();
+
+                        try
+                        {
+                                for (; frame<frameCount; frame++)
+                                {
+                                        try
+                                        {
+                                                Header header = stream.readFrame();
+                                                if (header==null)
+                                                        break;
+
+                                                progressListener.readFrame(frame, header);
+
+                                                if (output==null)
+                                                {
+                                                        // REVIEW: Incorrect functionality.
+                                                        // the decoder should provide decoded
+                                                        // frequency and channels output as it may differ from
+                                                        // the source (e.g. when downmixing stereo to mono.)
+                                                        int channels = (header.mode()==Header.SINGLE_CHANNEL) ? 1 : 2;
+                                                        int freq = header.frequency();
+                                                        output = new WaveFileObuffer(channels, freq, destName);
+                                                        decoder.setOutputBuffer(output);
+                                                }
+
+                                                Obuffer decoderOutput = decoder.decodeFrame(header, stream);
+
+                                                // REVIEW: the way the output buffer is set
+                                                // on the decoder is a bit dodgy. Even though
+                                                // this exception should never happen, we test to be sure.
+                                                if (decoderOutput!=output)
+                                                        throw new InternalError("Output buffers are different.");
+
+
+                                                progressListener.decodedFrame(frame, header, output);
+
+                                                stream.closeFrame();
+
+                                        }
+                                        catch (Exception ex)
+                                        {
+                                                boolean stop = !progressListener.converterException(ex);
+
+                                                if (stop)
+                                                {
+                                                        throw new JavaLayerException(ex.getLocalizedMessage(), ex);
+                                                }
+                                        }
+                                }
+
+                        }
+                        finally
+                        {
+
+                                if (output!=null)
+                                        output.close();
+                        }
+
+                        int time = (int)(System.currentTimeMillis()-startTime);
+                        progressListener.converterUpdate(ProgressListener.UPDATE_CONVERT_COMPLETE,
+                                time, frame);
+                }
+                catch (IOException ex)
+                {
+                        throw new JavaLayerException(ex.getLocalizedMessage(), ex);
+                }
+        }
+
+
+        protected int countFrames(InputStream in)
+        {
+                return -1;
+        }
+
+
+        protected InputStream openInput(String fileName)
+                throws IOException
+        {
+                // ensure name is abstract path name
+                File file = new File(fileName);
+                InputStream fileIn = new FileInputStream(file);
+                BufferedInputStream bufIn = new BufferedInputStream(fileIn);
+
+                return bufIn;
+        }
+
+
+        /**
+         * This interface is used by the Converter to provide
+         * notification of tasks being carried out by the converter,
+         * and to provide new information as it becomes available.
+         */
+
+        static public interface ProgressListener
+        {
+                public static final int UPDATE_FRAME_COUNT = 1;
+
+                /**
+                 * Conversion is complete. Param1 contains the time
+                 * to convert in milliseconds. Param2 contains the number
+                 * of MPEG audio frames converted.
+                 */
+                public static final int UPDATE_CONVERT_COMPLETE = 2;
+
+
+                /**
+                 * Notifies the listener that new information is available.
+                 *
+                 * @param updateID      Code indicating the information that has been
+                 *                                      updated.
+                 *
+                 * @param param1        Parameter whose value depends upon the update code.
+                 * @param param2        Parameter whose value depends upon the update code.
+                 *
+                 * The <code>updateID</code> parameter can take these values:
+                 *
+                 * UPDATE_FRAME_COUNT: param1 is the frame count, or -1 if not known.
+                 * UPDATE_CONVERT_COMPLETE: param1 is the conversion time, param2
+                 *              is the number of frames converted.
+                 */
+                public void converterUpdate(int updateID, int param1, int param2);
+
+                /**
+                 * If the converter wishes to make a first pass over the
+                 * audio frames, this is called as each frame is parsed.
+                 */
+                public void parsedFrame(int frameNo, Header header);
+
+                /**
+                 * This method is called after each frame has been read,
+                 * but before it has been decoded.
+                 *
+                 * @param frameNo       The 0-based sequence number of the frame.
+                 * @param header        The Header rerpesenting the frame just read.
+                 */
+                public void readFrame(int frameNo, Header header);
+
+                /**
+                 * This method is called after a frame has been decoded.
+                 *
+                 * @param frameNo       The 0-based sequence number of the frame.
+                 * @param header        The Header rerpesenting the frame just read.
+                 * @param o                     The Obuffer the deocded data was written to.
+                 */
+                public void decodedFrame(int frameNo, Header header, Obuffer o);
+
+                /**
+                 * Called when an exception is thrown during while converting
+                 * a frame.
+                 *
+                 * @param       t       The <code>Throwable</code> instance that
+                 *                              was thrown.
+                 *
+                 * @return <code>true</code> to continue processing, or false
+                 *                      to abort conversion.
+                 *
+                 * If this method returns <code>false</code>, the exception
+                 * is propagated to the caller of the convert() method. If
+                 * <code>true</code> is returned, the exception is silently
+                 * ignored and the converter moves onto the next frame.
+                 */
+                public boolean converterException(Throwable t);
+
+        }
+
+
+        /**
+         * Implementation of <code>ProgressListener</code> that writes
+         * notification text to a <code>PrintWriter</code>.
+         */
+        // REVIEW: i18n of text and order required.
+        static public class PrintWriterProgressListener implements ProgressListener
+        {
+                static public final int NO_DETAIL = 0;
+
+                /**
+                 * Level of detail typically expected of expert
+                 * users.
+                 */
+                static public final int EXPERT_DETAIL = 1;
+
+                /**
+                 * Verbose detail.
+                 */
+                static public final int VERBOSE_DETAIL = 2;
+
+                /**
+                 * Debug detail. All frame read notifications are shown.
+                 */
+                static public final int DEBUG_DETAIL = 7;
+
+                static public final int MAX_DETAIL = 10;
+
+                private PrintWriter pw;
+
+                private int detailLevel;
+
+                static public PrintWriterProgressListener newStdOut(int detail)
+                {
+                        return new PrintWriterProgressListener(
+                                new PrintWriter(System.out, true), detail);
+                }
+
+                public PrintWriterProgressListener(PrintWriter writer, int detailLevel)
+                {
+                        this.pw = writer;
+                        this.detailLevel = detailLevel;
+                }
+
+
+                public boolean isDetail(int detail)
+                {
+                        return (this.detailLevel >= detail);
+                }
+
+                public void converterUpdate(int updateID, int param1, int param2)
+                {
+                        if (isDetail(VERBOSE_DETAIL))
+                        {
+                                switch (updateID)
+                                {
+                                case UPDATE_CONVERT_COMPLETE:
+                                        // catch divide by zero errors.
+                                        if (param2==0)
+                                                param2 = 1;
+
+                                        pw.println();
+                                        pw.println("Converted "+param2+" frames in "+param1+" ms ("+
+                                                           (param1/param2)+" ms per frame.)");
+                                }
+                        }
+                }
+
+                public void parsedFrame(int frameNo, Header header)
+                {
+                        if ((frameNo==0) && isDetail(VERBOSE_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("File is a "+headerString);
+                        }
+                        else if (isDetail(MAX_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("Prased frame "+frameNo+": "+headerString);
+                        }
+                }
+
+                public void readFrame(int frameNo, Header header)
+                {
+                        if ((frameNo==0) && isDetail(VERBOSE_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("File is a "+headerString);
+                        }
+                        else if (isDetail(MAX_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("Read frame "+frameNo+": "+headerString);
+                        }
+                }
+
+                public void decodedFrame(int frameNo, Header header, Obuffer o)
+                {
+                        if (isDetail(MAX_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("Decoded frame "+frameNo+": "+headerString);
+                                pw.println("Output: "+o);
+                        }
+                        else if (isDetail(VERBOSE_DETAIL))
+                        {
+                                if (frameNo==0)
+                                {
+                                        pw.print("Converting.");
+                                        pw.flush();
+                                }
+
+                                if ((frameNo % 10)==0)
+                                {
+                                        pw.print('.');
+                                        pw.flush();
+                                }
+                        }
+                }
+
+                public boolean converterException(Throwable t)
+                {
+                        if (this.detailLevel>NO_DETAIL)
+                        {
+                                t.printStackTrace(pw);
+                                pw.flush();
+                        }
+                        return false;
+                }
+
+        }
+
+
+}
\ No newline at end of file
diff --git a/songdbj/javazoom/jl/converter/RiffFile.java b/songdbj/javazoom/jl/converter/RiffFile.java
new file mode 100644
index 0000000000..fb5d9e53c6
--- /dev/null
+++ b/songdbj/javazoom/jl/converter/RiffFile.java
@@ -0,0 +1,495 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 02/23/99 JavaConversion by E.B
+ * Don Cross, April 1993.
+ * RIFF file format classes.
+ * See Chapter 8 of "Multimedia Programmer's Reference" in
+ * the Microsoft Windows SDK.
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.converter;
+
+import java.io.IOException;
+import java.io.RandomAccessFile;
+
+
+/**
+ * Class to manage RIFF files
+ */
+public class RiffFile
+{
+   class RiffChunkHeader
+   {
+        public int    ckID = 0;       // Four-character chunk ID
+        public int    ckSize = 0;     // Length of data in chunk
+        public RiffChunkHeader()
+        {}
+   }
+ 
+ 
+   // DDCRET
+   public static final int      DDC_SUCCESS = 0;           // The operation succeded
+   public static final int      DDC_FAILURE = 1;           // The operation failed for unspecified reasons
+   public static final int      DDC_OUT_OF_MEMORY = 2;     // Operation failed due to running out of memory
+   public static final int      DDC_FILE_ERROR = 3;        // Operation encountered file I/O error
+   public static final int      DDC_INVALID_CALL = 4;      // Operation was called with invalid parameters
+   public static final int      DDC_USER_ABORT = 5;        // Operation was aborted by the user
+   public static final int      DDC_INVALID_FILE = 6;      // File format does not match
+   
+   // RiffFileMode
+   public static final int      RFM_UNKNOWN = 0;           // undefined type (can use to mean "N/A" or "not open")
+   public static final int      RFM_WRITE = 1;             // open for write
+   public static final int      RFM_READ = 2;              // open for read
+
+   private RiffChunkHeader      riff_header;      // header for whole file
+   protected int                        fmode;            // current file I/O mode
+   protected RandomAccessFile   file;             // I/O stream to use
+
+   /**
+    * Dummy Constructor
+        */
+   public RiffFile()
+   {
+      file = null;
+      fmode = RFM_UNKNOWN;
+      riff_header = new RiffChunkHeader();
+   
+      riff_header.ckID = FourCC("RIFF");
+          riff_header.ckSize = 0;
+   }
+ 
+   /**
+    * Return File Mode.
+        */
+   public int CurrentFileMode()
+   {return fmode;}
+   
+   /**
+    * Open a RIFF file.
+        */
+   public int Open(String Filename, int NewMode)
+   {
+      int retcode = DDC_SUCCESS;
+   
+      if ( fmode != RFM_UNKNOWN )
+      {
+                retcode = Close();
+      }
+   
+      if ( retcode == DDC_SUCCESS )
+      {
+                switch ( NewMode )
+                {
+                 case RFM_WRITE:
+                        try
+                        {       
+                                file = new RandomAccessFile(Filename,"rw");
+                                
+                            try
+                                {
+                                   // Write the RIFF header...
+                                   // We will have to come back later and patch it!
+                                   byte[] br = new byte[8];
+                                   br[0] = (byte) ((riff_header.ckID >>> 24) & 0x000000FF);
+                                   br[1] = (byte) ((riff_header.ckID >>> 16) & 0x000000FF);
+                                   br[2] = (byte) ((riff_header.ckID >>> 8) & 0x000000FF);
+                                   br[3] = (byte) (riff_header.ckID & 0x000000FF);
+                                  
+                               byte br4 = (byte) ((riff_header.ckSize >>> 24)& 0x000000FF);
+                                   byte br5 = (byte) ((riff_header.ckSize >>> 16)& 0x000000FF);
+                                   byte br6 = (byte) ((riff_header.ckSize >>> 8)& 0x000000FF);
+                                   byte br7 = (byte) (riff_header.ckSize & 0x000000FF);
+                                   
+                                   br[4] = br7;
+                                   br[5] = br6;
+                                   br[6] = br5;
+                                   br[7] = br4;
+                                   
+                                        file.write(br,0,8);
+                                   fmode = RFM_WRITE;
+                                } catch (IOException ioe)
+                                  {
+                                    file.close();
+                                        fmode = RFM_UNKNOWN;
+                                  }
+                        } catch (IOException ioe)
+                          {
+                             fmode = RFM_UNKNOWN;
+                                 retcode = DDC_FILE_ERROR;
+                          }
+                          break;
+   
+                 case RFM_READ:
+                        try
+                        {       
+                                file = new RandomAccessFile(Filename,"r");
+                            try
+                                {
+                                   // Try to read the RIFF header...                               
+                                   byte[] br = new byte[8];
+                                   file.read(br,0,8);
+                                   fmode = RFM_READ;
+                                   riff_header.ckID = ((br[0]<<24)& 0xFF000000) | ((br[1]<<16)&0x00FF0000) | ((br[2]<<8)&0x0000FF00) | (br[3]&0x000000FF);
+                                   riff_header.ckSize = ((br[4]<<24)& 0xFF000000) | ((br[5]<<16)&0x00FF0000) | ((br[6]<<8)&0x0000FF00) | (br[7]&0x000000FF);
+                                } catch (IOException ioe)
+                                  {
+                                    file.close();
+                                        fmode = RFM_UNKNOWN;
+                                  }
+                        } catch (IOException ioe)
+                          {
+                                 fmode = RFM_UNKNOWN;
+                                 retcode = DDC_FILE_ERROR;
+                          }
+                          break;
+                 default:
+                          retcode = DDC_INVALID_CALL;
+                }
+      }
+         return retcode;
+   }
+   
+   /**
+    * Write NumBytes data.
+        */
+   public int Write(byte[] Data, int NumBytes )
+   {
+      if ( fmode != RFM_WRITE )
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {     
+                file.write(Data,0,NumBytes);
+            fmode = RFM_WRITE;
+          } 
+          catch (IOException ioe)
+          {
+                        return DDC_FILE_ERROR;
+          }
+      riff_header.ckSize += NumBytes;
+          return DDC_SUCCESS;
+   }
+   
+
+
+   /**
+    * Write NumBytes data.
+        */     
+   public int Write(short[] Data, int NumBytes )
+   {
+      byte[] theData = new byte[NumBytes];
+      int yc = 0;
+      for (int y = 0;y<NumBytes;y=y+2)
+      {
+        theData[y] = (byte) (Data[yc] & 0x00FF);
+        theData[y+1] =(byte) ((Data[yc++] >>> 8) & 0x00FF);
+      }
+      if ( fmode != RFM_WRITE )
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {     
+                file.write(theData,0,NumBytes);
+            fmode = RFM_WRITE;
+          } 
+          catch (IOException ioe)
+           {
+                return DDC_FILE_ERROR;
+           }
+          riff_header.ckSize += NumBytes;
+          return DDC_SUCCESS;
+   }
+
+   /**
+    * Write NumBytes data.
+        */
+   public int Write(RiffChunkHeader Triff_header, int NumBytes )
+   {
+          byte[] br = new byte[8];
+          br[0] = (byte) ((Triff_header.ckID >>> 24) & 0x000000FF);
+          br[1] = (byte) ((Triff_header.ckID >>> 16) & 0x000000FF);
+          br[2] = (byte) ((Triff_header.ckID >>> 8) & 0x000000FF);
+          br[3] = (byte) (Triff_header.ckID & 0x000000FF);
+
+          byte br4 = (byte) ((Triff_header.ckSize >>> 24)& 0x000000FF);
+          byte br5 = (byte) ((Triff_header.ckSize >>> 16)& 0x000000FF);
+          byte br6 = (byte) ((Triff_header.ckSize >>> 8)& 0x000000FF);
+          byte br7 = (byte) (Triff_header.ckSize & 0x000000FF);
+          
+          br[4] = br7;
+          br[5] = br6;
+          br[6] = br5;
+          br[7] = br4;    
+          
+      if ( fmode != RFM_WRITE )
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {     
+                file.write(br,0,NumBytes);
+            fmode = RFM_WRITE;
+          } catch (IOException ioe)
+                 {
+                        return DDC_FILE_ERROR;
+                 }
+      riff_header.ckSize += NumBytes;
+          return DDC_SUCCESS;
+   }
+
+   /**
+    * Write NumBytes data.
+        */
+   public int Write(short Data, int NumBytes )
+   {
+      short theData = (short) ( ((Data>>>8)&0x00FF) | ((Data<<8)&0xFF00) );
+      if ( fmode != RFM_WRITE )
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {     
+                file.writeShort(theData);
+            fmode = RFM_WRITE;
+          } catch (IOException ioe)
+                 {
+                        return DDC_FILE_ERROR;
+                 }
+      riff_header.ckSize += NumBytes;
+          return DDC_SUCCESS;
+   }
+   /**
+    * Write NumBytes data.
+        */
+   public int Write(int Data, int NumBytes )
+   {
+    short theDataL = (short) ((Data>>>16)&0x0000FFFF);
+    short theDataR = (short) (Data&0x0000FFFF);
+    short theDataLI = (short) ( ((theDataL>>>8)&0x00FF) | ((theDataL<<8)&0xFF00) );
+    short theDataRI = (short) ( ((theDataR>>>8)&0x00FF) | ((theDataR<<8)&0xFF00) );
+    int theData = ((theDataRI<<16)&0xFFFF0000) | (theDataLI&0x0000FFFF);
+      if ( fmode != RFM_WRITE )
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {     
+                file.writeInt(theData);
+            fmode = RFM_WRITE;
+          } catch (IOException ioe)
+                 {
+                        return DDC_FILE_ERROR;
+                 }
+      riff_header.ckSize += NumBytes;
+          return DDC_SUCCESS;
+   }
+
+
+
+   /**
+    * Read NumBytes data.
+        */   
+   public int Read (byte[] Data, int NumBytes)
+   {
+      int retcode = DDC_SUCCESS;
+          try
+          {
+                  file.read(Data,0,NumBytes);
+      } catch (IOException ioe)
+                    {
+                           retcode = DDC_FILE_ERROR;
+                        }   
+      return retcode;
+   }
+   
+   /**
+    * Expect NumBytes data.
+        */
+   public int Expect(String Data, int NumBytes )
+   {
+      byte      target = 0;
+          int   cnt = 0;
+          try
+          {
+                   while ((NumBytes--) != 0)
+           {
+                        target = file.readByte();
+                                if (target != Data.charAt(cnt++)) return DDC_FILE_ERROR;
+                   }                    
+      } catch (IOException ioe)
+                 {
+                   return DDC_FILE_ERROR;
+                 }   
+                return DDC_SUCCESS;
+   }
+   
+   /**
+    * Close Riff File.
+        * Length is written too.
+        */
+   public int Close()
+   {
+     int retcode = DDC_SUCCESS;
+   
+      switch ( fmode )
+      {
+                case RFM_WRITE:
+                  try
+                  {
+                        file.seek(0);
+                    try
+                        {
+                                byte[] br = new byte[8];
+                                br[0] = (byte) ((riff_header.ckID >>> 24) & 0x000000FF);
+                                br[1] = (byte) ((riff_header.ckID >>> 16) & 0x000000FF);
+                                br[2] = (byte) ((riff_header.ckID >>> 8) & 0x000000FF);
+                                br[3] = (byte) (riff_header.ckID & 0x000000FF);
+                            
+                                br[7] = (byte) ((riff_header.ckSize >>> 24)& 0x000000FF);
+                                br[6] = (byte) ((riff_header.ckSize >>> 16)& 0x000000FF);
+                                br[5] = (byte) ((riff_header.ckSize >>> 8)& 0x000000FF);
+                                br[4] = (byte) (riff_header.ckSize & 0x000000FF);
+                                file.write(br,0,8);     
+                                file.close();
+                        } catch (IOException ioe)
+                            {
+                                   retcode = DDC_FILE_ERROR;
+                                }
+                  } catch (IOException ioe)
+                    {
+                           retcode = DDC_FILE_ERROR;
+                        }
+                   break;
+   
+                case RFM_READ:
+                   try
+                   {
+                        file.close();
+                   } catch (IOException ioe)
+                    {
+                           retcode = DDC_FILE_ERROR;
+                        }
+                   break;
+      }
+      file = null;   
+      fmode = RFM_UNKNOWN;
+          return retcode;
+   }
+
+   /**
+    * Return File Position.
+        */
+   public long CurrentFilePosition()
+   {
+          long  position;
+          try
+          {
+              position = file.getFilePointer();
+          } catch (IOException ioe)
+            {
+              position = -1;
+            }
+      return position;
+   }
+
+   /**
+    * Write Data to specified offset.
+        */
+   public int Backpatch (long FileOffset, RiffChunkHeader Data, int NumBytes )
+   {
+      if (file == null)
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {
+              file.seek(FileOffset);
+          } catch (IOException ioe)
+            {
+              return DDC_FILE_ERROR;
+            }   
+          return Write ( Data, NumBytes );
+   }
+
+   public int Backpatch (long FileOffset, byte[] Data, int NumBytes )
+   {
+      if (file == null)
+      {
+                return DDC_INVALID_CALL;
+      }
+          try
+          {
+              file.seek(FileOffset);
+          } catch (IOException ioe)
+            {
+              return DDC_FILE_ERROR;
+            }   
+          return Write ( Data, NumBytes );
+   }
+
+
+   /**
+    * Seek in the File.
+        */
+   protected int Seek(long offset)
+   {
+      int rc;
+          try
+          {
+              file.seek(offset);
+                  rc = DDC_SUCCESS;
+          } catch (IOException ioe)
+            {
+              rc = DDC_FILE_ERROR;
+            }
+          return rc;
+   }
+
+   /**
+    * Error Messages.
+        */
+   private String DDCRET_String(int retcode)
+   {
+         switch ( retcode )
+         {
+          case DDC_SUCCESS:          return "DDC_SUCCESS";
+          case DDC_FAILURE:          return "DDC_FAILURE";
+          case DDC_OUT_OF_MEMORY:    return "DDC_OUT_OF_MEMORY";
+          case DDC_FILE_ERROR:       return "DDC_FILE_ERROR";
+          case DDC_INVALID_CALL:     return "DDC_INVALID_CALL";
+          case DDC_USER_ABORT:       return "DDC_USER_ABORT";
+          case DDC_INVALID_FILE:     return "DDC_INVALID_FILE";
+     }
+     return "Unknown Error";   
+   }
+
+   /**
+    * Fill the header.
+        */
+   public static int FourCC(String ChunkName)
+   {
+      byte[] p = {0x20,0x20,0x20,0x20};
+          ChunkName.getBytes(0,4,p,0);
+          int ret = (((p[0] << 24)& 0xFF000000) | ((p[1] << 16)&0x00FF0000) | ((p[2] << 8)&0x0000FF00) | (p[3]&0x000000FF));
+      return ret;
+   }
+
+}
diff --git a/songdbj/javazoom/jl/converter/WaveFile.java b/songdbj/javazoom/jl/converter/WaveFile.java
new file mode 100644
index 0000000000..f158d7a39a
--- /dev/null
+++ b/songdbj/javazoom/jl/converter/WaveFile.java
@@ -0,0 +1,522 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 02/23/99 JavaConversion by E.B
+ * Don Cross, April 1993.
+ * RIFF file format classes.
+ * See Chapter 8 of "Multimedia Programmer's Reference" in
+ * the Microsoft Windows SDK.
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.converter;
+
+/**
+ * Class allowing WaveFormat Access
+ */
+public class WaveFile extends RiffFile
+{
+    public static final int     MAX_WAVE_CHANNELS = 2;
+    
+        class WaveFormat_ChunkData
+        {
+           public short         wFormatTag = 0;       // Format category (PCM=1)
+           public short         nChannels = 0;        // Number of channels (mono=1, stereo=2)
+           public int           nSamplesPerSec = 0;   // Sampling rate [Hz]
+           public int           nAvgBytesPerSec = 0;
+           public short         nBlockAlign = 0;
+           public short         nBitsPerSample = 0;
+           
+           public WaveFormat_ChunkData()
+           {
+              wFormatTag = 1;     // PCM
+              Config(44100,(short)16,(short)1);
+                }
+
+           public void Config (int NewSamplingRate, short NewBitsPerSample, short NewNumChannels)
+       {
+          nSamplesPerSec  = NewSamplingRate;
+          nChannels       = NewNumChannels;
+          nBitsPerSample  = NewBitsPerSample;
+          nAvgBytesPerSec = (nChannels * nSamplesPerSec * nBitsPerSample) / 8;
+          nBlockAlign     = (short) ((nChannels * nBitsPerSample) / 8);
+       }
+   }
+
+
+        class WaveFormat_Chunk
+        {
+                public RiffChunkHeader         header;
+                public WaveFormat_ChunkData    data;
+
+                public WaveFormat_Chunk()
+                {
+                    header = new RiffChunkHeader();
+                    data = new WaveFormat_ChunkData();
+                header.ckID     =   FourCC("fmt ");
+                header.ckSize   =   16;
+                }
+
+                public int VerifyValidity()
+                {
+            boolean ret = header.ckID == FourCC("fmt ") &&
+
+            (data.nChannels == 1 || data.nChannels == 2) &&
+
+             data.nAvgBytesPerSec == ( data.nChannels *
+                                       data.nSamplesPerSec *
+                                       data.nBitsPerSample    ) / 8   &&
+
+             data.nBlockAlign == ( data.nChannels *
+                                   data.nBitsPerSample ) / 8;
+            if (ret == true) return 1;
+            else return 0;
+                }
+        }
+
+        public class WaveFileSample
+        {
+                public short[]                          chan;
+                
+                public WaveFileSample()
+                {chan = new short[WaveFile.MAX_WAVE_CHANNELS];}
+        }
+
+   private WaveFormat_Chunk      wave_format;
+   private RiffChunkHeader       pcm_data;
+   private long                          pcm_data_offset = 0;  // offset of 'pcm_data' in output file
+   private int                           num_samples = 0;
+
+
+   /**
+    * Constructs a new WaveFile instance. 
+        */
+   public WaveFile()
+   {
+       pcm_data = new RiffChunkHeader();
+       wave_format = new WaveFormat_Chunk();
+           pcm_data.ckID = FourCC("data");
+           pcm_data.ckSize = 0;
+           num_samples = 0;
+   }
+
+   /**
+    *
+        *
+   public int OpenForRead (String Filename)
+   {
+      // Verify filename parameter as best we can...
+      if (Filename == null)
+      {
+                return DDC_INVALID_CALL;
+      }
+      int retcode = Open ( Filename, RFM_READ );
+   
+      if ( retcode == DDC_SUCCESS )
+      {
+                retcode = Expect ( "WAVE", 4 );
+   
+                if ( retcode == DDC_SUCCESS )
+            {
+                        retcode = Read(wave_format,24);
+   
+                        if ( retcode == DDC_SUCCESS && !wave_format.VerifyValidity() )
+                    {
+                                // This isn't standard PCM, so we don't know what it is!
+                                retcode = DDC_FILE_ERROR;
+                    }
+   
+                    if ( retcode == DDC_SUCCESS )
+                    {
+                          pcm_data_offset = CurrentFilePosition();
+   
+                          // Figure out number of samples from
+                          // file size, current file position, and
+                          // WAVE header.
+                          retcode = Read (pcm_data, 8 );
+                          num_samples = filelength(fileno(file)) - CurrentFilePosition();
+                          num_samples /= NumChannels();
+                          num_samples /= (BitsPerSample() / 8);
+                    }
+            }
+     }
+     return retcode;
+   }*/
+
+   /**
+    *
+        */
+   public int OpenForWrite (String Filename, int SamplingRate, short BitsPerSample, short NumChannels)
+   {
+      // Verify parameters...
+      if ( (Filename==null) ||
+                (BitsPerSample != 8 && BitsPerSample != 16) ||
+                NumChannels < 1 || NumChannels > 2 )
+      {
+                return DDC_INVALID_CALL;
+      }
+   
+      wave_format.data.Config ( SamplingRate, BitsPerSample, NumChannels );
+   
+      int retcode = Open ( Filename, RFM_WRITE );
+   
+      if ( retcode == DDC_SUCCESS )
+      {
+        byte [] theWave = {(byte)'W',(byte)'A',(byte)'V',(byte)'E'};
+                retcode = Write ( theWave, 4 );
+   
+                if ( retcode == DDC_SUCCESS )
+                {
+            // Ecriture de wave_format
+            retcode = Write (wave_format.header, 8);   
+            retcode = Write (wave_format.data.wFormatTag, 2);
+            retcode = Write (wave_format.data.nChannels, 2);
+            retcode = Write (wave_format.data.nSamplesPerSec, 4);
+            retcode = Write (wave_format.data.nAvgBytesPerSec, 4);
+            retcode = Write (wave_format.data.nBlockAlign, 2);
+            retcode = Write (wave_format.data.nBitsPerSample, 2);
+            /* byte[] br = new byte[16];
+                br[0] = (byte) ((wave_format.data.wFormatTag >> 8) & 0x00FF);
+                br[1] = (byte) (wave_format.data.wFormatTag & 0x00FF);
+          
+                br[2] = (byte) ((wave_format.data.nChannels >> 8) & 0x00FF);
+                br[3] = (byte) (wave_format.data.nChannels & 0x00FF);
+          
+                br[4] = (byte) ((wave_format.data.nSamplesPerSec >> 24)& 0x000000FF);
+                br[5] = (byte) ((wave_format.data.nSamplesPerSec >> 16)& 0x000000FF);
+                br[6] = (byte) ((wave_format.data.nSamplesPerSec >> 8)& 0x000000FF);
+                br[7] = (byte) (wave_format.data.nSamplesPerSec & 0x000000FF);
+          
+                br[8] = (byte) ((wave_format.data.nAvgBytesPerSec>> 24)& 0x000000FF);
+                br[9] = (byte) ((wave_format.data.nAvgBytesPerSec >> 16)& 0x000000FF);
+                br[10] = (byte) ((wave_format.data.nAvgBytesPerSec >> 8)& 0x000000FF);
+                br[11] = (byte) (wave_format.data.nAvgBytesPerSec & 0x000000FF);
+
+                br[12] = (byte) ((wave_format.data.nBlockAlign >> 8) & 0x00FF);
+                br[13] = (byte) (wave_format.data.nBlockAlign & 0x00FF);
+          
+                br[14] = (byte) ((wave_format.data.nBitsPerSample >> 8) & 0x00FF);
+                br[15] = (byte) (wave_format.data.nBitsPerSample & 0x00FF);                     
+                        retcode = Write (br, 16); */
+                        
+   
+                        if ( retcode == DDC_SUCCESS )
+                        {
+                                pcm_data_offset = CurrentFilePosition();
+                                retcode = Write ( pcm_data, 8 );
+                        }
+                }
+      }
+   
+        return retcode;
+   }
+
+   /**
+    *
+        *
+   public int ReadSample ( short[] Sample )
+   {
+   
+   }*/
+   
+   /**
+    *
+        *
+   public int WriteSample( short[] Sample )
+   {
+      int retcode = DDC_SUCCESS;
+      switch ( wave_format.data.nChannels )
+      {
+                case 1:
+                   switch ( wave_format.data.nBitsPerSample )
+                   {
+                          case 8:
+                                   pcm_data.ckSize += 1;
+                                   retcode = Write ( Sample, 1 );
+                                   break;
+   
+                          case 16:
+                                   pcm_data.ckSize += 2;
+                                   retcode = Write ( Sample, 2 );
+                                   break;
+   
+                          default:
+                                   retcode = DDC_INVALID_CALL;
+                   }
+                   break;
+   
+                case 2:
+                   switch ( wave_format.data.nBitsPerSample )
+                   {
+                          case 8:
+                                   retcode = Write ( Sample, 1 );
+                                   if ( retcode == DDC_SUCCESS )
+                                   {
+                                      // &Sample[1]
+                                          retcode = Write (Sample, 1 );
+                                          if ( retcode == DDC_SUCCESS )
+                                          {
+                                                 pcm_data.ckSize += 2;
+                                          }
+                                   }
+                                   break;
+   
+                          case 16:
+                                   retcode = Write ( Sample, 2 );
+                                   if ( retcode == DDC_SUCCESS )
+                                   {
+                      // &Sample[1]
+                                          retcode = Write (Sample, 2 );
+                                          if ( retcode == DDC_SUCCESS )
+                                          {
+                                                 pcm_data.ckSize += 4;
+                                          }
+                                   }
+                                   break;
+   
+                          default:
+                                   retcode = DDC_INVALID_CALL;
+                   }
+                   break;
+   
+                default:
+                   retcode = DDC_INVALID_CALL;
+      }
+   
+          return retcode;
+        }*/
+        
+        /**
+         *
+         *
+   public int SeekToSample ( long SampleIndex )
+   {
+      if ( SampleIndex >= NumSamples() )
+      {
+            return DDC_INVALID_CALL;
+      }
+      int SampleSize = (BitsPerSample() + 7) / 8;
+      int rc = Seek ( pcm_data_offset + 8 +
+                                          SampleSize * NumChannels() * SampleIndex );
+          return rc;
+   }*/
+
+   /**
+    * Write 16-bit audio
+        */
+   public int WriteData ( short[] data, int numData )
+   {
+          int extraBytes = numData * 2;
+          pcm_data.ckSize += extraBytes;
+          return super.Write ( data, extraBytes );
+   }
+
+   /**
+    * Read 16-bit audio.
+        *
+   public int ReadData  (short[] data, int numData)
+   {return super.Read ( data, numData * 2);} */
+
+   /**
+    * Write 8-bit audio.
+        *
+   public int WriteData ( byte[] data, int numData )
+   {
+          pcm_data.ckSize += numData;
+          return super.Write ( data, numData );
+   }*/
+
+   /**
+    * Read 8-bit audio.
+        *
+   public int ReadData ( byte[] data, int numData )
+   {return super.Read ( data, numData );} */
+   
+   
+   /**
+    *
+        *
+   public int ReadSamples  (int num, int [] WaveFileSample)
+   {
+   
+   }*/
+
+   /**
+    *
+        *
+   public int WriteMonoSample ( short[] SampleData )
+   {
+      switch ( wave_format.data.nBitsPerSample )
+      {
+                case 8:
+                   pcm_data.ckSize += 1;
+                   return Write ( SampleData, 1 );
+   
+                case 16:
+                   pcm_data.ckSize += 2;
+                   return Write ( SampleData, 2 );
+      }
+          return DDC_INVALID_CALL;
+   }*/
+
+   /**
+    *
+        *
+   public int WriteStereoSample  ( short[] LeftSample, short[] RightSample )
+   {
+      int retcode = DDC_SUCCESS;
+      switch ( wave_format.data.nBitsPerSample )
+      {
+                case 8:
+                   retcode = Write ( LeftSample, 1 );
+                   if ( retcode == DDC_SUCCESS )
+                   {
+                          retcode = Write ( RightSample, 1 );
+                          if ( retcode == DDC_SUCCESS )
+                          {
+                                 pcm_data.ckSize += 2;
+                          }
+                   }
+                   break;
+   
+                case 16:
+                   retcode = Write ( LeftSample, 2 );
+                   if ( retcode == DDC_SUCCESS )
+                   {
+                          retcode = Write ( RightSample, 2 );
+                          if ( retcode == DDC_SUCCESS )
+                          {
+                                 pcm_data.ckSize += 4;
+                          }
+                   }
+                   break;
+   
+                default:
+                   retcode = DDC_INVALID_CALL;
+      }   
+      return retcode;
+   }*/
+   
+   /**
+    *
+        *
+   public int ReadMonoSample ( short[] Sample )
+   {
+      int retcode = DDC_SUCCESS;
+      switch ( wave_format.data.nBitsPerSample )
+      {
+                case 8:
+                   byte[] x = {0};
+                   retcode = Read ( x, 1 );
+                   Sample[0] = (short)(x[0]);
+                   break;
+   
+                case 16:
+                   retcode = Read ( Sample, 2 );
+                   break;
+   
+          default:
+                   retcode = DDC_INVALID_CALL;
+      }
+        return retcode;
+   }*/
+
+   /**
+    *
+        *
+   public int ReadStereoSample ( short[] LeftSampleData, short[] RightSampleData )
+   {
+      int retcode = DDC_SUCCESS;
+      byte[] x = new byte[2];
+      short[] y = new short[2];
+      switch ( wave_format.data.nBitsPerSample )
+      {
+                case 8:
+                   retcode = Read ( x, 2 );
+                   L[0] = (short) ( x[0] );
+                   R[0] = (short) ( x[1] );
+                   break;
+   
+            case 16:
+                   retcode = Read ( y, 4 );
+                   L[0] = (short) ( y[0] );
+                   R[0] = (short) ( y[1] );
+                   break;
+   
+            default:
+                   retcode = DDC_INVALID_CALL;
+      }
+         return retcode;
+   }*/
+
+   
+   /**
+    *
+        */
+   public int Close()
+   {
+      int rc = DDC_SUCCESS;
+      
+      if ( fmode == RFM_WRITE )
+         rc = Backpatch ( pcm_data_offset, pcm_data, 8 );
+      if ( rc == DDC_SUCCESS )
+          rc = super.Close();
+      return rc;
+   }
+
+   // [Hz]
+   public int SamplingRate()
+   {return wave_format.data.nSamplesPerSec;}
+
+   public short BitsPerSample()
+   {return wave_format.data.nBitsPerSample;}
+
+   public short NumChannels()
+   {return wave_format.data.nChannels;}
+
+   public int NumSamples()
+   {return num_samples;}
+
+ 
+   /**
+    * Open for write using another wave file's parameters...
+        */
+   public int OpenForWrite (String Filename, WaveFile OtherWave )
+   {
+      return OpenForWrite ( Filename,
+                            OtherWave.SamplingRate(),
+                            OtherWave.BitsPerSample(),
+                            OtherWave.NumChannels() );
+   }
+
+   /**
+    *
+        */
+   public long CurrentFilePosition()
+   {
+      return super.CurrentFilePosition();
+   }
+
+   /* public int FourCC(String ChunkName)
+   {
+      byte[] p = {0x20,0x20,0x20,0x20};
+          ChunkName.getBytes(0,4,p,0);
+          int ret = (((p[0] << 24)& 0xFF000000) | ((p[1] << 16)&0x00FF0000) | ((p[2] << 8)&0x0000FF00) | (p[3]&0x000000FF));
+      return ret;
+   }*/
+
+}
\ No newline at end of file
diff --git a/songdbj/javazoom/jl/converter/WaveFileObuffer.java b/songdbj/javazoom/jl/converter/WaveFileObuffer.java
new file mode 100644
index 0000000000..eaa1dd46d4
--- /dev/null
+++ b/songdbj/javazoom/jl/converter/WaveFileObuffer.java
@@ -0,0 +1,141 @@
+/*
+ * 11/19/04  1.0 moved to LGPL.
+ * 
+ * 12/12/99      0.0.7 Renamed class, additional constructor arguments 
+ *                       and larger write buffers. mdm@techie.com.
+ *
+ * 15/02/99  Java Conversion by E.B ,javalayer@javazoom.net
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.converter;
+
+import javazoom.jl.decoder.Obuffer;
+
+/**
+ * Implements an Obuffer by writing the data to
+ * a file in RIFF WAVE format. 
+ *  
+ * @since 0.0
+ */
+
+
+public class WaveFileObuffer extends Obuffer
+{
+  private short[]               buffer;
+  private short[]               bufferp;
+  private int                   channels;
+  private WaveFile      outWave;
+
+  /**
+   * Creates a new WareFileObuffer instance. 
+   * 
+   * @param number_of_channels  
+   *                            The number of channels of audio data
+   *                            this buffer will receive. 
+   * 
+   * @param freq        The sample frequency of the samples in the buffer.
+   * 
+   * @param fileName    The filename to write the data to.
+   */
+  public WaveFileObuffer(int number_of_channels, int freq, String FileName)
+  {
+        if (FileName==null)
+                throw new NullPointerException("FileName");
+        
+        buffer = new short[OBUFFERSIZE];
+        bufferp = new short[MAXCHANNELS];
+        channels = number_of_channels;
+        
+        for (int i = 0; i < number_of_channels; ++i) 
+                bufferp[i] = (short)i;
+        
+        outWave = new WaveFile();
+        
+    int rc = outWave.OpenForWrite (FileName,freq,(short)16,(short)channels);
+  }
+
+  /**
+   * Takes a 16 Bit PCM sample.
+   */
+  public void append(int channel, short value)
+  {
+    buffer[bufferp[channel]] = value;
+    bufferp[channel] += channels;
+  }
+
+  /**
+   * Write the samples to the file (Random Acces).
+   */
+  short[] myBuffer = new short[2];
+  public void write_buffer(int val)
+  {
+          
+    int k = 0;
+    int rc = 0;
+    
+        rc = outWave.WriteData(buffer, bufferp[0]);
+        // REVIEW: handle RiffFile errors. 
+        /*
+    for (int j=0;j<bufferp[0];j=j+2)
+    {
+        
+        //myBuffer[0] = (short)(((buffer[j]>>8)&0x000000FF) | ((buffer[j]<<8)&0x0000FF00));
+        //myBuffer[1] = (short) (((buffer[j+1]>>8)&0x000000FF) | ((buffer[j+1]<<8)&0x0000FF00));
+        myBuffer[0] = buffer[j];
+        myBuffer[1] = buffer[j+1];
+        rc = outWave.WriteData (myBuffer,2);
+    }
+        */
+    for (int i = 0; i < channels; ++i) bufferp[i] = (short)i;
+  }
+
+  public void close()
+  {
+    outWave.Close(); 
+  }
+  
+  /**
+   *
+   */
+  public void clear_buffer()
+  {}
+
+  /**
+   *
+   */
+  public void set_stop_flag()
+  {}
+
+  /*
+   * Create STDOUT buffer
+   *
+   *
+  public static Obuffer create_stdout_obuffer(MPEG_Args maplay_args)
+  {
+        Obuffer thebuffer = null;
+    int mode = maplay_args.MPEGheader.mode();
+    int which_channels = maplay_args.which_c;
+     if (mode == Header.single_channel || which_channels != MPEG_Args.both)
+        thebuffer = new FileObuffer(1,maplay_args.output_filename);
+     else
+        thebuffer = new FileObuffer(2,maplay_args.output_filename);
+     return(thebuffer);
+  }
+  */
+}
diff --git a/songdbj/javazoom/jl/converter/jlc.java b/songdbj/javazoom/jl/converter/jlc.java
new file mode 100644
index 0000000000..57c84eba4a
--- /dev/null
+++ b/songdbj/javazoom/jl/converter/jlc.java
@@ -0,0 +1,216 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ *  
+ * 29/01/00             Initial version. mdm@techie.com
+ * 
+ * 12/12/99     JavaLayer 0.0.7 mdm@techie.com
+ * 
+ * 14/02/99     MPEG_Args Based Class - E.B
+ * Adapted from javalayer and MPEG_Args.
+ * Doc'ed and integerated with JL converter. Removed
+ * Win32 specifics from original Maplay code.
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.converter;
+
+import java.io.PrintWriter;
+
+import javazoom.jl.decoder.Crc16;
+import javazoom.jl.decoder.JavaLayerException;
+import javazoom.jl.decoder.OutputChannels;
+
+/**
+ * The <code>jlc</code> class presents the JavaLayer
+ * Conversion functionality as a command-line program.
+ *
+ * @since 0.0.7
+ */
+public class jlc
+{
+
+        static public void main(String args[])
+        {
+                String[] argv;
+                long start = System.currentTimeMillis();
+                int argc = args.length + 1;
+                argv = new String[argc];
+                argv[0] = "jlc";
+                for(int i=0;i<args.length;i++)
+                        argv[i+1] = args[i];
+
+                jlcArgs ma = new jlcArgs();
+                if (!ma.processArgs(argv))
+                        System.exit(1);
+
+                Converter conv = new Converter();
+
+                int detail = (ma.verbose_mode ?
+                                          ma.verbose_level :
+                                Converter.PrintWriterProgressListener.NO_DETAIL);
+
+                Converter.ProgressListener listener =
+                        new Converter.PrintWriterProgressListener(
+                                new PrintWriter(System.out, true), detail);
+
+                try
+                {
+                        conv.convert(ma.filename, ma.output_filename, listener);
+                }
+                catch (JavaLayerException ex)
+                {
+                        System.err.println("Convertion failure: "+ex);
+                }
+
+                System.exit(0);
+  }
+
+
+        /**
+         * Class to contain arguments for maplay.
+         */
+        static class jlcArgs
+        {
+                // channel constants moved into OutputChannels class.
+          //public static final int     both = 0;
+          //public static final int     left = 1;
+          //public static final int     right = 2;
+          //public static final int     downmix = 3;
+
+          public int                            which_c;
+          public int                            output_mode;
+          public boolean                        use_own_scalefactor;
+          public float                          scalefactor;
+          public String                         output_filename;
+          public String                         filename;
+          //public boolean                      stdout_mode;
+          public boolean                        verbose_mode;
+          public int                            verbose_level = 3;
+
+          public jlcArgs()
+          {
+                which_c = OutputChannels.BOTH_CHANNELS;
+                use_own_scalefactor = false;
+                scalefactor = (float) 32768.0;
+            //stdout_mode = false;
+            verbose_mode = false;
+          }
+
+          /**
+           * Process user arguments.
+           *
+           * Returns true if successful.
+           */
+          public boolean processArgs(String[] argv)
+          {
+                 filename = null;
+                 Crc16[] crc;
+                 crc = new Crc16[1];
+             int i;
+                 int argc = argv.length;
+
+                 //stdout_mode  = false;
+             verbose_mode = false;
+             output_mode = OutputChannels.BOTH_CHANNELS;
+             output_filename = "";
+             if (argc < 2 || argv[1].equals("-h"))
+                         return Usage();
+
+                 i = 1;
+             while (i < argc)
+                 {
+                   /* System.out.println("Option = "+argv[i]);*/
+                   if (argv[i].charAt(0) == '-')
+                   {
+                         if (argv[i].startsWith("-v"))
+                         {
+                                verbose_mode = true;
+                                if (argv[i].length()>2)
+                                {
+                                        try
+                                        {
+                                                String level = argv[i].substring(2);
+                                                verbose_level = Integer.parseInt(level);
+                                        }
+                                        catch (NumberFormatException ex)
+                                        {
+                                                System.err.println("Invalid verbose level. Using default.");
+                                        }
+                                }
+                                System.out.println("Verbose Activated (level "+verbose_level+")");
+                         }
+                         /* else if (argv[i].equals("-s"))
+                                ma.stdout_mode = true; */
+                         else if (argv[i].equals("-p"))
+                         {
+                        if (++i == argc)
+                                {
+                           System.out.println("Please specify an output filename after the -p option!");
+                           System.exit (1);
+                        }
+                        //output_mode = O_WAVEFILE;
+                            output_filename = argv[i];
+                         }
+                         /*else if (argv[i].equals("-f"))
+                         {
+                        if (++i == argc)
+                                {
+                           System.out.println("Please specify a new scalefactor after the -f option!");
+                           System.exit(1);
+                                }
+                            ma.use_own_scalefactor = true;
+                                // ma.scalefactor = argv[i];
+                         }*/
+                     else return Usage();
+              }
+                  else
+                  {
+                        filename = argv[i];
+                        System.out.println("FileName = "+argv[i]);
+                        if (filename == null) return Usage();
+                  }
+                  i++;
+            }
+                if (filename == null)
+                        return Usage();
+
+                return true;
+          }
+
+
+           /**
+            * Usage of JavaLayer.
+                */
+           public boolean Usage()
+           {
+                 System.out.println("JavaLayer Converter :");
+                 System.out.println("  -v[x]         verbose mode. ");
+                 System.out.println("                default = 2");
+             /* System.out.println("  -s         write u-law samples at 8 kHz rate to stdout");
+             System.out.println("  -l         decode only the left channel");
+             System.out.println("  -r         decode only the right channel");
+             System.out.println("  -d         downmix mode (layer III only)");
+             System.out.println("  -s         write pcm samples to stdout");
+             System.out.println("  -d         downmix mode (layer III only)");*/
+             System.out.println("  -p name    output as a PCM wave file");
+             System.out.println("");
+             System.out.println("  More info on http://www.javazoom.net");
+             /* System.out.println("  -f ushort  use this scalefactor instead of the default value 32768");*/
+                 return false;
+           }
+        };
+};
\ No newline at end of file
diff --git a/songdbj/javazoom/jl/decoder/BitReserve.java b/songdbj/javazoom/jl/decoder/BitReserve.java
new file mode 100644
index 0000000000..a5d3056d61
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/BitReserve.java
@@ -0,0 +1,223 @@
+/*
+ * 11/19/04                     1.0 moved to LGPL.
+ * 
+ * 12/12/99 0.0.7       Implementation stores single bits 
+ *                                      as ints for better performance. mdm@techie.com.
+ *
+ * 02/28/99 0.0     Java Conversion by E.B, javalayer@javazoom.net
+ *
+ *                  Adapted from the public c code by Jeff Tsay.
+ *
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+        
+/**
+ * Implementation of Bit Reservoir for Layer III.
+ * <p>
+ * The implementation stores single bits as a word in the buffer. If
+ * a bit is set, the corresponding word in the buffer will be non-zero.
+ * If a bit is clear, the corresponding word is zero. Although this
+ * may seem waseful, this can be a factor of two quicker than 
+ * packing 8 bits to a byte and extracting. 
+ * <p> 
+ */
+
+// REVIEW: there is no range checking, so buffer underflow or overflow
+// can silently occur.
+final class BitReserve
+{
+   /**
+    * Size of the internal buffer to store the reserved bits.
+    * Must be a power of 2. And x8, as each bit is stored as a single
+    * entry.
+    */
+        private static final int                BUFSIZE = 4096*8;
+        
+        /**
+         * Mask that can be used to quickly implement the
+         * modulus operation on BUFSIZE.
+         */
+        private static final int                BUFSIZE_MASK = BUFSIZE-1;
+        
+        private int                                     offset, totbit, buf_byte_idx;
+        private final int[]                     buf = new int[BUFSIZE];
+        private int                                     buf_bit_idx;
+        
+   BitReserve()
+   {
+          
+          offset = 0;
+      totbit = 0;
+      buf_byte_idx = 0;   
+   }
+      
+   
+   /**
+    * Return totbit Field.
+        */
+   public int hsstell() 
+   { 
+           return(totbit); 
+   }
+
+   /**
+    * Read a number bits from the bit stream.
+    * @param N the number of
+        */
+   public int hgetbits(int N)
+   {
+         totbit += N;
+         
+         int val = 0;
+         
+         int pos = buf_byte_idx;
+         if (pos+N < BUFSIZE)
+         {
+                while (N-- > 0)
+                {
+                        val <<= 1;
+                        val |= ((buf[pos++]!=0) ? 1 : 0);                
+                }
+        }
+         else
+         {       
+                 while (N-- > 0)
+                {
+                         val <<= 1;                      
+                         val |= ((buf[pos]!=0) ? 1 : 0);
+                         pos = (pos+1) & BUFSIZE_MASK;
+                }                
+         }      
+         buf_byte_idx = pos;
+         return val;
+   }
+   
+         
+   
+   /**
+    * Read 1 bit from the bit stream.
+        */
+/*
+   public int hget1bit_old()
+   {
+          int val;
+          totbit++;
+          if (buf_bit_idx == 0)
+          {
+         buf_bit_idx = 8;
+             buf_byte_idx++;             
+          }
+      // BUFSIZE = 4096 = 2^12, so
+      // buf_byte_idx%BUFSIZE == buf_byte_idx & 0xfff
+      val = buf[buf_byte_idx & BUFSIZE_MASK] & putmask[buf_bit_idx];
+      buf_bit_idx--;
+          val = val >>> buf_bit_idx;
+      return val;   
+   }
+ */
+   /**
+    * Returns next bit from reserve.
+    * @returns 0 if next bit is reset, or 1 if next bit is set.
+    */
+   public int hget1bit()
+   {      
+          totbit++;       
+          int val = buf[buf_byte_idx];
+          buf_byte_idx = (buf_byte_idx+1) & BUFSIZE_MASK;
+      return val;
+   }
+   
+   /**
+    * Retrieves bits from the reserve.     
+    */
+/*   
+   public int readBits(int[] out, int len)
+   {
+                if (buf_bit_idx == 0)
+                {
+                   buf_bit_idx = 8;
+                   buf_byte_idx++;
+                   current = buf[buf_byte_idx & BUFSIZE_MASK];
+                }      
+                
+                
+                
+                // save total number of bits returned
+                len = buf_bit_idx;
+                buf_bit_idx = 0;
+                  
+                int b = current;
+                int count = len-1;
+                  
+                while (count >= 0)
+                {
+                    out[count--] = (b & 0x1);
+                    b >>>= 1;
+                }
+          
+                totbit += len;
+                return len;
+   }
+  */
+   
+   /**
+    * Write 8 bits into the bit stream.
+        */
+   public void hputbuf(int val)
+   {      
+           int ofs = offset;
+           buf[ofs++] = val & 0x80;
+           buf[ofs++] = val & 0x40;
+           buf[ofs++] = val & 0x20;
+           buf[ofs++] = val & 0x10;
+           buf[ofs++] = val & 0x08;
+           buf[ofs++] = val & 0x04;
+           buf[ofs++] = val & 0x02;
+           buf[ofs++] = val & 0x01;
+           
+           if (ofs==BUFSIZE)
+                        offset = 0;
+           else
+                        offset = ofs;
+           
+   }
+ 
+   /**
+    * Rewind N bits in Stream.
+        */
+   public void rewindNbits(int N)
+   {
+          totbit -= N;            
+          buf_byte_idx -= N;
+          if (buf_byte_idx<0)
+                  buf_byte_idx += BUFSIZE;
+   }
+        
+   /**
+    * Rewind N bytes in Stream.
+        */
+   public void rewindNbytes(int N)
+   {
+      int bits = (N << 3);
+          totbit -= bits;
+          buf_byte_idx -= bits;   
+          if (buf_byte_idx<0)
+                  buf_byte_idx += BUFSIZE;
+   }
+}
diff --git a/songdbj/javazoom/jl/decoder/Bitstream.java b/songdbj/javazoom/jl/decoder/Bitstream.java
new file mode 100644
index 0000000000..cebbd5b03b
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Bitstream.java
@@ -0,0 +1,655 @@
+/*
+ * 11/19/04  1.0 moved to LGPL.
+ * 
+ * 11/17/04      Uncomplete frames discarded. E.B, javalayer@javazoom.net 
+ *
+ * 12/05/03      ID3v2 tag returned. E.B, javalayer@javazoom.net 
+ *
+ * 12/12/99      Based on Ibitstream. Exceptions thrown on errors,
+ *                       Temporary removed seek functionality. mdm@techie.com
+ *
+ * 02/12/99 : Java Conversion by E.B , javalayer@javazoom.net
+ *
+ * 04/14/97 : Added function prototypes for new syncing and seeking
+ * mechanisms. Also made this file portable. Changes made by Jeff Tsay
+ *
+ *  @(#) ibitstream.h 1.5, last edit: 6/15/94 16:55:34
+ *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
+ *  @(#) Berlin University of Technology
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+import java.io.BufferedInputStream;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+
+
+/**
+ * The <code>Bistream</code> class is responsible for parsing
+ * an MPEG audio bitstream.
+ *
+ * <b>REVIEW:</b> much of the parsing currently occurs in the
+ * various decoders. This should be moved into this class and associated
+ * inner classes.
+ */
+public final class Bitstream implements BitstreamErrors
+{
+        /**
+         * Synchronization control constant for the initial
+         * synchronization to the start of a frame.
+         */
+        static byte             INITIAL_SYNC = 0;
+
+        /**
+         * Synchronization control constant for non-initial frame
+         * synchronizations.
+         */
+        static byte             STRICT_SYNC = 1;
+
+        // max. 1730 bytes per frame: 144 * 384kbit/s / 32000 Hz + 2 Bytes CRC
+        /**
+         * Maximum size of the frame buffer.
+         */
+        private static final int        BUFFER_INT_SIZE = 433;
+
+        /**
+         * The frame buffer that holds the data for the current frame.
+         */
+        private final int[]             framebuffer = new int[BUFFER_INT_SIZE];
+
+        /**
+         * Number of valid bytes in the frame buffer.
+         */
+        private int                             framesize;
+
+        /**
+         * The bytes read from the stream.
+         */
+        private byte[]                  frame_bytes = new byte[BUFFER_INT_SIZE*4];
+
+        /**
+         * Index into <code>framebuffer</code> where the next bits are
+         * retrieved.
+         */
+        private int                             wordpointer;
+
+        /**
+         * Number (0-31, from MSB to LSB) of next bit for get_bits()
+         */
+        private int                             bitindex;
+
+        /**
+         * The current specified syncword
+         */
+        private int                             syncword;
+        
+        /**
+         * Audio header position in stream.
+         */
+        private int                             header_pos = 0;
+
+        /**
+         *
+         */
+        private boolean                 single_ch_mode;
+  //private int                         current_frame_number;
+  //private int                         last_frame_number;
+
+        private final int               bitmask[] = {0, // dummy
+         0x00000001, 0x00000003, 0x00000007, 0x0000000F,
+         0x0000001F, 0x0000003F, 0x0000007F, 0x000000FF,
+         0x000001FF, 0x000003FF, 0x000007FF, 0x00000FFF,
+         0x00001FFF, 0x00003FFF, 0x00007FFF, 0x0000FFFF,
+     0x0001FFFF };
+
+        private final PushbackInputStream       source;
+
+        private final Header                    header = new Header();
+
+        private final byte                              syncbuf[] = new byte[4];
+
+        private Crc16[]                                 crc = new Crc16[1];
+
+        private byte[]                                  rawid3v2 = null;
+
+        private boolean                                 firstframe = true;
+
+
+        /**
+         * Construct a IBitstream that reads data from a
+         * given InputStream.
+         *
+         * @param in    The InputStream to read from.
+         */
+        public Bitstream(InputStream in)
+        {
+                if (in==null) throw new NullPointerException("in");
+                in = new BufferedInputStream(in);               
+                loadID3v2(in);
+                firstframe = true;
+                //source = new PushbackInputStream(in, 1024);
+                source = new PushbackInputStream(in, BUFFER_INT_SIZE*4);
+                
+                closeFrame();
+                //current_frame_number = -1;
+                //last_frame_number = -1;
+        }
+
+        /**
+         * Return position of the first audio header.
+         * @return size of ID3v2 tag frames.
+         */
+        public int header_pos()
+        {
+                return header_pos;
+        }
+        
+        /**
+         * Load ID3v2 frames.
+         * @param in MP3 InputStream.
+         * @author JavaZOOM
+         */
+        private void loadID3v2(InputStream in)
+        {               
+                int size = -1;
+                try
+                {
+                        // Read ID3v2 header (10 bytes).
+                        in.mark(10);                    
+                        size = readID3v2Header(in);
+                        header_pos = size;                      
+                }
+                catch (IOException e)
+                {}
+                finally
+                {
+                        try
+                        {
+                                // Unread ID3v2 header (10 bytes).
+                                in.reset();
+                        }
+                        catch (IOException e)
+                        {}
+                }
+                // Load ID3v2 tags.
+                try
+                {
+                        if (size > 0)
+                        {
+                                rawid3v2 = new byte[size];
+                                in.read(rawid3v2,0,rawid3v2.length);
+                        }                       
+                }
+                catch (IOException e)
+                {}
+        }
+        
+        /**
+         * Parse ID3v2 tag header to find out size of ID3v2 frames. 
+         * @param in MP3 InputStream
+         * @return size of ID3v2 frames + header
+         * @throws IOException
+         * @author JavaZOOM
+         */
+        private int readID3v2Header(InputStream in) throws IOException
+        {               
+                byte[] id3header = new byte[4];
+                int size = -10;
+                in.read(id3header,0,3);
+                // Look for ID3v2
+                if ( (id3header[0]=='I') && (id3header[1]=='D') && (id3header[2]=='3'))
+                {
+                        in.read(id3header,0,3);
+                        int majorVersion = id3header[0];
+                        int revision = id3header[1];
+                        in.read(id3header,0,4);
+                        size = (int) (id3header[0] << 21) + (id3header[1] << 14) + (id3header[2] << 7) + (id3header[3]);
+                }
+                return (size+10);
+        }
+        
+        /**
+         * Return raw ID3v2 frames + header.
+         * @return ID3v2 InputStream or null if ID3v2 frames are not available.
+         */
+        public InputStream getRawID3v2()
+        {
+                if (rawid3v2 == null) return null;
+                else
+                {
+                        ByteArrayInputStream bain = new ByteArrayInputStream(rawid3v2);         
+                        return bain;
+                }
+        }
+
+        /**
+         * Close the Bitstream.
+         * @throws BitstreamException
+         */
+        public void close() throws BitstreamException
+        {
+                try
+                {
+                        source.close();
+                }
+                catch (IOException ex)
+                {
+                        throw newBitstreamException(STREAM_ERROR, ex);
+                }
+        }
+
+        /**
+         * Reads and parses the next frame from the input source.
+         * @return the Header describing details of the frame read,
+         *      or null if the end of the stream has been reached.
+         */
+        public Header readFrame() throws BitstreamException
+        {
+                Header result = null;
+                try
+                {
+                        result = readNextFrame();
+                        // E.B, Parse VBR (if any) first frame.
+                        if (firstframe == true)
+                        {
+                                result.parseVBR(frame_bytes);
+                                firstframe = false;
+                        }                       
+                }
+                catch (BitstreamException ex)
+                {
+                        if ((ex.getErrorCode()==INVALIDFRAME))
+                        {
+                                // Try to skip this frame.
+                                //System.out.println("INVALIDFRAME");
+                                try
+                                {
+                                        closeFrame();
+                                        result = readNextFrame();
+                                }
+                                catch (BitstreamException e)
+                                {
+                                        if ((e.getErrorCode()!=STREAM_EOF))
+                                        {
+                                                // wrap original exception so stack trace is maintained.
+                                                throw newBitstreamException(e.getErrorCode(), e);
+                                        }
+                                }
+                        }
+                        else if ((ex.getErrorCode()!=STREAM_EOF))
+                        {
+                                // wrap original exception so stack trace is maintained.
+                                throw newBitstreamException(ex.getErrorCode(), ex);
+                        }
+                }
+                return result;
+        }
+
+        /**
+         * Read next MP3 frame.
+         * @return MP3 frame header.
+         * @throws BitstreamException
+         */
+        private Header readNextFrame() throws BitstreamException
+        {
+                if (framesize == -1)
+                {
+                        nextFrame();
+                }
+                return header;
+        }
+
+
+        /**
+         * Read next MP3 frame.
+         * @throws BitstreamException
+         */
+        private void nextFrame() throws BitstreamException
+        {
+                // entire frame is read by the header class.
+                header.read_header(this, crc);
+        }
+
+        /**
+         * Unreads the bytes read from the frame.
+         * @throws BitstreamException
+         */
+        // REVIEW: add new error codes for this.
+        public void unreadFrame() throws BitstreamException
+        {
+                if (wordpointer==-1 && bitindex==-1 && (framesize>0))
+                {
+                        try
+                        {
+                                source.unread(frame_bytes, 0, framesize);
+                        }
+                        catch (IOException ex)
+                        {
+                                throw newBitstreamException(STREAM_ERROR);
+                        }
+                }
+        }
+
+        /**
+         * Close MP3 frame.
+         */
+        public void closeFrame()
+        {
+                framesize = -1;
+                wordpointer = -1;
+                bitindex = -1;
+        }
+
+        /**
+         * Determines if the next 4 bytes of the stream represent a
+         * frame header.
+         */
+        public boolean isSyncCurrentPosition(int syncmode) throws BitstreamException
+        {
+                int read = readBytes(syncbuf, 0, 4);
+                int headerstring = ((syncbuf[0] << 24) & 0xFF000000) | ((syncbuf[1] << 16) & 0x00FF0000) | ((syncbuf[2] << 8) & 0x0000FF00) | ((syncbuf[3] << 0) & 0x000000FF);
+
+                try
+                {
+                        source.unread(syncbuf, 0, read);
+                }
+                catch (IOException ex)
+                {
+                }
+
+                boolean sync = false;
+                switch (read)
+                {
+                        case 0:
+                                sync = true;
+                                break;
+                        case 4:
+                                sync = isSyncMark(headerstring, syncmode, syncword);
+                                break;
+                }
+
+                return sync;
+        }
+
+
+        // REVIEW: this class should provide inner classes to
+        // parse the frame contents. Eventually, readBits will
+        // be removed.
+        public int readBits(int n)
+        {
+                return get_bits(n);
+        }
+
+        public int readCheckedBits(int n)
+        {
+                // REVIEW: implement CRC check.
+                return get_bits(n);
+        }
+
+        protected BitstreamException newBitstreamException(int errorcode)
+        {
+                return new BitstreamException(errorcode, null);
+        }
+        protected BitstreamException newBitstreamException(int errorcode, Throwable throwable)
+        {
+                return new BitstreamException(errorcode, throwable);
+        }
+
+  /**
+   * Get next 32 bits from bitstream.
+   * They are stored in the headerstring.
+   * syncmod allows Synchro flag ID
+   * The returned value is False at the end of stream.
+   */
+
+        int syncHeader(byte syncmode) throws BitstreamException
+        {
+                boolean sync;
+                int headerstring;
+                // read additional 2 bytes
+                int bytesRead = readBytes(syncbuf, 0, 3);
+
+                if (bytesRead!=3) throw newBitstreamException(STREAM_EOF, null);
+
+                headerstring = ((syncbuf[0] << 16) & 0x00FF0000) | ((syncbuf[1] << 8) & 0x0000FF00) | ((syncbuf[2] << 0) & 0x000000FF);
+
+                do
+                {
+                        headerstring <<= 8;
+
+                        if (readBytes(syncbuf, 3, 1)!=1)
+                                throw newBitstreamException(STREAM_EOF, null);
+
+                        headerstring |= (syncbuf[3] & 0x000000FF);
+
+                        sync = isSyncMark(headerstring, syncmode, syncword);
+                }
+                while (!sync);
+
+                //current_frame_number++;
+                //if (last_frame_number < current_frame_number) last_frame_number = current_frame_number;
+
+                return headerstring;
+        }
+
+        public boolean isSyncMark(int headerstring, int syncmode, int word)
+        {
+                boolean sync = false;
+
+                if (syncmode == INITIAL_SYNC)
+                {
+                        //sync =  ((headerstring & 0xFFF00000) == 0xFFF00000);
+                        sync =  ((headerstring & 0xFFE00000) == 0xFFE00000);    // SZD: MPEG 2.5
+                }
+                else
+                {
+                        sync =  ((headerstring & 0xFFF80C00) == word) &&
+                            (((headerstring & 0x000000C0) == 0x000000C0) == single_ch_mode);
+                }
+
+                // filter out invalid sample rate
+                if (sync)
+                        sync = (((headerstring >>> 10) & 3)!=3);
+                // filter out invalid layer
+                if (sync)
+                        sync = (((headerstring >>> 17) & 3)!=0);
+                // filter out invalid version
+                if (sync)
+                        sync = (((headerstring >>> 19) & 3)!=1);
+
+                return sync;
+        }
+
+        /**
+         * Reads the data for the next frame. The frame is not parsed
+         * until parse frame is called.
+         */
+        int read_frame_data(int bytesize) throws BitstreamException
+        {
+                int     numread = 0;
+                numread = readFully(frame_bytes, 0, bytesize);
+                framesize = bytesize;
+                wordpointer = -1;
+            bitindex = -1;
+            return numread;
+        }
+
+  /**
+   * Parses the data previously read with read_frame_data().
+   */
+  void parse_frame() throws BitstreamException
+  {
+        // Convert Bytes read to int
+        int     b=0;
+        byte[] byteread = frame_bytes;
+        int bytesize = framesize;
+
+        // Check ID3v1 TAG (True only if last frame).
+        //for (int t=0;t<(byteread.length)-2;t++)
+        //{
+        //      if ((byteread[t]=='T') && (byteread[t+1]=='A') && (byteread[t+2]=='G'))
+        //      {
+        //              System.out.println("ID3v1 detected at offset "+t);
+        //              throw newBitstreamException(INVALIDFRAME, null);
+        //      }       
+        //}
+        
+        for (int k=0;k<bytesize;k=k+4)
+        {
+                int convert = 0;
+                byte b0 = 0;
+                byte b1 = 0;
+                byte b2 = 0;
+                byte b3 = 0;
+                b0 = byteread[k];
+                if (k+1<bytesize) b1 = byteread[k+1];
+                if (k+2<bytesize) b2 = byteread[k+2];
+                if (k+3<bytesize) b3 = byteread[k+3];
+                framebuffer[b++] = ((b0 << 24) &0xFF000000) | ((b1 << 16) & 0x00FF0000) | ((b2 << 8) & 0x0000FF00) | (b3 & 0x000000FF);
+        }
+        wordpointer = 0;
+    bitindex = 0;
+  }
+
+  /**
+   * Read bits from buffer into the lower bits of an unsigned int.
+   * The LSB contains the latest read bit of the stream.
+   * (1 <= number_of_bits <= 16)
+   */
+  public int get_bits(int number_of_bits)
+  {
+        int                             returnvalue = 0;
+        int                     sum = bitindex + number_of_bits;
+
+        // E.B
+        // There is a problem here, wordpointer could be -1 ?!
+    if (wordpointer < 0) wordpointer = 0;
+    // E.B : End.
+
+        if (sum <= 32)
+        {
+           // all bits contained in *wordpointer
+           returnvalue = (framebuffer[wordpointer] >>> (32 - sum)) & bitmask[number_of_bits];
+           // returnvalue = (wordpointer[0] >> (32 - sum)) & bitmask[number_of_bits];
+           if ((bitindex += number_of_bits) == 32)
+           {
+                 bitindex = 0;
+                 wordpointer++; // added by me!
+           }
+           return returnvalue;
+    }
+
+    // E.B : Check that ?
+    //((short[])&returnvalue)[0] = ((short[])wordpointer + 1)[0];
+    //wordpointer++; // Added by me!
+    //((short[])&returnvalue + 1)[0] = ((short[])wordpointer)[0];
+        int Right = (framebuffer[wordpointer] & 0x0000FFFF);
+        wordpointer++;
+        int Left = (framebuffer[wordpointer] & 0xFFFF0000);
+        returnvalue = ((Right << 16) & 0xFFFF0000) | ((Left >>> 16)& 0x0000FFFF);
+
+    returnvalue >>>= 48 - sum;  // returnvalue >>= 16 - (number_of_bits - (32 - bitindex))
+    returnvalue &= bitmask[number_of_bits];
+    bitindex = sum - 32;
+    return returnvalue;
+}
+
+        /**
+         * Set the word we want to sync the header to.
+         * In Big-Endian byte order
+         */
+        void set_syncword(int syncword0)
+        {
+                syncword = syncword0 & 0xFFFFFF3F;
+                single_ch_mode = ((syncword0 & 0x000000C0) == 0x000000C0);
+        }
+        /**
+         * Reads the exact number of bytes from the source
+         * input stream into a byte array.
+         *
+         * @param b             The byte array to read the specified number
+         *                              of bytes into.
+         * @param offs  The index in the array where the first byte
+         *                              read should be stored.
+         * @param len   the number of bytes to read.
+         *
+         * @exception BitstreamException is thrown if the specified
+         *              number of bytes could not be read from the stream.
+         */
+        private int readFully(byte[] b, int offs, int len)
+                throws BitstreamException
+        {               
+                int nRead = 0;
+                try
+                {
+                        while (len > 0)
+                        {
+                                int bytesread = source.read(b, offs, len);
+                                if (bytesread == -1)
+                                {
+                                        while (len-->0)
+                                        {
+                                                b[offs++] = 0;
+                                        }
+                                        break;
+                                        //throw newBitstreamException(UNEXPECTED_EOF, new EOFException());
+                                }
+                                nRead = nRead + bytesread;
+                                offs += bytesread;
+                                len -= bytesread;
+                        }
+                }
+                catch (IOException ex)
+                {
+                        throw newBitstreamException(STREAM_ERROR, ex);
+                }
+                return nRead;
+        }
+
+        /**
+         * Simlar to readFully, but doesn't throw exception when
+         * EOF is reached.
+         */
+        private int readBytes(byte[] b, int offs, int len)
+                throws BitstreamException
+        {
+                int totalBytesRead = 0;
+                try
+                {
+                        while (len > 0)
+                        {
+                                int bytesread = source.read(b, offs, len);
+                                if (bytesread == -1)
+                                {
+                                        break;
+                                }
+                                totalBytesRead += bytesread;
+                                offs += bytesread;
+                                len -= bytesread;
+                        }
+                }
+                catch (IOException ex)
+                {
+                        throw newBitstreamException(STREAM_ERROR, ex);
+                }
+                return totalBytesRead;
+        }
+}
diff --git a/songdbj/javazoom/jl/decoder/BitstreamErrors.java b/songdbj/javazoom/jl/decoder/BitstreamErrors.java
new file mode 100644
index 0000000000..2bdee6d797
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/BitstreamErrors.java
@@ -0,0 +1,72 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 11/17/04             INVALIDFRAME code added.        javalayer@javazoom.net
+ * 12/12/99             Initial version.                        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * This interface describes all error codes that can be thrown 
+ * in <code>BistreamException</code>s.
+ * 
+ * @see BitstreamException
+ * 
+ * @author      MDM             12/12/99
+ * @since       0.0.6
+ */
+
+public interface BitstreamErrors extends JavaLayerErrors
+{
+        
+        /**
+         * An undeterminable error occurred. 
+         */
+        static public final int UNKNOWN_ERROR = BITSTREAM_ERROR + 0;
+        
+        /**
+         * The header describes an unknown sample rate.
+         */
+        static public final int UNKNOWN_SAMPLE_RATE = BITSTREAM_ERROR + 1;
+
+        /**
+         * A problem occurred reading from the stream.
+         */
+        static public final int STREAM_ERROR = BITSTREAM_ERROR + 2;
+        
+        /**
+         * The end of the stream was reached prematurely. 
+         */
+        static public final int UNEXPECTED_EOF = BITSTREAM_ERROR + 3;
+        
+        /**
+         * The end of the stream was reached. 
+         */
+        static public final int STREAM_EOF = BITSTREAM_ERROR + 4;
+        
+        /**
+         * Frame data are missing. 
+         */
+        static public final int INVALIDFRAME = BITSTREAM_ERROR + 5;
+
+        /**
+         * 
+         */
+        static public final int BITSTREAM_LAST = 0x1ff;
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/BitstreamException.java b/songdbj/javazoom/jl/decoder/BitstreamException.java
new file mode 100644
index 0000000000..99faa8962d
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/BitstreamException.java
@@ -0,0 +1,71 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Instances of <code>BitstreamException</code> are thrown 
+ * when operations on a <code>Bitstream</code> fail. 
+ * <p>
+ * The exception provides details of the exception condition 
+ * in two ways:
+ * <ol><li>
+ *              as an error-code describing the nature of the error
+ * </li><br></br><li>
+ *              as the <code>Throwable</code> instance, if any, that was thrown
+ *              indicating that an exceptional condition has occurred. 
+ * </li></ol></p>
+ * 
+ * @since 0.0.6
+ * @author MDM  12/12/99
+ */
+
+public class BitstreamException extends JavaLayerException
+        implements BitstreamErrors
+{       
+        private int errorcode = UNKNOWN_ERROR;
+        
+        public BitstreamException(String msg, Throwable t)
+        {
+                super(msg, t);  
+        }
+        
+        public BitstreamException(int errorcode, Throwable t)
+        {
+                this(getErrorString(errorcode), t);
+                this.errorcode = errorcode;
+        }
+        
+        public int getErrorCode()
+        {
+                return errorcode;       
+        }
+        
+        
+        static public String getErrorString(int errorcode)
+        {
+                // REVIEW: use resource bundle to map error codes
+                // to locale-sensitive strings.
+                
+                return "Bitstream errorcode "+Integer.toHexString(errorcode);
+        }
+        
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/Control.java b/songdbj/javazoom/jl/decoder/Control.java
new file mode 100644
index 0000000000..080ed5215e
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Control.java
@@ -0,0 +1,57 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Work in progress.
+ */
+
+public interface Control
+{
+        
+        /**
+         * Starts playback of the media presented by this control.
+         */
+        public void start();
+        
+        /**
+         * Stops playback of the media presented by this control.
+         */
+        public void stop();
+        
+        public boolean isPlaying();
+        
+        public void pause();
+                
+        
+        public boolean isRandomAccess();
+        
+        /**
+         * Retrieves the current position.
+         */
+        public double   getPosition();
+        
+        /**
+         * 
+         */
+        public void             setPosition(double d);
+        
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/Crc16.java b/songdbj/javazoom/jl/decoder/Crc16.java
new file mode 100644
index 0000000000..c35cc19341
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Crc16.java
@@ -0,0 +1,70 @@
+/*
+ * 11/19/04 : 1.0 moved to LGPL.
+ * 
+ * 02/12/99 : Java Conversion by E.B , javalayer@javazoom.net
+ *
+ *  @(#) crc.h 1.5, last edit: 6/15/94 16:55:32
+ *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
+ *  @(#) Berlin University of Technology
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+package javazoom.jl.decoder;
+
+/**
+ * 16-Bit CRC checksum
+ */
+public final class Crc16
+{
+  private static        short polynomial=(short)0x8005;
+  private                       short crc;
+
+  /**
+   * Dummy Constructor
+   */
+  public Crc16()
+  { 
+        crc = (short) 0xFFFF;
+  }
+
+  /**
+   * Feed a bitstring to the crc calculation (0 < length <= 32).
+   */
+  public void add_bits (int bitstring, int length)
+  {
+        int bitmask = 1 << (length - 1);
+        do
+         if (((crc & 0x8000) == 0) ^ ((bitstring & bitmask) == 0 ))
+         {
+                crc <<= 1;
+                crc ^= polynomial;
+         }
+         else
+                crc <<= 1;
+        while ((bitmask >>>= 1) != 0);
+  }
+
+  /**
+   * Return the calculated checksum.
+   * Erase it for next calls to add_bits().
+   */
+  public short  checksum()
+  {
+    short sum = crc;
+    crc = (short) 0xFFFF;
+    return sum;
+  }
+}
diff --git a/songdbj/javazoom/jl/decoder/Decoder.java b/songdbj/javazoom/jl/decoder/Decoder.java
new file mode 100644
index 0000000000..076f9dea27
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Decoder.java
@@ -0,0 +1,357 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 01/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+ 
+package javazoom.jl.decoder;
+
+/**
+ * The <code>Decoder</code> class encapsulates the details of
+ * decoding an MPEG audio frame. 
+ * 
+ * @author      MDM     
+ * @version 0.0.7 12/12/99
+ * @since       0.0.5
+ */
+public class Decoder implements DecoderErrors
+{
+        static private final Params DEFAULT_PARAMS = new Params();
+        
+        /**
+         * The Bistream from which the MPEG audio frames are read.
+         */
+        //private Bitstream                             stream;
+        
+        /**
+         * The Obuffer instance that will receive the decoded
+         * PCM samples.
+         */
+        private Obuffer                 output;
+                
+        /**
+         * Synthesis filter for the left channel.
+         */
+        private SynthesisFilter                 filter1;
+        
+        /**
+         * Sythesis filter for the right channel.
+         */
+        private SynthesisFilter                 filter2;        
+                        
+        /**
+         * The decoder used to decode layer III frames.
+         */
+        private LayerIIIDecoder                 l3decoder;
+        private LayerIIDecoder                  l2decoder;
+        private LayerIDecoder                   l1decoder;
+        
+        private int                                             outputFrequency;
+        private int                                             outputChannels;
+        
+        private Equalizer                               equalizer = new Equalizer();
+        
+        private Params                                  params;
+        
+        private boolean                                 initialized;
+                
+        
+        /**
+         * Creates a new <code>Decoder</code> instance with default 
+         * parameters.
+         */
+        
+        public Decoder()
+        {
+                this(null);
+        }
+
+        /**
+         * Creates a new <code>Decoder</code> instance with default 
+         * parameters.
+         * 
+         * @param params        The <code>Params</code> instance that describes
+         *                                      the customizable aspects of the decoder.  
+         */
+        public Decoder(Params params0)
+        {
+                if (params0==null)
+                        params0 = DEFAULT_PARAMS;
+        
+                params = params0;
+                
+                Equalizer eq = params.getInitialEqualizerSettings();
+                if (eq!=null)
+                {
+                        equalizer.setFrom(eq);
+                }
+        }
+        
+        static public Params getDefaultParams()
+        {
+                return (Params)DEFAULT_PARAMS.clone();
+        }
+        
+        public void setEqualizer(Equalizer eq)
+        {
+                if (eq==null)
+                        eq = Equalizer.PASS_THRU_EQ;
+                
+                equalizer.setFrom(eq);
+                
+                float[] factors = equalizer.getBandFactors();
+
+                if (filter1!=null)
+                        filter1.setEQ(factors);
+                
+                if (filter2!=null)
+                        filter2.setEQ(factors);                 
+        }
+        
+        /**
+         * Decodes one frame from an MPEG audio bitstream.
+         * 
+         * @param header                The header describing the frame to decode.
+         * @param bitstream             The bistream that provides the bits for te body of the frame. 
+         * 
+         * @return A SampleBuffer containing the decoded samples.
+         */
+        public Obuffer decodeFrame(Header header, Bitstream stream)
+                throws DecoderException
+        {
+                if (!initialized)
+                {
+                        initialize(header);
+                }
+                
+                int layer = header.layer();
+                
+                output.clear_buffer();
+                
+                FrameDecoder decoder = retrieveDecoder(header, stream, layer);
+                
+                decoder.decodeFrame();
+                                
+                output.write_buffer(1);
+                
+                return output;  
+        }
+        
+        /**
+         * Changes the output buffer. This will take effect the next time
+         * decodeFrame() is called. 
+         */
+        public void setOutputBuffer(Obuffer out)
+        {
+                output = out;
+        }
+        
+        /**
+         * Retrieves the sample frequency of the PCM samples output
+         * by this decoder. This typically corresponds to the sample
+         * rate encoded in the MPEG audio stream.
+         * 
+         * @param the sample rate (in Hz) of the samples written to the
+         *              output buffer when decoding. 
+         */
+        public int getOutputFrequency()
+        {
+                return outputFrequency;
+        }
+        
+        /**
+         * Retrieves the number of channels of PCM samples output by
+         * this decoder. This usually corresponds to the number of
+         * channels in the MPEG audio stream, although it may differ.
+         * 
+         * @return The number of output channels in the decoded samples: 1 
+         *              for mono, or 2 for stereo.
+         *              
+         */
+        public int getOutputChannels()
+        {
+                return outputChannels;  
+        }
+        
+        /**
+         * Retrieves the maximum number of samples that will be written to
+         * the output buffer when one frame is decoded. This can be used to
+         * help calculate the size of other buffers whose size is based upon 
+         * the number of samples written to the output buffer. NB: this is
+         * an upper bound and fewer samples may actually be written, depending
+         * upon the sample rate and number of channels.
+         * 
+         * @return The maximum number of samples that are written to the 
+         *              output buffer when decoding a single frame of MPEG audio.
+         */
+        public int getOutputBlockSize()
+        {
+                return Obuffer.OBUFFERSIZE;
+        }
+        
+        
+        protected DecoderException newDecoderException(int errorcode)
+        {
+                return new DecoderException(errorcode, null);
+        }
+        
+        protected DecoderException newDecoderException(int errorcode, Throwable throwable)
+        {
+                return new DecoderException(errorcode, throwable);
+        }
+        
+        protected FrameDecoder retrieveDecoder(Header header, Bitstream stream, int layer)
+                throws DecoderException
+        {
+                FrameDecoder decoder = null;
+                
+                // REVIEW: allow channel output selection type
+                // (LEFT, RIGHT, BOTH, DOWNMIX)
+                switch (layer)
+                {
+                case 3:
+                        if (l3decoder==null)
+                        {
+                                l3decoder = new LayerIIIDecoder(stream, 
+                                        header, filter1, filter2, 
+                                        output, OutputChannels.BOTH_CHANNELS);
+                        }                                               
+                        
+                        decoder = l3decoder;
+                        break;
+                case 2:
+                        if (l2decoder==null)
+                        {
+                                l2decoder = new LayerIIDecoder();
+                                l2decoder.create(stream, 
+                                        header, filter1, filter2, 
+                                        output, OutputChannels.BOTH_CHANNELS);                          
+                        }
+                        decoder = l2decoder;
+                        break;
+                case 1:
+                        if (l1decoder==null)
+                        {
+                                l1decoder = new LayerIDecoder();
+                                l1decoder.create(stream, 
+                                        header, filter1, filter2, 
+                                        output, OutputChannels.BOTH_CHANNELS);                          
+                        }
+                        decoder = l1decoder;
+                        break;
+                }
+                                                
+                if (decoder==null)
+                {
+                        throw newDecoderException(UNSUPPORTED_LAYER, null);
+                }
+                
+                return decoder;
+        }
+        
+        private void initialize(Header header)
+                throws DecoderException
+        {
+                
+                // REVIEW: allow customizable scale factor
+                float scalefactor = 32700.0f;
+                
+                int mode = header.mode();
+                int layer = header.layer();
+                int channels = mode==Header.SINGLE_CHANNEL ? 1 : 2;
+
+                                        
+                // set up output buffer if not set up by client.
+                if (output==null)
+                        output = new SampleBuffer(header.frequency(), channels);
+                
+                float[] factors = equalizer.getBandFactors();
+                filter1 = new SynthesisFilter(0, scalefactor, factors);
+                
+                // REVIEW: allow mono output for stereo
+                if (channels==2) 
+                        filter2 = new SynthesisFilter(1, scalefactor, factors);
+
+                outputChannels = channels;
+                outputFrequency = header.frequency();
+                
+                initialized = true;
+        }
+        
+        /**
+         * The <code>Params</code> class presents the customizable
+         * aspects of the decoder. 
+         * <p>
+         * Instances of this class are not thread safe. 
+         */
+        public static class Params implements Cloneable
+        {
+                private OutputChannels  outputChannels = OutputChannels.BOTH;
+                
+                private Equalizer               equalizer = new Equalizer();
+                
+                public Params()
+                {                       
+                }
+                
+                public Object clone()
+                {
+                        try
+                        {
+                                return super.clone();
+                        }
+                        catch (CloneNotSupportedException ex)
+                        {                               
+                                throw new InternalError(this+": "+ex);
+                        }
+                }
+                                
+                public void setOutputChannels(OutputChannels out)
+                {
+                        if (out==null)
+                                throw new NullPointerException("out");
+                        
+                        outputChannels = out;
+                }
+                
+                public OutputChannels getOutputChannels()
+                {
+                        return outputChannels;
+                }
+                
+                /**
+                 * Retrieves the equalizer settings that the decoder's equalizer
+                 * will be initialized from.
+                 * <p>
+                 * The <code>Equalizer</code> instance returned 
+                 * cannot be changed in real time to affect the 
+                 * decoder output as it is used only to initialize the decoders
+                 * EQ settings. To affect the decoder's output in realtime,
+                 * use the Equalizer returned from the getEqualizer() method on
+                 * the decoder. 
+                 * 
+                 * @return      The <code>Equalizer</code> used to initialize the
+                 *                      EQ settings of the decoder. 
+                 */
+                public Equalizer getInitialEqualizerSettings()
+                {
+                        return equalizer;       
+                }
+                                
+        };
+}
+
diff --git a/songdbj/javazoom/jl/decoder/DecoderErrors.java b/songdbj/javazoom/jl/decoder/DecoderErrors.java
new file mode 100644
index 0000000000..66c1935051
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/DecoderErrors.java
@@ -0,0 +1,38 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 01/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * This interface provides constants describing the error
+ * codes used by the Decoder to indicate errors. 
+ * 
+ * @author      MDM
+ */
+public interface DecoderErrors extends JavaLayerErrors
+{
+        
+        static public final int UNKNOWN_ERROR = DECODER_ERROR + 0;
+        
+        /**
+         * Layer not supported by the decoder. 
+         */
+        static public final int UNSUPPORTED_LAYER = DECODER_ERROR + 1;
+}
diff --git a/songdbj/javazoom/jl/decoder/DecoderException.java b/songdbj/javazoom/jl/decoder/DecoderException.java
new file mode 100644
index 0000000000..b75710870f
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/DecoderException.java
@@ -0,0 +1,61 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 01/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * The <code>DecoderException</code> represents the class of
+ * errors that can occur when decoding MPEG audio. 
+ * 
+ * @author MDM
+ */
+public class DecoderException extends JavaLayerException
+        implements DecoderErrors
+{       
+        private int             errorcode = UNKNOWN_ERROR;
+        
+        public DecoderException(String msg, Throwable t)
+        {
+                super(msg, t);  
+        }
+        
+        public DecoderException(int errorcode, Throwable t)
+        {
+                this(getErrorString(errorcode), t);
+                this.errorcode = errorcode;
+        }
+        
+        public int getErrorCode()
+        {
+                return errorcode;       
+        }
+        
+        
+        static public String getErrorString(int errorcode)
+        {
+                // REVIEW: use resource file to map error codes
+                // to locale-sensitive strings. 
+                
+                return "Decoder errorcode "+Integer.toHexString(errorcode);
+        }
+        
+        
+}
+
diff --git a/songdbj/javazoom/jl/decoder/Equalizer.java b/songdbj/javazoom/jl/decoder/Equalizer.java
new file mode 100644
index 0000000000..57545a939d
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Equalizer.java
@@ -0,0 +1,227 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+
+package javazoom.jl.decoder;
+
+/**
+ * The <code>Equalizer</code> class can be used to specify
+ * equalization settings for the MPEG audio decoder. 
+ * <p>
+ * The equalizer consists of 32 band-pass filters. 
+ * Each band of the equalizer can take on a fractional value between 
+ * -1.0 and +1.0.
+ * At -1.0, the input signal is attenuated by 6dB, at +1.0 the signal is
+ * amplified by 6dB. 
+ * 
+ * @see Decoder
+ * 
+ * @author MDM
+ */
+public final class Equalizer
+{               
+        /**
+         * Equalizer setting to denote that a given band will not be
+         * present in the output signal.
+         */
+        static public final float BAND_NOT_PRESENT = Float.NEGATIVE_INFINITY;
+                
+        static public final Equalizer   PASS_THRU_EQ = new Equalizer();
+        
+        private static final int BANDS = 32;
+        
+        private final float[]   settings = new float[BANDS];
+        
+        /**
+         * Creates a new <code>Equalizer</code> instance. 
+         */
+        public Equalizer()
+        {               
+        }
+        
+//      private Equalizer(float b1, float b2, float b3, float b4, float b5,
+//                                       float b6, float b7, float b8, float b9, float b10, float b11,
+//                                       float b12, float b13, float b14, float b15, float b16,
+//                                       float b17, float b18, float b19, float b20);
+
+        public Equalizer(float[] settings)
+        {
+                setFrom(settings);
+        }
+        
+        public Equalizer(EQFunction eq)
+        {
+                setFrom(eq);
+        }
+        
+        public void setFrom(float[] eq)
+        {
+                reset();
+                int max = (eq.length > BANDS) ? BANDS : eq.length;
+                
+                for (int i=0; i<max; i++)
+                {
+                        settings[i] = limit(eq[i]);
+                }
+        }
+
+        public void setFrom(EQFunction eq)
+        {
+                reset();
+                int max = BANDS;
+                
+                for (int i=0; i<max; i++)
+                {
+                        settings[i] = limit(eq.getBand(i));
+                }               
+        }
+        
+        /**
+         * Sets the bands of this equalizer to the value the bands of
+         * another equalizer. Bands that are not present in both equalizers are ignored. 
+         */
+        public void setFrom(Equalizer eq)
+        {
+                if (eq!=this)
+                {
+                        setFrom(eq.settings);
+                }
+        }
+        
+        
+        
+        
+        /**
+         * Sets all bands to 0.0
+         */
+        public void reset()
+        {
+                for (int i=0; i<BANDS; i++)
+                {
+                        settings[i] = 0.0f;
+                }
+        }
+
+        
+        /**
+         * Retrieves the number of bands present in this equalizer.
+         */
+        public int getBandCount()
+        {
+                return settings.length; 
+        }
+        
+        public float setBand(int band, float neweq)
+        {
+                float eq = 0.0f;
+                
+                if ((band>=0) && (band<BANDS))
+                {
+                        eq = settings[band];
+                        settings[band] = limit(neweq);
+                }
+                
+                return eq;              
+        }
+        
+        
+        
+        /**
+         * Retrieves the eq setting for a given band.
+         */
+        public float getBand(int band)
+        {
+                float eq = 0.0f;
+                
+                if ((band>=0) && (band<BANDS))
+                {
+                        eq = settings[band];
+                }
+                
+                return eq;
+        }
+        
+        private float limit(float eq)
+        {
+                if (eq==BAND_NOT_PRESENT)
+                        return eq;
+                if (eq > 1.0f)
+                        return 1.0f;
+                if (eq < -1.0f)
+                        return -1.0f;
+                
+                return eq;
+        }
+        
+        /**
+         * Retrieves an array of floats whose values represent a
+         * scaling factor that can be applied to linear samples
+         * in each band to provide the equalization represented by
+         * this instance. 
+         * 
+         * @return      an array of factors that can be applied to the
+         *                      subbands.
+         */
+        float[] getBandFactors()
+        {
+                float[] factors = new float[BANDS];
+                for (int i=0, maxCount=BANDS; i<maxCount; i++)
+                {
+                        factors[i] = getBandFactor(settings[i]);
+                }
+                
+                return factors;
+        }
+        
+        /**
+         * Converts an equalizer band setting to a sample factor.
+         * The factor is determined by the function f = 2^n where
+         * n is the equalizer band setting in the range [-1.0,1.0].
+         *       
+         */
+        float getBandFactor(float eq)
+        {
+                if (eq==BAND_NOT_PRESENT)
+                        return 0.0f;
+                
+                float f = (float)Math.pow(2.0, eq);
+                return f;
+        }
+        
+        
+        static abstract public class EQFunction
+        {
+                /**
+                 * Returns the setting of a band in the equalizer. 
+                 * 
+                 * @param band  The index of the band to retrieve the setting
+                 *                              for. 
+                 * 
+                 * @return              the setting of the specified band. This is a value between
+                 *                              -1 and +1.
+                 */
+                public float getBand(int band)
+                {
+                        return 0.0f;    
+                }
+                
+        }
+                
+}
diff --git a/songdbj/javazoom/jl/decoder/FrameDecoder.java b/songdbj/javazoom/jl/decoder/FrameDecoder.java
new file mode 100644
index 0000000000..eec6ac6a22
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/FrameDecoder.java
@@ -0,0 +1,38 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Implementations of FrameDecoder are responsible for decoding
+ * an MPEG audio frame.
+ *  
+ */
+//REVIEW: the interface currently is too thin. There should be
+// methods to specify the output buffer, the synthesis filters and
+// possibly other objects used by the decoder. 
+public interface FrameDecoder
+{
+        /**
+         * Decodes one frame of MPEG audio. 
+         */
+        public void decodeFrame();
+                
+}
diff --git a/songdbj/javazoom/jl/decoder/Header.java b/songdbj/javazoom/jl/decoder/Header.java
new file mode 100644
index 0000000000..e85fe19f64
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Header.java
@@ -0,0 +1,762 @@
+/*
+ * 11/19/04 : 1.0 moved to LGPL.
+ *            VBRI header support added, E.B javalayer@javazoom.net
+ * 
+ * 12/04/03 : VBR (XING) header support added, E.B javalayer@javazoom.net
+ *
+ * 02/13/99 : Java Conversion by JavaZOOM , E.B javalayer@javazoom.net
+ *
+ * Declarations for MPEG header class
+ * A few layer III, MPEG-2 LSF, and seeking modifications made by Jeff Tsay.
+ * Last modified : 04/19/97
+ *
+ *  @(#) header.h 1.7, last edit: 6/15/94 16:55:33
+ *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
+ *  @(#) Berlin University of Technology
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+package javazoom.jl.decoder;
+
+/**
+ * Class for extracting information from a frame header.
+ */
+public final class Header
+{
+        public  static final int[][]    frequencies =
+                                                {{22050, 24000, 16000, 1},
+                                                {44100, 48000, 32000, 1},
+                                                {11025, 12000, 8000, 1}};       // SZD: MPEG25
+
+        /**
+         * Constant for MPEG-2 LSF version
+         */
+        public static final int         MPEG2_LSF = 0;
+        public static final int         MPEG25_LSF = 2; // SZD
+
+        /**
+         * Constant for MPEG-1 version
+         */
+        public static final int         MPEG1 = 1;
+
+        public static final int         STEREO = 0;
+        public static final int         JOINT_STEREO = 1;
+        public static final int         DUAL_CHANNEL = 2;
+        public static final int         SINGLE_CHANNEL = 3;
+        public static final int         FOURTYFOUR_POINT_ONE = 0;
+        public static final int         FOURTYEIGHT=1;
+        public static final int         THIRTYTWO=2;
+
+        private int                             h_layer, h_protection_bit, h_bitrate_index,
+                                                        h_padding_bit, h_mode_extension;
+        private int                             h_version;
+        private int                             h_mode;
+        private int                             h_sample_frequency;
+        private int                             h_number_of_subbands, h_intensity_stereo_bound;
+        private boolean                 h_copyright, h_original;
+        // VBR support added by E.B
+        private double[]                h_vbr_time_per_frame = {-1, 384, 1152, 1152};
+        private boolean                 h_vbr;
+        private int                             h_vbr_frames;
+        private int                             h_vbr_scale;
+        private int                             h_vbr_bytes;
+        private byte[]                  h_vbr_toc;
+        
+        private byte                    syncmode = Bitstream.INITIAL_SYNC;
+        private Crc16                   crc;
+
+        public short                    checksum;
+        public int                              framesize;
+        public int                              nSlots;
+
+        private int                             _headerstring = -1; // E.B
+
+        Header()
+        {
+        }
+        public String toString()
+        {
+                StringBuffer buffer = new StringBuffer(200);
+                buffer.append("Layer ");
+                buffer.append(layer_string());
+                buffer.append(" frame ");
+                buffer.append(mode_string());
+                buffer.append(' ');
+                buffer.append(version_string());
+                if (!checksums())
+                        buffer.append(" no");
+                buffer.append(" checksums");
+                buffer.append(' ');
+                buffer.append(sample_frequency_string());
+                buffer.append(',');
+                buffer.append(' ');
+                buffer.append(bitrate_string());
+
+                String s =  buffer.toString();
+                return s;
+        }
+
+        /**
+         * Read a 32-bit header from the bitstream.
+         */
+        void read_header(Bitstream stream, Crc16[] crcp) throws BitstreamException
+        {
+                int headerstring;
+                int channel_bitrate;
+                boolean sync = false;
+                do
+                {
+                        headerstring = stream.syncHeader(syncmode);
+                        _headerstring = headerstring; // E.B
+                        if (syncmode == Bitstream.INITIAL_SYNC)
+                        {
+                                h_version = ((headerstring >>> 19) & 1);
+                                if (((headerstring >>> 20) & 1) == 0) // SZD: MPEG2.5 detection
+                                        if (h_version == MPEG2_LSF)
+                                                h_version = MPEG25_LSF;
+                                        else
+                                                throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
+                                if ((h_sample_frequency = ((headerstring >>> 10) & 3)) == 3)
+                                {
+                                        throw stream.newBitstreamException(Bitstream.UNKNOWN_ERROR);
+                                }
+                        }
+                        h_layer = 4 - (headerstring >>> 17) & 3;
+                        h_protection_bit = (headerstring >>> 16) & 1;
+                        h_bitrate_index = (headerstring >>> 12) & 0xF;
+                        h_padding_bit = (headerstring >>> 9) & 1;
+                        h_mode = ((headerstring >>> 6) & 3);
+                        h_mode_extension = (headerstring >>> 4) & 3;
+                        if (h_mode == JOINT_STEREO)
+                                h_intensity_stereo_bound = (h_mode_extension << 2) + 4;
+                        else
+                                h_intensity_stereo_bound = 0; // should never be used
+                        if (((headerstring >>> 3) & 1) == 1)
+                                h_copyright = true;
+                        if (((headerstring >>> 2) & 1) == 1)
+                                h_original = true;
+                        // calculate number of subbands:
+                        if (h_layer == 1)
+                                h_number_of_subbands = 32;
+                        else
+                        {
+                                channel_bitrate = h_bitrate_index;
+                                // calculate bitrate per channel:
+                                if (h_mode != SINGLE_CHANNEL)
+                                        if (channel_bitrate == 4)
+                                                channel_bitrate = 1;
+                                        else
+                                                channel_bitrate -= 4;
+                                if ((channel_bitrate == 1) || (channel_bitrate == 2))
+                                        if (h_sample_frequency == THIRTYTWO)
+                                                h_number_of_subbands = 12;
+                                        else
+                                                h_number_of_subbands = 8;
+                                else if ((h_sample_frequency == FOURTYEIGHT) || ((channel_bitrate >= 3) && (channel_bitrate <= 5)))
+                                        h_number_of_subbands = 27;
+                                else
+                                        h_number_of_subbands = 30;
+                        }
+                        if (h_intensity_stereo_bound > h_number_of_subbands)
+                                h_intensity_stereo_bound = h_number_of_subbands;
+                        // calculate framesize and nSlots
+                        calculate_framesize();
+                        // read framedata:
+                        int framesizeloaded = stream.read_frame_data(framesize);
+                        if ((framesize >=0) && (framesizeloaded != framesize))
+                        {
+                                // Data loaded does not match to expected framesize,
+                                // it might be an ID3v1 TAG. (Fix 11/17/04).
+                                throw stream.newBitstreamException(Bitstream.INVALIDFRAME);
+                        }
+                        if (stream.isSyncCurrentPosition(syncmode))
+                        {
+                                if (syncmode == Bitstream.INITIAL_SYNC)
+                                {
+                                        syncmode = Bitstream.STRICT_SYNC;
+                                        stream.set_syncword(headerstring & 0xFFF80CC0);
+                                }
+                                sync = true;
+                        }
+                        else
+                        {
+                                stream.unreadFrame();
+                        }
+                }
+                while (!sync);
+                stream.parse_frame();
+                if (h_protection_bit == 0)
+                {
+                        // frame contains a crc checksum
+                        checksum = (short) stream.get_bits(16);
+                        if (crc == null)
+                                crc = new Crc16();
+                        crc.add_bits(headerstring, 16);
+                        crcp[0] = crc;
+                }
+                else
+                        crcp[0] = null;
+                if (h_sample_frequency == FOURTYFOUR_POINT_ONE)
+                {
+                        /*
+                                if (offset == null)
+                          {
+                                  int max = max_number_of_frames(stream);
+                                  offset = new int[max];
+                             for(int i=0; i<max; i++) offset[i] = 0;
+                          }
+                          // E.B : Investigate more
+                          int cf = stream.current_frame();
+                          int lf = stream.last_frame();
+                          if ((cf > 0) && (cf == lf))
+                          {
+                                   offset[cf] = offset[cf-1] + h_padding_bit;
+                          }
+                          else
+                          {
+                                       offset[0] = h_padding_bit;
+                          }
+                        */
+                }
+        }
+
+        /**
+         * Parse frame to extract optionnal VBR frame.
+         * @param firstframe
+         * @author E.B (javalayer@javazoom.net)
+         */
+        void parseVBR(byte[] firstframe) throws BitstreamException
+        {
+                // Trying Xing header.
+                String xing = "Xing";
+                byte tmp[] = new byte[4];
+                int offset = 0;
+                // Compute "Xing" offset depending on MPEG version and channels.
+                if (h_version == MPEG1) 
+                {
+                  if (h_mode == SINGLE_CHANNEL)  offset=21-4;
+                  else offset=36-4;
+                } 
+                else 
+                {
+                  if (h_mode == SINGLE_CHANNEL) offset=13-4;
+                  else offset = 21-4;             
+                }
+                try
+                {
+                        System.arraycopy(firstframe, offset, tmp, 0, 4);
+                        // Is "Xing" ?
+                        if (xing.equals(new String(tmp)))
+                        {
+                                //Yes.
+                                h_vbr = true;
+                                h_vbr_frames = -1;
+                                h_vbr_bytes = -1;
+                                h_vbr_scale = -1;
+                                h_vbr_toc = new byte[100];
+                                                                
+                                int length = 4;
+                                // Read flags.
+                                byte flags[] = new byte[4];
+                                System.arraycopy(firstframe, offset + length, flags, 0, flags.length);
+                                length += flags.length;
+                                // Read number of frames (if available).
+                                if ((flags[3] & (byte) (1 << 0)) != 0)
+                                {
+                                        System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
+                                        h_vbr_frames = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
+                                        length += 4;    
+                                }
+                                // Read size (if available).
+                                if ((flags[3] & (byte) (1 << 1)) != 0)
+                                {
+                                        System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
+                                        h_vbr_bytes = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
+                                        length += 4;    
+                                }
+                                // Read TOC (if available).
+                                if ((flags[3] & (byte) (1 << 2)) != 0)
+                                {
+                                        System.arraycopy(firstframe, offset + length, h_vbr_toc, 0, h_vbr_toc.length);
+                                        length += h_vbr_toc.length;     
+                                }
+                                // Read scale (if available).
+                                if ((flags[3] & (byte) (1 << 3)) != 0)
+                                {
+                                        System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
+                                        h_vbr_scale = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
+                                        length += 4;    
+                                }
+                                //System.out.println("VBR:"+xing+" Frames:"+ h_vbr_frames +" Size:"+h_vbr_bytes);                       
+                        }                               
+                }
+                catch (ArrayIndexOutOfBoundsException e)
+                {
+                        throw new BitstreamException("XingVBRHeader Corrupted",e);
+                }
+                
+                // Trying VBRI header.                  
+                String vbri = "VBRI";
+                offset = 36-4;
+                try
+                {
+                        System.arraycopy(firstframe, offset, tmp, 0, 4);
+                        // Is "VBRI" ?
+                        if (vbri.equals(new String(tmp)))
+                        {
+                                //Yes.
+                                h_vbr = true;
+                                h_vbr_frames = -1;
+                                h_vbr_bytes = -1;
+                                h_vbr_scale = -1;
+                                h_vbr_toc = new byte[100];
+                                // Bytes.                               
+                                int length = 4 + 6;
+                                System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
+                                h_vbr_bytes = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
+                                length += 4;    
+                                // Frames.      
+                                System.arraycopy(firstframe, offset + length, tmp, 0, tmp.length);
+                                h_vbr_frames = (tmp[0] << 24)&0xFF000000 | (tmp[1] << 16)&0x00FF0000 | (tmp[2] << 8)&0x0000FF00 | tmp[3]&0x000000FF;
+                                length += 4;    
+                                //System.out.println("VBR:"+vbri+" Frames:"+ h_vbr_frames +" Size:"+h_vbr_bytes);
+                                // TOC
+                                // TODO                         
+                        }
+                }
+                catch (ArrayIndexOutOfBoundsException e)
+                {
+                        throw new BitstreamException("VBRIVBRHeader Corrupted",e);
+                }
+        }
+        
+        // Functions to query header contents:
+        /**
+         * Returns version.
+         */
+        public int version() { return h_version; }
+
+        /**
+         * Returns Layer ID.
+         */
+        public int layer() { return h_layer; }
+
+        /**
+         * Returns bitrate index.
+         */
+        public int bitrate_index() { return h_bitrate_index; }
+
+        /**
+         * Returns Sample Frequency.
+         */
+        public int sample_frequency() { return h_sample_frequency; }
+
+        /**
+         * Returns Frequency.
+         */
+        public int frequency() {return frequencies[h_version][h_sample_frequency];}
+
+        /**
+         * Returns Mode.
+         */
+        public int mode() { return h_mode; }
+
+        /**
+         * Returns Protection bit.
+         */
+        public boolean checksums()
+        {
+                if (h_protection_bit == 0) return true;
+          else return false;
+        }
+
+        /**
+         * Returns Copyright.
+         */
+        public boolean copyright() { return h_copyright; }
+
+        /**
+         * Returns Original.
+         */
+        public boolean original() { return h_original; }
+
+        /**
+         * Return VBR.
+         * @return true if VBR header is found
+         */
+        public boolean vbr() { return h_vbr; }
+
+        /**
+         * Return VBR scale.
+         * @return scale of -1 if not available
+         */
+        public int vbr_scale() { return h_vbr_scale; }
+
+        /**
+         * Return VBR TOC.
+         * @return vbr toc ot null if not available
+         */
+        public byte[] vbr_toc() { return h_vbr_toc; }
+
+        /**
+         * Returns Checksum flag.
+         * Compares computed checksum with stream checksum.
+         */
+        public boolean checksum_ok () { return (checksum == crc.checksum()); }
+
+        // Seeking and layer III stuff
+        /**
+         * Returns Layer III Padding bit.
+         */
+        public boolean padding()
+        {
+                if (h_padding_bit == 0) return false;
+          else return true;
+        }
+
+        /**
+         * Returns Slots.
+         */
+        public int slots() { return nSlots; }
+
+        /**
+         * Returns Mode Extension.
+         */
+        public int mode_extension() { return h_mode_extension; }
+
+        // E.B -> private to public
+        public static final int bitrates[][][] = {
+                {{0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
+          112000, 128000, 144000, 160000, 176000, 192000 ,224000, 256000, 0},
+                {0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
+          56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0},
+                {0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
+          56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0}},
+
+                {{0 /*free format*/, 32000, 64000, 96000, 128000, 160000, 192000,
+           224000, 256000, 288000, 320000, 352000, 384000, 416000, 448000, 0},
+          {0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
+           112000, 128000, 160000, 192000, 224000, 256000, 320000, 384000, 0},
+          {0 /*free format*/, 32000, 40000, 48000, 56000, 64000, 80000,
+           96000, 112000, 128000, 160000, 192000, 224000, 256000, 320000, 0}},
+                // SZD: MPEG2.5
+                {{0 /*free format*/, 32000, 48000, 56000, 64000, 80000, 96000,
+          112000, 128000, 144000, 160000, 176000, 192000 ,224000, 256000, 0},
+                {0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
+          56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0},
+                {0 /*free format*/, 8000, 16000, 24000, 32000, 40000, 48000,
+          56000, 64000, 80000, 96000, 112000, 128000, 144000, 160000, 0}},
+
+                };
+
+        // E.B -> private to public
+        /**
+         * Calculate Frame size.
+         * Calculates framesize in bytes excluding header size.
+         */
+        public int calculate_framesize()
+        {
+
+         if (h_layer == 1)
+         {
+           framesize = (12 * bitrates[h_version][0][h_bitrate_index]) /
+                       frequencies[h_version][h_sample_frequency];
+           if (h_padding_bit != 0 ) framesize++;
+           framesize <<= 2;             // one slot is 4 bytes long
+           nSlots = 0;
+         }
+         else
+         {
+           framesize = (144 * bitrates[h_version][h_layer - 1][h_bitrate_index]) /
+                       frequencies[h_version][h_sample_frequency];
+           if (h_version == MPEG2_LSF || h_version == MPEG25_LSF) framesize >>= 1;      // SZD
+           if (h_padding_bit != 0) framesize++;
+           // Layer III slots
+           if (h_layer == 3)
+           {
+             if (h_version == MPEG1)
+             {
+                         nSlots = framesize - ((h_mode == SINGLE_CHANNEL) ? 17 : 32) // side info size
+                                                                          -  ((h_protection_bit!=0) ? 0 : 2)                   // CRC size
+                                                                          - 4;                                                                       // header size
+             }
+             else
+                 {  // MPEG-2 LSF, SZD: MPEG-2.5 LSF
+                nSlots = framesize - ((h_mode == SINGLE_CHANNEL) ?  9 : 17) // side info size
+                                                                  -  ((h_protection_bit!=0) ? 0 : 2)                   // CRC size
+                                                                          - 4;                                                                       // header size
+             }
+           }
+           else
+           {
+                 nSlots = 0;
+           }
+         }
+         framesize -= 4;             // subtract header size
+         return framesize;
+        }
+
+        /**
+         * Returns the maximum number of frames in the stream.
+         * @param streamsize
+         * @return number of frames
+         */
+        public int max_number_of_frames(int streamsize)  // E.B
+        {
+                if (h_vbr == true) return h_vbr_frames;
+                else
+                {
+                        if ((framesize + 4 - h_padding_bit) == 0) return 0;
+                        else return(streamsize / (framesize + 4 - h_padding_bit));
+                }
+        }
+
+        /**
+         * Returns the maximum number of frames in the stream.
+         * @param streamsize
+         * @return number of frames
+         */
+        public int min_number_of_frames(int streamsize) // E.B
+        {
+                if (h_vbr == true) return h_vbr_frames;
+                else
+                {
+                        if ((framesize + 5 - h_padding_bit) == 0) return 0;
+                        else return(streamsize / (framesize + 5 - h_padding_bit));
+                }
+        }
+
+
+        /**
+         * Returns ms/frame.
+         * @return milliseconds per frame
+         */
+        public float ms_per_frame() // E.B
+        {
+                if (h_vbr == true)
+                {                       
+                        double tpf = h_vbr_time_per_frame[layer()] / frequency();
+                        if ((h_version == MPEG2_LSF) || (h_version == MPEG25_LSF)) tpf /= 2;
+                        return ((float) (tpf * 1000));
+                }
+                else
+                {
+                        float ms_per_frame_array[][] = {{8.707483f,  8.0f, 12.0f},
+                                                                                        {26.12245f, 24.0f, 36.0f},
+                                                                                        {26.12245f, 24.0f, 36.0f}};
+                        return(ms_per_frame_array[h_layer-1][h_sample_frequency]);
+                }
+        }
+
+        /**
+         * Returns total ms.
+         * @param streamsize
+         * @return total milliseconds
+         */
+        public float total_ms(int streamsize) // E.B
+        {
+                return(max_number_of_frames(streamsize) * ms_per_frame());
+        }
+
+        /**
+         * Returns synchronized header.
+         */
+        public int getSyncHeader() // E.B
+        {
+                return _headerstring;
+        }
+
+        // functions which return header informations as strings:
+        /**
+         * Return Layer version.
+         */
+        public String layer_string()
+        {
+                switch (h_layer)
+                {
+           case 1:
+                return "I";
+           case 2:
+                return "II";
+           case 3:
+                return "III";
+                }
+          return null;
+        }
+
+        // E.B -> private to public
+        public static final String bitrate_str[][][] = {
+                {{"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
+          "80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s",
+          "160 kbit/s", "176 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s",
+          "forbidden"},
+          {"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
+          "40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
+          "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
+          "forbidden"},
+          {"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
+          "40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
+          "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
+          "forbidden"}},
+
+          {{"free format", "32 kbit/s", "64 kbit/s", "96 kbit/s", "128 kbit/s",
+          "160 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s", "288 kbit/s",
+          "320 kbit/s", "352 kbit/s", "384 kbit/s", "416 kbit/s", "448 kbit/s",
+          "forbidden"},
+          {"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
+          "80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "160 kbit/s",
+          "192 kbit/s", "224 kbit/s", "256 kbit/s", "320 kbit/s", "384 kbit/s",
+          "forbidden"},
+          {"free format", "32 kbit/s", "40 kbit/s", "48 kbit/s", "56 kbit/s",
+          "64 kbit/s", "80 kbit/s" , "96 kbit/s", "112 kbit/s", "128 kbit/s",
+          "160 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s", "320 kbit/s",
+          "forbidden"}},
+                // SZD: MPEG2.5
+                {{"free format", "32 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s",
+          "80 kbit/s", "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s",
+          "160 kbit/s", "176 kbit/s", "192 kbit/s", "224 kbit/s", "256 kbit/s",
+          "forbidden"},
+          {"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
+          "40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
+          "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
+          "forbidden"},
+          {"free format", "8 kbit/s", "16 kbit/s", "24 kbit/s", "32 kbit/s",
+          "40 kbit/s", "48 kbit/s", "56 kbit/s", "64 kbit/s", "80 kbit/s",
+          "96 kbit/s", "112 kbit/s", "128 kbit/s", "144 kbit/s", "160 kbit/s",
+          "forbidden"}},
+          };
+
+        /**
+         * Return Bitrate.
+         * @return bitrate in bps
+         */
+        public String bitrate_string()
+        {
+                if (h_vbr == true)
+                {
+                        return Integer.toString(bitrate()/1000)+" kb/s";                
+                }
+          else return bitrate_str[h_version][h_layer - 1][h_bitrate_index];
+        }
+
+        /**
+         * Return Bitrate.
+         * @return bitrate in bps and average bitrate for VBR header
+         */
+        public int bitrate()
+        {
+                if (h_vbr == true)
+                {
+                        return ((int) ((h_vbr_bytes * 8) / (ms_per_frame() * h_vbr_frames)))*1000;              
+                }
+                else return bitrates[h_version][h_layer - 1][h_bitrate_index];
+        }
+
+        /**
+         * Return Instant Bitrate.
+         * Bitrate for VBR is not constant.
+         * @return bitrate in bps
+         */
+        public int bitrate_instant()
+        {
+                return bitrates[h_version][h_layer - 1][h_bitrate_index];
+        }
+
+        /**
+         * Returns Frequency
+         * @return frequency string in kHz
+         */
+        public String sample_frequency_string()
+        {
+                switch (h_sample_frequency)
+                {
+            case THIRTYTWO:
+                if (h_version == MPEG1)
+                        return "32 kHz";
+                else if (h_version == MPEG2_LSF)
+                return "16 kHz";
+            else        // SZD
+                return "8 kHz";
+            case FOURTYFOUR_POINT_ONE:
+                if (h_version == MPEG1)
+                        return "44.1 kHz";
+                else if (h_version == MPEG2_LSF)
+                return "22.05 kHz";
+                else    // SZD
+                return "11.025 kHz";
+            case FOURTYEIGHT:
+                if (h_version == MPEG1)
+                        return "48 kHz";
+                else if (h_version == MPEG2_LSF)
+                return "24 kHz";
+                else    // SZD
+                        return "12 kHz";
+          }
+          return(null);
+        }
+
+        /**
+         * Returns Mode.
+         */
+        public String mode_string()
+        {
+           switch (h_mode)
+           {
+             case STEREO:
+                return "Stereo";
+             case JOINT_STEREO:
+                return "Joint stereo";
+             case DUAL_CHANNEL:
+                return "Dual channel";
+             case SINGLE_CHANNEL:
+                return "Single channel";
+           }
+           return null;
+        }
+
+        /**
+         * Returns Version.
+         * @return MPEG-1 or MPEG-2 LSF or MPEG-2.5 LSF
+         */
+        public String version_string()
+        {
+          switch (h_version)
+          {
+            case MPEG1:
+              return "MPEG-1";
+            case MPEG2_LSF:
+              return "MPEG-2 LSF";
+            case MPEG25_LSF:    // SZD
+              return "MPEG-2.5 LSF";
+          }
+          return(null);
+        }
+
+        /**
+         * Returns the number of subbands in the current frame.
+         * @return number of subbands
+         */
+        public int number_of_subbands() {return h_number_of_subbands;}
+
+        /**
+         * Returns Intensity Stereo.
+         * (Layer II joint stereo only).
+         * Returns the number of subbands which are in stereo mode,
+         * subbands above that limit are in intensity stereo mode.
+         * @return intensity
+         */
+        public int intensity_stereo_bound() {return h_intensity_stereo_bound;}
+}
diff --git a/songdbj/javazoom/jl/decoder/InputStreamSource.java b/songdbj/javazoom/jl/decoder/InputStreamSource.java
new file mode 100644
index 0000000000..5c62947049
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/InputStreamSource.java
@@ -0,0 +1,80 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * <i>Work In Progress.</i>
+ * 
+ * An instance of <code>InputStreamSource</code> implements a
+ * <code>Source</code> that provides data from an <code>InputStream
+ * </code>. Seeking functionality is not supported. 
+ * 
+ * @author MDM
+ */
+public class InputStreamSource implements Source
+{
+        private final InputStream               in;
+        
+        public InputStreamSource(InputStream in)
+        {
+                if (in==null)
+                        throw new NullPointerException("in");
+                
+                this.in = in;           
+        }
+        
+        public int read(byte[] b, int offs, int len)
+                throws IOException
+        {
+                int read = in.read(b, offs, len);
+                return read;
+        }
+        
+        public boolean willReadBlock()
+        {
+                return true;
+                //boolean block = (in.available()==0);
+                //return block;
+        }
+        
+        public boolean isSeekable()
+        {
+                return false;   
+        }
+        
+        public long     tell()
+        {
+                return -1;      
+        }
+        
+        public long     seek(long to)
+        {
+                return -1;      
+        }
+        
+        public long length()
+        {
+                return -1;
+        }
+}
diff --git a/songdbj/javazoom/jl/decoder/JavaLayerError.java b/songdbj/javazoom/jl/decoder/JavaLayerError.java
new file mode 100644
index 0000000000..d9910bcc71
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/JavaLayerError.java
@@ -0,0 +1,31 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Work in progress.
+ * 
+ * API usage errors may be handled by throwing an instance of this
+ * class, as per JMF 2.0. 
+ */
+public class JavaLayerError extends Error
+{       
+}
diff --git a/songdbj/javazoom/jl/decoder/JavaLayerErrors.java b/songdbj/javazoom/jl/decoder/JavaLayerErrors.java
new file mode 100644
index 0000000000..3b9c2ff9d7
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/JavaLayerErrors.java
@@ -0,0 +1,40 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Exception erorr codes for components of the JavaLayer API.
+ */
+public interface JavaLayerErrors
+{
+        /**
+         * The first bitstream error code. See the {@link DecoderErrors DecoderErrors}
+         * interface for other bitstream error codes.
+         */
+        static public final int BITSTREAM_ERROR = 0x100;
+
+        /**
+         * The first decoder error code. See the {@link DecoderErrors DecoderErrors}
+         * interface for other decoder error codes.
+         */
+        static public final int DECODER_ERROR = 0x200;
+
+}
diff --git a/songdbj/javazoom/jl/decoder/JavaLayerException.java b/songdbj/javazoom/jl/decoder/JavaLayerException.java
new file mode 100644
index 0000000000..e7a50a8340
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/JavaLayerException.java
@@ -0,0 +1,80 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+import java.io.PrintStream;
+
+
+/**
+ * The JavaLayerException is the base class for all API-level
+ * exceptions thrown by JavaLayer. To facilitate conversion and 
+ * common handling of exceptions from other domains, the class 
+ * can delegate some functionality to a contained Throwable instance. 
+ * <p> 
+ * 
+ * @author MDM
+ */
+public class JavaLayerException extends Exception
+{
+        
+        private Throwable               exception;
+        
+        
+        public JavaLayerException()
+        {
+        }
+        
+        public JavaLayerException(String msg)
+        {
+                super(msg);
+        }
+        
+        public JavaLayerException(String msg, Throwable t)
+        {
+                super(msg);
+                exception = t;
+        }
+        
+        public Throwable getException()
+        {
+                return exception;       
+        }
+        
+        
+        public void printStackTrace()
+        {
+                printStackTrace(System.err);    
+        }
+        
+        public void printStackTrace(PrintStream ps)
+        {
+                if (this.exception==null)
+                {
+                        super.printStackTrace(ps);      
+                }
+                else
+                {
+                        exception.printStackTrace();
+                }
+        }
+        
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/JavaLayerHook.java b/songdbj/javazoom/jl/decoder/JavaLayerHook.java
new file mode 100644
index 0000000000..352059433d
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/JavaLayerHook.java
@@ -0,0 +1,36 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+import java.io.InputStream;
+
+/**
+ * The <code>JavaLayerHooks</code> class allows developers to change
+ * the way the JavaLayer library uses Resources. 
+ */
+
+public interface JavaLayerHook
+{
+        /**
+         * Retrieves the named resource. This allows resources to be
+         * obtained without specifying how they are retrieved. 
+         */
+        public InputStream getResourceAsStream(String name);
+}
diff --git a/songdbj/javazoom/jl/decoder/JavaLayerUtils.java b/songdbj/javazoom/jl/decoder/JavaLayerUtils.java
new file mode 100644
index 0000000000..c9ce3838e5
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/JavaLayerUtils.java
@@ -0,0 +1,207 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 12/12/99             Initial version.        mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InvalidClassException;
+import java.io.InvalidObjectException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Array;
+
+/**
+ * The JavaLayerUtils class is not strictly part of the JavaLayer API.
+ * It serves to provide useful methods and system-wide hooks.
+ * 
+ * @author MDM
+ */
+public class JavaLayerUtils
+{
+        static private JavaLayerHook    hook = null;
+        
+        /**
+         * Deserializes the object contained in the given input stream.
+         * @param in    The input stream to deserialize an object from.
+         * @param cls   The expected class of the deserialized object. 
+         */
+        static public Object deserialize(InputStream in, Class cls)
+                throws IOException
+        {
+                if (cls==null)
+                        throw new NullPointerException("cls");
+                
+                Object obj = deserialize(in, cls);
+                if (!cls.isInstance(obj))
+                {
+                        throw new InvalidObjectException("type of deserialized instance not of required class.");
+                }
+                
+                return obj;
+        }
+        
+        /**
+         * Deserializes an object from the given <code>InputStream</code>.
+         * The deserialization is delegated to an <code>
+         * ObjectInputStream</code> instance. 
+         * 
+         * @param in    The <code>InputStream</code> to deserialize an object
+         *                              from.
+         * 
+         * @return The object deserialized from the stream. 
+         * @exception IOException is thrown if there was a problem reading
+         *              the underlying stream, or an object could not be deserialized
+         *              from the stream.
+         * 
+         * @see java.io.ObjectInputStream
+         */
+        static public Object deserialize(InputStream in)
+                throws IOException
+        {
+                if (in==null)
+                        throw new NullPointerException("in");
+                
+                ObjectInputStream objIn = new ObjectInputStream(in);
+                
+                Object obj;
+                
+                try
+                {
+                        obj = objIn.readObject();
+                }
+                catch (ClassNotFoundException ex)
+                {
+                        throw new InvalidClassException(ex.toString());
+                }
+                
+                return obj;
+        }
+
+        /**
+         * Deserializes an array from a given <code>InputStream</code>.
+         * 
+         * @param in            The <code>InputStream</code> to 
+         *                                      deserialize an object from.
+         *                              
+         * @param elemType      The class denoting the type of the array
+         *                                      elements.
+         * @param length        The expected length of the array, or -1 if
+         *                                      any length is expected.
+         */
+        static public Object deserializeArray(InputStream in, Class elemType, int length)
+                throws IOException
+        {
+                if (elemType==null)
+                        throw new NullPointerException("elemType");
+                
+                if (length<-1)
+                        throw new IllegalArgumentException("length");
+                
+                Object obj = deserialize(in);
+                
+                Class cls = obj.getClass();
+                
+                
+                if (!cls.isArray())
+                        throw new InvalidObjectException("object is not an array");
+                
+                Class arrayElemType = cls.getComponentType();
+                if (arrayElemType!=elemType)
+                        throw new InvalidObjectException("unexpected array component type");
+                                
+                if (length != -1)
+                {
+                        int arrayLength = Array.getLength(obj);
+                        if (arrayLength!=length)
+                                throw new InvalidObjectException("array length mismatch");
+                }
+                
+                return obj;
+        }
+
+        static public Object deserializeArrayResource(String name, Class elemType, int length)
+                throws IOException
+        {               
+                InputStream str = getResourceAsStream(name);
+                if (str==null)
+                        throw new IOException("unable to load resource '"+name+"'");
+                
+                Object obj = deserializeArray(str, elemType, length);
+                
+                return obj;
+        }       
+        
+        static public void serialize(OutputStream out, Object obj)
+                throws IOException
+        {
+                if (out==null)
+                        throw new NullPointerException("out");
+                
+                if (obj==null)
+                        throw new NullPointerException("obj");
+                
+                ObjectOutputStream objOut = new ObjectOutputStream(out);
+                objOut.writeObject(obj);
+                                
+        }
+
+        /**
+         * Sets the system-wide JavaLayer hook.
+         */
+        static synchronized public void setHook(JavaLayerHook hook0)            
+        {
+                hook = hook0;
+        }
+        
+        static synchronized public JavaLayerHook getHook()
+        {
+                return hook;    
+        }
+        
+        /**
+         * Retrieves an InputStream for a named resource. 
+         * 
+         * @param name  The name of the resource. This must be a simple
+         *                              name, and not a qualified package name.
+         * 
+         * @return              The InputStream for the named resource, or null if
+         *                              the resource has not been found. If a hook has been 
+         *                              provided, its getResourceAsStream() method is called
+         *                              to retrieve the resource. 
+         */
+        static synchronized public InputStream getResourceAsStream(String name)
+        {
+                InputStream is = null;
+                
+                if (hook!=null)
+                {
+                        is = hook.getResourceAsStream(name);    
+                }
+                else
+                {
+                        Class cls = JavaLayerUtils.class;
+                        is = cls.getResourceAsStream(name);
+                }
+                
+                return is;              
+        }
+}
diff --git a/songdbj/javazoom/jl/decoder/LayerIDecoder.java b/songdbj/javazoom/jl/decoder/LayerIDecoder.java
new file mode 100644
index 0000000000..b633dd2403
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/LayerIDecoder.java
@@ -0,0 +1,444 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 
+ * 12/12/99             Initial version. Adapted from javalayer.java
+ *                              and Subband*.java. mdm@techie.com
+ *
+ * 02/28/99             Initial version : javalayer.java by E.B
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+ 
+package javazoom.jl.decoder;
+
+/**
+ * Implements decoding of MPEG Audio Layer I frames. 
+ */
+class LayerIDecoder implements FrameDecoder
+{
+        protected Bitstream                     stream;
+    protected Header                            header;
+    protected SynthesisFilter           filter1, filter2;
+    protected Obuffer                           buffer;
+    protected int                                       which_channels;
+        protected int                                   mode;
+        
+        protected int                                   num_subbands;
+        protected Subband[]                             subbands;
+        protected Crc16                         crc     = null; // new Crc16[1] to enable CRC checking.
+        
+        public LayerIDecoder()
+        {
+                crc = new Crc16();
+        }
+        
+        public void create(Bitstream stream0, Header header0,
+                SynthesisFilter filtera, SynthesisFilter filterb,
+                Obuffer buffer0, int which_ch0)
+        {               
+                stream         = stream0;
+                header         = header0;
+                filter1        = filtera;
+                filter2        = filterb;
+                buffer         = buffer0;
+                which_channels = which_ch0;
+                  
+        }
+        
+        
+        
+        public void decodeFrame()
+        {
+                
+                num_subbands = header.number_of_subbands();
+                subbands = new Subband[32];
+                mode = header.mode();
+                
+                createSubbands();
+                
+                readAllocation();
+                readScaleFactorSelection();
+                
+            if ((crc != null) || header.checksum_ok())
+                {
+                        readScaleFactors();
+                        
+                        readSampleData();                       
+                }
+
+        }
+
+        protected void createSubbands()
+        {               
+                int i;
+                if (mode == Header.SINGLE_CHANNEL)
+                  for (i = 0; i < num_subbands; ++i)
+                    subbands[i] = new SubbandLayer1(i);
+                else if (mode == Header.JOINT_STEREO)
+                {
+                  for (i = 0; i < header.intensity_stereo_bound(); ++i)
+                    subbands[i] = new SubbandLayer1Stereo(i);
+                  for (; i < num_subbands; ++i)
+                    subbands[i] = new SubbandLayer1IntensityStereo(i);
+                }
+                else
+                {
+                  for (i = 0; i < num_subbands; ++i)
+                    subbands[i] = new SubbandLayer1Stereo(i);
+            }           
+        }
+        
+        protected void readAllocation()
+        {
+                // start to read audio data:
+            for (int i = 0; i < num_subbands; ++i)
+              subbands[i].read_allocation(stream, header, crc);
+                
+        }
+
+        protected void readScaleFactorSelection()
+        {
+                // scale factor selection not present for layer I. 
+        }
+        
+        protected void readScaleFactors()
+        {
+                for (int i = 0; i < num_subbands; ++i)
+                  subbands[i].read_scalefactor(stream, header);                 
+        }
+        
+        protected void readSampleData()
+        {
+                boolean read_ready = false;
+                boolean write_ready = false;
+                int mode = header.mode();
+                int i;
+                do
+                {
+                  for (i = 0; i < num_subbands; ++i)
+                        read_ready = subbands[i].read_sampledata(stream);
+                  do
+                  {
+                        for (i = 0; i < num_subbands; ++i)
+                                write_ready = subbands[i].put_next_sample(which_channels,filter1, filter2);
+
+                        filter1.calculate_pcm_samples(buffer);
+                        if ((which_channels == OutputChannels.BOTH_CHANNELS) && (mode != Header.SINGLE_CHANNEL))
+                        filter2.calculate_pcm_samples(buffer);
+                  } while (!write_ready);
+                } while (!read_ready);
+                
+        }
+
+        /**
+         * Abstract base class for subband classes of layer I and II
+         */
+        static abstract class Subband
+        {
+         /*
+          *  Changes from version 1.1 to 1.2:
+          *    - array size increased by one, although a scalefactor with index 63
+          *      is illegal (to prevent segmentation faults)
+          */
+          // Scalefactors for layer I and II, Annex 3-B.1 in ISO/IEC DIS 11172:
+          public static final float scalefactors[] =
+          {
+          2.00000000000000f, 1.58740105196820f, 1.25992104989487f, 1.00000000000000f,
+          0.79370052598410f, 0.62996052494744f, 0.50000000000000f, 0.39685026299205f,
+          0.31498026247372f, 0.25000000000000f, 0.19842513149602f, 0.15749013123686f,
+          0.12500000000000f, 0.09921256574801f, 0.07874506561843f, 0.06250000000000f,
+          0.04960628287401f, 0.03937253280921f, 0.03125000000000f, 0.02480314143700f,
+          0.01968626640461f, 0.01562500000000f, 0.01240157071850f, 0.00984313320230f,
+          0.00781250000000f, 0.00620078535925f, 0.00492156660115f, 0.00390625000000f,
+          0.00310039267963f, 0.00246078330058f, 0.00195312500000f, 0.00155019633981f,
+          0.00123039165029f, 0.00097656250000f, 0.00077509816991f, 0.00061519582514f,
+          0.00048828125000f, 0.00038754908495f, 0.00030759791257f, 0.00024414062500f,
+          0.00019377454248f, 0.00015379895629f, 0.00012207031250f, 0.00009688727124f,
+          0.00007689947814f, 0.00006103515625f, 0.00004844363562f, 0.00003844973907f,
+          0.00003051757813f, 0.00002422181781f, 0.00001922486954f, 0.00001525878906f,
+          0.00001211090890f, 0.00000961243477f, 0.00000762939453f, 0.00000605545445f,
+          0.00000480621738f, 0.00000381469727f, 0.00000302772723f, 0.00000240310869f,
+          0.00000190734863f, 0.00000151386361f, 0.00000120155435f, 0.00000000000000f /* illegal scalefactor */
+          };
+
+          public abstract void read_allocation (Bitstream stream, Header header, Crc16 crc);
+          public abstract void read_scalefactor (Bitstream stream, Header header);
+          public abstract boolean read_sampledata (Bitstream stream);
+          public abstract boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2);
+        };
+        
+        /**
+         * Class for layer I subbands in single channel mode.
+         * Used for single channel mode
+         * and in derived class for intensity stereo mode
+         */
+        static class SubbandLayer1 extends Subband
+        {
+
+          // Factors and offsets for sample requantization
+          public static final float table_factor[] = {
+           0.0f, (1.0f/2.0f) * (4.0f/3.0f), (1.0f/4.0f) * (8.0f/7.0f), (1.0f/8.0f) * (16.0f/15.0f),
+          (1.0f/16.0f) * (32.0f/31.0f), (1.0f/32.0f) * (64.0f/63.0f), (1.0f/64.0f) * (128.0f/127.0f),
+          (1.0f/128.0f) * (256.0f/255.0f), (1.0f/256.0f) * (512.0f/511.0f),
+          (1.0f/512.0f) * (1024.0f/1023.0f), (1.0f/1024.0f) * (2048.0f/2047.0f),
+          (1.0f/2048.0f) * (4096.0f/4095.0f), (1.0f/4096.0f) * (8192.0f/8191.0f),
+          (1.0f/8192.0f) * (16384.0f/16383.0f), (1.0f/16384.0f) * (32768.0f/32767.0f)
+          };
+
+          public static final float table_offset[] = {
+           0.0f, ((1.0f/2.0f)-1.0f) * (4.0f/3.0f), ((1.0f/4.0f)-1.0f) * (8.0f/7.0f), ((1.0f/8.0f)-1.0f) * (16.0f/15.0f),
+          ((1.0f/16.0f)-1.0f) * (32.0f/31.0f), ((1.0f/32.0f)-1.0f) * (64.0f/63.0f), ((1.0f/64.0f)-1.0f) * (128.0f/127.0f),
+          ((1.0f/128.0f)-1.0f) * (256.0f/255.0f), ((1.0f/256.0f)-1.0f) * (512.0f/511.0f),
+          ((1.0f/512.0f)-1.0f) * (1024.0f/1023.0f), ((1.0f/1024.0f)-1.0f) * (2048.0f/2047.0f),
+          ((1.0f/2048.0f)-1.0f) * (4096.0f/4095.0f), ((1.0f/4096.0f)-1.0f) * (8192.0f/8191.0f),
+          ((1.0f/8192.0f)-1.0f) * (16384.0f/16383.0f), ((1.0f/16384.0f)-1.0f) * (32768.0f/32767.0f)
+          };
+
+          protected int                  subbandnumber;
+          protected int                  samplenumber;
+          protected int                  allocation;
+          protected float                scalefactor;
+          protected int                  samplelength;
+          protected float                sample;
+          protected float                factor, offset;
+
+          /**
+           * Construtor.
+           */
+          public SubbandLayer1(int subbandnumber)
+          {
+            this.subbandnumber = subbandnumber;
+            samplenumber = 0;  
+          }
+          
+          /**
+           *
+           */
+          public void read_allocation(Bitstream stream, Header header, Crc16 crc)
+          {
+            if ((allocation = stream.get_bits (4)) == 15) ;
+                //       cerr << "WARNING: stream contains an illegal allocation!\n";
+                // MPEG-stream is corrupted!
+                if (crc != null)
+                        crc.add_bits (allocation, 4);
+                if (allocation != 0)
+            {
+                 samplelength = allocation + 1;
+                 factor = table_factor[allocation];
+             offset = table_offset[allocation];
+            }
+          }
+
+          /**
+           *
+           */
+          public void read_scalefactor(Bitstream stream, Header header)
+          {
+            if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
+          }
+
+          /**
+           *
+           */
+          public boolean read_sampledata(Bitstream stream)
+          {
+            if (allocation != 0)
+            {
+                   sample = (float) (stream.get_bits(samplelength));
+            }
+            if (++samplenumber == 12)
+            {
+                   samplenumber = 0;
+                   return true;
+            }
+            return false;  
+          }
+
+          /**
+           *
+           */
+          public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          {
+            if ((allocation !=0) && (channels != OutputChannels.RIGHT_CHANNEL))
+            {
+                   float scaled_sample = (sample * factor + offset) * scalefactor;
+                   filter1.input_sample (scaled_sample, subbandnumber);
+            }
+            return true;
+          }
+        };
+        
+        /**
+         * Class for layer I subbands in joint stereo mode.
+         */
+        static class SubbandLayer1IntensityStereo extends SubbandLayer1
+        {
+          protected float               channel2_scalefactor;
+
+          /**
+           * Constructor
+           */
+          public SubbandLayer1IntensityStereo(int subbandnumber)
+          {
+                super(subbandnumber);  
+          }
+
+          /**
+           *
+           */
+          public void read_allocation(Bitstream stream, Header header, Crc16 crc)
+          {
+            super.read_allocation (stream, header, crc);
+          }
+          
+          /**
+           *
+           */
+          public void read_scalefactor (Bitstream stream, Header header)
+          {
+            if (allocation != 0)
+            {
+                  scalefactor = scalefactors[stream.get_bits(6)];
+                  channel2_scalefactor = scalefactors[stream.get_bits(6)];
+            }
+          }
+
+          /**
+           *
+           */
+          public boolean read_sampledata(Bitstream stream)
+          {
+                 return super.read_sampledata (stream);
+          }
+          
+          /**
+           *
+           */
+          public boolean put_next_sample (int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          {
+            if (allocation !=0 )
+            {
+              sample = sample * factor + offset;                // requantization
+                  if (channels == OutputChannels.BOTH_CHANNELS)
+              {
+                        float sample1 = sample * scalefactor,
+                        sample2 = sample * channel2_scalefactor;
+                        filter1.input_sample(sample1, subbandnumber);
+                        filter2.input_sample(sample2, subbandnumber);
+                  }
+                  else if (channels == OutputChannels.LEFT_CHANNEL)
+                  {
+                        float sample1 = sample * scalefactor;
+                        filter1.input_sample(sample1, subbandnumber);
+                  }
+                  else
+                  {
+                        float sample2 = sample * channel2_scalefactor;
+                        filter1.input_sample(sample2, subbandnumber);
+                  }
+            }
+            return true;
+          }
+        };
+        
+        /**
+         * Class for layer I subbands in stereo mode.
+         */
+        static class SubbandLayer1Stereo extends SubbandLayer1
+        {
+          protected int                 channel2_allocation;
+          protected float               channel2_scalefactor;
+          protected int                 channel2_samplelength;
+          protected float               channel2_sample;
+          protected float               channel2_factor, channel2_offset;
+
+
+          /**
+           * Constructor
+           */
+          public SubbandLayer1Stereo(int subbandnumber)
+          {
+            super(subbandnumber);
+          }
+          
+          /**
+           *
+           */
+          public void read_allocation (Bitstream stream, Header header, Crc16 crc)
+          {
+                 allocation = stream.get_bits(4);
+             channel2_allocation = stream.get_bits(4);
+             if (crc != null)
+             {
+                   crc.add_bits (allocation, 4);
+               crc.add_bits (channel2_allocation, 4);
+             }
+             if (allocation != 0)
+             {
+                    samplelength = allocation + 1;
+                factor = table_factor[allocation];
+                offset = table_offset[allocation];
+             }
+             if (channel2_allocation != 0)
+             {
+                channel2_samplelength = channel2_allocation + 1;
+                    channel2_factor = table_factor[channel2_allocation];
+                    channel2_offset = table_offset[channel2_allocation];
+             }
+          }
+          
+          /**
+           *
+           */
+          public void read_scalefactor(Bitstream stream, Header header)
+          {
+            if (allocation != 0) scalefactor = scalefactors[stream.get_bits(6)];
+            if (channel2_allocation != 0) channel2_scalefactor = scalefactors[stream.get_bits(6)];
+          }
+
+          /**
+           *
+           */
+          public boolean read_sampledata (Bitstream stream)
+          {
+             boolean returnvalue = super.read_sampledata(stream);
+             if (channel2_allocation != 0)
+             {
+                    channel2_sample = (float) (stream.get_bits(channel2_samplelength));
+              }
+            return(returnvalue);
+          }
+          
+          /**
+           *
+           */
+          public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          {
+             super.put_next_sample (channels, filter1, filter2);
+             if ((channel2_allocation != 0) && (channels != OutputChannels.LEFT_CHANNEL))
+             {
+                    float sample2 = (channel2_sample * channel2_factor + channel2_offset) *
+                                          channel2_scalefactor;
+                    if (channels == OutputChannels.BOTH_CHANNELS)
+                           filter2.input_sample (sample2, subbandnumber);
+                    else
+                           filter1.input_sample (sample2, subbandnumber);
+             }
+             return true;
+          }
+        };
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/LayerIIDecoder.java b/songdbj/javazoom/jl/decoder/LayerIIDecoder.java
new file mode 100644
index 0000000000..7265b1f8fa
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/LayerIIDecoder.java
@@ -0,0 +1,1064 @@
+/*
+ * 11/19/04  1.0 moved to LGPL.
+ * 
+ * 29/05/01  Michael Scheerer,  Fixed some C++ to Java porting bugs. 
+ *
+ * 16/07/01  Michael Scheerer, Catched a bug in method
+ *           read_sampledata, which causes an outOfIndexException.
+ * 
+ * 12/12/99  Initial version. Adapted from javalayer.java
+ *                       and Subband*.java. mdm@techie.com
+ *
+ * 02/28/99  Initial version : javalayer.java by E.B
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Implements decoding of MPEG Audio Layer II frames. 
+ */
+class LayerIIDecoder extends LayerIDecoder implements FrameDecoder
+{
+
+        public LayerIIDecoder()
+        {
+        }
+
+        
+        protected void createSubbands()
+        {               
+                int i;
+                if (mode == Header.SINGLE_CHANNEL)
+                  for (i = 0; i < num_subbands; ++i)
+                    subbands[i] = new SubbandLayer2(i);
+                else if (mode == Header.JOINT_STEREO)
+                {
+                  for (i = 0; i < header.intensity_stereo_bound(); ++i)
+                      subbands[i] = new SubbandLayer2Stereo(i);
+                  for (; i < num_subbands; ++i)
+                      subbands[i] = new SubbandLayer2IntensityStereo(i);
+                }
+                else
+                {
+                  for (i = 0; i < num_subbands; ++i)
+                      subbands[i] = new SubbandLayer2Stereo(i);
+        }
+                
+        }
+        
+        protected void readScaleFactorSelection()
+        {
+                for (int i = 0; i < num_subbands; ++i)
+                  ((SubbandLayer2)subbands[i]).read_scalefactor_selection(stream, crc);         
+        }
+        
+        
+
+         /**
+          * Class for layer II subbands in single channel mode.
+          */
+        static class SubbandLayer2 extends Subband
+        {
+          // this table contains 3 requantized samples for each legal codeword
+          // when grouped in 5 bits, i.e. 3 quantizationsteps per sample
+        public static final float grouping_5bits[] = new float[]
+        {
+          -2.0f/3.0f, -2.0f/3.0f, -2.0f/3.0f,
+                         0.0f, -2.0f/3.0f, -2.0f/3.0f,
+                2.0f/3.0f, -2.0f/3.0f, -2.0f/3.0f,
+          -2.0f/3.0f,      0.0f, -2.0f/3.0f,
+                         0.0f,      0.0f, -2.0f/3.0f,
+                2.0f/3.0f,      0.0f, -2.0f/3.0f,
+          -2.0f/3.0f,  2.0f/3.0f, -2.0f/3.0f,
+                         0.0f,  2.0f/3.0f, -2.0f/3.0f,
+                2.0f/3.0f,  2.0f/3.0f, -2.0f/3.0f,
+          -2.0f/3.0f, -2.0f/3.0f,      0.0f,
+                         0.0f, -2.0f/3.0f,      0.0f,
+                2.0f/3.0f, -2.0f/3.0f,      0.0f,
+          -2.0f/3.0f,      0.0f,      0.0f,
+                         0.0f,      0.0f,      0.0f,
+                2.0f/3.0f,      0.0f,      0.0f,
+          -2.0f/3.0f,  2.0f/3.0f,      0.0f,
+                         0.0f,  2.0f/3.0f,      0.0f,
+                2.0f/3.0f,  2.0f/3.0f,      0.0f,
+          -2.0f/3.0f, -2.0f/3.0f,  2.0f/3.0f,
+               0.0f, -2.0f/3.0f,  2.0f/3.0f,
+                2.0f/3.0f, -2.0f/3.0f,  2.0f/3.0f,
+          -2.0f/3.0f,      0.0f,  2.0f/3.0f,
+               0.0f,      0.0f,  2.0f/3.0f,
+           2.0f/3.0f,      0.0f,  2.0f/3.0f,
+          -2.0f/3.0f,  2.0f/3.0f,  2.0f/3.0f,
+                         0.0f,  2.0f/3.0f,  2.0f/3.0f,
+           2.0f/3.0f,  2.0f/3.0f,  2.0f/3.0f
+        };
+
+        // this table contains 3 requantized samples for each legal codeword
+        // when grouped in 7 bits, i.e. 5 quantizationsteps per sample
+        public static final float grouping_7bits[] = new float[]
+        {
+          -0.8f, -0.8f, -0.8f,   -0.4f, -0.8f, -0.8f,    0.0f, -0.8f, -0.8f,    0.4f, -0.8f, -0.8f,    0.8f, -0.8f, -0.8f,
+          -0.8f, -0.4f, -0.8f,   -0.4f, -0.4f, -0.8f,    0.0f, -0.4f, -0.8f,    0.4f, -0.4f, -0.8f,    0.8f, -0.4f, -0.8f,
+          -0.8f,  0.0f, -0.8f,   -0.4f,  0.0f, -0.8f,    0.0f,  0.0f, -0.8f,    0.4f,  0.0f, -0.8f,    0.8f,  0.0f, -0.8f,
+          -0.8f,  0.4f, -0.8f,   -0.4f,  0.4f, -0.8f,    0.0f,  0.4f, -0.8f,    0.4f,  0.4f, -0.8f,    0.8f,  0.4f, -0.8f,
+          -0.8f,  0.8f, -0.8f,   -0.4f,  0.8f, -0.8f,    0.0f,  0.8f, -0.8f,    0.4f,  0.8f, -0.8f,    0.8f,  0.8f, -0.8f,
+          -0.8f, -0.8f, -0.4f,   -0.4f, -0.8f, -0.4f,    0.0f, -0.8f, -0.4f,    0.4f, -0.8f, -0.4f,    0.8f, -0.8f, -0.4f,
+          -0.8f, -0.4f, -0.4f,   -0.4f, -0.4f, -0.4f,    0.0f, -0.4f, -0.4f,    0.4f, -0.4f, -0.4f,    0.8f, -0.4f, -0.4f,
+          -0.8f,  0.0f, -0.4f,   -0.4f,  0.0f, -0.4f,    0.0f,  0.0f, -0.4f,    0.4f,  0.0f, -0.4f,    0.8f,  0.0f, -0.4f,
+          -0.8f,  0.4f, -0.4f,   -0.4f,  0.4f, -0.4f,    0.0f,  0.4f, -0.4f,    0.4f,  0.4f, -0.4f,    0.8f,  0.4f, -0.4f,
+          -0.8f,  0.8f, -0.4f,   -0.4f,  0.8f, -0.4f,    0.0f,  0.8f, -0.4f,    0.4f,  0.8f, -0.4f,    0.8f,  0.8f, -0.4f,
+          -0.8f, -0.8f,  0.0f,   -0.4f, -0.8f,  0.0f,    0.0f, -0.8f,  0.0f,    0.4f, -0.8f,  0.0f,    0.8f, -0.8f,  0.0f,
+          -0.8f, -0.4f,  0.0f,   -0.4f, -0.4f,  0.0f,    0.0f, -0.4f,  0.0f,    0.4f, -0.4f,  0.0f,    0.8f, -0.4f,  0.0f,
+          -0.8f,  0.0f,  0.0f,   -0.4f,  0.0f,  0.0f,    0.0f,  0.0f,  0.0f,    0.4f,  0.0f,  0.0f,    0.8f,  0.0f,  0.0f,
+          -0.8f,  0.4f,  0.0f,   -0.4f,  0.4f,  0.0f,    0.0f,  0.4f,  0.0f,    0.4f,  0.4f,  0.0f,    0.8f,  0.4f,  0.0f,
+          -0.8f,  0.8f,  0.0f,   -0.4f,  0.8f,  0.0f,    0.0f,  0.8f,  0.0f,    0.4f,  0.8f,  0.0f,    0.8f,  0.8f,  0.0f,
+          -0.8f, -0.8f,  0.4f,   -0.4f, -0.8f,  0.4f,    0.0f, -0.8f,  0.4f,    0.4f, -0.8f,  0.4f,    0.8f, -0.8f,  0.4f,
+          -0.8f, -0.4f,  0.4f,   -0.4f, -0.4f,  0.4f,    0.0f, -0.4f,  0.4f,    0.4f, -0.4f,  0.4f,    0.8f, -0.4f,  0.4f,
+          -0.8f,  0.0f,  0.4f,   -0.4f,  0.0f,  0.4f,    0.0f,  0.0f,  0.4f,    0.4f,  0.0f,  0.4f,    0.8f,  0.0f,  0.4f,
+          -0.8f,  0.4f,  0.4f,   -0.4f,  0.4f,  0.4f,    0.0f,  0.4f,  0.4f,    0.4f,  0.4f,  0.4f,    0.8f,  0.4f,  0.4f,
+          -0.8f,  0.8f,  0.4f,   -0.4f,  0.8f,  0.4f,    0.0f,  0.8f,  0.4f,    0.4f,  0.8f,  0.4f,    0.8f,  0.8f,  0.4f,
+          -0.8f, -0.8f,  0.8f,   -0.4f, -0.8f,  0.8f,    0.0f, -0.8f,  0.8f,    0.4f, -0.8f,  0.8f,    0.8f, -0.8f,  0.8f,
+          -0.8f, -0.4f,  0.8f,   -0.4f, -0.4f,  0.8f,    0.0f, -0.4f,  0.8f,    0.4f, -0.4f,  0.8f,    0.8f, -0.4f,  0.8f,
+          -0.8f,  0.0f,  0.8f,   -0.4f,  0.0f,  0.8f,    0.0f,  0.0f,  0.8f,    0.4f,  0.0f,  0.8f,    0.8f,  0.0f,  0.8f,
+          -0.8f,  0.4f,  0.8f,   -0.4f,  0.4f,  0.8f,    0.0f,  0.4f,  0.8f,    0.4f,  0.4f,  0.8f,    0.8f,  0.4f,  0.8f,
+          -0.8f,  0.8f,  0.8f,   -0.4f,  0.8f,  0.8f,    0.0f,  0.8f,  0.8f,    0.4f,  0.8f,  0.8f,    0.8f,  0.8f,  0.8f
+        };
+
+        // this table contains 3 requantized samples for each legal codeword
+        // when grouped in 10 bits, i.e. 9 quantizationsteps per sample
+        public static final float grouping_10bits[] =
+        {
+          -8.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,        0.0f, -8.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,        0.0f, -6.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,        0.0f, -4.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,        0.0f, -2.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f,      0.0f, -8.0f/9.0f,   -6.0f/9.0f,      0.0f, -8.0f/9.0f,   -4.0f/9.0f,      0.0f, -8.0f/9.0f,
+          -2.0f/9.0f,      0.0f, -8.0f/9.0f,        0.0f,      0.0f, -8.0f/9.0f,    2.0f/9.0f,      0.0f, -8.0f/9.0f,
+                4.0f/9.0f,      0.0f, -8.0f/9.0f,    6.0f/9.0f,      0.0f, -8.0f/9.0f,    8.0f/9.0f,      0.0f, -8.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,        0.0f,  2.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,        0.0f,  4.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,        0.0f,  6.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,        0.0f,  8.0f/9.0f, -8.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,
+                4.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f, -8.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,        0.0f, -8.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,        0.0f, -6.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,        0.0f, -4.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,        0.0f, -2.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f,      0.0f, -6.0f/9.0f,   -6.0f/9.0f,      0.0f, -6.0f/9.0f,   -4.0f/9.0f,      0.0f, -6.0f/9.0f,
+          -2.0f/9.0f,      0.0f, -6.0f/9.0f,        0.0f,      0.0f, -6.0f/9.0f,    2.0f/9.0f,      0.0f, -6.0f/9.0f,
+                4.0f/9.0f,      0.0f, -6.0f/9.0f,    6.0f/9.0f,      0.0f, -6.0f/9.0f,    8.0f/9.0f,      0.0f, -6.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,        0.0f,  2.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,        0.0f,  4.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,        0.0f,  6.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,        0.0f,  8.0f/9.0f, -6.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,
+                4.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f, -6.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,        0.0f, -8.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,        0.0f, -6.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,        0.0f, -4.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,        0.0f, -2.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f,      0.0f, -4.0f/9.0f,   -6.0f/9.0f,      0.0f, -4.0f/9.0f,   -4.0f/9.0f,      0.0f, -4.0f/9.0f,
+          -2.0f/9.0f,      0.0f, -4.0f/9.0f,        0.0f,      0.0f, -4.0f/9.0f,    2.0f/9.0f,      0.0f, -4.0f/9.0f,
+                4.0f/9.0f,      0.0f, -4.0f/9.0f,    6.0f/9.0f,      0.0f, -4.0f/9.0f,    8.0f/9.0f,      0.0f, -4.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,        0.0f,  2.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,        0.0f,  4.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,        0.0f,  6.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,        0.0f,  8.0f/9.0f, -4.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,
+                4.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f, -4.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,        0.0f, -8.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,        0.0f, -6.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,        0.0f, -4.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,        0.0f, -2.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f,      0.0f, -2.0f/9.0f,   -6.0f/9.0f,      0.0f, -2.0f/9.0f,   -4.0f/9.0f,      0.0f, -2.0f/9.0f,
+          -2.0f/9.0f,      0.0f, -2.0f/9.0f,        0.0f,      0.0f, -2.0f/9.0f,    2.0f/9.0f,      0.0f, -2.0f/9.0f,
+                4.0f/9.0f,      0.0f, -2.0f/9.0f,    6.0f/9.0f,      0.0f, -2.0f/9.0f,    8.0f/9.0f,      0.0f, -2.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,        0.0f,  2.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,        0.0f,  4.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,        0.0f,  6.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,        0.0f,  8.0f/9.0f, -2.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,
+                4.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f, -2.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f,      0.0f,   -6.0f/9.0f, -8.0f/9.0f,      0.0f,   -4.0f/9.0f, -8.0f/9.0f,      0.0f,
+          -2.0f/9.0f, -8.0f/9.0f,      0.0f,        0.0f, -8.0f/9.0f,      0.0f,    2.0f/9.0f, -8.0f/9.0f,      0.0f,
+                4.0f/9.0f, -8.0f/9.0f,      0.0f,    6.0f/9.0f, -8.0f/9.0f,      0.0f,    8.0f/9.0f, -8.0f/9.0f,      0.0f,
+          -8.0f/9.0f, -6.0f/9.0f,      0.0f,   -6.0f/9.0f, -6.0f/9.0f,      0.0f,   -4.0f/9.0f, -6.0f/9.0f,      0.0f,
+          -2.0f/9.0f, -6.0f/9.0f,      0.0f,        0.0f, -6.0f/9.0f,      0.0f,    2.0f/9.0f, -6.0f/9.0f,      0.0f,
+                4.0f/9.0f, -6.0f/9.0f,      0.0f,    6.0f/9.0f, -6.0f/9.0f,      0.0f,    8.0f/9.0f, -6.0f/9.0f,      0.0f,
+          -8.0f/9.0f, -4.0f/9.0f,      0.0f,   -6.0f/9.0f, -4.0f/9.0f,      0.0f,   -4.0f/9.0f, -4.0f/9.0f,      0.0f,
+          -2.0f/9.0f, -4.0f/9.0f,      0.0f,        0.0f, -4.0f/9.0f,      0.0f,    2.0f/9.0f, -4.0f/9.0f,      0.0f,
+                4.0f/9.0f, -4.0f/9.0f,      0.0f,    6.0f/9.0f, -4.0f/9.0f,      0.0f,    8.0f/9.0f, -4.0f/9.0f,      0.0f,
+          -8.0f/9.0f, -2.0f/9.0f,      0.0f,   -6.0f/9.0f, -2.0f/9.0f,      0.0f,   -4.0f/9.0f, -2.0f/9.0f,      0.0f,
+          -2.0f/9.0f, -2.0f/9.0f,      0.0f,        0.0f, -2.0f/9.0f,      0.0f,    2.0f/9.0f, -2.0f/9.0f,      0.0f,
+                4.0f/9.0f, -2.0f/9.0f,      0.0f,    6.0f/9.0f, -2.0f/9.0f,      0.0f,    8.0f/9.0f, -2.0f/9.0f,      0.0f,
+          -8.0f/9.0f,      0.0f,      0.0f,   -6.0f/9.0f,      0.0f,      0.0f,   -4.0f/9.0f,      0.0f,      0.0f,
+          -2.0f/9.0f,      0.0f,      0.0f,        0.0f,      0.0f,      0.0f,    2.0f/9.0f,      0.0f,      0.0f,
+                4.0f/9.0f,      0.0f,      0.0f,    6.0f/9.0f,      0.0f,      0.0f,    8.0f/9.0f,      0.0f,      0.0f,
+          -8.0f/9.0f,  2.0f/9.0f,      0.0f,   -6.0f/9.0f,  2.0f/9.0f,      0.0f,   -4.0f/9.0f,  2.0f/9.0f,      0.0f,
+          -2.0f/9.0f,  2.0f/9.0f,      0.0f,        0.0f,  2.0f/9.0f,      0.0f,    2.0f/9.0f,  2.0f/9.0f,      0.0f,
+                4.0f/9.0f,  2.0f/9.0f,      0.0f,    6.0f/9.0f,  2.0f/9.0f,      0.0f,    8.0f/9.0f,  2.0f/9.0f,      0.0f,
+          -8.0f/9.0f,  4.0f/9.0f,      0.0f,   -6.0f/9.0f,  4.0f/9.0f,      0.0f,   -4.0f/9.0f,  4.0f/9.0f,      0.0f,
+          -2.0f/9.0f,  4.0f/9.0f,      0.0f,        0.0f,  4.0f/9.0f,      0.0f,    2.0f/9.0f,  4.0f/9.0f,      0.0f,
+                4.0f/9.0f,  4.0f/9.0f,      0.0f,    6.0f/9.0f,  4.0f/9.0f,      0.0f,    8.0f/9.0f,  4.0f/9.0f,      0.0f,
+          -8.0f/9.0f,  6.0f/9.0f,      0.0f,   -6.0f/9.0f,  6.0f/9.0f,      0.0f,   -4.0f/9.0f,  6.0f/9.0f,      0.0f,
+          -2.0f/9.0f,  6.0f/9.0f,      0.0f,        0.0f,  6.0f/9.0f,      0.0f,    2.0f/9.0f,  6.0f/9.0f,      0.0f,
+                4.0f/9.0f,  6.0f/9.0f,      0.0f,    6.0f/9.0f,  6.0f/9.0f,      0.0f,    8.0f/9.0f,  6.0f/9.0f,      0.0f,
+          -8.0f/9.0f,  8.0f/9.0f,      0.0f,   -6.0f/9.0f,  8.0f/9.0f,      0.0f,   -4.0f/9.0f,  8.0f/9.0f,      0.0f,
+          -2.0f/9.0f,  8.0f/9.0f,      0.0f,        0.0f,  8.0f/9.0f,      0.0f,    2.0f/9.0f,  8.0f/9.0f,      0.0f,
+           4.0f/9.0f,  8.0f/9.0f,      0.0f,    6.0f/9.0f,  8.0f/9.0f,      0.0f,    8.0f/9.0f,  8.0f/9.0f,      0.0f,
+          -8.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,        0.0f, -8.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,
+                4.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,        0.0f, -6.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,
+                4.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,        0.0f, -4.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,
+           4.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,        0.0f, -2.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,
+           4.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f,      0.0f,  2.0f/9.0f,   -6.0f/9.0f,      0.0f,  2.0f/9.0f,   -4.0f/9.0f,      0.0f,  2.0f/9.0f,
+          -2.0f/9.0f,      0.0f,  2.0f/9.0f,        0.0f,      0.0f,  2.0f/9.0f,    2.0f/9.0f,      0.0f,  2.0f/9.0f,
+           4.0f/9.0f,      0.0f,  2.0f/9.0f,    6.0f/9.0f,      0.0f,  2.0f/9.0f,    8.0f/9.0f,      0.0f,  2.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,        0.0f,  2.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,
+           4.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,        0.0f,  4.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,        0.0f,  6.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,
+           4.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,        0.0f,  8.0f/9.0f,  2.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,
+           4.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f,  2.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,        0.0f, -8.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,
+                4.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,        0.0f, -6.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,
+           4.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,        0.0f, -4.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,
+           4.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,        0.0f, -2.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,
+                4.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f,      0.0f,  4.0f/9.0f,   -6.0f/9.0f,      0.0f,  4.0f/9.0f,   -4.0f/9.0f,      0.0f,  4.0f/9.0f,
+          -2.0f/9.0f,      0.0f,  4.0f/9.0f,        0.0f,      0.0f,  4.0f/9.0f,    2.0f/9.0f,      0.0f,  4.0f/9.0f,
+           4.0f/9.0f,      0.0f,  4.0f/9.0f,    6.0f/9.0f,      0.0f,  4.0f/9.0f,    8.0f/9.0f,      0.0f,  4.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,        0.0f,  2.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,
+           4.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,        0.0f,  4.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,
+           4.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,        0.0f,  6.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,
+                4.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,        0.0f,  8.0f/9.0f,  4.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,
+                4.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f,  4.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,        0.0f, -8.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,
+           4.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,        0.0f, -6.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,
+           4.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,        0.0f, -4.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,
+                4.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,        0.0f, -2.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,
+           4.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f,      0.0f,  6.0f/9.0f,   -6.0f/9.0f,      0.0f,  6.0f/9.0f,   -4.0f/9.0f,      0.0f,  6.0f/9.0f,
+          -2.0f/9.0f,      0.0f,  6.0f/9.0f,        0.0f,      0.0f,  6.0f/9.0f,    2.0f/9.0f,      0.0f,  6.0f/9.0f,
+                4.0f/9.0f,      0.0f,  6.0f/9.0f,    6.0f/9.0f,      0.0f,  6.0f/9.0f,    8.0f/9.0f,      0.0f,  6.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,        0.0f,  2.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,
+                4.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,        0.0f,  4.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,        0.0f,  6.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,
+                4.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,        0.0f,  8.0f/9.0f,  6.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,
+                4.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f,  6.0f/9.0f,
+          -8.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,        0.0f, -8.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,
+           4.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f, -8.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,        0.0f, -6.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,
+                4.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f, -6.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,        0.0f, -4.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,
+           4.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f, -4.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,        0.0f, -2.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,
+           4.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f, -2.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f,      0.0f,  8.0f/9.0f,   -6.0f/9.0f,      0.0f,  8.0f/9.0f,   -4.0f/9.0f,      0.0f,  8.0f/9.0f,
+          -2.0f/9.0f,      0.0f,  8.0f/9.0f,        0.0f,      0.0f,  8.0f/9.0f,    2.0f/9.0f,      0.0f,  8.0f/9.0f,
+           4.0f/9.0f,      0.0f,  8.0f/9.0f,    6.0f/9.0f,      0.0f,  8.0f/9.0f,    8.0f/9.0f,      0.0f,  8.0f/9.0f,
+          -8.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,        0.0f,  2.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,
+                4.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f,  2.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,        0.0f,  4.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,
+                4.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f,  4.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,        0.0f,  6.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,
+           4.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f,  6.0f/9.0f,  8.0f/9.0f,
+          -8.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,   -6.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,   -4.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,
+          -2.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,        0.0f,  8.0f/9.0f,  8.0f/9.0f,    2.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,
+           4.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,    6.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f,    8.0f/9.0f,  8.0f/9.0f,  8.0f/9.0f
+        };
+
+        // data taken from ISO/IEC DIS 11172, Annexes 3-B.2[abcd] and 3-B.4:
+
+        // subbands 0-2 in tables 3-B.2a and 2b: (index is allocation)
+        public static final int table_ab1_codelength[] =
+          // bits per codeword
+        { 0, 5, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
+
+        public static final float table_ab1_groupingtables[][] =
+          // pointer to sample grouping table, or NULL-pointer if ungrouped
+        { null, grouping_5bits, null, null, null, null, null, null, null, null, null, null, null, null, null, null };
+
+        public static final float table_ab1_factor[] =
+          // factor for requantization: (real)sample * factor - 1.0 gives requantized sample
+        { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/16.0f, 1.0f/32.0f, 1.0f/64.0f,
+          1.0f/128.0f, 1.0f/256.0f, 1.0f/512.0f, 1.0f/1024.0f, 1.0f/2048.0f,
+          1.0f/4096.0f, 1.0f/8192.0f, 1.0f/16384.0f, 1.0f/32768.0f };
+
+        public static final float table_ab1_c[] =
+          // factor c for requantization from table 3-B.4
+        { 0.0f,           1.33333333333f, 1.14285714286f, 1.06666666666f, 1.03225806452f,
+          1.01587301587f, 1.00787401575f, 1.00392156863f, 1.00195694716f, 1.00097751711f,
+          1.00048851979f, 1.00024420024f, 1.00012208522f, 1.00006103888f, 1.00003051851f,
+          1.00001525902f };
+
+        public static final float table_ab1_d[] =
+          // addend d for requantization from table 3-B.4
+        { 0.0f,           0.50000000000f, 0.25000000000f, 0.12500000000f, 0.06250000000f,
+          0.03125000000f, 0.01562500000f, 0.00781250000f, 0.00390625000f, 0.00195312500f,
+          0.00097656250f, 0.00048828125f, 0.00024414063f, 0.00012207031f, 0.00006103516f,
+          0.00003051758f };
+
+        // subbands 3-... tables 3-B.2a and 2b:
+        public static final float[] table_ab234_groupingtables[] =
+        { null, grouping_5bits, grouping_7bits, null, grouping_10bits, null, null, null, null, null, null, null, null, null, null, null };
+
+        // subbands 3-10 in tables 3-B.2a and 2b:
+        public static final int table_ab2_codelength[] =
+        { 0, 5, 7, 3, 10, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16 };
+        public static final float table_ab2_factor[] =
+        { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/8.0f, 1.0f/16.0f,
+          1.0f/32.0f, 1.0f/64.0f, 1.0f/128.0f, 1.0f/256.0f, 1.0f/512.0f,
+          1.0f/1024.0f, 1.0f/2048.0f, 1.0f/4096.0f, 1.0f/32768.0f };
+        public static final float table_ab2_c[] =
+        { 0.0f,           1.33333333333f, 1.60000000000f, 1.14285714286f, 1.77777777777f,
+          1.06666666666f, 1.03225806452f, 1.01587301587f, 1.00787401575f, 1.00392156863f,
+          1.00195694716f, 1.00097751711f, 1.00048851979f, 1.00024420024f, 1.00012208522f,
+          1.00001525902f };
+        public static final float table_ab2_d[] =
+        { 0.0f,           0.50000000000f, 0.50000000000f, 0.25000000000f, 0.50000000000f,
+          0.12500000000f, 0.06250000000f, 0.03125000000f, 0.01562500000f, 0.00781250000f,
+          0.00390625000f, 0.00195312500f, 0.00097656250f, 0.00048828125f, 0.00024414063f,
+          0.00003051758f };
+
+        // subbands 11-22 in tables 3-B.2a and 2b:
+        public static final int table_ab3_codelength[] = { 0, 5, 7, 3, 10, 4, 5, 16 };
+        public static final float table_ab3_factor[] =
+        { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/8.0f, 1.0f/16.0f, 1.0f/32768.0f };
+        public static final float table_ab3_c[] =
+        { 0.0f,           1.33333333333f, 1.60000000000f, 1.14285714286f, 1.77777777777f,
+          1.06666666666f, 1.03225806452f, 1.00001525902f };
+        public static final float table_ab3_d[] =
+        { 0.0f,           0.50000000000f, 0.50000000000f, 0.25000000000f, 0.50000000000f,
+          0.12500000000f, 0.06250000000f, 0.00003051758f };
+
+        // subbands 23-... in tables 3-B.2a and 2b:
+        public static final int table_ab4_codelength[] = { 0, 5, 7, 16 };
+        public static final float table_ab4_factor[] = { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/32768.0f };
+        public static final float table_ab4_c[] = { 0.0f, 1.33333333333f, 1.60000000000f, 1.00001525902f };
+        public static final float table_ab4_d[] = { 0.0f, 0.50000000000f, 0.50000000000f, 0.00003051758f };
+
+        // subbands in tables 3-B.2c and 2d:
+        public static final int table_cd_codelength[] =
+        { 0, 5, 7, 10, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+        public static final float table_cd_groupingtables[][] =
+        { null, grouping_5bits, grouping_7bits, grouping_10bits, null, null, null, null, null, null, null, null, null, null, null, null };
+        public static final float table_cd_factor[] =
+        { 0.0f, 1.0f/2.0f, 1.0f/4.0f, 1.0f/8.0f, 1.0f/8.0f, 1.0f/16.0f, 1.0f/32.0f, 1.0f/64.0f,
+          1.0f/128.0f, 1.0f/256.0f, 1.0f/512.0f, 1.0f/1024.0f, 1.0f/2048.0f, 1.0f/4096.0f,
+          1.0f/8192.0f, 1.0f/16384.0f };
+        public static final float table_cd_c[] =
+        { 0.0f,           1.33333333333f, 1.60000000000f, 1.77777777777f, 1.06666666666f,
+          1.03225806452f, 1.01587301587f, 1.00787401575f, 1.00392156863f, 1.00195694716f,
+          1.00097751711f, 1.00048851979f, 1.00024420024f, 1.00012208522f, 1.00006103888f,
+          1.00003051851f };
+        public static final float table_cd_d[] =
+        { 0.0f,           0.50000000000f, 0.50000000000f, 0.50000000000f, 0.12500000000f,
+          0.06250000000f, 0.03125000000f, 0.01562500000f, 0.00781250000f, 0.00390625000f,
+          0.00195312500f, 0.00097656250f, 0.00048828125f, 0.00024414063f, 0.00012207031f,
+          0.00006103516f };
+
+
+
+          protected int                     subbandnumber;
+          protected int                         allocation;
+          protected int                         scfsi;
+          protected float                       scalefactor1, scalefactor2, scalefactor3;
+          protected int[]                       codelength = {0}; 
+          protected float groupingtable[][] = new float[2][]; 
+          //protected float[][]                 groupingtable = {{0},{0}} ;
+          protected float[]                     factor = {0.0f};
+          protected int                         groupnumber;
+          protected int                         samplenumber;
+          protected float[]                     samples = new float[3];
+          protected float[]                     c = {0};
+          protected float[]                 d = {0};
+          /**
+           * Constructor
+           */
+          public SubbandLayer2(int subbandnumber)
+          {     
+                this.subbandnumber = subbandnumber;
+            groupnumber = samplenumber = 0;  
+          }
+          
+          
+          /**
+           *
+           */
+          protected int get_allocationlength (Header header)
+          {
+                if (header.version() == Header.MPEG1)
+                {
+                  int channel_bitrate = header.bitrate_index();
+
+                  // calculate bitrate per channel:
+                  if (header.mode() != Header.SINGLE_CHANNEL)
+                         if (channel_bitrate == 4)
+                                channel_bitrate = 1;
+                         else
+                                channel_bitrate -= 4;
+
+                  if (channel_bitrate == 1 || channel_bitrate == 2)
+                         // table 3-B.2c or 3-B.2d
+                         if (subbandnumber <= 1)
+                                return 4;
+                         else
+                                return 3;
+                  else
+                         // tables 3-B.2a or 3-B.2b
+                         if (subbandnumber <= 10)
+                                return 4;
+                         else if (subbandnumber <= 22)
+                                return 3;
+                         else
+                                return 2;
+            }
+                else
+                { // MPEG-2 LSF -- Jeff
+
+                 // table B.1 of ISO/IEC 13818-3
+             if (subbandnumber <= 3)
+                        return 4;
+             else if (subbandnumber <= 10)
+                        return 3;
+             else
+                        return 2;
+            }
+          }
+          
+          /**
+           *
+           */
+           protected void prepare_sample_reading(Header header, int allocation,
+                                                                                         //float[][] groupingtable,
+                                                                                           int channel,
+                                                 float[] factor, int[] codelength,
+                                                 float[] c, float[] d)
+           {
+                        int channel_bitrate = header.bitrate_index();
+                        // calculate bitrate per channel:
+                        if (header.mode() != Header.SINGLE_CHANNEL)
+                                if (channel_bitrate == 4)
+                                        channel_bitrate = 1;
+                                else
+                                        channel_bitrate -= 4;
+                        
+                         if (channel_bitrate == 1 || channel_bitrate == 2)
+                         {
+                                 // table 3-B.2c or 3-B.2d
+                                 groupingtable[channel] = table_cd_groupingtables[allocation];
+                                 factor[0] = table_cd_factor[allocation];
+                                 codelength[0] = table_cd_codelength[allocation];
+                                 c[0] = table_cd_c[allocation];
+                                 d[0] = table_cd_d[allocation];
+                         }
+                         else
+                         {
+                                 // tables 3-B.2a or 3-B.2b
+                                 if (subbandnumber <= 2)
+                                 {
+                                        groupingtable[channel] = table_ab1_groupingtables[allocation];
+                                        factor[0] = table_ab1_factor[allocation];
+                                        codelength[0] = table_ab1_codelength[allocation];
+                                c[0] = table_ab1_c[allocation];
+                                d[0] = table_ab1_d[allocation];
+                             }
+                                 else
+                                 {
+                                groupingtable[channel] = table_ab234_groupingtables[allocation];
+                                        if (subbandnumber <= 10)
+                                        {
+                                                factor[0] = table_ab2_factor[allocation];
+                                                codelength[0] = table_ab2_codelength[allocation];
+                                                c[0] = table_ab2_c[allocation];
+                                                d[0] = table_ab2_d[allocation];
+                                }
+                                else if (subbandnumber <= 22)
+                                {
+                                                factor[0] = table_ab3_factor[allocation];
+                                                codelength[0] = table_ab3_codelength[allocation];
+                                                c[0] = table_ab3_c[allocation];
+                                                d[0] = table_ab3_d[allocation];
+                                }
+                                        else
+                                {
+                                                factor[0] = table_ab4_factor[allocation];
+                                                codelength[0] = table_ab4_codelength[allocation];
+                                                c[0] = table_ab4_c[allocation];
+                                                d[0] = table_ab4_d[allocation];
+                                }
+                                 }
+                         }   
+           }
+                                         
+          
+          /**
+           *
+           */
+          public void read_allocation(Bitstream stream, Header header, Crc16 crc)
+          {
+                 int length = get_allocationlength(header);
+                 allocation = stream.get_bits(length);
+                 if (crc != null) 
+                         crc.add_bits(allocation, length);  
+          }
+          
+          /**
+           *
+           */
+          public void read_scalefactor_selection (Bitstream stream, Crc16 crc)
+          {
+                if (allocation != 0)
+                {
+                scfsi = stream.get_bits(2);
+                if (crc != null) crc.add_bits(scfsi, 2);
+            }
+          }
+
+          /**
+           *
+           */
+          public void read_scalefactor (Bitstream stream, Header header)
+          {
+                if (allocation != 0)
+                {
+                   switch (scfsi)
+               {
+                case 0:
+                         scalefactor1 = scalefactors[stream.get_bits(6)];
+                         scalefactor2 = scalefactors[stream.get_bits(6)];
+                         scalefactor3 = scalefactors[stream.get_bits(6)];
+                         break;
+                        case 1:
+                         scalefactor1 = scalefactor2 = scalefactors[stream.get_bits(6)];
+                         scalefactor3 = scalefactors[stream.get_bits(6)];
+                         break;
+                case 2:
+                         scalefactor1 = scalefactor2 = scalefactor3 = scalefactors[stream.get_bits(6)];
+                         break;
+                    case 3:
+                         scalefactor1 = scalefactors[stream.get_bits(6)];
+                     scalefactor2 = scalefactor3 = scalefactors[stream.get_bits(6)];
+                     break;
+                }
+                prepare_sample_reading(header, allocation, 0,
+                                    factor, codelength, c, d);
+          }
+          }
+          
+          /**
+           *
+           */
+          public boolean read_sampledata (Bitstream stream)
+          {
+                if (allocation != 0)
+                 if (groupingtable[0] != null)
+                 {
+                        int samplecode = stream.get_bits(codelength[0]);
+                        // create requantized samples:
+                        samplecode += samplecode << 1;
+                        float[] target = samples;
+                        float[] source = groupingtable[0];
+                  /*
+                  int tmp = 0;
+                        int temp = 0;
+                        target[tmp++] = source[samplecode + temp];
+                        temp++;
+                        target[tmp++] = source[samplecode + temp];
+                        temp++;
+                        target[tmp] = source[samplecode + temp];
+                        */
+                        //Bugfix:
+                        int tmp = 0;
+                        int temp = samplecode;
+                        
+                        if(temp > source.length - 3) temp = source.length - 3;
+                        
+                        target[tmp] = source[temp];
+                        temp++;tmp++;
+                        target[tmp] = source[temp];
+                        temp++;tmp++;
+                        target[tmp] = source[temp];
+                        
+                        // memcpy (samples, groupingtable + samplecode, 3 * sizeof (real));
+                 }
+                 else
+                 {
+                        samples[0] = (float) ((stream.get_bits(codelength[0])) * factor[0] - 1.0);
+                        samples[1] = (float) ((stream.get_bits(codelength[0])) * factor[0] - 1.0);
+                        samples[2] = (float) ((stream.get_bits(codelength[0])) * factor[0] - 1.0);
+                 }
+
+                samplenumber = 0;
+                  if (++groupnumber == 12)
+                         return true;
+                  else
+                         return false;
+          }
+
+          /**
+           *
+           */
+          public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          {
+            if ((allocation != 0) && (channels != OutputChannels.RIGHT_CHANNEL))
+            {
+                 float sample = samples[samplenumber];
+          
+                 if (groupingtable[0] == null)
+                        sample = (sample + d[0]) * c[0];
+                 if (groupnumber <= 4)
+                        sample *= scalefactor1;
+                 else if (groupnumber <= 8)
+                        sample *= scalefactor2;
+                 else
+                        sample *= scalefactor3;
+                 filter1.input_sample(sample, subbandnumber);
+            }
+          
+            if (++samplenumber == 3)
+                 return true;
+            else
+                 return false;
+          }
+        };
+        
+         /**
+          * Class for layer II subbands in joint stereo mode.
+          */
+        static class SubbandLayer2IntensityStereo extends SubbandLayer2
+        {
+          protected int          channel2_scfsi;
+          protected float        channel2_scalefactor1, channel2_scalefactor2, channel2_scalefactor3;
+
+          /**
+           * Constructor
+           */
+          public SubbandLayer2IntensityStereo (int subbandnumber)
+          {
+                super(subbandnumber);
+          }
+
+          /**
+           *
+           */
+          public void read_allocation(Bitstream stream, Header header, Crc16 crc)
+          {
+            super.read_allocation (stream, header, crc);
+          }
+          
+          /**
+           *
+           */
+          public void read_scalefactor_selection(Bitstream stream, Crc16 crc)
+          {
+            if (allocation != 0)
+            {
+                 scfsi = stream.get_bits(2);
+                 channel2_scfsi = stream.get_bits(2);
+                 if (crc != null)
+                 {
+                        crc.add_bits(scfsi, 2);
+                        crc.add_bits(channel2_scfsi, 2);
+                 }
+            }  
+          }
+          
+          /**
+           *
+           */
+          public void read_scalefactor(Bitstream stream, Header header)
+          {
+            if (allocation != 0)
+            {
+                 super.read_scalefactor(stream, header);
+                 switch (channel2_scfsi)
+                 {
+                        case 0:
+                        channel2_scalefactor1 = scalefactors[stream.get_bits(6)];
+                        channel2_scalefactor2 = scalefactors[stream.get_bits(6)];
+                        channel2_scalefactor3 = scalefactors[stream.get_bits(6)];
+                        break;
+          
+                        case 1:
+                        channel2_scalefactor1 = channel2_scalefactor2 = scalefactors[stream.get_bits (6)];
+                        channel2_scalefactor3 = scalefactors[stream.get_bits(6)];
+                        break;
+          
+                        case 2:
+                        channel2_scalefactor1 = channel2_scalefactor2 =
+                        channel2_scalefactor3 = scalefactors[stream.get_bits(6)];
+                        break;
+          
+                        case 3:
+                        channel2_scalefactor1 = scalefactors[stream.get_bits(6)];
+                        channel2_scalefactor2 = channel2_scalefactor3 = scalefactors[stream.get_bits (6)];
+                        break;
+                 }
+            }
+          
+          }
+          
+          /**
+           *
+           */
+          public boolean read_sampledata(Bitstream stream)
+          {
+                 return super.read_sampledata (stream);
+          }
+          
+          /**
+           *
+           */
+          public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          {
+                  if (allocation != 0)
+                  {
+                         float sample = samples[samplenumber];
+                
+                         if (groupingtable[0] == null)
+                                sample = (sample + d[0]) * c[0];
+                       if (channels == OutputChannels.BOTH_CHANNELS)
+                           {
+                                  float sample2 = sample;
+                              if (groupnumber <= 4)
+                              {
+                                        sample *= scalefactor1;
+                                        sample2 *= channel2_scalefactor1;
+                                  }
+                                  else if (groupnumber <= 8)
+                                  {
+                                        sample *= scalefactor2;
+                                        sample2 *= channel2_scalefactor2;
+                                  }
+                                  else
+                                  {
+                                        sample *= scalefactor3;
+                                        sample2 *= channel2_scalefactor3;
+                                  }
+                                  filter1.input_sample(sample, subbandnumber);
+                              filter2.input_sample(sample2, subbandnumber);
+                            }
+                                else if (channels == OutputChannels.LEFT_CHANNEL)
+                                {
+                                        if (groupnumber <= 4)
+                                                sample *= scalefactor1;
+                                else if (groupnumber <= 8)
+                                                sample *= scalefactor2;
+                                        else
+                                                sample *= scalefactor3;
+                                        filter1.input_sample(sample, subbandnumber);
+                                 }
+                                 else
+                                 {
+                                        if (groupnumber <= 4)
+                                        sample *= channel2_scalefactor1;
+                                        else if (groupnumber <= 8)
+                                                sample *= channel2_scalefactor2;
+                                        else
+                                                sample *= channel2_scalefactor3;
+                                        filter1.input_sample(sample, subbandnumber);
+                                }
+                        }
+                
+                  if (++samplenumber == 3)
+                         return true;
+                  else
+                 return false;
+          }
+        };
+
+         /**
+          * Class for layer II subbands in stereo mode.
+          */
+        static class SubbandLayer2Stereo extends SubbandLayer2
+        {
+          protected int                 channel2_allocation;
+          protected int                 channel2_scfsi;
+          protected float               channel2_scalefactor1, channel2_scalefactor2, channel2_scalefactor3;
+          //protected boolean           channel2_grouping;  ???? Never used!
+          protected int[]               channel2_codelength = {0};
+          //protected float[][]         channel2_groupingtable = {{0},{0}};
+          protected float[]             channel2_factor = {0};
+          protected float[]     channel2_samples;
+          protected float[]             channel2_c = {0};
+          protected float[]             channel2_d = {0};
+          
+          /**
+           * Constructor
+           */
+          public SubbandLayer2Stereo(int subbandnumber)
+          {
+                super(subbandnumber);
+                channel2_samples = new float[3];
+          }
+          
+          /**
+           *
+           */
+          public void read_allocation (Bitstream stream, Header header, Crc16 crc)
+          {
+            int length = get_allocationlength(header);
+            allocation = stream.get_bits(length);
+            channel2_allocation = stream.get_bits(length);
+            if (crc != null)
+            {
+                 crc.add_bits(allocation, length);
+                 crc.add_bits(channel2_allocation, length);
+            }
+          }
+
+          /**
+           *
+           */
+          public void read_scalefactor_selection(Bitstream stream, Crc16 crc)
+          {
+                  if (allocation != 0)
+                  {
+                         scfsi = stream.get_bits(2);
+                         if (crc != null)
+                                crc.add_bits(scfsi, 2);
+                  }
+                  if (channel2_allocation != 0)
+                  {
+                         channel2_scfsi = stream.get_bits(2);
+                         if (crc != null)
+                                crc.add_bits(channel2_scfsi, 2);
+                  }
+          }
+
+          /**
+           *
+           */
+          public void read_scalefactor(Bitstream stream, Header header)
+          {
+            super.read_scalefactor(stream, header);
+            if (channel2_allocation != 0)
+            {
+                 switch (channel2_scfsi)
+                 {
+                        case 0:
+                   channel2_scalefactor1 = scalefactors[stream.get_bits(6)];
+                           channel2_scalefactor2 = scalefactors[stream.get_bits(6)];
+                       channel2_scalefactor3 = scalefactors[stream.get_bits(6)];
+                       break;
+          
+                        case 1:
+                           channel2_scalefactor1 = channel2_scalefactor2 =
+                                                                      scalefactors[stream.get_bits(6)];
+                       channel2_scalefactor3 = scalefactors[stream.get_bits(6)];
+                       break;
+          
+                        case 2:
+                           channel2_scalefactor1 = channel2_scalefactor2 =
+                       channel2_scalefactor3 = scalefactors[stream.get_bits(6)];
+                       break;
+          
+                        case 3:
+                           channel2_scalefactor1 = scalefactors[stream.get_bits(6)];
+                       channel2_scalefactor2 = channel2_scalefactor3 =
+                                                                           scalefactors[stream.get_bits(6)];
+                   break;
+                 }
+                 prepare_sample_reading(header, channel2_allocation, 1,
+                                     channel2_factor, channel2_codelength, channel2_c,
+                                     channel2_d);
+           }
+          }
+
+          /**
+           *
+           */
+          public boolean read_sampledata (Bitstream stream)
+          {
+            boolean returnvalue = super.read_sampledata(stream);
+          
+            if (channel2_allocation != 0)
+                 if (groupingtable[1] != null)
+                 {
+                        int samplecode = stream.get_bits(channel2_codelength[0]);
+                        // create requantized samples:
+                        samplecode += samplecode << 1;
+                /*
+                        float[] target = channel2_samples;
+                        float[] source = channel2_groupingtable[0];
+                        int tmp = 0;
+                        int temp = 0;
+                        target[tmp++] = source[samplecode + temp];
+                        temp++;
+                        target[tmp++] = source[samplecode + temp];
+                        temp++;
+                        target[tmp] = source[samplecode + temp];
+                        // memcpy (channel2_samples, channel2_groupingtable + samplecode, 3 * sizeof (real));
+                */
+                float[] target = channel2_samples;
+            float[] source = groupingtable[1];
+                        int tmp = 0;
+                        int temp = samplecode;
+                target[tmp] = source[temp];
+                        temp++;tmp++;
+                target[tmp] = source[temp];
+                        temp++;tmp++;
+                target[tmp] = source[temp];
+                
+              } 
+                  else 
+                  {
+                        channel2_samples[0] = (float) ((stream.get_bits(channel2_codelength[0])) *
+                                                                         channel2_factor[0] - 1.0);
+                        channel2_samples[1] = (float) ((stream.get_bits(channel2_codelength[0])) *
+                                                                         channel2_factor[0] - 1.0);
+                        channel2_samples[2] = (float) ((stream.get_bits(channel2_codelength[0])) *
+                                      channel2_factor[0] - 1.0);
+                 }
+             return returnvalue;
+          }
+
+          /**
+           *
+           */
+          public boolean put_next_sample(int channels, SynthesisFilter filter1, SynthesisFilter filter2)
+          {
+            boolean returnvalue = super.put_next_sample(channels, filter1, filter2);
+            if ((channel2_allocation != 0) && (channels != OutputChannels.LEFT_CHANNEL))
+            {
+                 float sample = channel2_samples[samplenumber - 1];
+          
+                 if (groupingtable[1] == null)
+                        sample = (sample + channel2_d[0]) * channel2_c[0];
+          
+                 if (groupnumber <= 4)
+                        sample *= channel2_scalefactor1;
+                 else if (groupnumber <= 8)
+                        sample *= channel2_scalefactor2;
+                 else
+                        sample *= channel2_scalefactor3;
+                 if (channels == OutputChannels.BOTH_CHANNELS)
+                        filter2.input_sample(sample, subbandnumber);
+                 else
+                        filter1.input_sample(sample, subbandnumber);
+            }
+                return returnvalue;
+          }
+        }
+}
diff --git a/songdbj/javazoom/jl/decoder/LayerIIIDecoder.java b/songdbj/javazoom/jl/decoder/LayerIIIDecoder.java
new file mode 100644
index 0000000000..602badf0f2
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/LayerIIIDecoder.java
@@ -0,0 +1,2439 @@
+/*
+ * 11/19/04      1.0 moved to LGPL.
+ * 
+ * 18/06/01  Michael Scheerer,  Fixed bugs which causes
+ *           negative indexes in method huffmann_decode and in method 
+ *           dequanisize_sample.
+ *
+ * 16/07/01  Michael Scheerer, Catched a bug in method
+ *           huffmann_decode, which causes an outOfIndexException.
+ *           Cause : Indexnumber of 24 at SfBandIndex,
+ *           which has only a length of 22. I have simply and dirty 
+ *           fixed the index to <= 22, because I'm not really be able
+ *           to fix the bug. The Indexnumber is taken from the MP3 
+ *           file and the origin Ma-Player with the same code works 
+ *           well.      
+ * 
+ * 02/19/99  Java Conversion by E.B, javalayer@javazoom.net
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Class Implementing Layer 3 Decoder.
+ *
+ * @since 0.0
+ */
+final class LayerIIIDecoder implements FrameDecoder
+{
+        final double d43 = (4.0/3.0);
+        
+        public int[]                            scalefac_buffer;
+
+        // MDM: removed, as this wasn't being used.
+        //private float               CheckSumOut1d = 0.0f;
+    private int                 CheckSumHuff = 0;
+        private int[]                           is_1d;
+    private float[][][]                 ro;
+    private float[][][]                 lr;
+        private float[]                         out_1d;
+    private float[][]               prevblck;
+    private float[][]                   k;
+    private int[]                               nonzero;
+        private Bitstream                       stream;
+    private Header                              header;
+    private SynthesisFilter     filter1, filter2;
+    private Obuffer                     buffer;
+    private int                                 which_channels;
+    private BitReserve                  br;
+    private III_side_info_t     si;
+
+    private temporaire2[]        III_scalefac_t;
+    private temporaire2[]        scalefac;
+    // private III_scalefac_t           scalefac;
+
+    private int                                 max_gr;
+    private int                                 frame_start;
+    private int                                 part2_start;
+    private int                                 channels;
+    private int                                 first_channel;
+    private int                                 last_channel;
+    private int                                 sfreq;
+
+
+        /**
+         * Constructor.
+         */
+        // REVIEW: these constructor arguments should be moved to the
+        // decodeFrame() method, where possible, so that one
+        public LayerIIIDecoder(Bitstream stream0, Header header0,
+                                SynthesisFilter filtera, SynthesisFilter filterb,
+                            Obuffer buffer0, int which_ch0)
+        {
+        huffcodetab.inithuff();
+                is_1d = new int[SBLIMIT*SSLIMIT+4];
+                ro = new float[2][SBLIMIT][SSLIMIT];
+                lr = new float[2][SBLIMIT][SSLIMIT];
+                out_1d = new float[SBLIMIT*SSLIMIT];
+                prevblck = new float[2][SBLIMIT*SSLIMIT];
+                k = new float[2][SBLIMIT*SSLIMIT];
+                nonzero = new int[2];
+
+        //III_scalefact_t
+        III_scalefac_t = new temporaire2[2];
+        III_scalefac_t[0] = new temporaire2();
+        III_scalefac_t[1] = new temporaire2();
+        scalefac = III_scalefac_t;
+        // L3TABLE INIT
+
+                sfBandIndex = new SBI[9];       // SZD: MPEG2.5 +3 indices
+                int[] l0 = {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576};
+                int[] s0 = {0,4,8,12,18,24,32,42,56,74,100,132,174,192};
+                int[] l1 = {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576};
+                int[] s1 = {0,4,8,12,18,26,36,48,62,80,104,136,180,192};
+                int[] l2 = {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576};
+                int[] s2 = {0,4,8,12,18,26,36,48,62,80,104,134,174,192};
+
+                int[] l3 = {0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576};
+                int[] s3 = {0,4,8,12,16,22,30,40,52,66,84,106,136,192};
+                int[] l4 = {0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576};
+                int[] s4 = {0,4,8,12,16,22,28,38,50,64,80,100,126,192};
+                int[] l5 = {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576};
+                int[] s5 = {0,4,8,12,16,22,30,42,58,78,104,138,180,192};
+                // SZD: MPEG2.5
+                int[] l6 = {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576};
+                int[] s6 = {0,4,8,12,18,26,36,48,62,80,104,134,174,192};
+                int[] l7 = {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576};
+                int[] s7 = {0,4,8,12,18,26,36,48,62,80,104,134,174,192};
+                int[] l8 = {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576};
+                int[] s8 = {0,8,16,24,36,52,72,96,124,160,162,164,166,192};
+
+                sfBandIndex[0]= new SBI(l0,s0);
+                sfBandIndex[1]= new SBI(l1,s1);
+                sfBandIndex[2]= new SBI(l2,s2);
+
+                sfBandIndex[3]= new SBI(l3,s3);
+                sfBandIndex[4]= new SBI(l4,s4);
+                sfBandIndex[5]= new SBI(l5,s5);
+                //SZD: MPEG2.5
+                sfBandIndex[6]= new SBI(l6,s6);
+                sfBandIndex[7]= new SBI(l7,s7);
+                sfBandIndex[8]= new SBI(l8,s8);
+                // END OF L3TABLE INIT
+
+                if(reorder_table == null) {     // SZD: generate LUT
+                        reorder_table = new int[9][];
+                        for(int i = 0; i < 9; i++)
+                                reorder_table[i] = reorder(sfBandIndex[i].s);
+                }
+
+                // Sftable
+                int[] ll0 = {0, 6, 11, 16, 21};
+                int[] ss0 = {0, 6, 12};
+                sftable = new Sftable(ll0,ss0);
+                // END OF Sftable
+
+        // scalefac_buffer
+                scalefac_buffer = new int[54];
+                // END OF scalefac_buffer
+
+                stream         = stream0;
+                header         = header0;
+                filter1        = filtera;
+                filter2        = filterb;
+                buffer         = buffer0;
+                which_channels = which_ch0;
+
+                frame_start = 0;
+                channels    = (header.mode() == Header.SINGLE_CHANNEL) ? 1 : 2;
+                max_gr      = (header.version() == Header.MPEG1) ? 2 : 1;
+
+                sfreq       =  header.sample_frequency() +
+                         ((header.version() == Header.MPEG1) ? 3 :
+                         (header.version() == Header.MPEG25_LSF) ? 6 : 0);      // SZD
+
+                if (channels == 2)
+                {
+                  switch (which_channels)
+                  {
+                case OutputChannels.LEFT_CHANNEL:
+                     case OutputChannels.DOWNMIX_CHANNELS:
+                     first_channel = last_channel = 0;
+                     break;
+
+                     case OutputChannels.RIGHT_CHANNEL:
+                     first_channel = last_channel = 1;
+                     break;
+
+                     case OutputChannels.BOTH_CHANNELS:
+                          default:
+                     first_channel  = 0;
+                     last_channel   = 1;
+                     break;
+             }
+           }
+           else
+           {
+            first_channel = last_channel = 0;
+           }
+
+          for(int ch=0;ch<2;ch++)
+             for (int j=0; j<576; j++)
+                        prevblck[ch][j] = 0.0f;
+
+          nonzero[0] = nonzero[1] = 576;
+
+          br = new BitReserve();
+          si = new III_side_info_t();
+        }
+
+   /**
+    * Notify decoder that a seek is being made.
+        */
+   public void seek_notify()
+   {
+          frame_start = 0;
+          for(int ch=0;ch<2;ch++)
+          for (int j=0; j<576; j++)
+           prevblck[ch][j] = 0.0f;
+          br = new BitReserve();
+   }
+
+   public void decodeFrame()
+   {
+           decode();
+   }
+
+   /**
+    * Decode one frame, filling the buffer with the output samples.
+        */
+
+   // subband samples are buffered and passed to the
+   // SynthesisFilter in one go.
+        private float[] samples1 = new float[32];
+        private float[] samples2 = new float[32];
+
+        public void decode()
+        {
+                int nSlots = header.slots();
+            int flush_main;
+            int gr, ch, ss, sb, sb18;
+            int main_data_end;
+                int bytes_to_discard;
+            int i;
+
+                get_side_info();
+
+            for (i=0; i<nSlots; i++)
+                br.hputbuf(stream.get_bits(8));
+
+            main_data_end = br.hsstell() >>> 3; // of previous frame
+
+            if ((flush_main = (br.hsstell() & 7)) != 0) {
+                 br.hgetbits(8 - flush_main);
+                                main_data_end++;
+                 }
+
+                 bytes_to_discard = frame_start - main_data_end
+                                                                  - si.main_data_begin;
+
+                 frame_start += nSlots;
+
+            if (bytes_to_discard < 0)
+                                return;
+
+                 if (main_data_end > 4096) {
+                                frame_start -= 4096;
+                                br.rewindNbytes(4096);
+                 }
+
+                 for (; bytes_to_discard > 0; bytes_to_discard--)
+                        br.hgetbits(8);
+
+                 for (gr=0;gr<max_gr;gr++) {
+
+                                for (ch=0; ch<channels; ch++) {
+                   part2_start = br.hsstell();
+
+                   if (header.version() == Header.MPEG1)
+                                          get_scale_factors(ch, gr);
+                           else  // MPEG-2 LSF, SZD: MPEG-2.5 LSF
+                      get_LSF_scale_factors(ch, gr);
+
+                                  huffman_decode(ch, gr);
+                                  // System.out.println("CheckSum HuffMan = " + CheckSumHuff);
+                                  dequantize_sample(ro[ch], ch, gr);
+                                }
+
+                 stereo(gr);
+
+                 if ((which_channels == OutputChannels.DOWNMIX_CHANNELS) && (channels > 1))
+                        do_downmix();
+
+                 for (ch=first_channel; ch<=last_channel; ch++) {
+
+                                reorder(lr[ch], ch, gr);
+                                                antialias(ch, gr);
+                 //for (int hb = 0;hb<576;hb++) CheckSumOut1d = CheckSumOut1d + out_1d[hb];
+                                 //System.out.println("CheckSumOut1d = "+CheckSumOut1d);
+
+                       hybrid(ch, gr);
+
+                     //for (int hb = 0;hb<576;hb++) CheckSumOut1d = CheckSumOut1d + out_1d[hb];
+                                 //System.out.println("CheckSumOut1d = "+CheckSumOut1d);
+
+                                                for (sb18=18;sb18<576;sb18+=36) // Frequency inversion
+                           for (ss=1;ss<SSLIMIT;ss+=2)
+                                  out_1d[sb18 + ss] = -out_1d[sb18 + ss];
+
+                                                if ((ch == 0) || (which_channels == OutputChannels.RIGHT_CHANNEL)) {
+                                                  for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
+                                sb = 0;
+                                        for (sb18=0; sb18<576; sb18+=18) {
+                                                                samples1[sb] =  out_1d[sb18+ss];
+                                                                //filter1.input_sample(out_1d[sb18+ss], sb);
+                                 sb++;
+                             }
+                                filter1.input_samples(samples1);
+                                                        filter1.calculate_pcm_samples(buffer);
+                                                  }
+                                                } else {
+                                                  for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
+                                sb = 0;
+                                        for (sb18=0; sb18<576; sb18+=18) {
+                                                                samples2[sb] =  out_1d[sb18+ss];
+                                                                         //filter2.input_sample(out_1d[sb18+ss], sb);
+                                 sb++;
+                             }
+                                filter2.input_samples(samples2);
+                                                        filter2.calculate_pcm_samples(buffer);
+                                                  }
+
+                       }
+                                }       // channels
+                 }      // granule
+
+
+                // System.out.println("Counter = ................................."+counter);
+                //if (counter <  609)
+                //{
+                    counter++;
+                    buffer.write_buffer(1);
+                //}
+                //else if (counter == 609)
+                //{
+                //    buffer.close();
+                //    counter++;
+                //}
+                //else
+                //{
+                //}
+
+        }
+
+    /**
+         * Reads the side info from the stream, assuming the entire.
+         * frame has been read already.
+         * Mono   : 136 bits (= 17 bytes)
+     * Stereo : 256 bits (= 32 bytes)
+         */
+        private boolean get_side_info()
+        {
+                int ch, gr;
+                if (header.version() == Header.MPEG1)
+                {
+
+                        si.main_data_begin = stream.get_bits(9);
+                        if (channels == 1)
+                                si.private_bits = stream.get_bits(5);
+                        else si.private_bits = stream.get_bits(3);
+
+                        for (ch=0; ch<channels; ch++) {
+                                si.ch[ch].scfsi[0] = stream.get_bits(1);
+                                si.ch[ch].scfsi[1] = stream.get_bits(1);
+                                si.ch[ch].scfsi[2] = stream.get_bits(1);
+                                si.ch[ch].scfsi[3] = stream.get_bits(1);
+                   }
+
+                        for (gr=0; gr<2; gr++) {
+                                for (ch=0; ch<channels; ch++) {
+                                        si.ch[ch].gr[gr].part2_3_length = stream.get_bits(12);
+                                        si.ch[ch].gr[gr].big_values = stream.get_bits(9);
+                                        si.ch[ch].gr[gr].global_gain = stream.get_bits(8);
+                                        si.ch[ch].gr[gr].scalefac_compress = stream.get_bits(4);
+                                        si.ch[ch].gr[gr].window_switching_flag = stream.get_bits(1);
+                                        if ((si.ch[ch].gr[gr].window_switching_flag) != 0) {
+                                                si.ch[ch].gr[gr].block_type       = stream.get_bits(2);
+                                                si.ch[ch].gr[gr].mixed_block_flag = stream.get_bits(1);
+
+                                                si.ch[ch].gr[gr].table_select[0]  = stream.get_bits(5);
+                                                si.ch[ch].gr[gr].table_select[1]  = stream.get_bits(5);
+
+                                                si.ch[ch].gr[gr].subblock_gain[0] = stream.get_bits(3);
+                                                si.ch[ch].gr[gr].subblock_gain[1] = stream.get_bits(3);
+                                                si.ch[ch].gr[gr].subblock_gain[2] = stream.get_bits(3);
+
+                                                // Set region_count parameters since they are implicit in this case.
+
+                                                if (si.ch[ch].gr[gr].block_type == 0) {
+                                                        //       Side info bad: block_type == 0 in split block
+                                                        return false;
+                                                } else if (si.ch[ch].gr[gr].block_type == 2
+                                                                          && si.ch[ch].gr[gr].mixed_block_flag == 0) {
+                                                        si.ch[ch].gr[gr].region0_count = 8;
+                       } else {
+                               si.ch[ch].gr[gr].region0_count = 7;
+                       }
+                                                si.ch[ch].gr[gr].region1_count = 20 -
+                                                                si.ch[ch].gr[gr].region0_count;
+                                        } else {
+                                                si.ch[ch].gr[gr].table_select[0] = stream.get_bits(5);
+                                                si.ch[ch].gr[gr].table_select[1] = stream.get_bits(5);
+                                                si.ch[ch].gr[gr].table_select[2] = stream.get_bits(5);
+                                                si.ch[ch].gr[gr].region0_count = stream.get_bits(4);
+                                                si.ch[ch].gr[gr].region1_count = stream.get_bits(3);
+                                                si.ch[ch].gr[gr].block_type = 0;
+                                        }
+                                        si.ch[ch].gr[gr].preflag = stream.get_bits(1);
+                                        si.ch[ch].gr[gr].scalefac_scale = stream.get_bits(1);
+                                        si.ch[ch].gr[gr].count1table_select = stream.get_bits(1);
+                 }
+              }
+
+                } else {        // MPEG-2 LSF, SZD: MPEG-2.5 LSF
+
+              si.main_data_begin = stream.get_bits(8);
+              if (channels == 1)
+                si.private_bits = stream.get_bits(1);
+              else si.private_bits = stream.get_bits(2);
+
+              for (ch=0; ch<channels; ch++) {
+
+                  si.ch[ch].gr[0].part2_3_length = stream.get_bits(12);
+                  si.ch[ch].gr[0].big_values = stream.get_bits(9);
+                  si.ch[ch].gr[0].global_gain = stream.get_bits(8);
+                  si.ch[ch].gr[0].scalefac_compress = stream.get_bits(9);
+                  si.ch[ch].gr[0].window_switching_flag = stream.get_bits(1);
+
+                  if ((si.ch[ch].gr[0].window_switching_flag) != 0) {
+
+                     si.ch[ch].gr[0].block_type = stream.get_bits(2);
+                     si.ch[ch].gr[0].mixed_block_flag = stream.get_bits(1);
+                     si.ch[ch].gr[0].table_select[0] = stream.get_bits(5);
+                     si.ch[ch].gr[0].table_select[1] = stream.get_bits(5);
+
+                     si.ch[ch].gr[0].subblock_gain[0] = stream.get_bits(3);
+                     si.ch[ch].gr[0].subblock_gain[1] = stream.get_bits(3);
+                     si.ch[ch].gr[0].subblock_gain[2] = stream.get_bits(3);
+
+                    // Set region_count parameters since they are implicit in this case.
+
+                     if (si.ch[ch].gr[0].block_type == 0) {
+                        // Side info bad: block_type == 0 in split block
+                        return false;
+                     } else if (si.ch[ch].gr[0].block_type == 2
+                              && si.ch[ch].gr[0].mixed_block_flag == 0) {
+                         si.ch[ch].gr[0].region0_count = 8;
+                                         } else {
+                         si.ch[ch].gr[0].region0_count = 7;
+                        si.ch[ch].gr[0].region1_count = 20 -
+                                                                                                                si.ch[ch].gr[0].region0_count;
+                     }
+
+                  } else {
+                     si.ch[ch].gr[0].table_select[0] = stream.get_bits(5);
+                     si.ch[ch].gr[0].table_select[1] = stream.get_bits(5);
+                     si.ch[ch].gr[0].table_select[2] = stream.get_bits(5);
+                     si.ch[ch].gr[0].region0_count = stream.get_bits(4);
+                     si.ch[ch].gr[0].region1_count = stream.get_bits(3);
+                     si.ch[ch].gr[0].block_type = 0;
+                  }
+
+                  si.ch[ch].gr[0].scalefac_scale = stream.get_bits(1);
+                  si.ch[ch].gr[0].count1table_select = stream.get_bits(1);
+              }   // for(ch=0; ch<channels; ch++)
+           } // if (header.version() == MPEG1)
+          return true;
+        }
+
+    /**
+         *
+         */
+        private void get_scale_factors(int ch, int gr)
+        {
+           int sfb, window;
+           gr_info_s gr_info = (si.ch[ch].gr[gr]);
+           int scale_comp   = gr_info.scalefac_compress;
+           int length0      = slen[0][scale_comp];
+           int length1      = slen[1][scale_comp];
+
+                if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
+                        if ((gr_info.mixed_block_flag) != 0) { // MIXED
+                                for (sfb = 0; sfb < 8; sfb++)
+                                        scalefac[ch].l[sfb] = br.hgetbits(
+                                                  slen[0][gr_info.scalefac_compress]);
+                                for (sfb = 3; sfb < 6; sfb++)
+                                        for (window=0; window<3; window++)
+                                                scalefac[ch].s[window][sfb] = br.hgetbits(
+                                                  slen[0][gr_info.scalefac_compress]);
+                                for (sfb = 6; sfb < 12; sfb++)
+                                        for (window=0; window<3; window++)
+                                                scalefac[ch].s[window][sfb] = br.hgetbits(
+                                                  slen[1][gr_info.scalefac_compress]);
+                                for (sfb=12,window=0; window<3; window++)
+                                        scalefac[ch].s[window][sfb] = 0;
+
+              } else {  // SHORT
+
+                 scalefac[ch].s[0][0]  = br.hgetbits(length0);
+                 scalefac[ch].s[1][0]  = br.hgetbits(length0);
+                 scalefac[ch].s[2][0]  = br.hgetbits(length0);
+                 scalefac[ch].s[0][1]  = br.hgetbits(length0);
+                 scalefac[ch].s[1][1]  = br.hgetbits(length0);
+                 scalefac[ch].s[2][1]  = br.hgetbits(length0);
+                 scalefac[ch].s[0][2]  = br.hgetbits(length0);
+                 scalefac[ch].s[1][2]  = br.hgetbits(length0);
+                 scalefac[ch].s[2][2]  = br.hgetbits(length0);
+                 scalefac[ch].s[0][3]  = br.hgetbits(length0);
+                 scalefac[ch].s[1][3]  = br.hgetbits(length0);
+                 scalefac[ch].s[2][3]  = br.hgetbits(length0);
+                 scalefac[ch].s[0][4]  = br.hgetbits(length0);
+                 scalefac[ch].s[1][4]  = br.hgetbits(length0);
+                 scalefac[ch].s[2][4]  = br.hgetbits(length0);
+                 scalefac[ch].s[0][5]  = br.hgetbits(length0);
+                 scalefac[ch].s[1][5]  = br.hgetbits(length0);
+                 scalefac[ch].s[2][5]  = br.hgetbits(length0);
+                 scalefac[ch].s[0][6]  = br.hgetbits(length1);
+                 scalefac[ch].s[1][6]  = br.hgetbits(length1);
+                 scalefac[ch].s[2][6]  = br.hgetbits(length1);
+                 scalefac[ch].s[0][7]  = br.hgetbits(length1);
+                 scalefac[ch].s[1][7]  = br.hgetbits(length1);
+                 scalefac[ch].s[2][7]  = br.hgetbits(length1);
+                 scalefac[ch].s[0][8]  = br.hgetbits(length1);
+                 scalefac[ch].s[1][8]  = br.hgetbits(length1);
+                 scalefac[ch].s[2][8]  = br.hgetbits(length1);
+                 scalefac[ch].s[0][9]  = br.hgetbits(length1);
+                 scalefac[ch].s[1][9]  = br.hgetbits(length1);
+                 scalefac[ch].s[2][9]  = br.hgetbits(length1);
+                 scalefac[ch].s[0][10] = br.hgetbits(length1);
+                 scalefac[ch].s[1][10] = br.hgetbits(length1);
+                 scalefac[ch].s[2][10] = br.hgetbits(length1);
+                 scalefac[ch].s[0][11] = br.hgetbits(length1);
+                 scalefac[ch].s[1][11] = br.hgetbits(length1);
+                 scalefac[ch].s[2][11] = br.hgetbits(length1);
+                 scalefac[ch].s[0][12] = 0;
+                                scalefac[ch].s[1][12] = 0;
+                                scalefac[ch].s[2][12] = 0;
+                        } // SHORT
+
+                } else {   // LONG types 0,1,3
+
+              if ((si.ch[ch].scfsi[0] == 0) || (gr == 0)) {
+                   scalefac[ch].l[0]  = br.hgetbits(length0);
+                   scalefac[ch].l[1]  = br.hgetbits(length0);
+                   scalefac[ch].l[2]  = br.hgetbits(length0);
+                   scalefac[ch].l[3]  = br.hgetbits(length0);
+                   scalefac[ch].l[4]  = br.hgetbits(length0);
+                   scalefac[ch].l[5]  = br.hgetbits(length0);
+                        }
+              if ((si.ch[ch].scfsi[1] == 0) || (gr == 0)) {
+                   scalefac[ch].l[6]  = br.hgetbits(length0);
+                   scalefac[ch].l[7]  = br.hgetbits(length0);
+                   scalefac[ch].l[8]  = br.hgetbits(length0);
+                   scalefac[ch].l[9]  = br.hgetbits(length0);
+                   scalefac[ch].l[10] = br.hgetbits(length0);
+                        }
+              if ((si.ch[ch].scfsi[2] == 0) || (gr == 0)) {
+                   scalefac[ch].l[11] = br.hgetbits(length1);
+                   scalefac[ch].l[12] = br.hgetbits(length1);
+                   scalefac[ch].l[13] = br.hgetbits(length1);
+                   scalefac[ch].l[14] = br.hgetbits(length1);
+                   scalefac[ch].l[15] = br.hgetbits(length1);
+                        }
+              if ((si.ch[ch].scfsi[3] == 0) || (gr == 0)) {
+                   scalefac[ch].l[16] = br.hgetbits(length1);
+                   scalefac[ch].l[17] = br.hgetbits(length1);
+                   scalefac[ch].l[18] = br.hgetbits(length1);
+                   scalefac[ch].l[19] = br.hgetbits(length1);
+                   scalefac[ch].l[20] = br.hgetbits(length1);
+                        }
+
+              scalefac[ch].l[21] = 0;
+                  scalefac[ch].l[22] = 0;
+                }
+        }
+
+    /**
+         *
+         */
+        // MDM: new_slen is fully initialized before use, no need
+        // to reallocate array.
+        private final int[] new_slen = new int[4];
+
+        private void get_LSF_scale_data(int ch, int gr)
+        {
+
+                int scalefac_comp, int_scalefac_comp;
+            int mode_ext = header.mode_extension();
+                int m;
+                int blocktypenumber;
+                int blocknumber = 0;
+
+                gr_info_s gr_info = (si.ch[ch].gr[gr]);
+
+                scalefac_comp =  gr_info.scalefac_compress;
+
+            if (gr_info.block_type == 2) {
+             if (gr_info.mixed_block_flag == 0)
+                blocktypenumber = 1;
+              else if (gr_info.mixed_block_flag == 1)
+                                blocktypenumber = 2;
+              else
+                blocktypenumber = 0;
+            } else {
+                blocktypenumber = 0;
+            }
+
+           if(!(((mode_ext == 1) || (mode_ext == 3)) && (ch == 1))) {
+
+                        if(scalefac_comp < 400) {
+
+                                new_slen[0] = (scalefac_comp >>> 4) / 5 ;
+                                new_slen[1] = (scalefac_comp >>> 4) % 5 ;
+                                new_slen[2] = (scalefac_comp & 0xF) >>> 2 ;
+                                new_slen[3] = (scalefac_comp & 3);
+                        si.ch[ch].gr[gr].preflag = 0;
+                        blocknumber = 0;
+
+               } else if (scalefac_comp  < 500) {
+
+                                new_slen[0] = ((scalefac_comp - 400) >>> 2) / 5 ;
+                                new_slen[1] = ((scalefac_comp - 400) >>> 2) % 5 ;
+                                new_slen[2] = (scalefac_comp - 400 ) & 3 ;
+                                new_slen[3] = 0;
+                        si.ch[ch].gr[gr].preflag = 0;
+                        blocknumber = 1;
+
+                   } else if (scalefac_comp < 512) {
+
+                                new_slen[0] = (scalefac_comp - 500 ) / 3 ;
+                                new_slen[1] = (scalefac_comp - 500)  % 3 ;
+                                new_slen[2] = 0;
+                                new_slen[3] = 0;
+                        si.ch[ch].gr[gr].preflag = 1;
+                        blocknumber = 2;
+                   }
+           }
+
+           if((((mode_ext == 1) || (mode_ext == 3)) && (ch == 1)))
+           {
+              int_scalefac_comp = scalefac_comp >>> 1;
+
+              if (int_scalefac_comp < 180)
+              {
+                                new_slen[0] = int_scalefac_comp  / 36 ;
+                                new_slen[1] = (int_scalefac_comp % 36 ) / 6 ;
+                                new_slen[2] = (int_scalefac_comp % 36) % 6;
+                                new_slen[3] = 0;
+                        si.ch[ch].gr[gr].preflag = 0;
+                        blocknumber = 3;
+              } else if (int_scalefac_comp < 244) {
+                                new_slen[0] = ((int_scalefac_comp - 180 )  & 0x3F) >>> 4 ;
+                                new_slen[1] = ((int_scalefac_comp - 180) & 0xF) >>> 2 ;
+                                new_slen[2] = (int_scalefac_comp - 180 ) & 3 ;
+                                new_slen[3] = 0;
+                        si.ch[ch].gr[gr].preflag = 0;
+                        blocknumber = 4;
+              } else if (int_scalefac_comp < 255) {
+                                new_slen[0] = (int_scalefac_comp - 244 ) / 3 ;
+                                new_slen[1] = (int_scalefac_comp - 244 )  % 3 ;
+                                new_slen[2] = 0 ;
+                                new_slen[3] = 0;
+                        si.ch[ch].gr[gr].preflag = 0;
+                        blocknumber = 5;
+              }
+           }
+
+           for (int x=0; x<45; x++) // why 45, not 54?
+                scalefac_buffer[x] = 0;
+
+           m = 0;
+           for (int i=0; i<4;i++) {
+                for (int j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i];
+                 j++)
+              {
+                scalefac_buffer[m] = (new_slen[i] == 0) ? 0 :
+                                                                          br.hgetbits(new_slen[i]);
+                m++;
+
+              } // for (unint32 j ...
+                } // for (uint32 i ...
+        }
+
+        /**
+         *
+         */
+    private void get_LSF_scale_factors(int ch, int gr)
+        {
+                int m = 0;
+            int sfb, window;
+                gr_info_s gr_info = (si.ch[ch].gr[gr]);
+
+            get_LSF_scale_data(ch, gr);
+
+            if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
+              if (gr_info.mixed_block_flag != 0) {      // MIXED
+                 for (sfb = 0; sfb < 8; sfb++)
+                 {
+                      scalefac[ch].l[sfb] = scalefac_buffer[m];
+                      m++;
+                 }
+                 for (sfb = 3; sfb < 12; sfb++) {
+                    for (window=0; window<3; window++)
+                    {
+                       scalefac[ch].s[window][sfb] = scalefac_buffer[m];
+                       m++;
+                    }
+                 }
+                 for (window=0; window<3; window++)
+                    scalefac[ch].s[window][12] = 0;
+
+              } else {  // SHORT
+
+                   for (sfb = 0; sfb < 12; sfb++) {
+                       for (window=0; window<3; window++)
+                       {
+                          scalefac[ch].s[window][sfb] = scalefac_buffer[m];
+                          m++;
+                       }
+                   }
+
+                   for (window=0; window<3; window++)
+                       scalefac[ch].s[window][12] = 0;
+              }
+           } else {   // LONG types 0,1,3
+
+              for (sfb = 0; sfb < 21; sfb++) {
+                  scalefac[ch].l[sfb] = scalefac_buffer[m];
+                  m++;
+              }
+              scalefac[ch].l[21] = 0; // Jeff
+              scalefac[ch].l[22] = 0;
+                }
+        }
+
+        /**
+         *
+         */
+    int[] x = {0};
+        int[] y = {0};
+        int[] v = {0};
+        int[] w = {0};
+        private void huffman_decode(int ch, int gr)
+        {
+                x[0] = 0;
+                y[0] = 0;
+                v[0] = 0;
+                w[0] = 0;
+
+                int part2_3_end = part2_start + si.ch[ch].gr[gr].part2_3_length;
+                int num_bits;
+                int region1Start;
+                int region2Start;
+            int index;
+
+            int buf, buf1;
+
+                huffcodetab h;
+
+                // Find region boundary for short block case
+
+                if ( ((si.ch[ch].gr[gr].window_switching_flag) != 0) &&
+                          (si.ch[ch].gr[gr].block_type == 2) ) {
+
+                        // Region2.
+            //MS: Extrahandling for 8KHZ
+            region1Start = (sfreq == 8) ? 72 : 36;  // sfb[9/3]*3=36 or in case 8KHZ = 72
+                        region2Start = 576; // No Region2 for short block case
+
+          } else {          // Find region boundary for long block case
+
+            buf = si.ch[ch].gr[gr].region0_count + 1;
+            buf1 = buf + si.ch[ch].gr[gr].region1_count + 1;
+
+            if(buf1 > sfBandIndex[sfreq].l.length - 1) buf1 = sfBandIndex[sfreq].l.length - 1;
+
+                        region1Start = sfBandIndex[sfreq].l[buf];
+                        region2Start = sfBandIndex[sfreq].l[buf1]; /* MI */
+           }
+
+           index = 0;
+                // Read bigvalues area
+                for (int i=0; i<(si.ch[ch].gr[gr].big_values<<1); i+=2) {
+                        if      (i<region1Start) h = huffcodetab.ht[si.ch[ch].gr[gr].table_select[0]];
+                        else if (i<region2Start) h = huffcodetab.ht[si.ch[ch].gr[gr].table_select[1]];
+                                  else                h = huffcodetab.ht[si.ch[ch].gr[gr].table_select[2]];
+
+                        huffcodetab.huffman_decoder(h, x, y, v, w, br);
+                  //if (index >= is_1d.length) System.out.println("i0="+i+"/"+(si.ch[ch].gr[gr].big_values<<1)+" Index="+index+" is_1d="+is_1d.length);
+              
+              is_1d[index++] = x[0];
+              is_1d[index++] = y[0];
+              
+              CheckSumHuff = CheckSumHuff + x[0] + y[0];
+              // System.out.println("x = "+x[0]+" y = "+y[0]);
+                }
+
+                // Read count1 area
+                h = huffcodetab.ht[si.ch[ch].gr[gr].count1table_select+32];
+            num_bits = br.hsstell();
+
+                while ((num_bits < part2_3_end) && (index < 576)) {
+
+                        huffcodetab.huffman_decoder(h, x, y, v, w, br);
+
+              is_1d[index++] = v[0];
+              is_1d[index++] = w[0];
+              is_1d[index++] = x[0];
+              is_1d[index++] = y[0];
+          CheckSumHuff = CheckSumHuff + v[0] + w[0] + x[0] + y[0];
+              // System.out.println("v = "+v[0]+" w = "+w[0]);
+              // System.out.println("x = "+x[0]+" y = "+y[0]);
+              num_bits = br.hsstell();
+           }
+
+                if (num_bits > part2_3_end) {
+                        br.rewindNbits(num_bits - part2_3_end);
+              index-=4;
+           }
+
+           num_bits = br.hsstell();
+
+                // Dismiss stuffing bits
+                if (num_bits < part2_3_end)
+                br.hgetbits(part2_3_end - num_bits);
+
+                // Zero out rest
+
+           if (index < 576)
+                   nonzero[ch] = index;
+           else
+                nonzero[ch] = 576;
+
+           if (index < 0) index = 0;
+
+           // may not be necessary
+           for (; index<576; index++)
+                is_1d[index] = 0;
+        }
+
+        /**
+         *
+         */
+    private void i_stereo_k_values(int is_pos, int io_type, int i)
+        {
+           if (is_pos == 0) {
+              k[0][i] = 1.0f;
+              k[1][i] = 1.0f;
+           } else if ((is_pos & 1) != 0) {
+                        k[0][i] = io[io_type][(is_pos + 1) >>> 1];
+              k[1][i] = 1.0f;
+           } else {
+              k[0][i] = 1.0f;
+              k[1][i] = io[io_type][is_pos >>> 1];
+           }
+        }
+
+        /**
+         *
+         */
+        private void dequantize_sample(float xr[][], int ch, int gr)
+        {
+                gr_info_s gr_info = (si.ch[ch].gr[gr]);
+                int  cb=0;
+                int  next_cb_boundary;
+                int cb_begin = 0;
+                int cb_width = 0;
+                int  index=0, t_index, j;
+                float g_gain;
+            float[][] xr_1d = xr;
+
+                // choose correct scalefactor band per block type, initalize boundary
+
+                if ((gr_info.window_switching_flag !=0 ) && (gr_info.block_type == 2) ) {
+                        if (gr_info.mixed_block_flag != 0)
+                                next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
+                        else {
+                 cb_width = sfBandIndex[sfreq].s[1];
+                           next_cb_boundary = (cb_width << 2) - cb_width;
+                           cb_begin = 0;
+                        }
+                } else {
+                        next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
+           }
+
+           // Compute overall (global) scaling.
+
+                g_gain = (float) Math.pow(2.0 , (0.25 * (gr_info.global_gain - 210.0)));
+
+                for (j=0; j<nonzero[ch]; j++)
+                {
+                    // Modif E.B 02/22/99
+            int reste = j % SSLIMIT;
+            int quotien = (int) ((j-reste)/SSLIMIT);
+                if (is_1d[j] == 0) xr_1d[quotien][reste] = 0.0f;
+                else
+                {
+                 int abv = is_1d[j];
+                 // Pow Array fix (11/17/04)
+                 if (abv < t_43.length)
+                 {
+                                if (is_1d[j] > 0) xr_1d[quotien][reste] = g_gain * t_43[abv];
+                                else
+                                {
+                                        if (-abv < t_43.length) xr_1d[quotien][reste] = -g_gain * t_43[-abv];
+                                        else xr_1d[quotien][reste] = -g_gain * (float)Math.pow(-abv, d43);      
+                                } 
+                 }
+                 else
+                 {
+                                if (is_1d[j] > 0) xr_1d[quotien][reste] = g_gain * (float)Math.pow(abv, d43);
+                                else xr_1d[quotien][reste] = -g_gain * (float)Math.pow(-abv, d43);                      
+                 }
+                }
+           }
+
+           // apply formula per block type
+           for (j=0; j<nonzero[ch]; j++)
+           {
+            // Modif E.B 02/22/99
+            int reste = j % SSLIMIT;
+            int quotien = (int) ((j-reste)/SSLIMIT);
+
+                        if (index == next_cb_boundary)  { /* Adjust critical band boundary */
+                if ((gr_info.window_switching_flag != 0) && (gr_info.block_type == 2)) {
+                        if (gr_info.mixed_block_flag != 0)  {
+
+                        if (index == sfBandIndex[sfreq].l[8])  {
+                          next_cb_boundary = sfBandIndex[sfreq].s[4];
+                          next_cb_boundary = (next_cb_boundary << 2) -
+                                                           next_cb_boundary;
+                          cb = 3;
+                          cb_width = sfBandIndex[sfreq].s[4] -
+                                                  sfBandIndex[sfreq].s[3];
+
+                          cb_begin = sfBandIndex[sfreq].s[3];
+                          cb_begin = (cb_begin << 2) - cb_begin;
+
+                       } else if (index < sfBandIndex[sfreq].l[8]) {
+
+                        next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
+
+                       } else {
+
+                        next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
+                          next_cb_boundary = (next_cb_boundary << 2) -
+                                                                next_cb_boundary;
+
+                          cb_begin = sfBandIndex[sfreq].s[cb];
+                                                        cb_width = sfBandIndex[sfreq].s[cb+1] -
+                                     cb_begin;
+                          cb_begin = (cb_begin << 2) - cb_begin;
+                       }
+
+                    } else  {
+
+                       next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
+                       next_cb_boundary = (next_cb_boundary << 2) -
+                                          next_cb_boundary;
+
+                       cb_begin = sfBandIndex[sfreq].s[cb];
+                                                cb_width = sfBandIndex[sfreq].s[cb+1] -
+                                  cb_begin;
+                       cb_begin = (cb_begin << 2) - cb_begin;
+                    }
+
+                 } else  { // long blocks
+
+                                                next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
+
+                 }
+              }
+
+                        // Do long/short dependent scaling operations
+
+                        if ((gr_info.window_switching_flag !=0)&&
+                                 (((gr_info.block_type == 2) && (gr_info.mixed_block_flag == 0)) ||
+                                  ((gr_info.block_type == 2) && (gr_info.mixed_block_flag!=0) && (j >= 36)) ))
+              {
+
+                                t_index = (index - cb_begin) / cb_width;
+        /*            xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info.subblock_gain[t_index])
+                                            -(0.5 * (1.0 + gr_info.scalefac_scale)
+                                              * scalefac[ch].s[t_index][cb]))); */
+                                int idx = scalefac[ch].s[t_index][cb]
+                                                 << gr_info.scalefac_scale;
+                 idx += (gr_info.subblock_gain[t_index] << 2);
+
+                                xr_1d[quotien][reste] *= two_to_negative_half_pow[idx];
+
+                        } else {   // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
+        /*                              xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info.scalefac_scale)
+                                                                                                                 * (scalefac[ch].l[cb]
+                                                                                                                 + gr_info.preflag * pretab[cb])); */
+                                int idx = scalefac[ch].l[cb];
+
+                        if (gr_info.preflag != 0)
+                                idx += pretab[cb];
+
+                           idx = idx << gr_info.scalefac_scale;
+                 xr_1d[quotien][reste] *= two_to_negative_half_pow[idx];
+                        }
+              index++;
+                }
+
+           for (j=nonzero[ch]; j<576; j++)
+           {
+            // Modif E.B 02/22/99
+            int reste = j % SSLIMIT;
+            int quotien = (int) ((j-reste)/SSLIMIT);
+            if(reste < 0) reste = 0;
+            if(quotien < 0) quotien = 0;
+                xr_1d[quotien][reste] = 0.0f;
+           }
+
+           return;
+        }
+
+    /**
+         *
+         */
+        private void reorder(float xr[][], int ch, int gr)
+        {
+           gr_info_s gr_info = (si.ch[ch].gr[gr]);
+           int freq, freq3;
+           int index;
+           int sfb, sfb_start, sfb_lines;
+           int src_line, des_line;
+           float[][] xr_1d = xr;
+
+           if ((gr_info.window_switching_flag !=0) && (gr_info.block_type == 2)) {
+
+              for(index=0; index<576; index++)
+                 out_1d[index] = 0.0f;
+
+                        if (gr_info.mixed_block_flag !=0 ) {
+                                // NO REORDER FOR LOW 2 SUBBANDS
+                    for (index = 0; index < 36; index++)
+                    {
+                    // Modif E.B 02/22/99
+                    int reste = index % SSLIMIT;
+                    int quotien = (int) ((index-reste)/SSLIMIT);
+                        out_1d[index] = xr_1d[quotien][reste];
+                    }
+                                // REORDERING FOR REST SWITCHED SHORT
+                                /*for( sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
+                                         sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
+                                         sfb < 13; sfb++,sfb_start = sfBandIndex[sfreq].s[sfb],
+                                         sfb_lines = sfBandIndex[sfreq].s[sfb+1] - sfb_start )
+                                         {*/                                               
+                                for( sfb=3; sfb < 13; sfb++)
+                         {                                                 
+                                                        //System.out.println("sfreq="+sfreq+" sfb="+sfb+" sfBandIndex="+sfBandIndex.length+" sfBandIndex[sfreq].s="+sfBandIndex[sfreq].s.length);
+                                                        sfb_start = sfBandIndex[sfreq].s[sfb];
+                                                        sfb_lines = sfBandIndex[sfreq].s[sfb+1] - sfb_start;
+
+                                                   int sfb_start3 = (sfb_start << 2) - sfb_start;
+
+                                                        for(freq=0, freq3=0; freq<sfb_lines;
+                                     freq++, freq3+=3) {
+
+                                                                src_line = sfb_start3 + freq;
+                                                                des_line = sfb_start3 + freq3;
+                                // Modif E.B 02/22/99
+                                int reste = src_line % SSLIMIT;
+                                int quotien = (int) ((src_line-reste)/SSLIMIT);
+
+                                                                out_1d[des_line] = xr_1d[quotien][reste];
+                                                                src_line += sfb_lines;
+                                                                des_line++;
+
+                                                                reste = src_line % SSLIMIT;
+                                                                quotien = (int) ((src_line-reste)/SSLIMIT);
+
+                                                                out_1d[des_line] = xr_1d[quotien][reste];
+                                                                src_line += sfb_lines;
+                                                                des_line++;
+
+                                                                reste = src_line % SSLIMIT;
+                                                                quotien = (int) ((src_line-reste)/SSLIMIT);
+
+                                                                out_1d[des_line] = xr_1d[quotien][reste];
+                                                   }
+                          }
+
+                        } else {  // pure short
+                for(index=0;index<576;index++)
+                {
+                int j = reorder_table[sfreq][index];
+                    int reste = j % SSLIMIT;
+                                int quotien = (int) ((j-reste)/SSLIMIT);
+                    out_1d[index] = xr_1d[quotien][reste];
+                }
+                        }
+                }
+                else {   // long blocks
+              for(index=0; index<576; index++)
+              {
+            // Modif E.B 02/22/99
+            int reste = index % SSLIMIT;
+            int quotien = (int) ((index-reste)/SSLIMIT);
+                out_1d[index] = xr_1d[quotien][reste];
+              }
+                }
+        }
+
+        /**
+         *
+         */
+
+        int[] is_pos = new int[576];
+        float[] is_ratio = new float[576];
+
+        private void stereo(int gr)
+        {
+          int sb, ss;
+
+                if  (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]
+
+                        for(sb=0;sb<SBLIMIT;sb++)
+                                for(ss=0;ss<SSLIMIT;ss+=3) {
+                                        lr[0][sb][ss]   = ro[0][sb][ss];
+                    lr[0][sb][ss+1] = ro[0][sb][ss+1];
+                                        lr[0][sb][ss+2] = ro[0][sb][ss+2];
+                 }
+
+           } else {
+
+                gr_info_s gr_info = (si.ch[0].gr[gr]);
+            int mode_ext = header.mode_extension();
+                int sfb;
+                int i;
+            int lines, temp, temp2;
+
+                boolean ms_stereo = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x2)!=0));
+                boolean i_stereo  = ((header.mode() == Header.JOINT_STEREO) && ((mode_ext & 0x1)!=0));
+                boolean lsf = ((header.version() == Header.MPEG2_LSF || header.version() == Header.MPEG25_LSF ));       // SZD
+
+                int io_type = (gr_info.scalefac_compress & 1);
+
+                // initialization
+
+           for (i=0; i<576; i++)
+           {
+                        is_pos[i] = 7;
+
+                        is_ratio[i] = 0.0f;
+           }
+
+                if (i_stereo) {
+                if ((gr_info.window_switching_flag !=0 )&& (gr_info.block_type == 2)) {
+                if (gr_info.mixed_block_flag != 0) {
+
+                         int max_sfb = 0;
+
+                                         for (int j=0; j<3; j++) {
+                         int sfbcnt;
+                                                sfbcnt = 2;
+                                                for( sfb=12; sfb >=3; sfb-- ) {
+                        i = sfBandIndex[sfreq].s[sfb];
+                                                        lines = sfBandIndex[sfreq].s[sfb+1] - i;
+                          i = (i << 2) - i + (j+1) * lines - 1;
+
+                                                        while (lines > 0) {
+                                if (ro[1][i/18][i%18] != 0.0f) {
+                                                        // MDM: in java, array access is very slow.
+                                                        // Is quicker to compute div and mod values.
+                                                //if (ro[1][ss_div[i]][ss_mod[i]] != 0.0f) {
+                                sfbcnt = sfb;
+                                                                        sfb = -10;
+                                                                        lines = -10;
+                                                                }
+
+                                                                lines--;
+                                                                i--;
+
+                                                        } // while (lines > 0)
+
+                                                } // for (sfb=12 ...
+                                                sfb = sfbcnt + 1;
+
+                                                if (sfb > max_sfb)
+                                                        max_sfb = sfb;
+
+                                                while(sfb < 12) {
+                        temp = sfBandIndex[sfreq].s[sfb];
+                        sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
+                          i    = (temp << 2) - temp + j * sb;
+
+                                                        for ( ; sb > 0; sb--) {
+                                is_pos[i] = scalefac[1].s[j][sfb];
+                                                                if (is_pos[i] != 7)
+                                if (lsf)
+                                   i_stereo_k_values(is_pos[i], io_type, i);
+                                else
+                                        is_ratio[i] = TAN12[is_pos[i]];
+
+                                                                i++;
+                                                        } // for (; sb>0...
+                                                        sfb++;
+                                                } // while (sfb < 12)
+                                                sfb = sfBandIndex[sfreq].s[10];
+                       sb  = sfBandIndex[sfreq].s[11] - sfb;
+                       sfb = (sfb << 2) - sfb + j * sb;
+                       temp  = sfBandIndex[sfreq].s[11];
+                       sb = sfBandIndex[sfreq].s[12] - temp;
+                       i = (temp << 2) - temp + j * sb;
+
+                                                for (; sb > 0; sb--) {
+                        is_pos[i] = is_pos[sfb];
+
+                                    if (lsf) {
+                                       k[0][i] = k[0][sfb];
+                                                 k[1][i] = k[1][sfb];
+                                    } else {
+                                                        is_ratio[i] = is_ratio[sfb];
+                          }
+                                                        i++;
+                                                } // for (; sb > 0 ...
+                                         }
+                                         if (max_sfb <= 3) {
+                        i = 2;
+                                                 ss = 17;
+                                                 sb = -1;
+                                                 while (i >= 0) {
+                                if (ro[1][i][ss] != 0.0f) {
+                                 sb = (i<<4) + (i<<1) + ss;
+                                                                 i = -1;
+                                                        } else {
+                              ss--;
+                                                                 if (ss < 0) {
+                                 i--;
+                                                                         ss = 17;
+                                                                 }
+                                                        } // if (ro ...
+                                                 } // while (i>=0)
+                                                 i = 0;
+                                                 while (sfBandIndex[sfreq].l[i] <= sb)
+                                                         i++;
+                                                 sfb = i;
+                                                 i = sfBandIndex[sfreq].l[i];
+                                                 for (; sfb<8; sfb++) {
+                           sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
+                                                         for (; sb>0; sb--) {
+                              is_pos[i] = scalefac[1].l[sfb];
+                                 if (is_pos[i] != 7)
+                                      if (lsf)
+                                   i_stereo_k_values(is_pos[i], io_type, i);
+                                 else
+                                        is_ratio[i] = TAN12[is_pos[i]];
+                                                                 i++;
+                                                         } // for (; sb>0 ...
+                                                 } // for (; sfb<8 ...
+                                         } // for (j=0 ...
+                                } else { // if (gr_info.mixed_block_flag)
+                        for (int j=0; j<3; j++) {
+                        int sfbcnt;
+                                                sfbcnt = -1;
+                                                for( sfb=12; sfb >=0; sfb-- )
+                                                {
+                                                        temp = sfBandIndex[sfreq].s[sfb];
+                          lines = sfBandIndex[sfreq].s[sfb+1] - temp;
+                          i = (temp << 2) - temp + (j+1) * lines - 1;
+
+                                                        while (lines > 0) {
+                                                                if (ro[1][i/18][i%18] != 0.0f) {
+                                                                // MDM: in java, array access is very slow.
+                                                                // Is quicker to compute div and mod values.
+                                                                //if (ro[1][ss_div[i]][ss_mod[i]] != 0.0f) {
+                                sfbcnt = sfb;
+                                                                        sfb = -10;
+                                                                        lines = -10;
+                                                                }
+                                                                lines--;
+                                                                i--;
+                                                        } // while (lines > 0) */
+
+                                                } // for (sfb=12 ...
+                                                sfb = sfbcnt + 1;
+                                                while(sfb<12) {
+                                                        temp = sfBandIndex[sfreq].s[sfb];
+                          sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
+                          i    = (temp << 2) - temp + j * sb;
+                                                        for ( ; sb > 0; sb--) {
+                                is_pos[i] = scalefac[1].s[j][sfb];
+                                                                if (is_pos[i] != 7)
+                                      if (lsf)
+                                   i_stereo_k_values(is_pos[i], io_type, i);
+                                 else
+                                        is_ratio[i] = TAN12[is_pos[i]];
+                                                                i++;
+                                                        } // for (; sb>0 ...
+                                                        sfb++;
+                                                } // while (sfb<12)
+
+                                                temp = sfBandIndex[sfreq].s[10];
+                       temp2= sfBandIndex[sfreq].s[11];
+                       sb   = temp2 - temp;
+                       sfb  = (temp << 2) - temp + j * sb;
+                       sb   = sfBandIndex[sfreq].s[12] - temp2;
+                       i    = (temp2 << 2) - temp2 + j * sb;
+
+                                                for (; sb>0; sb--) {
+                        is_pos[i] = is_pos[sfb];
+
+                                    if (lsf) {
+                                       k[0][i] = k[0][sfb];
+                                                 k[1][i] = k[1][sfb];
+                              } else {
+                                is_ratio[i] = is_ratio[sfb];
+                          }
+                                                        i++;
+                                                } // for (; sb>0 ...
+                                        } // for (sfb=12
+                                } // for (j=0 ...
+                        } else { // if (gr_info.window_switching_flag ...
+                i = 31;
+                                ss = 17;
+                                sb = 0;
+                                while (i >= 0) {
+                        if (ro[1][i][ss] != 0.0f) {
+                        sb = (i<<4) + (i<<1) + ss;
+                                                i = -1;
+                                        } else {
+                        ss--;
+                                                if (ss < 0) {
+                        i--;
+                                                        ss = 17;
+                                                }
+                                        }
+                                }
+                                i = 0;
+                                while (sfBandIndex[sfreq].l[i] <= sb)
+                                        i++;
+
+                                sfb = i;
+                                i = sfBandIndex[sfreq].l[i];
+                                for (; sfb<21; sfb++) {
+                        sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
+                        for (; sb > 0; sb--) {
+                        is_pos[i] = scalefac[1].l[sfb];
+                                                if (is_pos[i] != 7)
+                          if (lsf)
+                             i_stereo_k_values(is_pos[i], io_type, i);
+                          else
+                                is_ratio[i] = TAN12[is_pos[i]];
+                                                i++;
+                                        }
+                                }
+                                sfb = sfBandIndex[sfreq].l[20];
+                                for (sb = 576 - sfBandIndex[sfreq].l[21]; (sb > 0) && (i<576); sb--)
+                                {
+                        is_pos[i] = is_pos[sfb]; // error here : i >=576
+
+                    if (lsf) {
+                       k[0][i] = k[0][sfb];
+                                 k[1][i] = k[1][sfb];
+                    } else {
+                                                is_ratio[i] = is_ratio[sfb];
+                    }
+                                        i++;
+                                } // if (gr_info.mixed_block_flag)
+                        } // if (gr_info.window_switching_flag ...
+                } // if (i_stereo)
+
+                i = 0;
+                        for(sb=0;sb<SBLIMIT;sb++)
+                                for(ss=0;ss<SSLIMIT;ss++) {
+                                        if (is_pos[i] == 7) {
+                                                if (ms_stereo) {
+                                                        lr[0][sb][ss] = (ro[0][sb][ss]+ro[1][sb][ss]) * 0.707106781f;
+                                                        lr[1][sb][ss] = (ro[0][sb][ss]-ro[1][sb][ss]) * 0.707106781f;
+                                                } else {
+                                                        lr[0][sb][ss] = ro[0][sb][ss];
+                                                        lr[1][sb][ss] = ro[1][sb][ss];
+                                                }
+                                        }
+                                        else if (i_stereo) {
+
+                        if (lsf) {
+                          lr[0][sb][ss] = ro[0][sb][ss] * k[0][i];
+                          lr[1][sb][ss] = ro[0][sb][ss] * k[1][i];
+                       } else {
+                        lr[1][sb][ss] = ro[0][sb][ss] / (float) (1 + is_ratio[i]);
+                                                   lr[0][sb][ss] = lr[1][sb][ss] * is_ratio[i];
+                       }
+                                        }
+        /*                              else {
+                                                System.out.println("Error in stereo processing\n");
+                                        } */
+                    i++;
+                                }
+
+        } // channels == 2
+
+        }
+
+    /**
+         *
+         */
+        private void antialias(int ch, int gr)
+        {
+           int sb18, ss, sb18lim;
+           gr_info_s gr_info = (si.ch[ch].gr[gr]);
+           // 31 alias-reduction operations between each pair of sub-bands
+           // with 8 butterflies between each pair
+
+                if  ((gr_info.window_switching_flag !=0) && (gr_info.block_type == 2) &&
+                         !(gr_info.mixed_block_flag != 0) )
+               return;
+
+                if ((gr_info.window_switching_flag !=0) && (gr_info.mixed_block_flag != 0)&&
+                    (gr_info.block_type == 2)) {
+              sb18lim = 18;
+                } else {
+                        sb18lim = 558;
+           }
+
+           for (sb18=0; sb18 < sb18lim; sb18+=18) {
+              for (ss=0;ss<8;ss++) {
+                int src_idx1 = sb18 + 17 - ss;
+                 int src_idx2 = sb18 + 18 + ss;
+                float bu = out_1d[src_idx1];
+                                float bd = out_1d[src_idx2];
+                                out_1d[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
+                                out_1d[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
+              }
+          }
+        }
+
+        /**
+         *
+         */
+
+        // MDM: tsOutCopy and rawout do not need initializing, so the arrays
+        // can be reused.
+        float[] tsOutCopy = new float[18];
+        float[] rawout = new float[36];
+
+        private void hybrid(int ch, int gr)
+        {
+           int bt;
+           int sb18;
+           gr_info_s gr_info = (si.ch[ch].gr[gr]);
+           float[] tsOut;
+
+           float[][] prvblk;
+
+           for(sb18=0;sb18<576;sb18+=18)
+           {
+                        bt = ((gr_info.window_switching_flag !=0 ) && (gr_info.mixed_block_flag !=0) &&
+                                         (sb18 < 36)) ? 0 : gr_info.block_type;
+
+                   tsOut = out_1d;
+               // Modif E.B 02/22/99
+               for (int cc = 0;cc<18;cc++)
+                           tsOutCopy[cc] = tsOut[cc+sb18];
+
+                   inv_mdct(tsOutCopy, rawout, bt);
+
+
+                   for (int cc = 0;cc<18;cc++)
+                           tsOut[cc+sb18] = tsOutCopy[cc];
+                   // Fin Modif
+
+                        // overlap addition
+                   prvblk = prevblck;
+
+                   tsOut[0 + sb18]   = rawout[0]  + prvblk[ch][sb18 + 0];
+                   prvblk[ch][sb18 + 0]  = rawout[18];
+                   tsOut[1 + sb18]   = rawout[1]  + prvblk[ch][sb18 + 1];
+                   prvblk[ch][sb18 + 1]  = rawout[19];
+                   tsOut[2 + sb18]   = rawout[2]  + prvblk[ch][sb18 + 2];
+                   prvblk[ch][sb18 + 2]  = rawout[20];
+                   tsOut[3 + sb18]   = rawout[3]  + prvblk[ch][sb18 + 3];
+                   prvblk[ch][sb18 + 3]  = rawout[21];
+                   tsOut[4 + sb18]   = rawout[4]  + prvblk[ch][sb18 + 4];
+                   prvblk[ch][sb18 + 4]  = rawout[22];
+                   tsOut[5 + sb18]   = rawout[5]  + prvblk[ch][sb18 + 5];
+                   prvblk[ch][sb18 + 5]  = rawout[23];
+                   tsOut[6 + sb18]   = rawout[6]  + prvblk[ch][sb18 + 6];
+                   prvblk[ch][sb18 + 6]  = rawout[24];
+                   tsOut[7 + sb18]   = rawout[7]  + prvblk[ch][sb18 + 7];
+                   prvblk[ch][sb18 + 7]  = rawout[25];
+                   tsOut[8 + sb18]   = rawout[8]  + prvblk[ch][sb18 + 8];
+                   prvblk[ch][sb18 + 8]  = rawout[26];
+                   tsOut[9 + sb18]   = rawout[9]  + prvblk[ch][sb18 + 9];
+                   prvblk[ch][sb18 + 9]  = rawout[27];
+                   tsOut[10 + sb18]  = rawout[10] + prvblk[ch][sb18 + 10];
+                   prvblk[ch][sb18 + 10] = rawout[28];
+                   tsOut[11 + sb18]  = rawout[11] + prvblk[ch][sb18 + 11];
+                   prvblk[ch][sb18 + 11] = rawout[29];
+                   tsOut[12 + sb18]  = rawout[12] + prvblk[ch][sb18 + 12];
+                   prvblk[ch][sb18 + 12] = rawout[30];
+                   tsOut[13 + sb18]  = rawout[13] + prvblk[ch][sb18 + 13];
+                   prvblk[ch][sb18 + 13] = rawout[31];
+                   tsOut[14 + sb18]  = rawout[14] + prvblk[ch][sb18 + 14];
+                   prvblk[ch][sb18 + 14] = rawout[32];
+                   tsOut[15 + sb18]  = rawout[15] + prvblk[ch][sb18 + 15];
+                   prvblk[ch][sb18 + 15] = rawout[33];
+                   tsOut[16 + sb18]  = rawout[16] + prvblk[ch][sb18 + 16];
+                   prvblk[ch][sb18 + 16] = rawout[34];
+                   tsOut[17 + sb18]  = rawout[17] + prvblk[ch][sb18 + 17];
+                   prvblk[ch][sb18 + 17] = rawout[35];
+          }
+        }
+
+    /**
+         *
+         */
+        private void do_downmix()
+        {
+                for (int sb=0; sb<SSLIMIT; sb++) {
+                for (int ss=0; ss<SSLIMIT; ss+=3) {
+                lr[0][sb][ss]   = (lr[0][sb][ss]   + lr[1][sb][ss])   * 0.5f;
+                lr[0][sb][ss+1] = (lr[0][sb][ss+1] + lr[1][sb][ss+1]) * 0.5f;
+                lr[0][sb][ss+2] = (lr[0][sb][ss+2] + lr[1][sb][ss+2]) * 0.5f;
+              }
+                }
+        }
+
+        /**
+         * Fast INV_MDCT.
+         */
+
+        public void inv_mdct(float[] in, float[] out, int block_type)
+        {
+                 float[] win_bt;
+             int   i;
+
+                float tmpf_0, tmpf_1, tmpf_2, tmpf_3, tmpf_4, tmpf_5, tmpf_6, tmpf_7, tmpf_8, tmpf_9;
+                float tmpf_10, tmpf_11, tmpf_12, tmpf_13, tmpf_14, tmpf_15, tmpf_16, tmpf_17;
+
+                tmpf_0 = tmpf_1 = tmpf_2 = tmpf_3 = tmpf_4 = tmpf_5 = tmpf_6 = tmpf_7 = tmpf_8 = tmpf_9 =
+                tmpf_10 = tmpf_11 = tmpf_12 = tmpf_13 = tmpf_14 = tmpf_15 = tmpf_16 = tmpf_17 = 0.0f;
+
+
+
+                 if(block_type == 2)
+                 {
+
+        /*
+         *
+         *              Under MicrosoftVM 2922, This causes a GPF, or
+         *              At best, an ArrayIndexOutOfBoundsExceptin.
+                        for(int p=0;p<36;p+=9)
+                   {
+                          out[p]   = out[p+1] = out[p+2] = out[p+3] =
+                      out[p+4] = out[p+5] = out[p+6] = out[p+7] =
+                      out[p+8] = 0.0f;
+                   }
+        */
+                        out[0] = 0.0f;
+                        out[1] = 0.0f;
+                        out[2] = 0.0f;
+                        out[3] = 0.0f;
+                        out[4] = 0.0f;
+                        out[5] = 0.0f;
+                        out[6] = 0.0f;
+                        out[7] = 0.0f;
+                        out[8] = 0.0f;
+                        out[9] = 0.0f;
+                        out[10] = 0.0f;
+                        out[11] = 0.0f;
+                        out[12] = 0.0f;
+                        out[13] = 0.0f;
+                        out[14] = 0.0f;
+                        out[15] = 0.0f;
+                        out[16] = 0.0f;
+                        out[17] = 0.0f;
+                        out[18] = 0.0f;
+                        out[19] = 0.0f;
+                        out[20] = 0.0f;
+                        out[21] = 0.0f;
+                        out[22] = 0.0f;
+                        out[23] = 0.0f;
+                        out[24] = 0.0f;
+                        out[25] = 0.0f;
+                        out[26] = 0.0f;
+                        out[27] = 0.0f;
+                        out[28] = 0.0f;
+                        out[29] = 0.0f;
+                        out[30] = 0.0f;
+                        out[31] = 0.0f;
+                        out[32] = 0.0f;
+                        out[33] = 0.0f;
+                        out[34] = 0.0f;
+                        out[35] = 0.0f;
+
+               int six_i = 0;
+
+                   for(i=0;i<3;i++)
+                   {
+                        // 12 point IMDCT
+                        // Begin 12 point IDCT
+                                // Input aliasing for 12 pt IDCT
+                                in[15+i] += in[12+i]; in[12+i] += in[9+i]; in[9+i]  +=  in[6+i];
+                                in[6+i]  += in[3+i];  in[3+i]  += in[0+i];
+
+                                // Input aliasing on odd indices (for 6 point IDCT)
+                                in[15+i] += in[9+i];  in[9+i]  += in[3+i];
+
+                                // 3 point IDCT on even indices
+                                float   pp1, pp2, sum;
+                        pp2 = in[12+i] * 0.500000000f;
+                                pp1 = in[ 6+i] * 0.866025403f;
+                                sum = in[0+i] + pp2;
+                                tmpf_1 = in[0+i] - in[12+i];
+                                tmpf_0 = sum + pp1;
+                                tmpf_2 = sum - pp1;
+
+                        // End 3 point IDCT on even indices
+                                // 3 point IDCT on odd indices (for 6 point IDCT)
+                        pp2 = in[15+i] * 0.500000000f;
+                                pp1 = in[ 9+i] * 0.866025403f;
+                                sum = in[ 3+i] + pp2;
+                                tmpf_4 = in[3+i] - in[15+i];
+                                tmpf_5 = sum + pp1;
+                                tmpf_3 = sum - pp1;
+                        // End 3 point IDCT on odd indices
+                                // Twiddle factors on odd indices (for 6 point IDCT)
+
+                                tmpf_3 *= 1.931851653f;
+                                tmpf_4 *= 0.707106781f;
+                                tmpf_5 *= 0.517638090f;
+
+                                // Output butterflies on 2 3 point IDCT's (for 6 point IDCT)
+                                float save = tmpf_0;
+                                tmpf_0 += tmpf_5;
+                                tmpf_5 = save - tmpf_5;
+                                save = tmpf_1;
+                                tmpf_1 += tmpf_4;
+                                tmpf_4 = save - tmpf_4;
+                                save = tmpf_2;
+                                tmpf_2 += tmpf_3;
+                                tmpf_3 = save - tmpf_3;
+
+                                // End 6 point IDCT
+                                // Twiddle factors on indices (for 12 point IDCT)
+
+                                tmpf_0  *=  0.504314480f;
+                                tmpf_1  *=  0.541196100f;
+                                tmpf_2  *=  0.630236207f;
+                                tmpf_3  *=  0.821339815f;
+                                tmpf_4  *=  1.306562965f;
+                                tmpf_5  *=  3.830648788f;
+
+                        // End 12 point IDCT
+
+                                // Shift to 12 point modified IDCT, multiply by window type 2
+                                tmpf_8  = -tmpf_0 * 0.793353340f;
+                                tmpf_9  = -tmpf_0 * 0.608761429f;
+                                tmpf_7  = -tmpf_1 * 0.923879532f;
+                                tmpf_10 = -tmpf_1 * 0.382683432f;
+                                tmpf_6  = -tmpf_2 * 0.991444861f;
+                                tmpf_11 = -tmpf_2 * 0.130526192f;
+
+                                tmpf_0  =  tmpf_3;
+                                tmpf_1  =  tmpf_4 * 0.382683432f;
+                                tmpf_2  =  tmpf_5 * 0.608761429f;
+
+                                tmpf_3  = -tmpf_5 * 0.793353340f;
+                                tmpf_4  = -tmpf_4 * 0.923879532f;
+                                tmpf_5  = -tmpf_0 * 0.991444861f;
+
+                                tmpf_0 *= 0.130526192f;
+
+                                out[six_i + 6]  += tmpf_0;
+                                out[six_i + 7]  += tmpf_1;
+                                out[six_i + 8]  += tmpf_2;
+                                out[six_i + 9]  += tmpf_3;
+                                out[six_i + 10] += tmpf_4;
+                                out[six_i + 11] += tmpf_5;
+                                out[six_i + 12] += tmpf_6;
+                                out[six_i + 13] += tmpf_7;
+                                out[six_i + 14] += tmpf_8;
+                                out[six_i + 15] += tmpf_9;
+                                out[six_i + 16] += tmpf_10;
+                                out[six_i + 17] += tmpf_11;
+
+                                six_i += 6;
+                        }
+                 }
+                 else
+                 {
+                        // 36 point IDCT
+                        // input aliasing for 36 point IDCT
+                        in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; in[14]+=in[13];
+                        in[13]+=in[12]; in[12]+=in[11]; in[11]+=in[10]; in[10]+=in[9];
+                        in[9] +=in[8];  in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
+                        in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];  in[2] +=in[1];
+                        in[1] +=in[0];
+
+                        // 18 point IDCT for odd indices
+                        // input aliasing for 18 point IDCT
+                        in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
+                        in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
+
+                        float tmp0,tmp1,tmp2,tmp3,tmp4,tmp0_,tmp1_,tmp2_,tmp3_;
+                        float tmp0o,tmp1o,tmp2o,tmp3o,tmp4o,tmp0_o,tmp1_o,tmp2_o,tmp3_o;
+
+                        // Fast 9 Point Inverse Discrete Cosine Transform
+                        //
+                        // By  Francois-Raymond Boyer
+                        //         mailto:boyerf@iro.umontreal.ca
+                        //         http://www.iro.umontreal.ca/~boyerf
+                        //
+                        // The code has been optimized for Intel processors
+                        //  (takes a lot of time to convert float to and from iternal FPU representation)
+                        //
+                        // It is a simple "factorization" of the IDCT matrix.
+
+                        // 9 point IDCT on even indices
+
+                        // 5 points on odd indices (not realy an IDCT)
+                        float i00 = in[0]+in[0];
+                        float iip12 = i00 + in[12];
+
+                        tmp0 = iip12 + in[4]*1.8793852415718f  + in[8]*1.532088886238f   + in[16]*0.34729635533386f;
+                        tmp1 = i00    + in[4]                   - in[8] - in[12] - in[12] - in[16];
+                        tmp2 = iip12 - in[4]*0.34729635533386f - in[8]*1.8793852415718f  + in[16]*1.532088886238f;
+                        tmp3 = iip12 - in[4]*1.532088886238f   + in[8]*0.34729635533386f - in[16]*1.8793852415718f;
+                        tmp4 = in[0] - in[4]                   + in[8] - in[12]          + in[16];
+
+                        // 4 points on even indices
+                        float i66_ = in[6]*1.732050808f;                // Sqrt[3]
+
+                        tmp0_ = in[2]*1.9696155060244f  + i66_ + in[10]*1.2855752193731f  + in[14]*0.68404028665134f;
+                        tmp1_ = (in[2]                        - in[10]                   - in[14])*1.732050808f;
+                        tmp2_ = in[2]*1.2855752193731f  - i66_ - in[10]*0.68404028665134f + in[14]*1.9696155060244f;
+                        tmp3_ = in[2]*0.68404028665134f - i66_ + in[10]*1.9696155060244f  - in[14]*1.2855752193731f;
+
+                        // 9 point IDCT on odd indices
+                        // 5 points on odd indices (not realy an IDCT)
+                        float i0 = in[0+1]+in[0+1];
+                        float i0p12 = i0 + in[12+1];
+
+                        tmp0o = i0p12   + in[4+1]*1.8793852415718f  + in[8+1]*1.532088886238f       + in[16+1]*0.34729635533386f;
+                        tmp1o = i0      + in[4+1]                   - in[8+1] - in[12+1] - in[12+1] - in[16+1];
+                        tmp2o = i0p12   - in[4+1]*0.34729635533386f - in[8+1]*1.8793852415718f      + in[16+1]*1.532088886238f;
+                        tmp3o = i0p12   - in[4+1]*1.532088886238f   + in[8+1]*0.34729635533386f     - in[16+1]*1.8793852415718f;
+                        tmp4o = (in[0+1] - in[4+1]                   + in[8+1] - in[12+1]            + in[16+1])*0.707106781f; // Twiddled
+
+                        // 4 points on even indices
+                        float i6_ = in[6+1]*1.732050808f;               // Sqrt[3]
+
+                        tmp0_o = in[2+1]*1.9696155060244f  + i6_ + in[10+1]*1.2855752193731f  + in[14+1]*0.68404028665134f;
+                        tmp1_o = (in[2+1]                        - in[10+1]                   - in[14+1])*1.732050808f;
+                        tmp2_o = in[2+1]*1.2855752193731f  - i6_ - in[10+1]*0.68404028665134f + in[14+1]*1.9696155060244f;
+                        tmp3_o = in[2+1]*0.68404028665134f - i6_ + in[10+1]*1.9696155060244f  - in[14+1]*1.2855752193731f;
+
+                        // Twiddle factors on odd indices
+                        // and
+                        // Butterflies on 9 point IDCT's
+                        // and
+                        // twiddle factors for 36 point IDCT
+
+                        float e, o;
+                        e = tmp0 + tmp0_; o = (tmp0o + tmp0_o)*0.501909918f; tmpf_0 = e + o;    tmpf_17 = e - o;
+                        e = tmp1 + tmp1_; o = (tmp1o + tmp1_o)*0.517638090f; tmpf_1 = e + o;    tmpf_16 = e - o;
+                        e = tmp2 + tmp2_; o = (tmp2o + tmp2_o)*0.551688959f; tmpf_2 = e + o;    tmpf_15 = e - o;
+                        e = tmp3 + tmp3_; o = (tmp3o + tmp3_o)*0.610387294f; tmpf_3 = e + o;    tmpf_14 = e - o;
+                        tmpf_4 = tmp4 + tmp4o; tmpf_13 = tmp4 - tmp4o;
+                        e = tmp3 - tmp3_; o = (tmp3o - tmp3_o)*0.871723397f; tmpf_5 = e + o;    tmpf_12 = e - o;
+                        e = tmp2 - tmp2_; o = (tmp2o - tmp2_o)*1.183100792f; tmpf_6 = e + o;    tmpf_11 = e - o;
+                        e = tmp1 - tmp1_; o = (tmp1o - tmp1_o)*1.931851653f; tmpf_7 = e + o;    tmpf_10 = e - o;
+                        e = tmp0 - tmp0_; o = (tmp0o - tmp0_o)*5.736856623f; tmpf_8 = e + o;    tmpf_9 =  e - o;
+
+                        // end 36 point IDCT */
+                        // shift to modified IDCT
+                        win_bt = win[block_type];
+
+                        out[0] =-tmpf_9  * win_bt[0];
+                        out[1] =-tmpf_10 * win_bt[1];
+                        out[2] =-tmpf_11 * win_bt[2];
+                        out[3] =-tmpf_12 * win_bt[3];
+                        out[4] =-tmpf_13 * win_bt[4];
+                        out[5] =-tmpf_14 * win_bt[5];
+                        out[6] =-tmpf_15 * win_bt[6];
+                        out[7] =-tmpf_16 * win_bt[7];
+                        out[8] =-tmpf_17 * win_bt[8];
+                        out[9] = tmpf_17 * win_bt[9];
+                        out[10]= tmpf_16 * win_bt[10];
+                        out[11]= tmpf_15 * win_bt[11];
+                        out[12]= tmpf_14 * win_bt[12];
+                        out[13]= tmpf_13 * win_bt[13];
+                        out[14]= tmpf_12 * win_bt[14];
+                        out[15]= tmpf_11 * win_bt[15];
+                        out[16]= tmpf_10 * win_bt[16];
+                        out[17]= tmpf_9  * win_bt[17];
+                        out[18]= tmpf_8  * win_bt[18];
+                        out[19]= tmpf_7  * win_bt[19];
+                        out[20]= tmpf_6  * win_bt[20];
+                        out[21]= tmpf_5  * win_bt[21];
+                        out[22]= tmpf_4  * win_bt[22];
+                        out[23]= tmpf_3  * win_bt[23];
+                        out[24]= tmpf_2  * win_bt[24];
+                        out[25]= tmpf_1  * win_bt[25];
+                        out[26]= tmpf_0  * win_bt[26];
+                        out[27]= tmpf_0  * win_bt[27];
+                        out[28]= tmpf_1  * win_bt[28];
+                        out[29]= tmpf_2  * win_bt[29];
+                        out[30]= tmpf_3  * win_bt[30];
+                        out[31]= tmpf_4  * win_bt[31];
+                        out[32]= tmpf_5  * win_bt[32];
+                        out[33]= tmpf_6  * win_bt[33];
+                        out[34]= tmpf_7  * win_bt[34];
+                        out[35]= tmpf_8  * win_bt[35];
+                }
+        }
+
+    private int counter = 0;
+        private static final int                SSLIMIT=18;
+        private static final int                SBLIMIT=32;
+    // Size of the table of whole numbers raised to 4/3 power.
+    // This may be adjusted for performance without any problems.
+    //public static final int   POW_TABLE_LIMIT=512;
+
+    /************************************************************/
+        /*                            L3TABLE                       */
+        /************************************************************/
+
+        static class SBI
+        {
+           public int[]                 l;
+           public int[]                 s;
+
+           public SBI()
+           {
+                        l = new int[23];
+                        s = new int[14];
+           }
+           public SBI(int[] thel, int[] thes)
+           {
+                        l = thel;
+                        s = thes;
+           }
+        }
+
+        static class gr_info_s
+        {
+                public int              part2_3_length = 0;
+                public int              big_values = 0;
+                public int              global_gain = 0;
+                public int              scalefac_compress = 0;
+                public int              window_switching_flag = 0;
+                public int              block_type = 0;
+                public int              mixed_block_flag = 0;
+                public int[]    table_select;
+                public int[]    subblock_gain;
+                public int              region0_count = 0;
+                public int              region1_count = 0;
+                public int              preflag = 0;
+                public int              scalefac_scale = 0;
+                public int              count1table_select = 0;
+
+                /**
+                 * Dummy Constructor
+                 */
+                public gr_info_s()
+                {
+                        table_select = new int[3];
+                        subblock_gain = new int[3];
+                }
+        }
+
+        static class temporaire
+        {
+                public int[]                    scfsi;
+                public gr_info_s[]              gr;
+
+                /**
+                 * Dummy Constructor
+                 */
+                public temporaire()
+                {
+                        scfsi = new int[4];
+                        gr = new gr_info_s[2];
+                        gr[0] = new gr_info_s();
+                        gr[1] = new gr_info_s();
+                }
+        }
+
+        static class III_side_info_t
+        {
+
+                public int                              main_data_begin = 0;
+                public int                              private_bits = 0;
+                public temporaire[]             ch;
+                /**
+                 * Dummy Constructor
+                 */
+                public III_side_info_t()
+                {
+                                ch = new temporaire[2];
+                                ch[0] = new temporaire();
+                                ch[1] = new temporaire();
+                }
+        }
+
+        static class temporaire2
+        {
+                public int[]             l;         /* [cb] */
+        public int[][]           s;         /* [window][cb] */
+
+                /**
+                 * Dummy Constructor
+                 */
+                public temporaire2()
+                {
+                        l = new int[23];
+                        s = new int[3][13];
+                }
+        }
+        //class III_scalefac_t
+        //{
+        //    public temporaire2[]    tab;
+        //      /**
+        //       * Dummy Constructor
+        //       */
+        //      public III_scalefac_t()
+        //      {
+        //              tab = new temporaire2[2];
+        //      }
+        //}
+
+        private static final int slen[][] =
+        {
+         {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
+         {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
+        };
+
+        public static final int pretab[] =
+        {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0};
+
+    private SBI[]                       sfBandIndex; // Init in the constructor.
+
+        public static final float two_to_negative_half_pow[] =
+        { 1.0000000000E+00f, 7.0710678119E-01f, 5.0000000000E-01f, 3.5355339059E-01f,
+          2.5000000000E-01f, 1.7677669530E-01f, 1.2500000000E-01f, 8.8388347648E-02f,
+          6.2500000000E-02f, 4.4194173824E-02f, 3.1250000000E-02f, 2.2097086912E-02f,
+          1.5625000000E-02f, 1.1048543456E-02f, 7.8125000000E-03f, 5.5242717280E-03f,
+          3.9062500000E-03f, 2.7621358640E-03f, 1.9531250000E-03f, 1.3810679320E-03f,
+          9.7656250000E-04f, 6.9053396600E-04f, 4.8828125000E-04f, 3.4526698300E-04f,
+          2.4414062500E-04f, 1.7263349150E-04f, 1.2207031250E-04f, 8.6316745750E-05f,
+          6.1035156250E-05f, 4.3158372875E-05f, 3.0517578125E-05f, 2.1579186438E-05f,
+          1.5258789062E-05f, 1.0789593219E-05f, 7.6293945312E-06f, 5.3947966094E-06f,
+          3.8146972656E-06f, 2.6973983047E-06f, 1.9073486328E-06f, 1.3486991523E-06f,
+          9.5367431641E-07f, 6.7434957617E-07f, 4.7683715820E-07f, 3.3717478809E-07f,
+          2.3841857910E-07f, 1.6858739404E-07f, 1.1920928955E-07f, 8.4293697022E-08f,
+          5.9604644775E-08f, 4.2146848511E-08f, 2.9802322388E-08f, 2.1073424255E-08f,
+          1.4901161194E-08f, 1.0536712128E-08f, 7.4505805969E-09f, 5.2683560639E-09f,
+          3.7252902985E-09f, 2.6341780319E-09f, 1.8626451492E-09f, 1.3170890160E-09f,
+          9.3132257462E-10f, 6.5854450798E-10f, 4.6566128731E-10f, 3.2927225399E-10f
+        };
+
+
+        public static final float t_43[] = create_t_43();
+
+        static private float[] create_t_43()
+        {
+                float[] t43 = new float[8192];
+                final double d43 = (4.0/3.0);
+
+                for (int i=0; i<8192; i++)
+                {
+                        t43[i] = (float)Math.pow(i, d43);
+                }
+                return t43;
+        }
+
+        public static final float io[][] =
+        {
+         { 1.0000000000E+00f, 8.4089641526E-01f, 7.0710678119E-01f, 5.9460355751E-01f,
+           5.0000000001E-01f, 4.2044820763E-01f, 3.5355339060E-01f, 2.9730177876E-01f,
+           2.5000000001E-01f, 2.1022410382E-01f, 1.7677669530E-01f, 1.4865088938E-01f,
+           1.2500000000E-01f, 1.0511205191E-01f, 8.8388347652E-02f, 7.4325444691E-02f,
+           6.2500000003E-02f, 5.2556025956E-02f, 4.4194173826E-02f, 3.7162722346E-02f,
+           3.1250000002E-02f, 2.6278012978E-02f, 2.2097086913E-02f, 1.8581361173E-02f,
+           1.5625000001E-02f, 1.3139006489E-02f, 1.1048543457E-02f, 9.2906805866E-03f,
+           7.8125000006E-03f, 6.5695032447E-03f, 5.5242717285E-03f, 4.6453402934E-03f },
+         { 1.0000000000E+00f, 7.0710678119E-01f, 5.0000000000E-01f, 3.5355339060E-01f,
+           2.5000000000E-01f, 1.7677669530E-01f, 1.2500000000E-01f, 8.8388347650E-02f,
+           6.2500000001E-02f, 4.4194173825E-02f, 3.1250000001E-02f, 2.2097086913E-02f,
+           1.5625000000E-02f, 1.1048543456E-02f, 7.8125000002E-03f, 5.5242717282E-03f,
+           3.9062500001E-03f, 2.7621358641E-03f, 1.9531250001E-03f, 1.3810679321E-03f,
+           9.7656250004E-04f, 6.9053396603E-04f, 4.8828125002E-04f, 3.4526698302E-04f,
+           2.4414062501E-04f, 1.7263349151E-04f, 1.2207031251E-04f, 8.6316745755E-05f,
+           6.1035156254E-05f, 4.3158372878E-05f, 3.0517578127E-05f, 2.1579186439E-05f }
+        };
+
+
+
+        public static final float TAN12[] =
+        {
+         0.0f, 0.26794919f, 0.57735027f, 1.0f,
+         1.73205081f, 3.73205081f, 9.9999999e10f, -3.73205081f,
+         -1.73205081f, -1.0f, -0.57735027f, -0.26794919f,
+         0.0f, 0.26794919f, 0.57735027f, 1.0f
+        };
+
+        // REVIEW: in java, the array lookup may well be slower than
+        // the actual calculation
+        // 576 / 18
+/*
+        private static final int ss_div[] =
+        {
+                 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
+                 1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+                 2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+                 3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  3,
+                 4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,  4,
+                 5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,  5,
+                 6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,  6,
+                 7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,  7,
+                 8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,  8,
+                 9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,  9,
+                10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
+                11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+                12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+                13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+                14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+                15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+                16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+                17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
+                18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+                19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
+                20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+                21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
+                22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
+                23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
+                24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+                25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+                26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+                27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+                28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+                29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+                30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30,
+                31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31
+        };
+
+        // 576 % 18
+        private static final int ss_mod[] =
+        {
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
+                 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17
+        };
+*/
+        private static /*final*/ int reorder_table[][]/* = loadReorderTable()*/;        // SZD: will be generated on demand
+
+        /**
+         * Loads the data for the reorder
+         */
+        /*private static int[][] loadReorderTable()     // SZD: table will be generated
+        {
+                try
+                {
+                        Class elemType = int[][].class.getComponentType();
+                        Object o = JavaLayerUtils.deserializeArrayResource("l3reorder.ser", elemType, 6);
+                        return (int[][])o;
+                }
+                catch (IOException ex)
+                {
+                        throw new ExceptionInInitializerError(ex);
+                }
+        }*/
+
+        static int[] reorder(int scalefac_band[]) {     // SZD: converted from LAME
+                int j = 0;
+                int ix[] = new int[576];
+                for(int sfb = 0; sfb < 13; sfb++) {
+                        int start = scalefac_band[sfb];
+                        int end   = scalefac_band[sfb + 1];
+                        for(int window = 0; window < 3; window++)
+                                for(int i = start; i < end; i++)
+                                        ix[3 * i + window] = j++;
+                }
+                return ix;
+        }
+
+        /*static final int reorder_table_data[][]; =
+        {
+         {  0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11, 12, 16, 20, 13,
+           17, 21, 14, 18, 22, 15, 19, 23, 24, 28, 32, 25, 29, 33, 26, 30,
+           34, 27, 31, 35, 36, 42, 48, 37, 43, 49, 38, 44, 50, 39, 45, 51,
+           40, 46, 52, 41, 47, 53, 54, 60, 66, 55, 61, 67, 56, 62, 68, 57,
+           63, 69, 58, 64, 70, 59, 65, 71, 72, 80, 88, 73, 81, 89, 74, 82,
+           90, 75, 83, 91, 76, 84, 92, 77, 85, 93, 78, 86, 94, 79, 87, 95,
+           96,106,116, 97,107,117, 98,108,118, 99,109,119,100,110,120,101,
+          111,121,102,112,122,103,113,123,104,114,124,105,115,125,126,140,
+          154,127,141,155,128,142,156,129,143,157,130,144,158,131,145,159,
+          132,146,160,133,147,161,134,148,162,135,149,163,136,150,164,137,
+          151,165,138,152,166,139,153,167,168,186,204,169,187,205,170,188,
+          206,171,189,207,172,190,208,173,191,209,174,192,210,175,193,211,
+          176,194,212,177,195,213,178,196,214,179,197,215,180,198,216,181,
+          199,217,182,200,218,183,201,219,184,202,220,185,203,221,222,248,
+          274,223,249,275,224,250,276,225,251,277,226,252,278,227,253,279,
+          228,254,280,229,255,281,230,256,282,231,257,283,232,258,284,233,
+          259,285,234,260,286,235,261,287,236,262,288,237,263,289,238,264,
+          290,239,265,291,240,266,292,241,267,293,242,268,294,243,269,295,
+          244,270,296,245,271,297,246,272,298,247,273,299,300,332,364,301,
+          333,365,302,334,366,303,335,367,304,336,368,305,337,369,306,338,
+          370,307,339,371,308,340,372,309,341,373,310,342,374,311,343,375,
+          312,344,376,313,345,377,314,346,378,315,347,379,316,348,380,317,
+          349,381,318,350,382,319,351,383,320,352,384,321,353,385,322,354,
+          386,323,355,387,324,356,388,325,357,389,326,358,390,327,359,391,
+          328,360,392,329,361,393,330,362,394,331,363,395,396,438,480,397,
+          439,481,398,440,482,399,441,483,400,442,484,401,443,485,402,444,
+          486,403,445,487,404,446,488,405,447,489,406,448,490,407,449,491,
+          408,450,492,409,451,493,410,452,494,411,453,495,412,454,496,413,
+          455,497,414,456,498,415,457,499,416,458,500,417,459,501,418,460,
+          502,419,461,503,420,462,504,421,463,505,422,464,506,423,465,507,
+          424,466,508,425,467,509,426,468,510,427,469,511,428,470,512,429,
+          471,513,430,472,514,431,473,515,432,474,516,433,475,517,434,476,
+          518,435,477,519,436,478,520,437,479,521,522,540,558,523,541,559,
+          524,542,560,525,543,561,526,544,562,527,545,563,528,546,564,529,
+          547,565,530,548,566,531,549,567,532,550,568,533,551,569,534,552,
+          570,535,553,571,536,554,572,537,555,573,538,556,574,539,557,575},
+         {  0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11, 12, 16, 20, 13,
+           17, 21, 14, 18, 22, 15, 19, 23, 24, 28, 32, 25, 29, 33, 26, 30,
+           34, 27, 31, 35, 36, 42, 48, 37, 43, 49, 38, 44, 50, 39, 45, 51,
+           40, 46, 52, 41, 47, 53, 54, 62, 70, 55, 63, 71, 56, 64, 72, 57,
+           65, 73, 58, 66, 74, 59, 67, 75, 60, 68, 76, 61, 69, 77, 78, 88,
+           98, 79, 89, 99, 80, 90,100, 81, 91,101, 82, 92,102, 83, 93,103,
+           84, 94,104, 85, 95,105, 86, 96,106, 87, 97,107,108,120,132,109,
+          121,133,110,122,134,111,123,135,112,124,136,113,125,137,114,126,
+          138,115,127,139,116,128,140,117,129,141,118,130,142,119,131,143,
+          144,158,172,145,159,173,146,160,174,147,161,175,148,162,176,149,
+          163,177,150,164,178,151,165,179,152,166,180,153,167,181,154,168,
+          182,155,169,183,156,170,184,157,171,185,186,204,222,187,205,223,
+          188,206,224,189,207,225,190,208,226,191,209,227,192,210,228,193,
+          211,229,194,212,230,195,213,231,196,214,232,197,215,233,198,216,
+          234,199,217,235,200,218,236,201,219,237,202,220,238,203,221,239,
+          240,264,288,241,265,289,242,266,290,243,267,291,244,268,292,245,
+          269,293,246,270,294,247,271,295,248,272,296,249,273,297,250,274,
+          298,251,275,299,252,276,300,253,277,301,254,278,302,255,279,303,
+          256,280,304,257,281,305,258,282,306,259,283,307,260,284,308,261,
+          285,309,262,286,310,263,287,311,312,344,376,313,345,377,314,346,
+          378,315,347,379,316,348,380,317,349,381,318,350,382,319,351,383,
+          320,352,384,321,353,385,322,354,386,323,355,387,324,356,388,325,
+          357,389,326,358,390,327,359,391,328,360,392,329,361,393,330,362,
+          394,331,363,395,332,364,396,333,365,397,334,366,398,335,367,399,
+          336,368,400,337,369,401,338,370,402,339,371,403,340,372,404,341,
+          373,405,342,374,406,343,375,407,408,452,496,409,453,497,410,454,
+          498,411,455,499,412,456,500,413,457,501,414,458,502,415,459,503,
+          416,460,504,417,461,505,418,462,506,419,463,507,420,464,508,421,
+          465,509,422,466,510,423,467,511,424,468,512,425,469,513,426,470,
+          514,427,471,515,428,472,516,429,473,517,430,474,518,431,475,519,
+          432,476,520,433,477,521,434,478,522,435,479,523,436,480,524,437,
+          481,525,438,482,526,439,483,527,440,484,528,441,485,529,442,486,
+          530,443,487,531,444,488,532,445,489,533,446,490,534,447,491,535,
+          448,492,536,449,493,537,450,494,538,451,495,539,540,552,564,541,
+          553,565,542,554,566,543,555,567,544,556,568,545,557,569,546,558,
+          570,547,559,571,548,560,572,549,561,573,550,562,574,551,563,575},
+         {  0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11, 12, 16, 20, 13,
+           17, 21, 14, 18, 22, 15, 19, 23, 24, 28, 32, 25, 29, 33, 26, 30,
+           34, 27, 31, 35, 36, 42, 48, 37, 43, 49, 38, 44, 50, 39, 45, 51,
+           40, 46, 52, 41, 47, 53, 54, 62, 70, 55, 63, 71, 56, 64, 72, 57,
+           65, 73, 58, 66, 74, 59, 67, 75, 60, 68, 76, 61, 69, 77, 78, 88,
+           98, 79, 89, 99, 80, 90,100, 81, 91,101, 82, 92,102, 83, 93,103,
+           84, 94,104, 85, 95,105, 86, 96,106, 87, 97,107,108,120,132,109,
+          121,133,110,122,134,111,123,135,112,124,136,113,125,137,114,126,
+          138,115,127,139,116,128,140,117,129,141,118,130,142,119,131,143,
+          144,158,172,145,159,173,146,160,174,147,161,175,148,162,176,149,
+          163,177,150,164,178,151,165,179,152,166,180,153,167,181,154,168,
+          182,155,169,183,156,170,184,157,171,185,186,204,222,187,205,223,
+          188,206,224,189,207,225,190,208,226,191,209,227,192,210,228,193,
+          211,229,194,212,230,195,213,231,196,214,232,197,215,233,198,216,
+          234,199,217,235,200,218,236,201,219,237,202,220,238,203,221,239,
+          240,264,288,241,265,289,242,266,290,243,267,291,244,268,292,245,
+          269,293,246,270,294,247,271,295,248,272,296,249,273,297,250,274,
+          298,251,275,299,252,276,300,253,277,301,254,278,302,255,279,303,
+          256,280,304,257,281,305,258,282,306,259,283,307,260,284,308,261,
+          285,309,262,286,310,263,287,311,312,342,372,313,343,373,314,344,
+          374,315,345,375,316,346,376,317,347,377,318,348,378,319,349,379,
+          320,350,380,321,351,381,322,352,382,323,353,383,324,354,384,325,
+          355,385,326,356,386,327,357,387,328,358,388,329,359,389,330,360,
+          390,331,361,391,332,362,392,333,363,393,334,364,394,335,365,395,
+          336,366,396,337,367,397,338,368,398,339,369,399,340,370,400,341,
+          371,401,402,442,482,403,443,483,404,444,484,405,445,485,406,446,
+          486,407,447,487,408,448,488,409,449,489,410,450,490,411,451,491,
+          412,452,492,413,453,493,414,454,494,415,455,495,416,456,496,417,
+          457,497,418,458,498,419,459,499,420,460,500,421,461,501,422,462,
+          502,423,463,503,424,464,504,425,465,505,426,466,506,427,467,507,
+          428,468,508,429,469,509,430,470,510,431,471,511,432,472,512,433,
+          473,513,434,474,514,435,475,515,436,476,516,437,477,517,438,478,
+          518,439,479,519,440,480,520,441,481,521,522,540,558,523,541,559,
+          524,542,560,525,543,561,526,544,562,527,545,563,528,546,564,529,
+          547,565,530,548,566,531,549,567,532,550,568,533,551,569,534,552,
+          570,535,553,571,536,554,572,537,555,573,538,556,574,539,557,575},
+         {  0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11, 12, 16, 20, 13,
+           17, 21, 14, 18, 22, 15, 19, 23, 24, 28, 32, 25, 29, 33, 26, 30,
+           34, 27, 31, 35, 36, 40, 44, 37, 41, 45, 38, 42, 46, 39, 43, 47,
+           48, 54, 60, 49, 55, 61, 50, 56, 62, 51, 57, 63, 52, 58, 64, 53,
+           59, 65, 66, 74, 82, 67, 75, 83, 68, 76, 84, 69, 77, 85, 70, 78,
+           86, 71, 79, 87, 72, 80, 88, 73, 81, 89, 90,100,110, 91,101,111,
+           92,102,112, 93,103,113, 94,104,114, 95,105,115, 96,106,116, 97,
+          107,117, 98,108,118, 99,109,119,120,132,144,121,133,145,122,134,
+          146,123,135,147,124,136,148,125,137,149,126,138,150,127,139,151,
+          128,140,152,129,141,153,130,142,154,131,143,155,156,170,184,157,
+          171,185,158,172,186,159,173,187,160,174,188,161,175,189,162,176,
+          190,163,177,191,164,178,192,165,179,193,166,180,194,167,181,195,
+          168,182,196,169,183,197,198,216,234,199,217,235,200,218,236,201,
+          219,237,202,220,238,203,221,239,204,222,240,205,223,241,206,224,
+          242,207,225,243,208,226,244,209,227,245,210,228,246,211,229,247,
+          212,230,248,213,231,249,214,232,250,215,233,251,252,274,296,253,
+          275,297,254,276,298,255,277,299,256,278,300,257,279,301,258,280,
+          302,259,281,303,260,282,304,261,283,305,262,284,306,263,285,307,
+          264,286,308,265,287,309,266,288,310,267,289,311,268,290,312,269,
+          291,313,270,292,314,271,293,315,272,294,316,273,295,317,318,348,
+          378,319,349,379,320,350,380,321,351,381,322,352,382,323,353,383,
+          324,354,384,325,355,385,326,356,386,327,357,387,328,358,388,329,
+          359,389,330,360,390,331,361,391,332,362,392,333,363,393,334,364,
+          394,335,365,395,336,366,396,337,367,397,338,368,398,339,369,399,
+          340,370,400,341,371,401,342,372,402,343,373,403,344,374,404,345,
+          375,405,346,376,406,347,377,407,408,464,520,409,465,521,410,466,
+          522,411,467,523,412,468,524,413,469,525,414,470,526,415,471,527,
+          416,472,528,417,473,529,418,474,530,419,475,531,420,476,532,421,
+          477,533,422,478,534,423,479,535,424,480,536,425,481,537,426,482,
+          538,427,483,539,428,484,540,429,485,541,430,486,542,431,487,543,
+          432,488,544,433,489,545,434,490,546,435,491,547,436,492,548,437,
+          493,549,438,494,550,439,495,551,440,496,552,441,497,553,442,498,
+          554,443,499,555,444,500,556,445,501,557,446,502,558,447,503,559,
+          448,504,560,449,505,561,450,506,562,451,507,563,452,508,564,453,
+          509,565,454,510,566,455,511,567,456,512,568,457,513,569,458,514,
+          570,459,515,571,460,516,572,461,517,573,462,518,574,463,519,575},
+         {  0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11, 12, 16, 20, 13,
+           17, 21, 14, 18, 22, 15, 19, 23, 24, 28, 32, 25, 29, 33, 26, 30,
+           34, 27, 31, 35, 36, 40, 44, 37, 41, 45, 38, 42, 46, 39, 43, 47,
+           48, 54, 60, 49, 55, 61, 50, 56, 62, 51, 57, 63, 52, 58, 64, 53,
+           59, 65, 66, 72, 78, 67, 73, 79, 68, 74, 80, 69, 75, 81, 70, 76,
+           82, 71, 77, 83, 84, 94,104, 85, 95,105, 86, 96,106, 87, 97,107,
+           88, 98,108, 89, 99,109, 90,100,110, 91,101,111, 92,102,112, 93,
+          103,113,114,126,138,115,127,139,116,128,140,117,129,141,118,130,
+          142,119,131,143,120,132,144,121,133,145,122,134,146,123,135,147,
+          124,136,148,125,137,149,150,164,178,151,165,179,152,166,180,153,
+          167,181,154,168,182,155,169,183,156,170,184,157,171,185,158,172,
+          186,159,173,187,160,174,188,161,175,189,162,176,190,163,177,191,
+          192,208,224,193,209,225,194,210,226,195,211,227,196,212,228,197,
+          213,229,198,214,230,199,215,231,200,216,232,201,217,233,202,218,
+          234,203,219,235,204,220,236,205,221,237,206,222,238,207,223,239,
+          240,260,280,241,261,281,242,262,282,243,263,283,244,264,284,245,
+          265,285,246,266,286,247,267,287,248,268,288,249,269,289,250,270,
+          290,251,271,291,252,272,292,253,273,293,254,274,294,255,275,295,
+          256,276,296,257,277,297,258,278,298,259,279,299,300,326,352,301,
+          327,353,302,328,354,303,329,355,304,330,356,305,331,357,306,332,
+          358,307,333,359,308,334,360,309,335,361,310,336,362,311,337,363,
+          312,338,364,313,339,365,314,340,366,315,341,367,316,342,368,317,
+          343,369,318,344,370,319,345,371,320,346,372,321,347,373,322,348,
+          374,323,349,375,324,350,376,325,351,377,378,444,510,379,445,511,
+          380,446,512,381,447,513,382,448,514,383,449,515,384,450,516,385,
+          451,517,386,452,518,387,453,519,388,454,520,389,455,521,390,456,
+          522,391,457,523,392,458,524,393,459,525,394,460,526,395,461,527,
+          396,462,528,397,463,529,398,464,530,399,465,531,400,466,532,401,
+          467,533,402,468,534,403,469,535,404,470,536,405,471,537,406,472,
+          538,407,473,539,408,474,540,409,475,541,410,476,542,411,477,543,
+          412,478,544,413,479,545,414,480,546,415,481,547,416,482,548,417,
+          483,549,418,484,550,419,485,551,420,486,552,421,487,553,422,488,
+          554,423,489,555,424,490,556,425,491,557,426,492,558,427,493,559,
+          428,494,560,429,495,561,430,496,562,431,497,563,432,498,564,433,
+          499,565,434,500,566,435,501,567,436,502,568,437,503,569,438,504,
+          570,439,505,571,440,506,572,441,507,573,442,508,574,443,509,575},
+         {  0,  4,  8,  1,  5,  9,  2,  6, 10,  3,  7, 11, 12, 16, 20, 13,
+           17, 21, 14, 18, 22, 15, 19, 23, 24, 28, 32, 25, 29, 33, 26, 30,
+           34, 27, 31, 35, 36, 40, 44, 37, 41, 45, 38, 42, 46, 39, 43, 47,
+           48, 54, 60, 49, 55, 61, 50, 56, 62, 51, 57, 63, 52, 58, 64, 53,
+           59, 65, 66, 74, 82, 67, 75, 83, 68, 76, 84, 69, 77, 85, 70, 78,
+           86, 71, 79, 87, 72, 80, 88, 73, 81, 89, 90,102,114, 91,103,115,
+           92,104,116, 93,105,117, 94,106,118, 95,107,119, 96,108,120, 97,
+          109,121, 98,110,122, 99,111,123,100,112,124,101,113,125,126,142,
+          158,127,143,159,128,144,160,129,145,161,130,146,162,131,147,163,
+          132,148,164,133,149,165,134,150,166,135,151,167,136,152,168,137,
+          153,169,138,154,170,139,155,171,140,156,172,141,157,173,174,194,
+          214,175,195,215,176,196,216,177,197,217,178,198,218,179,199,219,
+          180,200,220,181,201,221,182,202,222,183,203,223,184,204,224,185,
+          205,225,186,206,226,187,207,227,188,208,228,189,209,229,190,210,
+          230,191,211,231,192,212,232,193,213,233,234,260,286,235,261,287,
+          236,262,288,237,263,289,238,264,290,239,265,291,240,266,292,241,
+          267,293,242,268,294,243,269,295,244,270,296,245,271,297,246,272,
+          298,247,273,299,248,274,300,249,275,301,250,276,302,251,277,303,
+          252,278,304,253,279,305,254,280,306,255,281,307,256,282,308,257,
+          283,309,258,284,310,259,285,311,312,346,380,313,347,381,314,348,
+          382,315,349,383,316,350,384,317,351,385,318,352,386,319,353,387,
+          320,354,388,321,355,389,322,356,390,323,357,391,324,358,392,325,
+          359,393,326,360,394,327,361,395,328,362,396,329,363,397,330,364,
+          398,331,365,399,332,366,400,333,367,401,334,368,402,335,369,403,
+          336,370,404,337,371,405,338,372,406,339,373,407,340,374,408,341,
+          375,409,342,376,410,343,377,411,344,378,412,345,379,413,414,456,
+          498,415,457,499,416,458,500,417,459,501,418,460,502,419,461,503,
+          420,462,504,421,463,505,422,464,506,423,465,507,424,466,508,425,
+          467,509,426,468,510,427,469,511,428,470,512,429,471,513,430,472,
+          514,431,473,515,432,474,516,433,475,517,434,476,518,435,477,519,
+          436,478,520,437,479,521,438,480,522,439,481,523,440,482,524,441,
+          483,525,442,484,526,443,485,527,444,486,528,445,487,529,446,488,
+          530,447,489,531,448,490,532,449,491,533,450,492,534,451,493,535,
+          452,494,536,453,495,537,454,496,538,455,497,539,540,552,564,541,
+          553,565,542,554,566,543,555,567,544,556,568,545,557,569,546,558,
+          570,547,559,571,548,560,572,549,561,573,550,562,574,551,563,575}
+        };
+*/
+
+        private static final float cs[] =
+        {
+         0.857492925712f, 0.881741997318f, 0.949628649103f, 0.983314592492f,
+         0.995517816065f, 0.999160558175f, 0.999899195243f, 0.999993155067f
+        };
+
+        private static final float ca[] =
+        {
+         -0.5144957554270f, -0.4717319685650f, -0.3133774542040f, -0.1819131996110f,
+         -0.0945741925262f, -0.0409655828852f, -0.0141985685725f, -0.00369997467375f
+        };
+
+    /************************************************************/
+        /*                       END OF L3TABLE                     */
+        /************************************************************/
+
+    /************************************************************/
+        /*                            L3TYPE                        */
+        /************************************************************/
+
+
+        /***************************************************************/
+        /*                          END OF L3TYPE                      */
+        /***************************************************************/
+
+        /***************************************************************/
+        /*                             INV_MDCT                        */
+        /***************************************************************/
+        public static final float win[][] =
+        {
+         { -1.6141214951E-02f, -5.3603178919E-02f, -1.0070713296E-01f, -1.6280817573E-01f,
+           -4.9999999679E-01f, -3.8388735032E-01f, -6.2061144372E-01f, -1.1659756083E+00f,
+           -3.8720752656E+00f, -4.2256286556E+00f, -1.5195289984E+00f, -9.7416483388E-01f,
+           -7.3744074053E-01f, -1.2071067773E+00f, -5.1636156596E-01f, -4.5426052317E-01f,
+           -4.0715656898E-01f, -3.6969460527E-01f, -3.3876269197E-01f, -3.1242222492E-01f,
+           -2.8939587111E-01f, -2.6880081906E-01f, -5.0000000266E-01f, -2.3251417468E-01f,
+           -2.1596714708E-01f, -2.0004979098E-01f, -1.8449493497E-01f, -1.6905846094E-01f,
+           -1.5350360518E-01f, -1.3758624925E-01f, -1.2103922149E-01f, -2.0710679058E-01f,
+           -8.4752577594E-02f, -6.4157525656E-02f, -4.1131172614E-02f, -1.4790705759E-02f },
+
+         { -1.6141214951E-02f, -5.3603178919E-02f, -1.0070713296E-01f, -1.6280817573E-01f,
+           -4.9999999679E-01f, -3.8388735032E-01f, -6.2061144372E-01f, -1.1659756083E+00f,
+           -3.8720752656E+00f, -4.2256286556E+00f, -1.5195289984E+00f, -9.7416483388E-01f,
+           -7.3744074053E-01f, -1.2071067773E+00f, -5.1636156596E-01f, -4.5426052317E-01f,
+           -4.0715656898E-01f, -3.6969460527E-01f, -3.3908542600E-01f, -3.1511810350E-01f,
+           -2.9642226150E-01f, -2.8184548650E-01f, -5.4119610000E-01f, -2.6213228100E-01f,
+           -2.5387916537E-01f, -2.3296291359E-01f, -1.9852728987E-01f, -1.5233534808E-01f,
+           -9.6496400054E-02f, -3.3423828516E-02f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f },
+
+         { -4.8300800645E-02f, -1.5715656932E-01f, -2.8325045177E-01f, -4.2953747763E-01f,
+           -1.2071067795E+00f, -8.2426483178E-01f, -1.1451749106E+00f, -1.7695290101E+00f,
+           -4.5470225061E+00f, -3.4890531002E+00f, -7.3296292804E-01f, -1.5076514758E-01f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f },
+
+         { 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f, 0.0000000000E+00f,
+           0.0000000000E+00f, 0.0000000000E+00f, -1.5076513660E-01f, -7.3296291107E-01f,
+           -3.4890530566E+00f, -4.5470224727E+00f, -1.7695290031E+00f, -1.1451749092E+00f,
+           -8.3137738100E-01f, -1.3065629650E+00f, -5.4142014250E-01f, -4.6528974900E-01f,
+           -4.1066990750E-01f, -3.7004680800E-01f, -3.3876269197E-01f, -3.1242222492E-01f,
+           -2.8939587111E-01f, -2.6880081906E-01f, -5.0000000266E-01f, -2.3251417468E-01f,
+           -2.1596714708E-01f, -2.0004979098E-01f, -1.8449493497E-01f, -1.6905846094E-01f,
+           -1.5350360518E-01f, -1.3758624925E-01f, -1.2103922149E-01f, -2.0710679058E-01f,
+           -8.4752577594E-02f, -6.4157525656E-02f, -4.1131172614E-02f, -1.4790705759E-02f }
+        };
+        /***************************************************************/
+        /*                         END OF INV_MDCT                     */
+        /***************************************************************/
+
+        class Sftable
+        {
+                public int[]     l;
+                public int[]     s;
+
+                public Sftable()
+                {
+                        l = new int[5];
+                        s = new int[3];
+                }
+
+                public Sftable(int[] thel, int[] thes)
+                {
+                        l = thel;
+                        s = thes;
+                }
+        }
+
+        public Sftable                          sftable;
+
+        public static final int         nr_of_sfb_block[][][] =
+        {{{ 6, 5, 5, 5} , { 9, 9, 9, 9} , { 6, 9, 9, 9}},
+    {{ 6, 5, 7, 3} , { 9, 9,12, 6} , { 6, 9,12, 6}},
+    {{11,10, 0, 0} , {18,18, 0, 0} , {15,18, 0, 0}},
+    {{ 7, 7, 7, 0} , {12,12,12, 0} , { 6,15,12, 0}},
+    {{ 6, 6, 6, 3} , {12, 9, 9, 6} , { 6,12, 9, 6}},
+    {{ 8, 8, 5, 0} , {15,12, 9, 0} , { 6,18, 9, 0}}};
+
+
+}
diff --git a/songdbj/javazoom/jl/decoder/Manager.java b/songdbj/javazoom/jl/decoder/Manager.java
new file mode 100644
index 0000000000..f566a232e7
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Manager.java
@@ -0,0 +1,46 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Work in progress.
+ * 
+ * Manages a number of controls.
+ */
+public class Manager //implements Control
+{
+        public void addControl(Control c)
+        {
+                
+        }
+        
+        public void removeControl(Control c)
+        {
+                
+        }
+        
+        public void removeAll()
+        {
+                
+        }
+        
+        // control interface delegates to a managed control
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/Obuffer.java b/songdbj/javazoom/jl/decoder/Obuffer.java
new file mode 100644
index 0000000000..45a71a9baf
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Obuffer.java
@@ -0,0 +1,88 @@
+/* 
+ * 11/19/04  1.0 moved to LGPL.
+ * 12/12/99  Added appendSamples() method for efficiency. MDM.
+ * 15/02/99 ,Java Conversion by E.B ,ebsp@iname.com, JavaLayer
+ *
+ *   Declarations for output buffer, includes operating system
+ *   implementation of the virtual Obuffer. Optional routines
+ *   enabling seeks and stops added by Jeff Tsay. 
+ *
+ *  @(#) obuffer.h 1.8, last edit: 6/15/94 16:51:56
+ *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
+ *  @(#) Berlin University of Technology
+ *
+ *  Idea and first implementation for u-law output with fast downsampling by
+ *  Jim Boucher (jboucher@flash.bu.edu)
+ *
+ *  LinuxObuffer class written by
+ *  Louis P. Kruger (lpkruger@phoenix.princeton.edu)
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+package javazoom.jl.decoder;
+
+/**
+ * Base Class for audio output.
+ */
+public abstract class Obuffer
+{
+  public static final int       OBUFFERSIZE = 2 * 1152; // max. 2 * 1152 samples per frame
+  public static final int   MAXCHANNELS = 2;        // max. number of channels
+
+  /**
+   * Takes a 16 Bit PCM sample.
+   */
+  public abstract void append(int channel, short value);
+
+  /**
+   * Accepts 32 new PCM samples. 
+   */
+        public void appendSamples(int channel, float[] f)
+        {
+            short s;
+            for (int i=0; i<32;)
+            {
+                        s = clip(f[i++]);
+                        append(channel, s); 
+            }
+        }
+
+  /**
+   * Clip Sample to 16 Bits
+   */
+  private final short clip(float sample)
+  {
+        return ((sample > 32767.0f) ? 32767 :
+           ((sample < -32768.0f) ? -32768 :
+                          (short) sample));
+  }
+  
+  /**
+   * Write the samples to the file or directly to the audio hardware.
+   */
+  public abstract void write_buffer(int val);
+  public abstract void close();
+
+  /**
+   * Clears all data in the buffer (for seeking).
+   */
+  public abstract void clear_buffer();
+
+  /**
+   * Notify the buffer that the user has stopped the stream.
+   */
+  public abstract void set_stop_flag();
+}
diff --git a/songdbj/javazoom/jl/decoder/OutputChannels.java b/songdbj/javazoom/jl/decoder/OutputChannels.java
new file mode 100644
index 0000000000..58c8310de7
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/OutputChannels.java
@@ -0,0 +1,143 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 12/12/99 Initial implementation.             mdm@techie.com. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+
+/**
+ * A Type-safe representation of the the supported output channel
+ * constants. 
+ * 
+ * This class is immutable and, hence, is thread safe. 
+ * 
+ * @author      Mat McGowan 12/12/99 
+ * @since       0.0.7
+ */
+public class OutputChannels
+{               
+        /**
+         * Flag to indicate output should include both channels. 
+         */
+        public static final int BOTH_CHANNELS = 0;
+                
+        /**
+         * Flag to indicate output should include the left channel only. 
+         */
+        public static final int LEFT_CHANNEL = 1;
+
+        /**
+         * Flag to indicate output should include the right channel only. 
+         */
+        public static final int RIGHT_CHANNEL = 2;
+                
+        /**
+         * Flag to indicate output is mono. 
+         */
+        public static final int DOWNMIX_CHANNELS = 3;
+
+        
+        public static final OutputChannels LEFT = new OutputChannels(LEFT_CHANNEL);
+        public static final OutputChannels RIGHT = new OutputChannels(RIGHT_CHANNEL);
+        public static final OutputChannels BOTH = new OutputChannels(BOTH_CHANNELS);
+        public static final OutputChannels DOWNMIX = new OutputChannels(DOWNMIX_CHANNELS);
+                                
+        
+        private /*final*/ int   outputChannels;
+                        
+        /**
+         * Creates an <code>OutputChannels</code> instance
+         * corresponding to the given channel code.
+         * 
+         * @param       code one of the OutputChannels channel code constants.
+         * 
+         * @throws      IllegalArgumentException if code is not a valid
+         *                      channel code. 
+         */
+        static public OutputChannels fromInt(int code)
+        {
+                switch (code)
+                {
+                case LEFT_CHANNEL:
+                        return LEFT;
+                case RIGHT_CHANNEL:
+                        return RIGHT;
+                case BOTH_CHANNELS:
+                        return BOTH;
+                case DOWNMIX_CHANNELS:
+                        return DOWNMIX;
+                default:
+                        throw new IllegalArgumentException("Invalid channel code: "+code);
+                }
+        }
+                
+        private OutputChannels(int channels)
+        {
+                outputChannels = channels;
+                        
+                if (channels<0 || channels>3)
+                        throw new IllegalArgumentException("channels");
+        }
+                
+        /**
+         * Retrieves the code representing the desired output channels.
+         * Will be one of LEFT_CHANNEL, RIGHT_CHANNEL, BOTH_CHANNELS
+         * or DOWNMIX_CHANNELS.
+         * 
+         * @return the channel code represented by this instance.
+         */
+        public int getChannelsOutputCode()
+        {
+                return outputChannels;  
+        }
+                
+        /**
+         * Retrieves the number of output channels represented 
+         * by this channel output type.
+         * 
+         * @return      The number of output channels for this channel output
+         *                      type. This will be 2 for BOTH_CHANNELS only, and 1
+         *                      for all other types. 
+         */
+        public int getChannelCount()
+        {
+                int count = (outputChannels==BOTH_CHANNELS) ?  2 : 1;
+                return count;
+        }
+                
+                
+        public boolean equals(Object o)
+        {
+                boolean equals = false;
+                        
+                if (o instanceof OutputChannels)
+                {
+                        OutputChannels oc = (OutputChannels)o;
+                        equals = (oc.outputChannels == outputChannels);
+                }
+                        
+                return equals;
+        }
+                                                          
+        public int hashCode()
+        {
+                return outputChannels;  
+        }
+                
+}
diff --git a/songdbj/javazoom/jl/decoder/SampleBuffer.java b/songdbj/javazoom/jl/decoder/SampleBuffer.java
new file mode 100644
index 0000000000..ba4bfa060f
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/SampleBuffer.java
@@ -0,0 +1,132 @@
+/* 
+ * 11/19/04      1.0 moved to LGPL.
+ * 
+ * 12/12/99  Initial Version based on FileObuffer.      mdm@techie.com.
+ * 
+ * FileObuffer:
+ * 15/02/99  Java Conversion by E.B ,javalayer@javazoom.net
+ *
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * The <code>SampleBuffer</code> class implements an output buffer
+ * that provides storage for a fixed size block of samples. 
+ */
+public class SampleBuffer extends Obuffer
+{
+  private short[]               buffer;
+  private int[]                 bufferp;
+  private int                   channels;
+  private int                   frequency;
+  
+  /**
+   * Constructor
+   */
+  public SampleBuffer(int sample_frequency, int number_of_channels)
+  {
+        buffer = new short[OBUFFERSIZE];
+        bufferp = new int[MAXCHANNELS];
+        channels = number_of_channels;
+        frequency = sample_frequency;
+        
+        for (int i = 0; i < number_of_channels; ++i) 
+                bufferp[i] = (short)i;
+        
+  }
+
+  public int getChannelCount()
+  {
+        return this.channels;  
+  }
+  
+  public int getSampleFrequency()
+  {
+          return this.frequency;
+  }
+  
+  public short[] getBuffer()
+  {
+        return this.buffer;  
+  }
+  
+  public int getBufferLength()
+  {
+          return bufferp[0];
+  }
+  
+  /**
+   * Takes a 16 Bit PCM sample.
+   */
+  public void append(int channel, short value)
+  {
+        buffer[bufferp[channel]] = value;
+        bufferp[channel] += channels;           
+  }
+  
+        public void appendSamples(int channel, float[] f)
+        {
+            int pos = bufferp[channel];
+                
+                short s;
+                float fs;
+            for (int i=0; i<32;)
+            {
+                        fs = f[i++];
+                        fs = (fs>32767.0f ? 32767.0f 
+                                                   : (fs < -32767.0f ? -32767.0f : fs));
+                        
+                        s = (short)fs;
+                        buffer[pos] = s;
+                        pos += channels;
+            }
+                
+                bufferp[channel] = pos;
+        }
+  
+  
+  /**
+   * Write the samples to the file (Random Acces).
+   */
+  public void write_buffer(int val)
+  {
+                                  
+        //for (int i = 0; i < channels; ++i) 
+        //      bufferp[i] = (short)i;
+
+  }
+
+  public void close()
+  {}
+  
+  /**
+   *
+   */
+  public void clear_buffer()
+  {
+        for (int i = 0; i < channels; ++i) 
+                bufferp[i] = (short)i;
+  }
+
+  /**
+   *
+   */
+  public void set_stop_flag()
+  {}
+}
diff --git a/songdbj/javazoom/jl/decoder/Source.java b/songdbj/javazoom/jl/decoder/Source.java
new file mode 100644
index 0000000000..9d6a5d732e
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/Source.java
@@ -0,0 +1,49 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+import java.io.IOException;
+
+/**
+ * Work in progress.
+ * 
+ * Class to describe a seekable data source. 
+ *  
+ */
+public interface Source
+{
+        
+        public static final long        LENGTH_UNKNOWN = -1;
+        
+        public int read(byte[] b, int offs, int len)
+                throws IOException;
+        
+        
+        public boolean  willReadBlock();
+                        
+        public boolean  isSeekable();
+                
+        public long             length();
+        
+        public long             tell();
+        
+        public long             seek(long pos);
+        
+}
diff --git a/songdbj/javazoom/jl/decoder/SynthesisFilter.java b/songdbj/javazoom/jl/decoder/SynthesisFilter.java
new file mode 100644
index 0000000000..581ab03cc2
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/SynthesisFilter.java
@@ -0,0 +1,1817 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 
+ * 04/01/00 Fixes for running under build 23xx Microsoft JVM. mdm.
+ * 
+ * 19/12/99 Performance improvements to compute_pcm_samples().  
+ *                      Mat McGowan. mdm@techie.com. 
+ *
+ * 16/02/99 Java Conversion by E.B , javalayer@javazoom.net
+ *
+ *  @(#) synthesis_filter.h 1.8, last edit: 6/15/94 16:52:00
+ *  @(#) Copyright (C) 1993, 1994 Tobias Bading (bading@cs.tu-berlin.de)
+ *  @(#) Berlin University of Technology
+ *
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+package javazoom.jl.decoder;
+
+import java.io.IOException;
+
+/**
+ * A class for the synthesis filter bank.
+ * This class does a fast downsampling from 32, 44.1 or 48 kHz to 8 kHz, if ULAW is defined.
+ * Frequencies above 4 kHz are removed by ignoring higher subbands.
+ */
+final class SynthesisFilter
+{
+  private float[]                        v1;
+  private float[]                        v2;
+  private float[]                        actual_v;                      // v1 or v2
+  private int                            actual_write_pos;      // 0-15
+  private float[]                        samples;                       // 32 new subband samples
+  private int                            channel;
+  private float                          scalefactor;
+  private float[]                        eq;
+        
+        /**
+         * Quality value for controlling CPU usage/quality tradeoff. 
+         */
+        /*
+        private int                             quality;
+        
+        private int                             v_inc;
+        
+        
+        
+        public static final int HIGH_QUALITY = 1;
+        public static final int MEDIUM_QUALITY = 2;
+        public static final int LOW_QUALITY = 4;
+        */
+        
+  /**
+   * Contructor.
+   * The scalefactor scales the calculated float pcm samples to short values
+   * (raw pcm samples are in [-1.0, 1.0], if no violations occur).
+   */
+  public SynthesisFilter(int channelnumber, float factor, float[] eq0)
+  {      
+          if (d==null)
+          {
+                        d = load_d();
+                        d16 = splitArray(d, 16);
+          }
+          
+          v1 = new float[512];
+         v2 = new float[512];
+         samples = new float[32];
+     channel = channelnumber;
+         scalefactor = factor;
+         setEQ(eq);      
+         //setQuality(HIGH_QUALITY);
+         
+     reset();
+  }
+  
+  public void setEQ(float[] eq0)
+  {
+         this.eq = eq0;  
+         if (eq==null)
+         {
+                 eq = new float[32];
+                 for (int i=0; i<32; i++)
+                         eq[i] = 1.0f;
+         }
+         if (eq.length<32)
+         {
+                throw new IllegalArgumentException("eq0");       
+         }
+          
+  }
+  
+        /*
+        private void setQuality(int quality0)
+        {
+                switch (quality0)
+                {               
+                case HIGH_QUALITY:
+                case MEDIUM_QUALITY:
+                case LOW_QUALITY:                                                 
+                        v_inc = 16 * quality0;                  
+                        quality = quality0;
+                        break;  
+                default :
+                        throw new IllegalArgumentException("Unknown quality value");
+                }                               
+        }
+        
+        public int getQuality()
+        {
+                return quality; 
+        }
+        */
+  
+  /**
+   * Reset the synthesis filter.
+   */
+  public void reset()
+  {
+     //float[] floatp;
+         // float[] floatp2;
+
+     // initialize v1[] and v2[]:
+     //for (floatp = v1 + 512, floatp2 = v2 + 512; floatp > v1; )
+         //   *--floatp = *--floatp2 = 0.0;
+         for (int p=0;p<512;p++) 
+                 v1[p] = v2[p] = 0.0f;
+
+     // initialize samples[]:
+     //for (floatp = samples + 32; floatp > samples; )
+         //  *--floatp = 0.0;
+         for (int p2=0;p2<32;p2++) 
+                 samples[p2] = 0.0f;
+
+     actual_v = v1;
+     actual_write_pos = 15;
+  }
+
+
+  /**
+   * Inject Sample.
+   */
+  public void input_sample(float sample, int subbandnumber)
+  {                               
+          samples[subbandnumber] = eq[subbandnumber]*sample;
+  }
+
+  public void input_samples(float[] s)
+  {
+          for (int i=31; i>=0; i--)
+          {             
+                 samples[i] = s[i]*eq[i];
+          }
+  }
+  
+  /**
+   * Compute new values via a fast cosine transform.
+   */
+  private void compute_new_v()
+  {
+        // p is fully initialized from x1
+         //float[] p = _p;
+         // pp is fully initialized from p
+         //float[] pp = _pp; 
+          
+         //float[] new_v = _new_v;
+          
+        //float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure 3-A.2 in ISO DIS 11172-3
+        //float[] p = new float[16];
+        //float[] pp = new float[16];
+          
+         /*
+         for (int i=31; i>=0; i--)
+         {
+                 new_v[i] = 0.0f;
+         }
+          */
+          
+        float new_v0, new_v1, new_v2, new_v3, new_v4, new_v5, new_v6, new_v7, new_v8, new_v9;
+        float new_v10, new_v11, new_v12, new_v13, new_v14, new_v15, new_v16, new_v17, new_v18, new_v19;
+        float new_v20, new_v21, new_v22, new_v23, new_v24, new_v25, new_v26, new_v27, new_v28, new_v29;
+        float new_v30, new_v31;
+          
+        new_v0 = new_v1 = new_v2 = new_v3 = new_v4 = new_v5 = new_v6 = new_v7 = new_v8 = new_v9 = 
+        new_v10 = new_v11 = new_v12 = new_v13 = new_v14 = new_v15 = new_v16 = new_v17 = new_v18 = new_v19 = 
+        new_v20 = new_v21 = new_v22 = new_v23 = new_v24 = new_v25 = new_v26 = new_v27 = new_v28 = new_v29 = 
+        new_v30 = new_v31 = 0.0f;
+        
+        
+//      float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure 3-A.2 in ISO DIS 11172-3
+//      float[] p = new float[16];
+//      float[] pp = new float[16];
+
+    float[] s = samples;
+        
+        float s0 = s[0];
+        float s1 = s[1];
+        float s2 = s[2];
+        float s3 = s[3];
+        float s4 = s[4];
+        float s5 = s[5];
+        float s6 = s[6];
+        float s7 = s[7];
+        float s8 = s[8];
+        float s9 = s[9];
+        float s10 = s[10];      
+        float s11 = s[11];
+        float s12 = s[12];
+        float s13 = s[13];
+        float s14 = s[14];
+        float s15 = s[15];
+        float s16 = s[16];
+        float s17 = s[17];
+        float s18 = s[18];
+        float s19 = s[19];
+        float s20 = s[20];      
+        float s21 = s[21];
+        float s22 = s[22];
+        float s23 = s[23];
+        float s24 = s[24];
+        float s25 = s[25];
+        float s26 = s[26];
+        float s27 = s[27];
+        float s28 = s[28];
+        float s29 = s[29];
+        float s30 = s[30];      
+        float s31 = s[31];
+                
+        float p0 = s0 + s31;
+        float p1 = s1 + s30;
+        float p2 = s2 + s29;
+        float p3 = s3 + s28;
+        float p4 = s4 + s27;
+        float p5 = s5 + s26;
+        float p6 = s6 + s25;
+        float p7 = s7 + s24;
+        float p8 = s8 + s23;
+        float p9 = s9 + s22;
+        float p10 = s10 + s21;
+        float p11 = s11 + s20;
+        float p12 = s12 + s19;
+        float p13 = s13 + s18;
+        float p14 = s14 + s17;
+        float p15 = s15 + s16;
+        
+        float pp0 = p0 + p15;
+        float pp1 = p1 + p14;
+        float pp2 = p2 + p13;
+        float pp3 = p3 + p12;
+        float pp4 = p4 + p11;
+        float pp5 = p5 + p10;
+        float pp6 = p6 + p9;
+        float pp7 = p7 + p8;
+        float pp8 = (p0 - p15) * cos1_32;
+        float pp9 = (p1 - p14) * cos3_32;
+        float pp10 = (p2 - p13) * cos5_32;
+        float pp11 = (p3 - p12) * cos7_32;
+        float pp12 = (p4 - p11) * cos9_32;
+        float pp13 = (p5 - p10) * cos11_32;
+        float pp14 = (p6 - p9) * cos13_32;
+        float pp15 = (p7 - p8) * cos15_32;
+
+        p0 = pp0 + pp7;
+        p1 = pp1 + pp6;
+        p2 = pp2 + pp5;
+        p3 = pp3 + pp4;
+        p4 = (pp0 - pp7) * cos1_16;
+        p5 = (pp1 - pp6) * cos3_16;
+        p6 = (pp2 - pp5) * cos5_16;
+        p7 = (pp3 - pp4) * cos7_16;
+        p8 = pp8 + pp15;
+        p9 = pp9 + pp14;
+        p10 = pp10 + pp13;
+        p11 = pp11 + pp12;
+        p12 = (pp8 - pp15) * cos1_16;
+        p13 = (pp9 - pp14) * cos3_16;
+        p14 = (pp10 - pp13) * cos5_16;
+        p15 = (pp11 - pp12) * cos7_16;
+        
+
+        pp0 = p0 + p3;
+        pp1 = p1 + p2;
+        pp2 = (p0 - p3) * cos1_8;
+        pp3 = (p1 - p2) * cos3_8;
+        pp4 = p4 + p7;
+        pp5 = p5 + p6;
+        pp6 = (p4 - p7) * cos1_8;
+        pp7 = (p5 - p6) * cos3_8;
+        pp8 = p8 + p11;
+        pp9 = p9 + p10;
+        pp10 = (p8 - p11) * cos1_8;
+        pp11 = (p9 - p10) * cos3_8;
+        pp12 = p12 + p15;
+        pp13 = p13 + p14;
+        pp14 = (p12 - p15) * cos1_8;
+        pp15 = (p13 - p14) * cos3_8;
+
+        p0 = pp0 + pp1;
+        p1 = (pp0 - pp1) * cos1_4;
+        p2 = pp2 + pp3;
+        p3 = (pp2 - pp3) * cos1_4;
+        p4 = pp4 + pp5;
+        p5 = (pp4 - pp5) * cos1_4;
+        p6 = pp6 + pp7;
+        p7 = (pp6 - pp7) * cos1_4;
+        p8 = pp8 + pp9;
+        p9 = (pp8 - pp9) * cos1_4;
+        p10 = pp10 + pp11;
+        p11 = (pp10 - pp11) * cos1_4;
+        p12 = pp12 + pp13;
+        p13 = (pp12 - pp13) * cos1_4;
+        p14 = pp14 + pp15;
+        p15 = (pp14 - pp15) * cos1_4;
+
+        // this is pretty insane coding
+        float tmp1;
+        new_v19/*36-17*/ = -(new_v4 = (new_v12 = p7) + p5) - p6;
+        new_v27/*44-17*/ = -p6 - p7 - p4;
+        new_v6 = (new_v10 = (new_v14 = p15) + p11) + p13;
+        new_v17/*34-17*/ = -(new_v2 = p15 + p13 + p9) - p14;
+        new_v21/*38-17*/ = (tmp1 = -p14 - p15 - p10 - p11) - p13;
+        new_v29/*46-17*/ = -p14 - p15 - p12 - p8;
+        new_v25/*42-17*/ = tmp1 - p12;
+        new_v31/*48-17*/ = -p0;
+        new_v0 = p1;
+        new_v23/*40-17*/ = -(new_v8 = p3) - p2;
+        
+        p0 = (s0 - s31) * cos1_64;
+        p1 = (s1 - s30) * cos3_64;
+        p2 = (s2 - s29) * cos5_64;
+        p3 = (s3 - s28) * cos7_64;
+        p4 = (s4 - s27) * cos9_64;
+        p5 = (s5 - s26) * cos11_64;
+        p6 = (s6 - s25) * cos13_64;
+        p7 = (s7 - s24) * cos15_64;
+        p8 = (s8 - s23) * cos17_64;
+        p9 = (s9 - s22) * cos19_64;
+        p10 = (s10 - s21) * cos21_64;
+        p11 = (s11 - s20) * cos23_64;
+        p12 = (s12 - s19) * cos25_64;
+        p13 = (s13 - s18) * cos27_64;
+        p14 = (s14 - s17) * cos29_64;
+        p15 = (s15 - s16) * cos31_64;
+
+        
+        pp0 = p0 + p15;
+        pp1 = p1 + p14;
+        pp2 = p2 + p13;
+        pp3 = p3 + p12;
+        pp4 = p4 + p11;
+        pp5 = p5 + p10;
+        pp6 = p6 + p9;
+        pp7 = p7 + p8;
+        pp8 = (p0 - p15) * cos1_32;
+        pp9 = (p1 - p14) * cos3_32;
+        pp10 = (p2 - p13) * cos5_32;
+        pp11 = (p3 - p12) * cos7_32;
+        pp12 = (p4 - p11) * cos9_32;
+        pp13 = (p5 - p10) * cos11_32;
+        pp14 = (p6 - p9) * cos13_32;
+        pp15 = (p7 - p8) * cos15_32;
+        
+
+        p0 = pp0 + pp7;
+        p1 = pp1 + pp6;
+        p2 = pp2 + pp5;
+        p3 = pp3 + pp4;
+        p4 = (pp0 - pp7) * cos1_16;
+        p5 = (pp1 - pp6) * cos3_16;
+        p6 = (pp2 - pp5) * cos5_16;
+        p7 = (pp3 - pp4) * cos7_16;
+        p8 = pp8 + pp15;
+        p9 = pp9 + pp14;
+        p10 = pp10 + pp13;
+        p11 = pp11 + pp12;
+        p12 = (pp8 - pp15) * cos1_16;
+        p13 = (pp9 - pp14) * cos3_16;
+        p14 = (pp10 - pp13) * cos5_16;
+        p15 = (pp11 - pp12) * cos7_16;
+
+
+        pp0 = p0 + p3;
+        pp1 = p1 + p2;
+        pp2 = (p0 - p3) * cos1_8;
+        pp3 = (p1 - p2) * cos3_8;
+        pp4 = p4 + p7;
+        pp5 = p5 + p6;
+        pp6 = (p4 - p7) * cos1_8;
+        pp7 = (p5 - p6) * cos3_8;
+        pp8 = p8 + p11;
+        pp9 = p9 + p10;
+        pp10 = (p8 - p11) * cos1_8;
+        pp11 = (p9 - p10) * cos3_8;
+        pp12 = p12 + p15;
+        pp13 = p13 + p14;
+        pp14 = (p12 - p15) * cos1_8;
+        pp15 = (p13 - p14) * cos3_8;
+
+        
+        p0 = pp0 + pp1;
+        p1 = (pp0 - pp1) * cos1_4;
+        p2 = pp2 + pp3;
+        p3 = (pp2 - pp3) * cos1_4;
+        p4 = pp4 + pp5;
+        p5 = (pp4 - pp5) * cos1_4;
+        p6 = pp6 + pp7;
+        p7 = (pp6 - pp7) * cos1_4;
+        p8 = pp8 + pp9;
+        p9 = (pp8 - pp9) * cos1_4;
+        p10 = pp10 + pp11;
+        p11 = (pp10 - pp11) * cos1_4;
+        p12 = pp12 + pp13;
+        p13 = (pp12 - pp13) * cos1_4;
+        p14 = pp14 + pp15;
+        p15 = (pp14 - pp15) * cos1_4;
+        
+
+        // manually doing something that a compiler should handle sucks
+        // coding like this is hard to read
+        float tmp2;
+        new_v5 = (new_v11 = (new_v13 = (new_v15 = p15) + p7) + p11)
+                                                        + p5 + p13;
+        new_v7 = (new_v9 = p15 + p11 + p3) + p13;
+        new_v16/*33-17*/ = -(new_v1 = (tmp1 = p13 + p15 + p9) + p1) - p14;
+        new_v18/*35-17*/ = -(new_v3 = tmp1 + p5 + p7) - p6 - p14;
+
+        new_v22/*39-17*/ = (tmp1 = -p10 - p11 - p14 - p15)
+                                                                        - p13 - p2 - p3;
+        new_v20/*37-17*/ = tmp1 - p13 - p5 - p6 - p7;
+        new_v24/*41-17*/ = tmp1 - p12 - p2 - p3;
+        new_v26/*43-17*/ = tmp1 - p12 - (tmp2 = p4 + p6 + p7);
+        new_v30/*47-17*/ = (tmp1 = -p8 - p12 - p14 - p15) - p0;
+        new_v28/*45-17*/ = tmp1 - tmp2;
+
+        // insert V[0-15] (== new_v[0-15]) into actual v:       
+        // float[] x2 = actual_v + actual_write_pos;
+        float dest[] = actual_v;
+        
+        int pos = actual_write_pos;
+        
+        dest[0 + pos] = new_v0;
+        dest[16 + pos] = new_v1;
+        dest[32 + pos] = new_v2;
+        dest[48 + pos] = new_v3;
+        dest[64 + pos] = new_v4;
+        dest[80 + pos] = new_v5;
+        dest[96 + pos] = new_v6;
+        dest[112 + pos] = new_v7;
+        dest[128 + pos] = new_v8;
+        dest[144 + pos] = new_v9;
+        dest[160 + pos] = new_v10;
+        dest[176 + pos] = new_v11;
+        dest[192 + pos] = new_v12;
+        dest[208 + pos] = new_v13;
+        dest[224 + pos] = new_v14;
+        dest[240 + pos] = new_v15;
+
+        // V[16] is always 0.0:
+        dest[256 + pos] = 0.0f;
+
+        // insert V[17-31] (== -new_v[15-1]) into actual v:
+        dest[272 + pos] = -new_v15;
+        dest[288 + pos] = -new_v14;
+        dest[304 + pos] = -new_v13;
+        dest[320 + pos] = -new_v12;
+        dest[336 + pos] = -new_v11;
+        dest[352 + pos] = -new_v10;
+        dest[368 + pos] = -new_v9;
+        dest[384 + pos] = -new_v8;
+        dest[400 + pos] = -new_v7;
+        dest[416 + pos] = -new_v6;
+        dest[432 + pos] = -new_v5;
+        dest[448 + pos] = -new_v4;
+        dest[464 + pos] = -new_v3;
+        dest[480 + pos] = -new_v2;
+        dest[496 + pos] = -new_v1;
+
+        // insert V[32] (== -new_v[0]) into other v:
+        dest = (actual_v==v1) ? v2 : v1;
+        
+        dest[0 + pos] = -new_v0;
+        // insert V[33-48] (== new_v[16-31]) into other v:
+        dest[16 + pos] = new_v16;
+        dest[32 + pos] = new_v17;
+        dest[48 + pos] = new_v18;
+        dest[64 + pos] = new_v19;
+        dest[80 + pos] = new_v20;
+        dest[96 + pos] = new_v21;
+        dest[112 + pos] = new_v22;
+        dest[128 + pos] = new_v23;
+        dest[144 + pos] = new_v24;
+        dest[160 + pos] = new_v25;
+        dest[176 + pos] = new_v26;
+        dest[192 + pos] = new_v27;
+        dest[208 + pos] = new_v28;
+        dest[224 + pos] = new_v29;
+        dest[240 + pos] = new_v30;
+        dest[256 + pos] = new_v31;
+        
+        // insert V[49-63] (== new_v[30-16]) into other v:
+        dest[272 + pos] = new_v30;
+        dest[288 + pos] = new_v29;
+        dest[304 + pos] = new_v28;
+        dest[320 + pos] = new_v27;
+        dest[336 + pos] = new_v26;
+        dest[352 + pos] = new_v25;
+        dest[368 + pos] = new_v24;
+        dest[384 + pos] = new_v23;
+        dest[400 + pos] = new_v22;
+        dest[416 + pos] = new_v21;
+        dest[432 + pos] = new_v20;
+        dest[448 + pos] = new_v19;
+        dest[464 + pos] = new_v18;
+        dest[480 + pos] = new_v17;
+        dest[496 + pos] = new_v16;                      
+/*
+        }
+        else
+        {
+                v1[0 + actual_write_pos] = -new_v0;
+                // insert V[33-48] (== new_v[16-31]) into other v:
+                v1[16 + actual_write_pos] = new_v16;
+                v1[32 + actual_write_pos] = new_v17;
+                v1[48 + actual_write_pos] = new_v18;
+                v1[64 + actual_write_pos] = new_v19;
+                v1[80 + actual_write_pos] = new_v20;
+                v1[96 + actual_write_pos] = new_v21;
+                v1[112 + actual_write_pos] = new_v22;
+                v1[128 + actual_write_pos] = new_v23;
+                v1[144 + actual_write_pos] = new_v24;
+                v1[160 + actual_write_pos] = new_v25;
+                v1[176 + actual_write_pos] = new_v26;
+                v1[192 + actual_write_pos] = new_v27;
+                v1[208 + actual_write_pos] = new_v28;
+                v1[224 + actual_write_pos] = new_v29;
+                v1[240 + actual_write_pos] = new_v30;
+                v1[256 + actual_write_pos] = new_v31;
+
+                // insert V[49-63] (== new_v[30-16]) into other v:
+                v1[272 + actual_write_pos] = new_v30;
+                v1[288 + actual_write_pos] = new_v29;
+                v1[304 + actual_write_pos] = new_v28;
+                v1[320 + actual_write_pos] = new_v27;
+                v1[336 + actual_write_pos] = new_v26;
+                v1[352 + actual_write_pos] = new_v25;
+                v1[368 + actual_write_pos] = new_v24;
+                v1[384 + actual_write_pos] = new_v23;
+                v1[400 + actual_write_pos] = new_v22;
+                v1[416 + actual_write_pos] = new_v21;
+                v1[432 + actual_write_pos] = new_v20;
+                v1[448 + actual_write_pos] = new_v19;
+                v1[464 + actual_write_pos] = new_v18;
+                v1[480 + actual_write_pos] = new_v17;
+                v1[496 + actual_write_pos] = new_v16;   
+        }
+*/      
+  }
+        
+  /**
+   * Compute new values via a fast cosine transform.
+   */
+  private void compute_new_v_old()
+  {
+        // p is fully initialized from x1
+         //float[] p = _p;
+         // pp is fully initialized from p
+         //float[] pp = _pp; 
+          
+         //float[] new_v = _new_v;
+          
+        float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure 3-A.2 in ISO DIS 11172-3
+        float[] p = new float[16];
+        float[] pp = new float[16];
+          
+          
+         for (int i=31; i>=0; i--)
+         {
+                 new_v[i] = 0.0f;
+         }
+         
+//      float[] new_v = new float[32]; // new V[0-15] and V[33-48] of Figure 3-A.2 in ISO DIS 11172-3
+//      float[] p = new float[16];
+//      float[] pp = new float[16];
+
+    float[] x1 = samples;
+        
+        p[0] = x1[0] + x1[31];
+        p[1] = x1[1] + x1[30];
+        p[2] = x1[2] + x1[29];
+        p[3] = x1[3] + x1[28];
+        p[4] = x1[4] + x1[27];
+        p[5] = x1[5] + x1[26];
+        p[6] = x1[6] + x1[25];
+        p[7] = x1[7] + x1[24];
+        p[8] = x1[8] + x1[23];
+        p[9] = x1[9] + x1[22];
+        p[10] = x1[10] + x1[21];
+        p[11] = x1[11] + x1[20];
+        p[12] = x1[12] + x1[19];
+        p[13] = x1[13] + x1[18];
+        p[14] = x1[14] + x1[17];
+        p[15] = x1[15] + x1[16];
+        
+        pp[0] = p[0] + p[15];
+        pp[1] = p[1] + p[14];
+        pp[2] = p[2] + p[13];
+        pp[3] = p[3] + p[12];
+        pp[4] = p[4] + p[11];
+        pp[5] = p[5] + p[10];
+        pp[6] = p[6] + p[9];
+        pp[7] = p[7] + p[8];
+        pp[8] = (p[0] - p[15]) * cos1_32;
+        pp[9] = (p[1] - p[14]) * cos3_32;
+        pp[10] = (p[2] - p[13]) * cos5_32;
+        pp[11] = (p[3] - p[12]) * cos7_32;
+        pp[12] = (p[4] - p[11]) * cos9_32;
+        pp[13] = (p[5] - p[10]) * cos11_32;
+        pp[14] = (p[6] - p[9]) * cos13_32;
+        pp[15] = (p[7] - p[8]) * cos15_32;
+
+        p[0] = pp[0] + pp[7];
+        p[1] = pp[1] + pp[6];
+        p[2] = pp[2] + pp[5];
+        p[3] = pp[3] + pp[4];
+        p[4] = (pp[0] - pp[7]) * cos1_16;
+        p[5] = (pp[1] - pp[6]) * cos3_16;
+        p[6] = (pp[2] - pp[5]) * cos5_16;
+        p[7] = (pp[3] - pp[4]) * cos7_16;
+        p[8] = pp[8] + pp[15];
+        p[9] = pp[9] + pp[14];
+        p[10] = pp[10] + pp[13];
+        p[11] = pp[11] + pp[12];
+        p[12] = (pp[8] - pp[15]) * cos1_16;
+        p[13] = (pp[9] - pp[14]) * cos3_16;
+        p[14] = (pp[10] - pp[13]) * cos5_16;
+        p[15] = (pp[11] - pp[12]) * cos7_16;
+        
+
+        pp[0] = p[0] + p[3];
+        pp[1] = p[1] + p[2];
+        pp[2] = (p[0] - p[3]) * cos1_8;
+        pp[3] = (p[1] - p[2]) * cos3_8;
+        pp[4] = p[4] + p[7];
+        pp[5] = p[5] + p[6];
+        pp[6] = (p[4] - p[7]) * cos1_8;
+        pp[7] = (p[5] - p[6]) * cos3_8;
+        pp[8] = p[8] + p[11];
+        pp[9] = p[9] + p[10];
+        pp[10] = (p[8] - p[11]) * cos1_8;
+        pp[11] = (p[9] - p[10]) * cos3_8;
+        pp[12] = p[12] + p[15];
+        pp[13] = p[13] + p[14];
+        pp[14] = (p[12] - p[15]) * cos1_8;
+        pp[15] = (p[13] - p[14]) * cos3_8;
+
+        p[0] = pp[0] + pp[1];
+        p[1] = (pp[0] - pp[1]) * cos1_4;
+        p[2] = pp[2] + pp[3];
+        p[3] = (pp[2] - pp[3]) * cos1_4;
+        p[4] = pp[4] + pp[5];
+        p[5] = (pp[4] - pp[5]) * cos1_4;
+        p[6] = pp[6] + pp[7];
+        p[7] = (pp[6] - pp[7]) * cos1_4;
+        p[8] = pp[8] + pp[9];
+        p[9] = (pp[8] - pp[9]) * cos1_4;
+        p[10] = pp[10] + pp[11];
+        p[11] = (pp[10] - pp[11]) * cos1_4;
+        p[12] = pp[12] + pp[13];
+        p[13] = (pp[12] - pp[13]) * cos1_4;
+        p[14] = pp[14] + pp[15];
+        p[15] = (pp[14] - pp[15]) * cos1_4;
+
+        // this is pretty insane coding
+        float tmp1;
+        new_v[36-17] = -(new_v[4] = (new_v[12] = p[7]) + p[5]) - p[6];
+        new_v[44-17] = -p[6] - p[7] - p[4];
+        new_v[6] = (new_v[10] = (new_v[14] = p[15]) + p[11]) + p[13];
+        new_v[34-17] = -(new_v[2] = p[15] + p[13] + p[9]) - p[14];
+        new_v[38-17] = (tmp1 = -p[14] - p[15] - p[10] - p[11]) - p[13];
+        new_v[46-17] = -p[14] - p[15] - p[12] - p[8];
+        new_v[42-17] = tmp1 - p[12];
+        new_v[48-17] = -p[0];
+        new_v[0] = p[1];
+        new_v[40-17] = -(new_v[8] = p[3]) - p[2];
+        
+        p[0] = (x1[0] - x1[31]) * cos1_64;
+        p[1] = (x1[1] - x1[30]) * cos3_64;
+        p[2] = (x1[2] - x1[29]) * cos5_64;
+        p[3] = (x1[3] - x1[28]) * cos7_64;
+        p[4] = (x1[4] - x1[27]) * cos9_64;
+        p[5] = (x1[5] - x1[26]) * cos11_64;
+        p[6] = (x1[6] - x1[25]) * cos13_64;
+        p[7] = (x1[7] - x1[24]) * cos15_64;
+        p[8] = (x1[8] - x1[23]) * cos17_64;
+        p[9] = (x1[9] - x1[22]) * cos19_64;
+        p[10] = (x1[10] - x1[21]) * cos21_64;
+        p[11] = (x1[11] - x1[20]) * cos23_64;
+        p[12] = (x1[12] - x1[19]) * cos25_64;
+        p[13] = (x1[13] - x1[18]) * cos27_64;
+        p[14] = (x1[14] - x1[17]) * cos29_64;
+        p[15] = (x1[15] - x1[16]) * cos31_64;
+
+        
+        pp[0] = p[0] + p[15];
+        pp[1] = p[1] + p[14];
+        pp[2] = p[2] + p[13];
+        pp[3] = p[3] + p[12];
+        pp[4] = p[4] + p[11];
+        pp[5] = p[5] + p[10];
+        pp[6] = p[6] + p[9];
+        pp[7] = p[7] + p[8];
+        pp[8] = (p[0] - p[15]) * cos1_32;
+        pp[9] = (p[1] - p[14]) * cos3_32;
+        pp[10] = (p[2] - p[13]) * cos5_32;
+        pp[11] = (p[3] - p[12]) * cos7_32;
+        pp[12] = (p[4] - p[11]) * cos9_32;
+        pp[13] = (p[5] - p[10]) * cos11_32;
+        pp[14] = (p[6] - p[9]) * cos13_32;
+        pp[15] = (p[7] - p[8]) * cos15_32;
+        
+
+        p[0] = pp[0] + pp[7];
+        p[1] = pp[1] + pp[6];
+        p[2] = pp[2] + pp[5];
+        p[3] = pp[3] + pp[4];
+        p[4] = (pp[0] - pp[7]) * cos1_16;
+        p[5] = (pp[1] - pp[6]) * cos3_16;
+        p[6] = (pp[2] - pp[5]) * cos5_16;
+        p[7] = (pp[3] - pp[4]) * cos7_16;
+        p[8] = pp[8] + pp[15];
+        p[9] = pp[9] + pp[14];
+        p[10] = pp[10] + pp[13];
+        p[11] = pp[11] + pp[12];
+        p[12] = (pp[8] - pp[15]) * cos1_16;
+        p[13] = (pp[9] - pp[14]) * cos3_16;
+        p[14] = (pp[10] - pp[13]) * cos5_16;
+        p[15] = (pp[11] - pp[12]) * cos7_16;
+
+
+        pp[0] = p[0] + p[3];
+        pp[1] = p[1] + p[2];
+        pp[2] = (p[0] - p[3]) * cos1_8;
+        pp[3] = (p[1] - p[2]) * cos3_8;
+        pp[4] = p[4] + p[7];
+        pp[5] = p[5] + p[6];
+        pp[6] = (p[4] - p[7]) * cos1_8;
+        pp[7] = (p[5] - p[6]) * cos3_8;
+        pp[8] = p[8] + p[11];
+        pp[9] = p[9] + p[10];
+        pp[10] = (p[8] - p[11]) * cos1_8;
+        pp[11] = (p[9] - p[10]) * cos3_8;
+        pp[12] = p[12] + p[15];
+        pp[13] = p[13] + p[14];
+        pp[14] = (p[12] - p[15]) * cos1_8;
+        pp[15] = (p[13] - p[14]) * cos3_8;
+
+        
+        p[0] = pp[0] + pp[1];
+        p[1] = (pp[0] - pp[1]) * cos1_4;
+        p[2] = pp[2] + pp[3];
+        p[3] = (pp[2] - pp[3]) * cos1_4;
+        p[4] = pp[4] + pp[5];
+        p[5] = (pp[4] - pp[5]) * cos1_4;
+        p[6] = pp[6] + pp[7];
+        p[7] = (pp[6] - pp[7]) * cos1_4;
+        p[8] = pp[8] + pp[9];
+        p[9] = (pp[8] - pp[9]) * cos1_4;
+        p[10] = pp[10] + pp[11];
+        p[11] = (pp[10] - pp[11]) * cos1_4;
+        p[12] = pp[12] + pp[13];
+        p[13] = (pp[12] - pp[13]) * cos1_4;
+        p[14] = pp[14] + pp[15];
+        p[15] = (pp[14] - pp[15]) * cos1_4;
+        
+
+        // manually doing something that a compiler should handle sucks
+        // coding like this is hard to read
+        float tmp2;
+        new_v[5] = (new_v[11] = (new_v[13] = (new_v[15] = p[15]) + p[7]) + p[11])
+                                                        + p[5] + p[13];
+        new_v[7] = (new_v[9] = p[15] + p[11] + p[3]) + p[13];
+        new_v[33-17] = -(new_v[1] = (tmp1 = p[13] + p[15] + p[9]) + p[1]) - p[14];
+        new_v[35-17] = -(new_v[3] = tmp1 + p[5] + p[7]) - p[6] - p[14];
+
+        new_v[39-17] = (tmp1 = -p[10] - p[11] - p[14] - p[15])
+                                                                        - p[13] - p[2] - p[3];
+        new_v[37-17] = tmp1 - p[13] - p[5] - p[6] - p[7];
+        new_v[41-17] = tmp1 - p[12] - p[2] - p[3];
+        new_v[43-17] = tmp1 - p[12] - (tmp2 = p[4] + p[6] + p[7]);
+        new_v[47-17] = (tmp1 = -p[8] - p[12] - p[14] - p[15]) - p[0];
+        new_v[45-17] = tmp1 - tmp2;
+
+        // insert V[0-15] (== new_v[0-15]) into actual v:
+        x1 = new_v;
+        // float[] x2 = actual_v + actual_write_pos;
+        float[] dest = actual_v;
+        
+        dest[0 + actual_write_pos] = x1[0];
+        dest[16 + actual_write_pos] = x1[1];
+        dest[32 + actual_write_pos] = x1[2];
+        dest[48 + actual_write_pos] = x1[3];
+        dest[64 + actual_write_pos] = x1[4];
+        dest[80 + actual_write_pos] = x1[5];
+        dest[96 + actual_write_pos] = x1[6];
+        dest[112 + actual_write_pos] = x1[7];
+        dest[128 + actual_write_pos] = x1[8];
+        dest[144 + actual_write_pos] = x1[9];
+        dest[160 + actual_write_pos] = x1[10];
+        dest[176 + actual_write_pos] = x1[11];
+        dest[192 + actual_write_pos] = x1[12];
+        dest[208 + actual_write_pos] = x1[13];
+        dest[224 + actual_write_pos] = x1[14];
+        dest[240 + actual_write_pos] = x1[15];
+
+        // V[16] is always 0.0:
+        dest[256 + actual_write_pos] = 0.0f;
+
+        // insert V[17-31] (== -new_v[15-1]) into actual v:
+        dest[272 + actual_write_pos] = -x1[15];
+        dest[288 + actual_write_pos] = -x1[14];
+        dest[304 + actual_write_pos] = -x1[13];
+        dest[320 + actual_write_pos] = -x1[12];
+        dest[336 + actual_write_pos] = -x1[11];
+        dest[352 + actual_write_pos] = -x1[10];
+        dest[368 + actual_write_pos] = -x1[9];
+        dest[384 + actual_write_pos] = -x1[8];
+        dest[400 + actual_write_pos] = -x1[7];
+        dest[416 + actual_write_pos] = -x1[6];
+        dest[432 + actual_write_pos] = -x1[5];
+        dest[448 + actual_write_pos] = -x1[4];
+        dest[464 + actual_write_pos] = -x1[3];
+        dest[480 + actual_write_pos] = -x1[2];
+        dest[496 + actual_write_pos] = -x1[1];
+
+        // insert V[32] (== -new_v[0]) into other v:
+        
+  }
+
+  /**
+   * Compute PCM Samples.
+   */
+  
+  private float[] _tmpOut = new float[32];
+  
+  
+  private void compute_pcm_samples0(Obuffer buffer)
+  {
+        final float[] vp = actual_v;    
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                float pcm_sample;
+                final float[] dp = d16[i];
+                pcm_sample = (float)(((vp[0 + dvp] * dp[0]) +
+                        (vp[15 + dvp] * dp[1]) +
+                        (vp[14 + dvp] * dp[2]) +
+                        (vp[13 + dvp] * dp[3]) +
+                        (vp[12 + dvp] * dp[4]) +
+                        (vp[11 + dvp] * dp[5]) +
+                        (vp[10 + dvp] * dp[6]) +
+                        (vp[9 + dvp] * dp[7]) +
+                        (vp[8 + dvp] * dp[8]) +
+                        (vp[7 + dvp] * dp[9]) +
+                        (vp[6 + dvp] * dp[10]) +
+                        (vp[5 + dvp] * dp[11]) +
+                        (vp[4 + dvp] * dp[12]) +
+                        (vp[3 + dvp] * dp[13]) +
+                        (vp[2 + dvp] * dp[14]) +
+                        (vp[1 + dvp] * dp[15])
+                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+        } // for
+  }
+  
+  private void compute_pcm_samples1(Obuffer buffer)
+  {
+        final float[] vp = actual_v;    
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[1 + dvp] * dp[0]) +
+                                        (vp[0 + dvp] * dp[1]) +
+                                        (vp[15 + dvp] * dp[2]) +
+                                        (vp[14 + dvp] * dp[3]) +
+                                        (vp[13 + dvp] * dp[4]) +
+                                        (vp[12 + dvp] * dp[5]) +
+                                        (vp[11 + dvp] * dp[6]) +
+                                        (vp[10 + dvp] * dp[7]) +
+                                        (vp[9 + dvp] * dp[8]) +
+                                        (vp[8 + dvp] * dp[9]) +
+                                        (vp[7 + dvp] * dp[10]) +
+                                        (vp[6 + dvp] * dp[11]) +
+                                        (vp[5 + dvp] * dp[12]) +
+                                        (vp[4 + dvp] * dp[13]) +
+                                        (vp[3 + dvp] * dp[14]) +
+                                        (vp[2 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+         } // for
+  }
+    private void compute_pcm_samples2(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[2 + dvp] * dp[0]) +
+                                        (vp[1 + dvp] * dp[1]) +
+                                        (vp[0 + dvp] * dp[2]) +
+                                        (vp[15 + dvp] * dp[3]) +
+                                        (vp[14 + dvp] * dp[4]) +
+                                        (vp[13 + dvp] * dp[5]) +
+                                        (vp[12 + dvp] * dp[6]) +
+                                        (vp[11 + dvp] * dp[7]) +
+                                        (vp[10 + dvp] * dp[8]) +
+                                        (vp[9 + dvp] * dp[9]) +
+                                        (vp[8 + dvp] * dp[10]) +
+                                        (vp[7 + dvp] * dp[11]) +
+                                        (vp[6 + dvp] * dp[12]) +
+                                        (vp[5 + dvp] * dp[13]) +
+                                        (vp[4 + dvp] * dp[14]) +
+                                        (vp[3 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+        }
+        
+          private void compute_pcm_samples3(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        int idx = 0;
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[3 + dvp] * dp[0]) +
+                                        (vp[2 + dvp] * dp[1]) +
+                                        (vp[1 + dvp] * dp[2]) +
+                                        (vp[0 + dvp] * dp[3]) +
+                                        (vp[15 + dvp] * dp[4]) +
+                                        (vp[14 + dvp] * dp[5]) +
+                                        (vp[13 + dvp] * dp[6]) +
+                                        (vp[12 + dvp] * dp[7]) +
+                                        (vp[11 + dvp] * dp[8]) +
+                                        (vp[10 + dvp] * dp[9]) +
+                                        (vp[9 + dvp] * dp[10]) +
+                                        (vp[8 + dvp] * dp[11]) +
+                                        (vp[7 + dvp] * dp[12]) +
+                                        (vp[6 + dvp] * dp[13]) +
+                                        (vp[5 + dvp] * dp[14]) +
+                                        (vp[4 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+          }
+                        
+  private void compute_pcm_samples4(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[4 + dvp] * dp[0]) +
+                                        (vp[3 + dvp] * dp[1]) +
+                                        (vp[2 + dvp] * dp[2]) +
+                                        (vp[1 + dvp] * dp[3]) +
+                                        (vp[0 + dvp] * dp[4]) +
+                                        (vp[15 + dvp] * dp[5]) +
+                                        (vp[14 + dvp] * dp[6]) +
+                                        (vp[13 + dvp] * dp[7]) +
+                                        (vp[12 + dvp] * dp[8]) +
+                                        (vp[11 + dvp] * dp[9]) +
+                                        (vp[10 + dvp] * dp[10]) +
+                                        (vp[9 + dvp] * dp[11]) +
+                                        (vp[8 + dvp] * dp[12]) +
+                                        (vp[7 + dvp] * dp[13]) +
+                                        (vp[6 + dvp] * dp[14]) +
+                                        (vp[5 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  
+  private void compute_pcm_samples5(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[5 + dvp] * dp[0]) +
+                                        (vp[4 + dvp] * dp[1]) +
+                                        (vp[3 + dvp] * dp[2]) +
+                                        (vp[2 + dvp] * dp[3]) +
+                                        (vp[1 + dvp] * dp[4]) +
+                                        (vp[0 + dvp] * dp[5]) +
+                                        (vp[15 + dvp] * dp[6]) +
+                                        (vp[14 + dvp] * dp[7]) +
+                                        (vp[13 + dvp] * dp[8]) +
+                                        (vp[12 + dvp] * dp[9]) +
+                                        (vp[11 + dvp] * dp[10]) +
+                                        (vp[10 + dvp] * dp[11]) +
+                                        (vp[9 + dvp] * dp[12]) +
+                                        (vp[8 + dvp] * dp[13]) +
+                                        (vp[7 + dvp] * dp[14]) +
+                                        (vp[6 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  
+  private void compute_pcm_samples6(Obuffer buffer)
+  {
+        final float[] vp = actual_v;    
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[6 + dvp] * dp[0]) +
+                                        (vp[5 + dvp] * dp[1]) +
+                                        (vp[4 + dvp] * dp[2]) +
+                                        (vp[3 + dvp] * dp[3]) +
+                                        (vp[2 + dvp] * dp[4]) +
+                                        (vp[1 + dvp] * dp[5]) +
+                                        (vp[0 + dvp] * dp[6]) +
+                                        (vp[15 + dvp] * dp[7]) +
+                                        (vp[14 + dvp] * dp[8]) +
+                                        (vp[13 + dvp] * dp[9]) +
+                                        (vp[12 + dvp] * dp[10]) +
+                                        (vp[11 + dvp] * dp[11]) +
+                                        (vp[10 + dvp] * dp[12]) +
+                                        (vp[9 + dvp] * dp[13]) +
+                                        (vp[8 + dvp] * dp[14]) +
+                                        (vp[7 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  
+    private void compute_pcm_samples7(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[7 + dvp] * dp[0]) +
+                                        (vp[6 + dvp] * dp[1]) +
+                                        (vp[5 + dvp] * dp[2]) +
+                                        (vp[4 + dvp] * dp[3]) +
+                                        (vp[3 + dvp] * dp[4]) +
+                                        (vp[2 + dvp] * dp[5]) +
+                                        (vp[1 + dvp] * dp[6]) +
+                                        (vp[0 + dvp] * dp[7]) +
+                                        (vp[15 + dvp] * dp[8]) +
+                                        (vp[14 + dvp] * dp[9]) +
+                                        (vp[13 + dvp] * dp[10]) +
+                                        (vp[12 + dvp] * dp[11]) +
+                                        (vp[11 + dvp] * dp[12]) +
+                                        (vp[10 + dvp] * dp[13]) +
+                                        (vp[9 + dvp] * dp[14]) +
+                                        (vp[8 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+        }
+  private void compute_pcm_samples8(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[8 + dvp] * dp[0]) +
+                                        (vp[7 + dvp] * dp[1]) +
+                                        (vp[6 + dvp] * dp[2]) +
+                                        (vp[5 + dvp] * dp[3]) +
+                                        (vp[4 + dvp] * dp[4]) +
+                                        (vp[3 + dvp] * dp[5]) +
+                                        (vp[2 + dvp] * dp[6]) +
+                                        (vp[1 + dvp] * dp[7]) +
+                                        (vp[0 + dvp] * dp[8]) +
+                                        (vp[15 + dvp] * dp[9]) +
+                                        (vp[14 + dvp] * dp[10]) +
+                                        (vp[13 + dvp] * dp[11]) +
+                                        (vp[12 + dvp] * dp[12]) +
+                                        (vp[11 + dvp] * dp[13]) +
+                                        (vp[10 + dvp] * dp[14]) +
+                                        (vp[9 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  
+  private void compute_pcm_samples9(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[9 + dvp] * dp[0]) +
+                                        (vp[8 + dvp] * dp[1]) +
+                                        (vp[7 + dvp] * dp[2]) +
+                                        (vp[6 + dvp] * dp[3]) +
+                                        (vp[5 + dvp] * dp[4]) +
+                                        (vp[4 + dvp] * dp[5]) +
+                                        (vp[3 + dvp] * dp[6]) +
+                                        (vp[2 + dvp] * dp[7]) +
+                                        (vp[1 + dvp] * dp[8]) +
+                                        (vp[0 + dvp] * dp[9]) +
+                                        (vp[15 + dvp] * dp[10]) +
+                                        (vp[14 + dvp] * dp[11]) +
+                                        (vp[13 + dvp] * dp[12]) +
+                                        (vp[12 + dvp] * dp[13]) +
+                                        (vp[11 + dvp] * dp[14]) +
+                                        (vp[10 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  
+  private void compute_pcm_samples10(Obuffer buffer)
+  {
+        final float[] vp = actual_v;    
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[10 + dvp] * dp[0]) +
+                                        (vp[9 + dvp] * dp[1]) +
+                                        (vp[8 + dvp] * dp[2]) +
+                                        (vp[7 + dvp] * dp[3]) +
+                                        (vp[6 + dvp] * dp[4]) +
+                                        (vp[5 + dvp] * dp[5]) +
+                                        (vp[4 + dvp] * dp[6]) +
+                                        (vp[3 + dvp] * dp[7]) +
+                                        (vp[2 + dvp] * dp[8]) +
+                                        (vp[1 + dvp] * dp[9]) +
+                                        (vp[0 + dvp] * dp[10]) +
+                                        (vp[15 + dvp] * dp[11]) +
+                                        (vp[14 + dvp] * dp[12]) +
+                                        (vp[13 + dvp] * dp[13]) +
+                                        (vp[12 + dvp] * dp[14]) +
+                                        (vp[11 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  private void compute_pcm_samples11(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[11 + dvp] * dp[0]) +
+                                        (vp[10 + dvp] * dp[1]) +
+                                        (vp[9 + dvp] * dp[2]) +
+                                        (vp[8 + dvp] * dp[3]) +
+                                        (vp[7 + dvp] * dp[4]) +
+                                        (vp[6 + dvp] * dp[5]) +
+                                        (vp[5 + dvp] * dp[6]) +
+                                        (vp[4 + dvp] * dp[7]) +
+                                        (vp[3 + dvp] * dp[8]) +
+                                        (vp[2 + dvp] * dp[9]) +
+                                        (vp[1 + dvp] * dp[10]) +
+                                        (vp[0 + dvp] * dp[11]) +
+                                        (vp[15 + dvp] * dp[12]) +
+                                        (vp[14 + dvp] * dp[13]) +
+                                        (vp[13 + dvp] * dp[14]) +
+                                        (vp[12 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+    private void compute_pcm_samples12(Obuffer buffer)
+  {
+        final float[] vp = actual_v;    
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                            final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[12 + dvp] * dp[0]) +
+                                        (vp[11 + dvp] * dp[1]) +
+                                        (vp[10 + dvp] * dp[2]) +
+                                        (vp[9 + dvp] * dp[3]) +
+                                        (vp[8 + dvp] * dp[4]) +
+                                        (vp[7 + dvp] * dp[5]) +
+                                        (vp[6 + dvp] * dp[6]) +
+                                        (vp[5 + dvp] * dp[7]) +
+                                        (vp[4 + dvp] * dp[8]) +
+                                        (vp[3 + dvp] * dp[9]) +
+                                        (vp[2 + dvp] * dp[10]) +
+                                        (vp[1 + dvp] * dp[11]) +
+                                        (vp[0 + dvp] * dp[12]) +
+                                        (vp[15 + dvp] * dp[13]) +
+                                        (vp[14 + dvp] * dp[14]) +
+                                        (vp[13 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+        }
+  private void compute_pcm_samples13(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[13 + dvp] * dp[0]) +
+                                        (vp[12 + dvp] * dp[1]) +
+                                        (vp[11 + dvp] * dp[2]) +
+                                        (vp[10 + dvp] * dp[3]) +
+                                        (vp[9 + dvp] * dp[4]) +
+                                        (vp[8 + dvp] * dp[5]) +
+                                        (vp[7 + dvp] * dp[6]) +
+                                        (vp[6 + dvp] * dp[7]) +
+                                        (vp[5 + dvp] * dp[8]) +
+                                        (vp[4 + dvp] * dp[9]) +
+                                        (vp[3 + dvp] * dp[10]) +
+                                        (vp[2 + dvp] * dp[11]) +
+                                        (vp[1 + dvp] * dp[12]) +
+                                        (vp[0 + dvp] * dp[13]) +
+                                        (vp[15 + dvp] * dp[14]) +
+                                        (vp[14 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  private void compute_pcm_samples14(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+        
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                final float[] dp = d16[i];
+                                float pcm_sample;
+
+                                pcm_sample = (float)(((vp[14 + dvp] * dp[0]) +
+                                        (vp[13 + dvp] * dp[1]) +
+                                        (vp[12 + dvp] * dp[2]) +
+                                        (vp[11 + dvp] * dp[3]) +
+                                        (vp[10 + dvp] * dp[4]) +
+                                        (vp[9 + dvp] * dp[5]) +
+                                        (vp[8 + dvp] * dp[6]) +
+                                        (vp[7 + dvp] * dp[7]) +
+                                        (vp[6 + dvp] * dp[8]) +
+                                        (vp[5 + dvp] * dp[9]) +
+                                        (vp[4 + dvp] * dp[10]) +
+                                        (vp[3 + dvp] * dp[11]) +
+                                        (vp[2 + dvp] * dp[12]) +
+                                        (vp[1 + dvp] * dp[13]) +
+                                        (vp[0 + dvp] * dp[14]) +
+                                        (vp[15 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;
+                        
+                        dvp += 16;
+                        } // for
+  }
+  private void compute_pcm_samples15(Obuffer buffer)
+  {
+        final float[] vp = actual_v;
+                
+        //int inc = v_inc;
+        final float[] tmpOut = _tmpOut;
+         int dvp =0;
+        
+                        // fat chance of having this loop unroll
+                        for( int i=0; i<32; i++)
+                        {
+                                float pcm_sample;
+                                final float dp[] = d16[i];
+                                pcm_sample = (float)(((vp[15 + dvp] * dp[0]) +
+                                        (vp[14 + dvp] * dp[1]) +
+                                        (vp[13 + dvp] * dp[2]) +
+                                        (vp[12 + dvp] * dp[3]) +
+                                        (vp[11 + dvp] * dp[4]) +
+                                        (vp[10 + dvp] * dp[5]) +
+                                        (vp[9 + dvp] * dp[6]) +
+                                        (vp[8 + dvp] * dp[7]) +
+                                        (vp[7 + dvp] * dp[8]) +
+                                        (vp[6 + dvp] * dp[9]) +
+                                        (vp[5 + dvp] * dp[10]) +
+                                        (vp[4 + dvp] * dp[11]) +
+                                        (vp[3 + dvp] * dp[12]) +
+                                        (vp[2 + dvp] * dp[13]) +
+                                        (vp[1 + dvp] * dp[14]) +
+                                        (vp[0 + dvp] * dp[15])
+                                        ) * scalefactor);
+
+            tmpOut[i] = pcm_sample;                     
+                        dvp += 16;
+                        } // for
+                }
+                                 
+private void compute_pcm_samples(Obuffer buffer)
+{
+        
+        switch (actual_write_pos)
+        {
+        case 0: 
+                compute_pcm_samples0(buffer);
+                break;
+        case 1: 
+                compute_pcm_samples1(buffer);
+                break;
+        case 2: 
+                compute_pcm_samples2(buffer);
+                break;
+        case 3: 
+                compute_pcm_samples3(buffer);
+                break;
+        case 4: 
+                compute_pcm_samples4(buffer);
+                break;
+        case 5: 
+                compute_pcm_samples5(buffer);
+                break;
+        case 6: 
+                compute_pcm_samples6(buffer);
+                break;
+        case 7: 
+                compute_pcm_samples7(buffer);
+                break;
+        case 8: 
+                compute_pcm_samples8(buffer);
+                break;
+        case 9: 
+                compute_pcm_samples9(buffer);
+                break;
+        case 10: 
+                compute_pcm_samples10(buffer);
+                break;
+        case 11: 
+                compute_pcm_samples11(buffer);
+                break;
+        case 12: 
+                compute_pcm_samples12(buffer);
+                break;
+        case 13: 
+                compute_pcm_samples13(buffer);
+                break;
+        case 14: 
+                compute_pcm_samples14(buffer);
+                break;
+        case 15: 
+                compute_pcm_samples15(buffer);
+                break;
+        }
+                
+        if (buffer!=null)
+        {               
+                buffer.appendSamples(channel, _tmpOut);
+        }
+         
+/*
+         // MDM: I was considering putting in quality control for
+         // low-spec CPUs, but the performance gain (about 10-15%) 
+         // did not justify the considerable drop in audio quality.
+                switch (inc)
+                {
+                case 16:                 
+                    buffer.appendSamples(channel, tmpOut);
+                    break;
+                case 32:
+                        for (int i=0; i<16; i++)
+                        {
+                                buffer.append(channel, (short)tmpOut[i]);
+                                buffer.append(channel, (short)tmpOut[i]); 
+                        }
+                        break;                  
+                case 64:
+                        for (int i=0; i<8; i++)
+                        {
+                                buffer.append(channel, (short)tmpOut[i]);
+                                buffer.append(channel, (short)tmpOut[i]);
+                                buffer.append(channel, (short)tmpOut[i]);
+                                buffer.append(channel, (short)tmpOut[i]); 
+                        }
+                        break;                  
+        
+                }
+*/       
+  }
+
+  /**
+   * Calculate 32 PCM samples and put the into the Obuffer-object.
+   */
+        
+  public void calculate_pcm_samples(Obuffer buffer)
+  {
+        compute_new_v();        
+        compute_pcm_samples(buffer);
+    
+        actual_write_pos = (actual_write_pos + 1) & 0xf;
+        actual_v = (actual_v == v1) ? v2 : v1;
+
+        // initialize samples[]:        
+    //for (register float *floatp = samples + 32; floatp > samples; )
+        // *--floatp = 0.0f;  
+        
+        // MDM: this may not be necessary. The Layer III decoder always
+        // outputs 32 subband samples, but I haven't checked layer I & II.
+        for (int p=0;p<32;p++) 
+                samples[p] = 0.0f;
+  }
+  
+  
+  private static final double MY_PI = 3.14159265358979323846;
+  private static final float cos1_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 64.0)));
+  private static final float cos3_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 64.0)));
+  private static final float cos5_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 64.0)));
+  private static final float cos7_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 64.0)));
+  private static final float cos9_64  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0  / 64.0)));
+  private static final float cos11_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 64.0)));
+  private static final float cos13_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 64.0)));
+  private static final float cos15_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 64.0)));
+  private static final float cos17_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 17.0 / 64.0)));
+  private static final float cos19_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 19.0 / 64.0)));
+  private static final float cos21_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 21.0 / 64.0)));
+  private static final float cos23_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 23.0 / 64.0)));
+  private static final float cos25_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 25.0 / 64.0)));
+  private static final float cos27_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 27.0 / 64.0)));
+  private static final float cos29_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 29.0 / 64.0)));
+  private static final float cos31_64 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 31.0 / 64.0)));
+  private static final float cos1_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 32.0)));
+  private static final float cos3_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 32.0)));
+  private static final float cos5_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 32.0)));
+  private static final float cos7_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 32.0)));
+  private static final float cos9_32  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 9.0  / 32.0)));
+  private static final float cos11_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 11.0 / 32.0)));
+  private static final float cos13_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 13.0 / 32.0)));
+  private static final float cos15_32 =(float) (1.0 / (2.0 * Math.cos(MY_PI * 15.0 / 32.0)));
+  private static final float cos1_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 16.0)));
+  private static final float cos3_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 16.0)));
+  private static final float cos5_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 5.0  / 16.0)));
+  private static final float cos7_16  =(float) (1.0 / (2.0 * Math.cos(MY_PI * 7.0  / 16.0)));
+  private static final float cos1_8   =(float) (1.0 / (2.0 * Math.cos(MY_PI        / 8.0)));
+  private static final float cos3_8   =(float) (1.0 / (2.0 * Math.cos(MY_PI * 3.0  / 8.0)));
+  private static final float cos1_4   =(float) (1.0 / (2.0 * Math.cos(MY_PI / 4.0)));
+  
+  // Note: These values are not in the same order
+  // as in Annex 3-B.3 of the ISO/IEC DIS 11172-3 
+  // private float d[] = {0.000000000, -4.000442505};
+  
+  private static float d[] = null;
+  
+  /** 
+   * d[] split into subarrays of length 16. This provides for
+   * more faster access by allowing a block of 16 to be addressed
+   * with constant offset. 
+   **/
+  private static float d16[][] = null;  
+  
+  /**
+   * Loads the data for the d[] from the resource SFd.ser. 
+   * @return the loaded values for d[].
+   */
+        static private float[] load_d()
+        {
+                try
+                {
+                        Class elemType = Float.TYPE;
+                        Object o = JavaLayerUtils.deserializeArrayResource("sfd.ser", elemType, 512);
+                        return (float[])o;
+                }
+                catch (IOException ex)
+                {
+                        throw new ExceptionInInitializerError(ex);
+                }               
+        }
+        
+        /**
+         * Converts a 1D array into a number of smaller arrays. This is used
+         * to achieve offset + constant indexing into an array. Each sub-array
+         * represents a block of values of the original array. 
+         * @param array                 The array to split up into blocks.
+         * @param blockSize             The size of the blocks to split the array
+         *                                              into. This must be an exact divisor of
+         *                                              the length of the array, or some data
+         *                                              will be lost from the main array.
+         * 
+         * @return      An array of arrays in which each element in the returned
+         *                      array will be of length <code>blockSize</code>.
+         */
+        static private float[][] splitArray(final float[] array, final int blockSize)
+        {
+                int size = array.length / blockSize;
+                float[][] split = new float[size][];
+                for (int i=0; i<size; i++)
+                {
+                        split[i] = subArray(array, i*blockSize, blockSize);
+                }
+                return split;
+        }
+        
+        /**
+         * Returns a subarray of an existing array.
+         * 
+         * @param array The array to retrieve a subarra from.
+         * @param offs  The offset in the array that corresponds to
+         *                              the first index of the subarray.
+         * @param len   The number of indeces in the subarray.
+         * @return The subarray, which may be of length 0.
+         */
+        static private float[] subArray(final float[] array, final int offs, int len)
+        {
+                if (offs+len > array.length)
+                {
+                        len = array.length-offs;
+                }
+                
+                if (len < 0)
+                        len = 0;
+                
+                float[] subarray = new float[len];
+                for (int i=0; i<len; i++)
+                {
+                        subarray[i] = array[offs+i];
+                }
+                
+                return subarray;
+        }
+        
+        // The original data for d[]. This data is loaded from a file
+        // to reduce the overall package size and to improve performance. 
+/*  
+  static final float d_data[] = {
+        0.000000000f, -0.000442505f,  0.003250122f, -0.007003784f,
+        0.031082153f, -0.078628540f,  0.100311279f, -0.572036743f,
+        1.144989014f,  0.572036743f,  0.100311279f,  0.078628540f,
+        0.031082153f,  0.007003784f,  0.003250122f,  0.000442505f,
+   -0.000015259f, -0.000473022f,  0.003326416f, -0.007919312f,
+        0.030517578f, -0.084182739f,  0.090927124f, -0.600219727f,
+        1.144287109f,  0.543823242f,  0.108856201f,  0.073059082f,
+        0.031478882f,  0.006118774f,  0.003173828f,  0.000396729f,
+   -0.000015259f, -0.000534058f,  0.003387451f, -0.008865356f,
+        0.029785156f, -0.089706421f,  0.080688477f, -0.628295898f,
+        1.142211914f,  0.515609741f,  0.116577148f,  0.067520142f,
+    0.031738281f,  0.005294800f,  0.003082275f,  0.000366211f,
+   -0.000015259f, -0.000579834f,  0.003433228f, -0.009841919f,
+    0.028884888f, -0.095169067f,  0.069595337f, -0.656219482f,
+        1.138763428f,  0.487472534f,  0.123474121f,  0.061996460f,
+    0.031845093f,  0.004486084f,  0.002990723f,  0.000320435f,
+   -0.000015259f, -0.000625610f,  0.003463745f, -0.010848999f,
+    0.027801514f, -0.100540161f,  0.057617188f, -0.683914185f,
+        1.133926392f,  0.459472656f,  0.129577637f,  0.056533813f,
+        0.031814575f,  0.003723145f,  0.002899170f,  0.000289917f,
+   -0.000015259f, -0.000686646f,  0.003479004f, -0.011886597f,
+        0.026535034f, -0.105819702f,  0.044784546f, -0.711318970f,
+        1.127746582f,  0.431655884f,  0.134887695f,  0.051132202f,
+        0.031661987f,  0.003005981f,  0.002792358f,  0.000259399f,
+   -0.000015259f, -0.000747681f,  0.003479004f, -0.012939453f,
+        0.025085449f, -0.110946655f,  0.031082153f, -0.738372803f,
+    1.120223999f,  0.404083252f,  0.139450073f,  0.045837402f,
+    0.031387329f,  0.002334595f,  0.002685547f,  0.000244141f,
+   -0.000030518f, -0.000808716f,  0.003463745f, -0.014022827f,
+    0.023422241f, -0.115921021f,  0.016510010f, -0.765029907f,
+        1.111373901f,  0.376800537f,  0.143264771f,  0.040634155f,
+    0.031005859f,  0.001693726f,  0.002578735f,  0.000213623f,
+   -0.000030518f, -0.000885010f,  0.003417969f, -0.015121460f,
+        0.021575928f, -0.120697021f,  0.001068115f, -0.791213989f,
+    1.101211548f,  0.349868774f,  0.146362305f,  0.035552979f,
+        0.030532837f,  0.001098633f,  0.002456665f,  0.000198364f,
+   -0.000030518f, -0.000961304f,  0.003372192f, -0.016235352f,
+    0.019531250f, -0.125259399f, -0.015228271f, -0.816864014f,
+        1.089782715f,  0.323318481f,  0.148773193f,  0.030609131f,
+        0.029937744f,  0.000549316f,  0.002349854f,  0.000167847f,
+   -0.000030518f, -0.001037598f,  0.003280640f, -0.017349243f,
+        0.017257690f, -0.129562378f, -0.032379150f, -0.841949463f,
+    1.077117920f,  0.297210693f,  0.150497437f,  0.025817871f,
+    0.029281616f,  0.000030518f,  0.002243042f,  0.000152588f,
+   -0.000045776f, -0.001113892f,  0.003173828f, -0.018463135f,
+        0.014801025f, -0.133590698f, -0.050354004f, -0.866363525f,
+        1.063217163f,  0.271591187f,  0.151596069f,  0.021179199f,
+        0.028533936f, -0.000442505f,  0.002120972f,  0.000137329f,
+   -0.000045776f, -0.001205444f,  0.003051758f, -0.019577026f,
+        0.012115479f, -0.137298584f, -0.069168091f, -0.890090942f,
+        1.048156738f,  0.246505737f,  0.152069092f,  0.016708374f,
+        0.027725220f, -0.000869751f,  0.002014160f,  0.000122070f,
+   -0.000061035f, -0.001296997f,  0.002883911f, -0.020690918f,
+    0.009231567f, -0.140670776f, -0.088775635f, -0.913055420f,
+        1.031936646f,  0.221984863f,  0.151962280f,  0.012420654f,
+    0.026840210f, -0.001266479f,  0.001907349f,  0.000106812f,
+   -0.000061035f, -0.001388550f,  0.002700806f, -0.021789551f,
+        0.006134033f, -0.143676758f, -0.109161377f, -0.935195923f,
+    1.014617920f,  0.198059082f,  0.151306152f,  0.008316040f,
+        0.025909424f, -0.001617432f,  0.001785278f,  0.000106812f,
+   -0.000076294f, -0.001480103f,  0.002487183f, -0.022857666f,
+        0.002822876f, -0.146255493f, -0.130310059f, -0.956481934f,
+        0.996246338f,  0.174789429f,  0.150115967f,  0.004394531f,
+    0.024932861f, -0.001937866f,  0.001693726f,  0.000091553f,
+   -0.000076294f, -0.001586914f,  0.002227783f, -0.023910522f,
+   -0.000686646f, -0.148422241f, -0.152206421f, -0.976852417f,
+    0.976852417f,  0.152206421f,  0.148422241f,  0.000686646f,
+        0.023910522f, -0.002227783f,  0.001586914f,  0.000076294f,
+   -0.000091553f, -0.001693726f,  0.001937866f, -0.024932861f,
+   -0.004394531f, -0.150115967f, -0.174789429f, -0.996246338f,
+    0.956481934f,  0.130310059f,  0.146255493f, -0.002822876f,
+    0.022857666f, -0.002487183f,  0.001480103f,  0.000076294f,
+   -0.000106812f, -0.001785278f,  0.001617432f, -0.025909424f,
+   -0.008316040f, -0.151306152f, -0.198059082f, -1.014617920f,
+    0.935195923f,  0.109161377f,  0.143676758f, -0.006134033f,
+    0.021789551f, -0.002700806f,  0.001388550f,  0.000061035f,
+   -0.000106812f, -0.001907349f,  0.001266479f, -0.026840210f,
+   -0.012420654f, -0.151962280f, -0.221984863f, -1.031936646f,
+        0.913055420f,  0.088775635f,  0.140670776f, -0.009231567f,
+        0.020690918f, -0.002883911f,  0.001296997f,  0.000061035f,
+   -0.000122070f, -0.002014160f,  0.000869751f, -0.027725220f,
+   -0.016708374f, -0.152069092f, -0.246505737f, -1.048156738f,
+    0.890090942f,  0.069168091f,  0.137298584f, -0.012115479f,
+        0.019577026f, -0.003051758f,  0.001205444f,  0.000045776f,
+   -0.000137329f, -0.002120972f,  0.000442505f, -0.028533936f,
+   -0.021179199f, -0.151596069f, -0.271591187f, -1.063217163f,
+    0.866363525f,  0.050354004f,  0.133590698f, -0.014801025f,
+    0.018463135f, -0.003173828f,  0.001113892f,  0.000045776f,
+   -0.000152588f, -0.002243042f, -0.000030518f, -0.029281616f,
+   -0.025817871f, -0.150497437f, -0.297210693f, -1.077117920f,
+        0.841949463f,  0.032379150f,  0.129562378f, -0.017257690f,
+        0.017349243f, -0.003280640f,  0.001037598f,  0.000030518f,
+   -0.000167847f, -0.002349854f, -0.000549316f, -0.029937744f,
+   -0.030609131f, -0.148773193f, -0.323318481f, -1.089782715f,
+        0.816864014f,  0.015228271f,  0.125259399f, -0.019531250f,
+    0.016235352f, -0.003372192f,  0.000961304f,  0.000030518f,
+   -0.000198364f, -0.002456665f, -0.001098633f, -0.030532837f,
+   -0.035552979f, -0.146362305f, -0.349868774f, -1.101211548f,
+        0.791213989f, -0.001068115f,  0.120697021f, -0.021575928f,
+        0.015121460f, -0.003417969f,  0.000885010f,  0.000030518f,
+   -0.000213623f, -0.002578735f, -0.001693726f, -0.031005859f,
+   -0.040634155f, -0.143264771f, -0.376800537f, -1.111373901f,
+    0.765029907f, -0.016510010f,  0.115921021f, -0.023422241f,
+    0.014022827f, -0.003463745f,  0.000808716f,  0.000030518f,
+   -0.000244141f, -0.002685547f, -0.002334595f, -0.031387329f,
+   -0.045837402f, -0.139450073f, -0.404083252f, -1.120223999f,
+    0.738372803f, -0.031082153f,  0.110946655f, -0.025085449f,
+        0.012939453f, -0.003479004f,  0.000747681f,  0.000015259f,
+   -0.000259399f, -0.002792358f, -0.003005981f, -0.031661987f,
+   -0.051132202f, -0.134887695f, -0.431655884f, -1.127746582f,
+        0.711318970f, -0.044784546f,  0.105819702f, -0.026535034f,
+    0.011886597f, -0.003479004f,  0.000686646f,  0.000015259f,
+   -0.000289917f, -0.002899170f, -0.003723145f, -0.031814575f,
+   -0.056533813f, -0.129577637f, -0.459472656f, -1.133926392f,
+    0.683914185f, -0.057617188f,  0.100540161f, -0.027801514f,
+        0.010848999f, -0.003463745f,  0.000625610f,  0.000015259f,
+   -0.000320435f, -0.002990723f, -0.004486084f, -0.031845093f,
+   -0.061996460f, -0.123474121f, -0.487472534f, -1.138763428f,
+        0.656219482f, -0.069595337f,  0.095169067f, -0.028884888f,
+        0.009841919f, -0.003433228f,  0.000579834f,  0.000015259f,
+   -0.000366211f, -0.003082275f, -0.005294800f, -0.031738281f,
+   -0.067520142f, -0.116577148f, -0.515609741f, -1.142211914f,
+        0.628295898f, -0.080688477f,  0.089706421f, -0.029785156f,
+        0.008865356f, -0.003387451f,  0.000534058f,  0.000015259f,
+   -0.000396729f, -0.003173828f, -0.006118774f, -0.031478882f,
+   -0.073059082f, -0.108856201f, -0.543823242f, -1.144287109f,
+        0.600219727f, -0.090927124f,  0.084182739f, -0.030517578f,
+        0.007919312f, -0.003326416f,  0.000473022f,  0.000015259f
+        };
+  */
+  
+}
diff --git a/songdbj/javazoom/jl/decoder/au2lin.ser b/songdbj/javazoom/jl/decoder/au2lin.ser
new file mode 100644
index 0000000000..de0d1f62d9
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/au2lin.ser
diff --git a/songdbj/javazoom/jl/decoder/huffcodetab.java b/songdbj/javazoom/jl/decoder/huffcodetab.java
new file mode 100644
index 0000000000..86975646f0
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/huffcodetab.java
@@ -0,0 +1,600 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 16/11/99 Renamed class, added javadoc, and changed table
+ *                      name from String to 3 chars. mdm@techie.com
+ * 02/15/99 Java Conversion by E.B, javalayer@javazoom.net
+ *
+ * 04/19/97 : Adapted from the ISO MPEG Audio Subgroup Software Simulation
+ *  Group's public c source for its MPEG audio decoder. Miscellaneous
+ *  changes by Jeff Tsay (ctsay@pasteur.eecs.berkeley.edu).
+ *-----------------------------------------------------------------------
+ * Copyright (c) 1991 MPEG/audio software simulation group, All Rights Reserved
+ * MPEG/audio coding/decoding software, work in progress              
+ *   NOT for public distribution until verified and approved by the   
+ *   MPEG/audio committee.  For further information, please contact   
+ *   Davis Pan, 508-493-2241, e-mail: pan@3d.enet.dec.com             
+ *                                                                    
+ * VERSION 4.1                                                        
+ *   changes made since last update:                                  
+ *   date   programmers         comment                        
+ *  27.2.92 F.O.Witte (ITT Intermetall)                                           
+ *  8/24/93 M. Iwadare          Changed for 1 pass decoding.          
+ *  7/14/94 J. Koller               useless 'typedef' before huffcodetab  removed
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.decoder;
+
+/**
+ * Class to implements Huffman decoder.
+ */
+final class huffcodetab
+{
+  private static final int       MXOFF=250;
+  private static final int       HTN=34;
+  
+  private char                           tablename0 = ' ';      /* string, containing table_description   */
+  private char                           tablename1 = ' ';      /* string, containing table_description   */
+  private char                           tablename2 = ' ';      /* string, containing table_description   */
+  
+  private int                            xlen;                          /* max. x-index+                          */
+  private int                            ylen;                  /* max. y-index+                                          */
+  private int                            linbits;                       /* number of linbits                      */
+  private int                            linmax;                        /* max number to be stored in linbits     */
+  private int                            ref;                           /* a positive value indicates a reference */
+  private int[]                          table=null;            /* pointer to array[xlen][ylen]               */
+  private int[]                          hlen=null;             /* pointer to array[xlen][ylen]               */
+  private int[][]                        val=null;                      /* decoder tree                               */
+  private int                            treelen;                   /* length of decoder tree                 */
+
+  private static int ValTab0[][] = {
+        {0,0}   // dummy
+        };
+
+  private static int ValTab1[][] = {
+        {2,1},{0,0},{2,1},{0,16},{2,1},{0,1},{0,17},
+        };
+        
+  private static int ValTab2[][] = {
+        {2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{2,1},{0,17},{4,1},{2,1},
+        {0,32},{0,33},{2,1},{0,18},{2,1},{0,2},{0,34},
+        };
+        
+  private static int ValTab3[][] = {
+        {4,1},{2,1},{0,0},{0,1},{2,1},{0,17},{2,1},{0,16},{4,1},{2,1},
+        {0,32},{0,33},{2,1},{0,18},{2,1},{0,2},{0,34},
+        };
+
+  private static int ValTab4[][] = {{0,0}};     // dummy
+
+  private static int ValTab5[][] = {
+        {2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{2,1},{0,17},{8,1},{4,1},
+        {2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{8,1},{4,1},{2,1},{0,34},
+        {0,48},{2,1},{0,3},{0,19},{2,1},{0,49},{2,1},{0,50},{2,1},{0,35},
+        {0,51},
+        };
+
+  private static int ValTab6[][] = {
+        {6,1},{4,1},{2,1},{0,0},{0,16},{0,17},{6,1},{2,1},{0,1},{2,1},
+        {0,32},{0,33},{6,1},{2,1},{0,18},{2,1},{0,2},{0,34},{4,1},{2,1},
+        {0,49},{0,19},{4,1},{2,1},{0,48},{0,50},{2,1},{0,35},{2,1},{0,3},
+        {0,51},
+        };
+        
+  private static int ValTab7[][] = {
+        {2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{8,1},{2,1},{0,17},{4,1},
+        {2,1},{0,32},{0,2},{0,33},{18,1},{6,1},{2,1},{0,18},{2,1},{0,34},
+        {0,48},{4,1},{2,1},{0,49},{0,19},{4,1},{2,1},{0,3},{0,50},{2,1},
+        {0,35},{0,4},{10,1},{4,1},{2,1},{0,64},{0,65},{2,1},{0,20},{2,1},
+        {0,66},{0,36},{12,1},{6,1},{4,1},{2,1},{0,51},{0,67},{0,80},{4,1},
+        {2,1},{0,52},{0,5},{0,81},{6,1},{2,1},{0,21},{2,1},{0,82},{0,37},
+        {4,1},{2,1},{0,68},{0,53},{4,1},{2,1},{0,83},{0,84},{2,1},{0,69},
+        {0,85},
+        };
+        
+  private static int ValTab8[][] = {
+        {6,1},{2,1},{0,0},{2,1},{0,16},{0,1},{2,1},{0,17},{4,1},{2,1},
+        {0,33},{0,18},{14,1},{4,1},{2,1},{0,32},{0,2},{2,1},{0,34},{4,1},
+        {2,1},{0,48},{0,3},{2,1},{0,49},{0,19},{14,1},{8,1},{4,1},{2,1},
+        {0,50},{0,35},{2,1},{0,64},{0,4},{2,1},{0,65},{2,1},{0,20},{0,66},
+        {12,1},{6,1},{2,1},{0,36},{2,1},{0,51},{0,80},{4,1},{2,1},{0,67},
+        {0,52},{0,81},{6,1},{2,1},{0,21},{2,1},{0,5},{0,82},{6,1},{2,1},
+        {0,37},{2,1},{0,68},{0,53},{2,1},{0,83},{2,1},{0,69},{2,1},{0,84},
+        {0,85},
+        };
+        
+  private static int ValTab9[][] = {
+        {8,1},{4,1},{2,1},{0,0},{0,16},{2,1},{0,1},{0,17},{10,1},{4,1},
+        {2,1},{0,32},{0,33},{2,1},{0,18},{2,1},{0,2},{0,34},{12,1},{6,1},
+        {4,1},{2,1},{0,48},{0,3},{0,49},{2,1},{0,19},{2,1},{0,50},{0,35},
+        {12,1},{4,1},{2,1},{0,65},{0,20},{4,1},{2,1},{0,64},{0,51},{2,1},
+        {0,66},{0,36},{10,1},{6,1},{4,1},{2,1},{0,4},{0,80},{0,67},{2,1},
+        {0,52},{0,81},{8,1},{4,1},{2,1},{0,21},{0,82},{2,1},{0,37},{0,68},
+        {6,1},{4,1},{2,1},{0,5},{0,84},{0,83},{2,1},{0,53},{2,1},{0,69},
+        {0,85},
+        };
+        
+  private static int ValTab10[][] = {
+        {2,1},{0,0},{4,1},{2,1},{0,16},{0,1},{10,1},{2,1},{0,17},{4,1},
+        {2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{28,1},{8,1},{4,1},{2,1},
+        {0,34},{0,48},{2,1},{0,49},{0,19},{8,1},{4,1},{2,1},{0,3},{0,50},
+        {2,1},{0,35},{0,64},{4,1},{2,1},{0,65},{0,20},{4,1},{2,1},{0,4},
+        {0,51},{2,1},{0,66},{0,36},{28,1},{10,1},{6,1},{4,1},{2,1},{0,80},
+        {0,5},{0,96},{2,1},{0,97},{0,22},{12,1},{6,1},{4,1},{2,1},{0,67},
+        {0,52},{0,81},{2,1},{0,21},{2,1},{0,82},{0,37},{4,1},{2,1},{0,38},
+        {0,54},{0,113},{20,1},{8,1},{2,1},{0,23},{4,1},{2,1},{0,68},{0,83},
+        {0,6},{6,1},{4,1},{2,1},{0,53},{0,69},{0,98},{2,1},{0,112},{2,1},
+        {0,7},{0,100},{14,1},{4,1},{2,1},{0,114},{0,39},{6,1},{2,1},{0,99},
+        {2,1},{0,84},{0,85},{2,1},{0,70},{0,115},{8,1},{4,1},{2,1},{0,55},
+        {0,101},{2,1},{0,86},{0,116},{6,1},{2,1},{0,71},{2,1},{0,102},{0,117},
+        {4,1},{2,1},{0,87},{0,118},{2,1},{0,103},{0,119},
+        };
+
+  private static int ValTab11[][] = {
+        {6,1},{2,1},{0,0},{2,1},{0,16},{0,1},{8,1},{2,1},{0,17},{4,1},
+        {2,1},{0,32},{0,2},{0,18},{24,1},{8,1},{2,1},{0,33},{2,1},{0,34},
+        {2,1},{0,48},{0,3},{4,1},{2,1},{0,49},{0,19},{4,1},{2,1},{0,50},
+        {0,35},{4,1},{2,1},{0,64},{0,4},{2,1},{0,65},{0,20},{30,1},{16,1},
+        {10,1},{4,1},{2,1},{0,66},{0,36},{4,1},{2,1},{0,51},{0,67},{0,80},
+        {4,1},{2,1},{0,52},{0,81},{0,97},{6,1},{2,1},{0,22},{2,1},{0,6},
+        {0,38},{2,1},{0,98},{2,1},{0,21},{2,1},{0,5},{0,82},{16,1},{10,1},
+        {6,1},{4,1},{2,1},{0,37},{0,68},{0,96},{2,1},{0,99},{0,54},{4,1},
+        {2,1},{0,112},{0,23},{0,113},{16,1},{6,1},{4,1},{2,1},{0,7},{0,100},
+        {0,114},{2,1},{0,39},{4,1},{2,1},{0,83},{0,53},{2,1},{0,84},{0,69},
+        {10,1},{4,1},{2,1},{0,70},{0,115},{2,1},{0,55},{2,1},{0,101},{0,86},
+        {10,1},{6,1},{4,1},{2,1},{0,85},{0,87},{0,116},{2,1},{0,71},{0,102},
+        {4,1},{2,1},{0,117},{0,118},{2,1},{0,103},{0,119},
+        };
+
+  private static int ValTab12[][] = {
+        {12,1},{4,1},{2,1},{0,16},{0,1},{2,1},{0,17},{2,1},{0,0},{2,1},
+        {0,32},{0,2},{16,1},{4,1},{2,1},{0,33},{0,18},{4,1},{2,1},{0,34},
+        {0,49},{2,1},{0,19},{2,1},{0,48},{2,1},{0,3},{0,64},{26,1},{8,1},
+        {4,1},{2,1},{0,50},{0,35},{2,1},{0,65},{0,51},{10,1},{4,1},{2,1},
+        {0,20},{0,66},{2,1},{0,36},{2,1},{0,4},{0,80},{4,1},{2,1},{0,67},
+        {0,52},{2,1},{0,81},{0,21},{28,1},{14,1},{8,1},{4,1},{2,1},{0,82},
+        {0,37},{2,1},{0,83},{0,53},{4,1},{2,1},{0,96},{0,22},{0,97},{4,1},
+        {2,1},{0,98},{0,38},{6,1},{4,1},{2,1},{0,5},{0,6},{0,68},{2,1},
+        {0,84},{0,69},{18,1},{10,1},{4,1},{2,1},{0,99},{0,54},{4,1},{2,1},
+        {0,112},{0,7},{0,113},{4,1},{2,1},{0,23},{0,100},{2,1},{0,70},{0,114},
+        {10,1},{6,1},{2,1},{0,39},{2,1},{0,85},{0,115},{2,1},{0,55},{0,86},
+        {8,1},{4,1},{2,1},{0,101},{0,116},{2,1},{0,71},{0,102},{4,1},{2,1},
+        {0,117},{0,87},{2,1},{0,118},{2,1},{0,103},{0,119},
+        };
+
+  private static int ValTab13[][] = {
+        {2,1},{0,0},{6,1},{2,1},{0,16},{2,1},{0,1},{0,17},{28,1},{8,1},
+        {4,1},{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{8,1},{4,1},{2,1},
+        {0,34},{0,48},{2,1},{0,3},{0,49},{6,1},{2,1},{0,19},{2,1},{0,50},
+        {0,35},{4,1},{2,1},{0,64},{0,4},{0,65},{70,1},{28,1},{14,1},{6,1},
+        {2,1},{0,20},{2,1},{0,51},{0,66},{4,1},{2,1},{0,36},{0,80},{2,1},
+        {0,67},{0,52},{4,1},{2,1},{0,81},{0,21},{4,1},{2,1},{0,5},{0,82},
+        {2,1},{0,37},{2,1},{0,68},{0,83},{14,1},{8,1},{4,1},{2,1},{0,96},
+        {0,6},{2,1},{0,97},{0,22},{4,1},{2,1},{0,128},{0,8},{0,129},{16,1},
+        {8,1},{4,1},{2,1},{0,53},{0,98},{2,1},{0,38},{0,84},{4,1},{2,1},
+        {0,69},{0,99},{2,1},{0,54},{0,112},{6,1},{4,1},{2,1},{0,7},{0,85},
+        {0,113},{2,1},{0,23},{2,1},{0,39},{0,55},{72,1},{24,1},{12,1},{4,1},
+        {2,1},{0,24},{0,130},{2,1},{0,40},{4,1},{2,1},{0,100},{0,70},{0,114},
+        {8,1},{4,1},{2,1},{0,132},{0,72},{2,1},{0,144},{0,9},{2,1},{0,145},
+        {0,25},{24,1},{14,1},{8,1},{4,1},{2,1},{0,115},{0,101},{2,1},{0,86},
+        {0,116},{4,1},{2,1},{0,71},{0,102},{0,131},{6,1},{2,1},{0,56},{2,1},
+        {0,117},{0,87},{2,1},{0,146},{0,41},{14,1},{8,1},{4,1},{2,1},{0,103},
+        {0,133},{2,1},{0,88},{0,57},{2,1},{0,147},{2,1},{0,73},{0,134},{6,1},
+        {2,1},{0,160},{2,1},{0,104},{0,10},{2,1},{0,161},{0,26},{68,1},{24,1},
+        {12,1},{4,1},{2,1},{0,162},{0,42},{4,1},{2,1},{0,149},{0,89},{2,1},
+        {0,163},{0,58},{8,1},{4,1},{2,1},{0,74},{0,150},{2,1},{0,176},{0,11},
+        {2,1},{0,177},{0,27},{20,1},{8,1},{2,1},{0,178},{4,1},{2,1},{0,118},
+        {0,119},{0,148},{6,1},{4,1},{2,1},{0,135},{0,120},{0,164},{4,1},{2,1},
+        {0,105},{0,165},{0,43},{12,1},{6,1},{4,1},{2,1},{0,90},{0,136},{0,179},
+        {2,1},{0,59},{2,1},{0,121},{0,166},{6,1},{4,1},{2,1},{0,106},{0,180},
+        {0,192},{4,1},{2,1},{0,12},{0,152},{0,193},{60,1},{22,1},{10,1},{6,1},
+        {2,1},{0,28},{2,1},{0,137},{0,181},{2,1},{0,91},{0,194},{4,1},{2,1},
+        {0,44},{0,60},{4,1},{2,1},{0,182},{0,107},{2,1},{0,196},{0,76},{16,1},
+        {8,1},{4,1},{2,1},{0,168},{0,138},{2,1},{0,208},{0,13},{2,1},{0,209},
+        {2,1},{0,75},{2,1},{0,151},{0,167},{12,1},{6,1},{2,1},{0,195},{2,1},
+        {0,122},{0,153},{4,1},{2,1},{0,197},{0,92},{0,183},{4,1},{2,1},{0,29},
+        {0,210},{2,1},{0,45},{2,1},{0,123},{0,211},{52,1},{28,1},{12,1},{4,1},
+        {2,1},{0,61},{0,198},{4,1},{2,1},{0,108},{0,169},{2,1},{0,154},{0,212},
+        {8,1},{4,1},{2,1},{0,184},{0,139},{2,1},{0,77},{0,199},{4,1},{2,1},
+        {0,124},{0,213},{2,1},{0,93},{0,224},{10,1},{4,1},{2,1},{0,225},{0,30},
+        {4,1},{2,1},{0,14},{0,46},{0,226},{8,1},{4,1},{2,1},{0,227},{0,109},
+        {2,1},{0,140},{0,228},{4,1},{2,1},{0,229},{0,186},{0,240},{38,1},{16,1},
+        {4,1},{2,1},{0,241},{0,31},{6,1},{4,1},{2,1},{0,170},{0,155},{0,185},
+        {2,1},{0,62},{2,1},{0,214},{0,200},{12,1},{6,1},{2,1},{0,78},{2,1},
+        {0,215},{0,125},{2,1},{0,171},{2,1},{0,94},{0,201},{6,1},{2,1},{0,15},
+        {2,1},{0,156},{0,110},{2,1},{0,242},{0,47},{32,1},{16,1},{6,1},{4,1},
+        {2,1},{0,216},{0,141},{0,63},{6,1},{2,1},{0,243},{2,1},{0,230},{0,202},
+        {2,1},{0,244},{0,79},{8,1},{4,1},{2,1},{0,187},{0,172},{2,1},{0,231},
+        {0,245},{4,1},{2,1},{0,217},{0,157},{2,1},{0,95},{0,232},{30,1},{12,1},
+        {6,1},{2,1},{0,111},{2,1},{0,246},{0,203},{4,1},{2,1},{0,188},{0,173},
+        {0,218},{8,1},{2,1},{0,247},{4,1},{2,1},{0,126},{0,127},{0,142},{6,1},
+        {4,1},{2,1},{0,158},{0,174},{0,204},{2,1},{0,248},{0,143},{18,1},{8,1},
+        {4,1},{2,1},{0,219},{0,189},{2,1},{0,234},{0,249},{4,1},{2,1},{0,159},
+        {0,235},{2,1},{0,190},{2,1},{0,205},{0,250},{14,1},{4,1},{2,1},{0,221},
+        {0,236},{6,1},{4,1},{2,1},{0,233},{0,175},{0,220},{2,1},{0,206},{0,251},
+        {8,1},{4,1},{2,1},{0,191},{0,222},{2,1},{0,207},{0,238},{4,1},{2,1},
+        {0,223},{0,239},{2,1},{0,255},{2,1},{0,237},{2,1},{0,253},{2,1},{0,252},
+        {0,254},
+        };
+
+  private static int ValTab14[][] = {
+        {0,0}  // dummy
+        };
+
+  private static int ValTab15[][] = {
+        {16,1},{6,1},{2,1},{0,0},{2,1},{0,16},{0,1},{2,1},{0,17},{4,1},
+        {2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{50,1},{16,1},{6,1},{2,1},
+        {0,34},{2,1},{0,48},{0,49},{6,1},{2,1},{0,19},{2,1},{0,3},{0,64},
+        {2,1},{0,50},{0,35},{14,1},{6,1},{4,1},{2,1},{0,4},{0,20},{0,65},
+        {4,1},{2,1},{0,51},{0,66},{2,1},{0,36},{0,67},{10,1},{6,1},{2,1},
+        {0,52},{2,1},{0,80},{0,5},{2,1},{0,81},{0,21},{4,1},{2,1},{0,82},
+        {0,37},{4,1},{2,1},{0,68},{0,83},{0,97},{90,1},{36,1},{18,1},{10,1},
+        {6,1},{2,1},{0,53},{2,1},{0,96},{0,6},{2,1},{0,22},{0,98},{4,1},
+        {2,1},{0,38},{0,84},{2,1},{0,69},{0,99},{10,1},{6,1},{2,1},{0,54},
+        {2,1},{0,112},{0,7},{2,1},{0,113},{0,85},{4,1},{2,1},{0,23},{0,100},
+        {2,1},{0,114},{0,39},{24,1},{16,1},{8,1},{4,1},{2,1},{0,70},{0,115},
+        {2,1},{0,55},{0,101},{4,1},{2,1},{0,86},{0,128},{2,1},{0,8},{0,116},
+        {4,1},{2,1},{0,129},{0,24},{2,1},{0,130},{0,40},{16,1},{8,1},{4,1},
+        {2,1},{0,71},{0,102},{2,1},{0,131},{0,56},{4,1},{2,1},{0,117},{0,87},
+        {2,1},{0,132},{0,72},{6,1},{4,1},{2,1},{0,144},{0,25},{0,145},{4,1},
+        {2,1},{0,146},{0,118},{2,1},{0,103},{0,41},{92,1},{36,1},{18,1},{10,1},
+        {4,1},{2,1},{0,133},{0,88},{4,1},{2,1},{0,9},{0,119},{0,147},{4,1},
+        {2,1},{0,57},{0,148},{2,1},{0,73},{0,134},{10,1},{6,1},{2,1},{0,104},
+        {2,1},{0,160},{0,10},{2,1},{0,161},{0,26},{4,1},{2,1},{0,162},{0,42},
+        {2,1},{0,149},{0,89},{26,1},{14,1},{6,1},{2,1},{0,163},{2,1},{0,58},
+        {0,135},{4,1},{2,1},{0,120},{0,164},{2,1},{0,74},{0,150},{6,1},{4,1},
+        {2,1},{0,105},{0,176},{0,177},{4,1},{2,1},{0,27},{0,165},{0,178},{14,1},
+        {8,1},{4,1},{2,1},{0,90},{0,43},{2,1},{0,136},{0,151},{2,1},{0,179},
+        {2,1},{0,121},{0,59},{8,1},{4,1},{2,1},{0,106},{0,180},{2,1},{0,75},
+        {0,193},{4,1},{2,1},{0,152},{0,137},{2,1},{0,28},{0,181},{80,1},{34,1},
+        {16,1},{6,1},{4,1},{2,1},{0,91},{0,44},{0,194},{6,1},{4,1},{2,1},
+        {0,11},{0,192},{0,166},{2,1},{0,167},{0,122},{10,1},{4,1},{2,1},{0,195},
+        {0,60},{4,1},{2,1},{0,12},{0,153},{0,182},{4,1},{2,1},{0,107},{0,196},
+        {2,1},{0,76},{0,168},{20,1},{10,1},{4,1},{2,1},{0,138},{0,197},{4,1},
+        {2,1},{0,208},{0,92},{0,209},{4,1},{2,1},{0,183},{0,123},{2,1},{0,29},
+        {2,1},{0,13},{0,45},{12,1},{4,1},{2,1},{0,210},{0,211},{4,1},{2,1},
+        {0,61},{0,198},{2,1},{0,108},{0,169},{6,1},{4,1},{2,1},{0,154},{0,184},
+        {0,212},{4,1},{2,1},{0,139},{0,77},{2,1},{0,199},{0,124},{68,1},{34,1},
+        {18,1},{10,1},{4,1},{2,1},{0,213},{0,93},{4,1},{2,1},{0,224},{0,14},
+        {0,225},{4,1},{2,1},{0,30},{0,226},{2,1},{0,170},{0,46},{8,1},{4,1},
+        {2,1},{0,185},{0,155},{2,1},{0,227},{0,214},{4,1},{2,1},{0,109},{0,62},
+        {2,1},{0,200},{0,140},{16,1},{8,1},{4,1},{2,1},{0,228},{0,78},{2,1},
+        {0,215},{0,125},{4,1},{2,1},{0,229},{0,186},{2,1},{0,171},{0,94},{8,1},
+        {4,1},{2,1},{0,201},{0,156},{2,1},{0,241},{0,31},{6,1},{4,1},{2,1},
+        {0,240},{0,110},{0,242},{2,1},{0,47},{0,230},{38,1},{18,1},{8,1},{4,1},
+        {2,1},{0,216},{0,243},{2,1},{0,63},{0,244},{6,1},{2,1},{0,79},{2,1},
+        {0,141},{0,217},{2,1},{0,187},{0,202},{8,1},{4,1},{2,1},{0,172},{0,231},
+        {2,1},{0,126},{0,245},{8,1},{4,1},{2,1},{0,157},{0,95},{2,1},{0,232},
+        {0,142},{2,1},{0,246},{0,203},{34,1},{18,1},{10,1},{6,1},{4,1},{2,1},
+        {0,15},{0,174},{0,111},{2,1},{0,188},{0,218},{4,1},{2,1},{0,173},{0,247},
+        {2,1},{0,127},{0,233},{8,1},{4,1},{2,1},{0,158},{0,204},{2,1},{0,248},
+        {0,143},{4,1},{2,1},{0,219},{0,189},{2,1},{0,234},{0,249},{16,1},{8,1},
+        {4,1},{2,1},{0,159},{0,220},{2,1},{0,205},{0,235},{4,1},{2,1},{0,190},
+        {0,250},{2,1},{0,175},{0,221},{14,1},{6,1},{4,1},{2,1},{0,236},{0,206},
+        {0,251},{4,1},{2,1},{0,191},{0,237},{2,1},{0,222},{0,252},{6,1},{4,1},
+        {2,1},{0,207},{0,253},{0,238},{4,1},{2,1},{0,223},{0,254},{2,1},{0,239},
+        {0,255},
+        };
+
+  private static int  ValTab16[][] = {
+        {2,1},{0,0},{6,1},{2,1},{0,16},{2,1},{0,1},{0,17},{42,1},{8,1},
+        {4,1},{2,1},{0,32},{0,2},{2,1},{0,33},{0,18},{10,1},{6,1},{2,1},
+        {0,34},{2,1},{0,48},{0,3},{2,1},{0,49},{0,19},{10,1},{4,1},{2,1},
+        {0,50},{0,35},{4,1},{2,1},{0,64},{0,4},{0,65},{6,1},{2,1},{0,20},
+        {2,1},{0,51},{0,66},{4,1},{2,1},{0,36},{0,80},{2,1},{0,67},{0,52},
+        {138,1},{40,1},{16,1},{6,1},{4,1},{2,1},{0,5},{0,21},{0,81},{4,1},
+        {2,1},{0,82},{0,37},{4,1},{2,1},{0,68},{0,53},{0,83},{10,1},{6,1},
+        {4,1},{2,1},{0,96},{0,6},{0,97},{2,1},{0,22},{0,98},{8,1},{4,1},
+        {2,1},{0,38},{0,84},{2,1},{0,69},{0,99},{4,1},{2,1},{0,54},{0,112},
+        {0,113},{40,1},{18,1},{8,1},{2,1},{0,23},{2,1},{0,7},{2,1},{0,85},
+        {0,100},{4,1},{2,1},{0,114},{0,39},{4,1},{2,1},{0,70},{0,101},{0,115},
+        {10,1},{6,1},{2,1},{0,55},{2,1},{0,86},{0,8},{2,1},{0,128},{0,129},
+        {6,1},{2,1},{0,24},{2,1},{0,116},{0,71},{2,1},{0,130},{2,1},{0,40},
+        {0,102},{24,1},{14,1},{8,1},{4,1},{2,1},{0,131},{0,56},{2,1},{0,117},
+        {0,132},{4,1},{2,1},{0,72},{0,144},{0,145},{6,1},{2,1},{0,25},{2,1},
+        {0,9},{0,118},{2,1},{0,146},{0,41},{14,1},{8,1},{4,1},{2,1},{0,133},
+        {0,88},{2,1},{0,147},{0,57},{4,1},{2,1},{0,160},{0,10},{0,26},{8,1},
+        {2,1},{0,162},{2,1},{0,103},{2,1},{0,87},{0,73},{6,1},{2,1},{0,148},
+        {2,1},{0,119},{0,134},{2,1},{0,161},{2,1},{0,104},{0,149},{220,1},{126,1},
+        {50,1},{26,1},{12,1},{6,1},{2,1},{0,42},{2,1},{0,89},{0,58},{2,1},
+        {0,163},{2,1},{0,135},{0,120},{8,1},{4,1},{2,1},{0,164},{0,74},{2,1},
+        {0,150},{0,105},{4,1},{2,1},{0,176},{0,11},{0,177},{10,1},{4,1},{2,1},
+        {0,27},{0,178},{2,1},{0,43},{2,1},{0,165},{0,90},{6,1},{2,1},{0,179},
+        {2,1},{0,166},{0,106},{4,1},{2,1},{0,180},{0,75},{2,1},{0,12},{0,193},
+        {30,1},{14,1},{6,1},{4,1},{2,1},{0,181},{0,194},{0,44},{4,1},{2,1},
+        {0,167},{0,195},{2,1},{0,107},{0,196},{8,1},{2,1},{0,29},{4,1},{2,1},
+        {0,136},{0,151},{0,59},{4,1},{2,1},{0,209},{0,210},{2,1},{0,45},{0,211},
+        {18,1},{6,1},{4,1},{2,1},{0,30},{0,46},{0,226},{6,1},{4,1},{2,1},
+        {0,121},{0,152},{0,192},{2,1},{0,28},{2,1},{0,137},{0,91},{14,1},{6,1},
+        {2,1},{0,60},{2,1},{0,122},{0,182},{4,1},{2,1},{0,76},{0,153},{2,1},
+        {0,168},{0,138},{6,1},{2,1},{0,13},{2,1},{0,197},{0,92},{4,1},{2,1},
+        {0,61},{0,198},{2,1},{0,108},{0,154},{88,1},{86,1},{36,1},{16,1},{8,1},
+        {4,1},{2,1},{0,139},{0,77},{2,1},{0,199},{0,124},{4,1},{2,1},{0,213},
+        {0,93},{2,1},{0,224},{0,14},{8,1},{2,1},{0,227},{4,1},{2,1},{0,208},
+        {0,183},{0,123},{6,1},{4,1},{2,1},{0,169},{0,184},{0,212},{2,1},{0,225},
+        {2,1},{0,170},{0,185},{24,1},{10,1},{6,1},{4,1},{2,1},{0,155},{0,214},
+        {0,109},{2,1},{0,62},{0,200},{6,1},{4,1},{2,1},{0,140},{0,228},{0,78},
+        {4,1},{2,1},{0,215},{0,229},{2,1},{0,186},{0,171},{12,1},{4,1},{2,1},
+        {0,156},{0,230},{4,1},{2,1},{0,110},{0,216},{2,1},{0,141},{0,187},{8,1},
+        {4,1},{2,1},{0,231},{0,157},{2,1},{0,232},{0,142},{4,1},{2,1},{0,203},
+        {0,188},{0,158},{0,241},{2,1},{0,31},{2,1},{0,15},{0,47},{66,1},{56,1},
+        {2,1},{0,242},{52,1},{50,1},{20,1},{8,1},{2,1},{0,189},{2,1},{0,94},
+        {2,1},{0,125},{0,201},{6,1},{2,1},{0,202},{2,1},{0,172},{0,126},{4,1},
+        {2,1},{0,218},{0,173},{0,204},{10,1},{6,1},{2,1},{0,174},{2,1},{0,219},
+        {0,220},{2,1},{0,205},{0,190},{6,1},{4,1},{2,1},{0,235},{0,237},{0,238},
+        {6,1},{4,1},{2,1},{0,217},{0,234},{0,233},{2,1},{0,222},{4,1},{2,1},
+        {0,221},{0,236},{0,206},{0,63},{0,240},{4,1},{2,1},{0,243},{0,244},{2,1},
+        {0,79},{2,1},{0,245},{0,95},{10,1},{2,1},{0,255},{4,1},{2,1},{0,246},
+        {0,111},{2,1},{0,247},{0,127},{12,1},{6,1},{2,1},{0,143},{2,1},{0,248},
+        {0,249},{4,1},{2,1},{0,159},{0,250},{0,175},{8,1},{4,1},{2,1},{0,251},
+        {0,191},{2,1},{0,252},{0,207},{4,1},{2,1},{0,253},{0,223},{2,1},{0,254},
+        {0,239},
+        };
+        
+  private static int ValTab24[][] = {
+        {60,1},{8,1},{4,1},{2,1},{0,0},{0,16},{2,1},{0,1},{0,17},{14,1},
+        {6,1},{4,1},{2,1},{0,32},{0,2},{0,33},{2,1},{0,18},{2,1},{0,34},
+        {2,1},{0,48},{0,3},{14,1},{4,1},{2,1},{0,49},{0,19},{4,1},{2,1},
+        {0,50},{0,35},{4,1},{2,1},{0,64},{0,4},{0,65},{8,1},{4,1},{2,1},
+        {0,20},{0,51},{2,1},{0,66},{0,36},{6,1},{4,1},{2,1},{0,67},{0,52},
+        {0,81},{6,1},{4,1},{2,1},{0,80},{0,5},{0,21},{2,1},{0,82},{0,37},
+        {250,1},{98,1},{34,1},{18,1},{10,1},{4,1},{2,1},{0,68},{0,83},{2,1},
+        {0,53},{2,1},{0,96},{0,6},{4,1},{2,1},{0,97},{0,22},{2,1},{0,98},
+        {0,38},{8,1},{4,1},{2,1},{0,84},{0,69},{2,1},{0,99},{0,54},{4,1},
+        {2,1},{0,113},{0,85},{2,1},{0,100},{0,70},{32,1},{14,1},{6,1},{2,1},
+        {0,114},{2,1},{0,39},{0,55},{2,1},{0,115},{4,1},{2,1},{0,112},{0,7},
+        {0,23},{10,1},{4,1},{2,1},{0,101},{0,86},{4,1},{2,1},{0,128},{0,8},
+        {0,129},{4,1},{2,1},{0,116},{0,71},{2,1},{0,24},{0,130},{16,1},{8,1},
+        {4,1},{2,1},{0,40},{0,102},{2,1},{0,131},{0,56},{4,1},{2,1},{0,117},
+        {0,87},{2,1},{0,132},{0,72},{8,1},{4,1},{2,1},{0,145},{0,25},{2,1},
+        {0,146},{0,118},{4,1},{2,1},{0,103},{0,41},{2,1},{0,133},{0,88},{92,1},
+        {34,1},{16,1},{8,1},{4,1},{2,1},{0,147},{0,57},{2,1},{0,148},{0,73},
+        {4,1},{2,1},{0,119},{0,134},{2,1},{0,104},{0,161},{8,1},{4,1},{2,1},
+        {0,162},{0,42},{2,1},{0,149},{0,89},{4,1},{2,1},{0,163},{0,58},{2,1},
+        {0,135},{2,1},{0,120},{0,74},{22,1},{12,1},{4,1},{2,1},{0,164},{0,150},
+        {4,1},{2,1},{0,105},{0,177},{2,1},{0,27},{0,165},{6,1},{2,1},{0,178},
+        {2,1},{0,90},{0,43},{2,1},{0,136},{0,179},{16,1},{10,1},{6,1},{2,1},
+        {0,144},{2,1},{0,9},{0,160},{2,1},{0,151},{0,121},{4,1},{2,1},{0,166},
+        {0,106},{0,180},{12,1},{6,1},{2,1},{0,26},{2,1},{0,10},{0,176},{2,1},
+        {0,59},{2,1},{0,11},{0,192},{4,1},{2,1},{0,75},{0,193},{2,1},{0,152},
+        {0,137},{67,1},{34,1},{16,1},{8,1},{4,1},{2,1},{0,28},{0,181},{2,1},
+        {0,91},{0,194},{4,1},{2,1},{0,44},{0,167},{2,1},{0,122},{0,195},{10,1},
+        {6,1},{2,1},{0,60},{2,1},{0,12},{0,208},{2,1},{0,182},{0,107},{4,1},
+        {2,1},{0,196},{0,76},{2,1},{0,153},{0,168},{16,1},{8,1},{4,1},{2,1},
+        {0,138},{0,197},{2,1},{0,92},{0,209},{4,1},{2,1},{0,183},{0,123},{2,1},
+        {0,29},{0,210},{9,1},{4,1},{2,1},{0,45},{0,211},{2,1},{0,61},{0,198},
+        {85,250},{4,1},{2,1},{0,108},{0,169},{2,1},{0,154},{0,212},{32,1},{16,1},
+        {8,1},{4,1},{2,1},{0,184},{0,139},{2,1},{0,77},{0,199},{4,1},{2,1},
+        {0,124},{0,213},{2,1},{0,93},{0,225},{8,1},{4,1},{2,1},{0,30},{0,226},
+        {2,1},{0,170},{0,185},{4,1},{2,1},{0,155},{0,227},{2,1},{0,214},{0,109},
+        {20,1},{10,1},{6,1},{2,1},{0,62},{2,1},{0,46},{0,78},{2,1},{0,200},
+        {0,140},{4,1},{2,1},{0,228},{0,215},{4,1},{2,1},{0,125},{0,171},{0,229},
+        {10,1},{4,1},{2,1},{0,186},{0,94},{2,1},{0,201},{2,1},{0,156},{0,110},
+        {8,1},{2,1},{0,230},{2,1},{0,13},{2,1},{0,224},{0,14},{4,1},{2,1},
+        {0,216},{0,141},{2,1},{0,187},{0,202},{74,1},{2,1},{0,255},{64,1},{58,1},
+        {32,1},{16,1},{8,1},{4,1},{2,1},{0,172},{0,231},{2,1},{0,126},{0,217},
+        {4,1},{2,1},{0,157},{0,232},{2,1},{0,142},{0,203},{8,1},{4,1},{2,1},
+        {0,188},{0,218},{2,1},{0,173},{0,233},{4,1},{2,1},{0,158},{0,204},{2,1},
+        {0,219},{0,189},{16,1},{8,1},{4,1},{2,1},{0,234},{0,174},{2,1},{0,220},
+        {0,205},{4,1},{2,1},{0,235},{0,190},{2,1},{0,221},{0,236},{8,1},{4,1},
+        {2,1},{0,206},{0,237},{2,1},{0,222},{0,238},{0,15},{4,1},{2,1},{0,240},
+        {0,31},{0,241},{4,1},{2,1},{0,242},{0,47},{2,1},{0,243},{0,63},{18,1},
+        {8,1},{4,1},{2,1},{0,244},{0,79},{2,1},{0,245},{0,95},{4,1},{2,1},
+        {0,246},{0,111},{2,1},{0,247},{2,1},{0,127},{0,143},{10,1},{4,1},{2,1},
+        {0,248},{0,249},{4,1},{2,1},{0,159},{0,175},{0,250},{8,1},{4,1},{2,1},
+        {0,251},{0,191},{2,1},{0,252},{0,207},{4,1},{2,1},{0,253},{0,223},{2,1},
+        {0,254},{0,239},
+        };
+        
+  private static int ValTab32[][] = {
+        {2,1},{0,0},{8,1},{4,1},{2,1},{0,8},{0,4},{2,1},{0,1},{0,2},
+        {8,1},{4,1},{2,1},{0,12},{0,10},{2,1},{0,3},{0,6},{6,1},{2,1},
+        {0,9},{2,1},{0,5},{0,7},{4,1},{2,1},{0,14},{0,13},{2,1},{0,15},
+        {0,11},
+        };
+
+  private static int ValTab33[][] = {
+        {16,1},{8,1},{4,1},{2,1},{0,0},{0,1},{2,1},{0,2},{0,3},{4,1},
+        {2,1},{0,4},{0,5},{2,1},{0,6},{0,7},{8,1},{4,1},{2,1},{0,8},
+        {0,9},{2,1},{0,10},{0,11},{4,1},{2,1},{0,12},{0,13},{2,1},{0,14},
+        {0,15},
+        };
+
+
+  public static huffcodetab[]  ht = null;     /* Simulate extern struct                 */
+
+  private static int[] bitbuf = new int[32];
+  
+  /**
+   * Big Constructor : Computes all Huffman Tables.
+   */
+  private huffcodetab(String S,int XLEN, int YLEN, int LINBITS, int LINMAX, int REF,
+                     int[] TABLE, int[] HLEN, int[][] VAL, int TREELEN)                     
+  {
+    tablename0 = S.charAt(0);
+        tablename1 = S.charAt(1);
+        tablename2 = S.charAt(2);
+    xlen = XLEN;
+    ylen = YLEN;
+    linbits = LINBITS;
+    linmax = LINMAX;
+    ref = REF;
+    table = TABLE;
+    hlen = HLEN;
+    val = VAL;
+    treelen = TREELEN;
+  }
+
+  
+  
+  /**
+   * Do the huffman-decoding.
+   * note! for counta,countb -the 4 bit value is returned in y,
+   * discard x.
+   */
+  public static int huffman_decoder(huffcodetab h, int[] x, int[] y, int[] v, int[] w, BitReserve br)
+  {
+        // array of all huffcodtable headers
+        // 0..31 Huffman code table 0..31
+        // 32,33 count1-tables
+
+        int dmask = 1 << ((4 * 8) - 1);
+        int hs    = 4 * 8;
+        int level;
+        int point = 0;
+        int error = 1;
+        level = dmask;
+
+        if (h.val == null) return 2;
+
+     /* table 0 needs no bits */
+     if ( h.treelen == 0)
+         { 
+           x[0] = y[0] = 0;
+           return 0;
+     }
+
+     /* Lookup in Huffman table. */
+
+         /*int bitsAvailable = 0;        
+         int bitIndex = 0;
+         
+         int bits[] = bitbuf;*/
+         do 
+         {
+            if (h.val[point][0]==0)
+                {   /*end of tree*/
+                   x[0] = h.val[point][1] >>> 4;
+                   y[0] = h.val[point][1] & 0xf;
+                   error = 0;
+                   break;
+            }
+            
+                // hget1bit() is called thousands of times, and so needs to be
+                // ultra fast. 
+                /*
+                if (bitIndex==bitsAvailable)
+                {
+                        bitsAvailable = br.readBits(bits, 32);                  
+                        bitIndex = 0;
+                }
+                */
+                //if (bits[bitIndex++]!=0)
+                if (br.hget1bit()!=0)
+                {
+                   while (h.val[point][1] >= MXOFF) point += h.val[point][1];
+                   point += h.val[point][1];
+            }
+            else
+                {
+                   while (h.val[point][0] >= MXOFF) point += h.val[point][0];
+                   point += h.val[point][0];
+            }
+            level >>>= 1;
+                // MDM: ht[0] is always 0;
+         } while ((level !=0 )  || (point < 0 /*ht[0].treelen*/) );
+                
+                // put back any bits not consumed
+        /*      
+         int unread = (bitsAvailable-bitIndex);
+                if (unread>0)
+                        br.rewindNbits(unread);
+         */
+          /* Process sign encodings for quadruples tables. */
+      // System.out.println(h.tablename);
+          if (h.tablename0 == '3' && (h.tablename1 == '2' || h.tablename1 == '3'))
+          {
+                v[0] = (y[0]>>3) & 1;
+                w[0] = (y[0]>>2) & 1;
+                x[0] = (y[0]>>1) & 1;
+                y[0] = y[0] & 1;
+
+            /* v, w, x and y are reversed in the bitstream.
+                  switch them around to make test bistream work. */
+
+                if (v[0]!=0)
+                  if (br.hget1bit() != 0) v[0] = -v[0];
+                if (w[0]!=0)
+                  if (br.hget1bit() != 0) w[0] = -w[0];
+                if (x[0]!=0)
+                  if (br.hget1bit() != 0) x[0] = -x[0];
+                if (y[0]!=0)
+                  if (br.hget1bit() != 0) y[0] = -y[0];
+       }
+           else
+           {
+                  // Process sign and escape encodings for dual tables.
+                  // x and y are reversed in the test bitstream.
+                  // Reverse x and y here to make test bitstream work.
+
+              if (h.linbits != 0)
+                   if ((h.xlen-1) == x[0])
+                        x[0] += br.hgetbits(h.linbits);
+                  if (x[0] != 0)
+                          if (br.hget1bit() != 0) x[0] = -x[0];
+                  if (h.linbits != 0)
+                         if ((h.ylen-1) == y[0])
+                                y[0] += br.hgetbits(h.linbits);
+                  if (y[0] != 0)
+                          if (br.hget1bit() != 0) y[0] = -y[0];
+           }
+           return error;
+  }
+
+  public static void inithuff()
+  {
+        
+        if (ht!=null)
+                return;
+        
+        ht = new huffcodetab[HTN];
+    ht[0] = new huffcodetab("0  ",0,0,0,0,-1,null,null,ValTab0,0);
+    ht[1] = new huffcodetab("1  ",2,2,0,0,-1,null,null,ValTab1,7);
+    ht[2] = new huffcodetab("2  ",3,3,0,0,-1,null,null,ValTab2,17);
+    ht[3] = new huffcodetab("3  ",3,3,0,0,-1,null,null,ValTab3,17);
+    ht[4] = new huffcodetab("4  ",0,0,0,0,-1,null,null,ValTab4,0);    
+    ht[5] = new huffcodetab("5  ",4,4,0,0,-1,null,null,ValTab5,31);
+    ht[6] = new huffcodetab("6  ",4,4,0,0,-1,null,null,ValTab6,31);
+    ht[7] = new huffcodetab("7  ",6,6,0,0,-1,null,null,ValTab7,71);
+    ht[8] = new huffcodetab("8  ",6,6,0,0,-1,null,null,ValTab8,71);
+    ht[9] = new huffcodetab("9  ",6,6,0,0,-1,null,null,ValTab9,71);
+    ht[10] = new huffcodetab("10 ",8,8,0,0,-1,null,null,ValTab10,127);  
+    ht[11] = new huffcodetab("11 ",8,8,0,0,-1,null,null,ValTab11,127);
+    ht[12] = new huffcodetab("12 ",8,8,0,0,-1,null,null,ValTab12,127);
+    ht[13] = new huffcodetab("13 ",16,16,0,0,-1,null,null,ValTab13,511);
+    ht[14] = new huffcodetab("14 ",0,0,0,0,-1,null,null,ValTab14,0);
+    ht[15] = new huffcodetab("15 ",16,16,0,0,-1,null,null,ValTab15,511);
+    ht[16] = new huffcodetab("16 ",16,16,1,1,-1,null,null,ValTab16,511);
+    ht[17] = new huffcodetab("17 ",16,16,2,3,16,null,null,ValTab16,511);
+    ht[18] = new huffcodetab("18 ",16,16,3,7,16,null,null,ValTab16,511);
+    ht[19] = new huffcodetab("19 ",16,16,4,15,16,null,null,ValTab16,511);
+    ht[20] = new huffcodetab("20 ",16,16,6,63,16,null,null,ValTab16,511);
+    ht[21] = new huffcodetab("21 ",16,16,8,255,16,null,null,ValTab16,511);
+    ht[22] = new huffcodetab("22 ",16,16,10,1023,16,null,null,ValTab16,511);
+    ht[23] = new huffcodetab("23 ",16,16,13,8191,16,null,null,ValTab16,511);
+    ht[24] = new huffcodetab("24 ",16,16,4,15,-1,null,null,ValTab24,512);
+    ht[25] = new huffcodetab("25 ",16,16,5,31,24,null,null,ValTab24,512);
+    ht[26] = new huffcodetab("26 ",16,16,6,63,24,null,null,ValTab24,512);
+    ht[27] = new huffcodetab("27 ",16,16,7,127,24,null,null,ValTab24,512);
+        ht[28] = new huffcodetab("28 ",16,16,8,255,24,null,null,ValTab24,512);  
+    ht[29] = new huffcodetab("29 ",16,16,9,511,24,null,null,ValTab24,512);
+    ht[30] = new huffcodetab("30 ",16,16,11,2047,24,null,null,ValTab24,512);
+    ht[31] = new huffcodetab("31 ",16,16,13,8191,24,null,null,ValTab24,512);
+    ht[32] = new huffcodetab("32 ",1,16,0,0,-1,null,null,ValTab32,31);
+    ht[33] = new huffcodetab("33 ",1,16,0,0,-1,null,null,ValTab33,31);
+  }
+}
diff --git a/songdbj/javazoom/jl/decoder/l3reorder.ser b/songdbj/javazoom/jl/decoder/l3reorder.ser
new file mode 100644
index 0000000000..d7e3e0fa61
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/l3reorder.ser
diff --git a/songdbj/javazoom/jl/decoder/lin2au.ser b/songdbj/javazoom/jl/decoder/lin2au.ser
new file mode 100644
index 0000000000..258231516e
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/lin2au.ser
diff --git a/songdbj/javazoom/jl/decoder/readme.txt b/songdbj/javazoom/jl/decoder/readme.txt
new file mode 100644
index 0000000000..7a765ec7dc
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/readme.txt
@@ -0,0 +1,15 @@
+
+TODO:
+
+
+Implement high-level Player and Converter classes.
+
+Add MP1 and MP2 support and test. 
+
+Add option to run each "stage" on own thread. 
+E.g. read & parse input, decode subbands, subband synthesis, audio output.
+
+Retrofit seek support (temporarily removed when reworking classes.)
+
+
+Document and give example code. 
\ No newline at end of file
diff --git a/songdbj/javazoom/jl/decoder/sfd.ser b/songdbj/javazoom/jl/decoder/sfd.ser
new file mode 100644
index 0000000000..e65b782f36
--- /dev/null
+++ b/songdbj/javazoom/jl/decoder/sfd.ser
diff --git a/songdbj/javazoom/jl/player/AudioDevice.java b/songdbj/javazoom/jl/player/AudioDevice.java
new file mode 100644
index 0000000000..45c28600e6
--- /dev/null
+++ b/songdbj/javazoom/jl/player/AudioDevice.java
@@ -0,0 +1,103 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * The <code>AudioDevice</code> interface provides an abstraction for
+ * a device capable of sounding audio samples. Samples are written to 
+ * the device wia the write() method. The device assumes
+ * that these samples are signed 16-bit samples taken at the output frequency
+ * of the decoder. If the decoder outputs more than one channel, the samples for
+ * each channel are assumed to appear consecutively, with the lower numbered
+ * channels preceeding higher-numbered channels. E.g. if there are two
+ * channels, the samples will appear in this order:
+ * <pre><code>
+ * 
+ *              l0, r0, l1, r1, l2, r2...
+ * 
+ * where 
+ *      l<i>x</i> indicates the <i>x</i>th sample on channel 0
+ *  r<i>x</i> indicates the <i>x</i>th sample on channel 1
+ * </code></pre>
+ *   
+ * @since       0.0.8
+ * @author      Mat McGowan
+ */
+public interface AudioDevice
+{
+        /**
+         * Prepares the AudioDevice for playback of audio samples. 
+         * @param decoder       The decoder that will be providing the audio
+         *                                      samples. 
+         * 
+         * If the audio device is already open, this method returns silently. 
+         * 
+         */
+        public void open(Decoder decoder) throws JavaLayerException;
+                
+        /**
+         * Retrieves the open state of this audio device. 
+         * 
+         * @return <code>true</code> if this audio device is open and playing
+         *                      audio samples, or <code>false</code> otherwise. 
+         */
+        public boolean isOpen();
+        
+        /**
+         * Writes a number of samples to this <code>AudioDevice</code>. 
+         * 
+         * @param samples       The array of signed 16-bit samples to write
+         *                                      to the audio device. 
+         * @param offs          The offset of the first sample.
+         * @param len           The number of samples to write. 
+         * 
+         * This method may return prior to the samples actually being played 
+         * by the audio device. 
+         */
+        public void write(short[] samples, int offs, int len) throws JavaLayerException;
+                
+        
+        /**
+         * Closes this audio device. Any currently playing audio is stopped 
+         * as soon as possible. Any previously written audio data that has not been heard
+         * is discarded. 
+         * 
+         * The implementation should ensure that any threads currently blocking
+         * on the device (e.g. during a <code>write</code> or <code>flush</code>
+         * operation should be unblocked by this method. 
+         */
+        public void close();
+        
+        
+        /**
+         * Blocks until all audio samples previously written to this audio device have
+         * been heard. 
+         */
+        public void flush();
+                        
+        /**
+         * Retrieves the current playback position in milliseconds. 
+         */
+        public int getPosition();
+}
diff --git a/songdbj/javazoom/jl/player/AudioDeviceBase.java b/songdbj/javazoom/jl/player/AudioDeviceBase.java
new file mode 100644
index 0000000000..d9c84f08e7
--- /dev/null
+++ b/songdbj/javazoom/jl/player/AudioDeviceBase.java
@@ -0,0 +1,177 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * The <code>AudioDeviceBase</code> class provides a simple thread-safe
+ * implementation of the <code>AudioDevice</code> interface. 
+ * Template methods are provided for subclasses to override and
+ * in doing so provide the implementation for the main operations
+ * of the <code>AudioDevice</code> interface. 
+ * 
+ * @since       0.0.8
+ * @author      Mat McGowan
+ */
+/*
+ * REVIEW:  It is desirable to be able to use the decoder whe
+ *                      in the implementation of open(), but the decoder
+ *                      has not yet read a frame, and so much of the 
+ *                      desired information (sample rate, channels etc.)
+ *                      are not available. 
+ */
+public abstract class AudioDeviceBase implements AudioDevice
+{
+        private boolean                 open = false;
+        
+        private Decoder                 decoder = null;
+        
+        /**
+         * Opens this audio device. 
+         * 
+         * @param decoder       The decoder that will provide audio data
+         *                                      to this audio device. 
+         */
+        public synchronized void open(Decoder decoder) throws JavaLayerException
+        {
+                if (!isOpen())
+                {
+                        this.decoder = decoder;
+                        openImpl();
+                        setOpen(true);
+                }
+        }
+        
+        /**
+         * Template method to provide the 
+         * implementation for the opening of the audio device. 
+         */
+        protected void openImpl() throws JavaLayerException
+        {                       
+        }
+        
+        /**
+         * Sets the open state for this audio device. 
+         */
+        protected void setOpen(boolean open)
+        {
+                this.open = open;
+        }
+        
+        /**
+         * Determines if this audio device is open or not. 
+         * 
+         * @return <code>true</code> if the audio device is open,
+         *              <code>false</code> if it is not.         
+         */
+        public synchronized boolean isOpen()
+        {
+                return open;    
+        }
+        
+        /**
+         * Closes this audio device. If the device is currently playing 
+         * audio, playback is stopped immediately without flushing
+         * any buffered audio data. 
+         */
+        public synchronized void close()
+        {
+                if (isOpen())
+                {
+                        closeImpl();
+                        setOpen(false); 
+                        decoder = null;
+                }
+        }
+        
+        /**
+         * Template method to provide the implementation for
+         * closing the audio device. 
+         */
+        protected void closeImpl()
+        {
+        }
+        
+        /**
+         * Writes audio data to this audio device. Audio data is
+         * assumed to be in the output format of the decoder. This
+         * method may return before the data has actually been sounded
+         * by the device if the device buffers audio samples. 
+         * 
+         * @param samples       The samples to write to the audio device.
+         * @param offs          The offset into the array of the first sample to write.
+         * @param len           The number of samples from the array to write. 
+         * @throws JavaLayerException if the audio data could not be
+         *                      written to the audio device. 
+         * If the audio device is not open, this method does nthing. 
+         */
+        public void write(short[] samples, int offs, int len) 
+                throws JavaLayerException
+        {
+                if (isOpen())
+                {
+                        writeImpl(samples, offs, len);
+                }
+        }
+        
+        /**
+         * Template method to provide the implementation for
+         * writing audio samples to the audio device. 
+         */
+        protected void writeImpl(short[] samples, int offs, int len) 
+                throws JavaLayerException
+        {
+        }
+        
+        /**
+         * Waits for any buffered audio samples to be played by the
+         * audio device. This method should only be called prior 
+         * to closing the device. 
+         */
+        public void flush()
+        {
+                if (isOpen())
+                {
+                        flushImpl();    
+                }
+        }
+        
+        /**
+         * Template method to provide the implementation for 
+         * flushing any buffered audio data. 
+         */
+        protected void flushImpl()
+        {               
+        }
+                        
+        /**
+         * Retrieves the decoder that provides audio data to this
+         * audio device.
+         * 
+         * @return The associated decoder. 
+         */
+        protected Decoder getDecoder()
+        {
+                return decoder; 
+        }
+}
diff --git a/songdbj/javazoom/jl/player/AudioDeviceFactory.java b/songdbj/javazoom/jl/player/AudioDeviceFactory.java
new file mode 100644
index 0000000000..2d502d2aad
--- /dev/null
+++ b/songdbj/javazoom/jl/player/AudioDeviceFactory.java
@@ -0,0 +1,87 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * An <code>AudioDeviceFactory</code> class is responsible for creating
+ * a specific <code>AudioDevice</code> implementation. A factory implementation
+ * can be as simple or complex as desired and may support just one implementation
+ * or may return several implementations depending upon the execution
+ * environment. 
+ * <p>
+ * When implementing a factory that provides an AudioDevice that uses
+ * class that may not be present, the factory should dynamically link to any
+ * specific implementation classes required to instantiate or test the audio
+ * implementation. This is so that the application as a whole
+ * can run without these classes being present. The audio
+ * device implementation, however, will usually statically link to the classes
+ * required. (See the JavaSound deivce and factory for an example
+ * of this.)
+ * 
+ * @see FactoryRegistry
+ * 
+ * @since       0.0.8
+ * @author      Mat McGowan
+ */
+public abstract class AudioDeviceFactory
+{
+        /**
+         * Creates a new <code>AudioDevice</code>.
+         * 
+         * @return      a new instance of a specific class of <code>AudioDevice</code>.
+         * @throws      JavaLayerException if an instance of AudioDevice could not
+         *                      be created. 
+         */
+        public abstract AudioDevice createAudioDevice() throws JavaLayerException;
+        
+        /**
+         * Creates an instance of an AudioDevice implementation. 
+         * @param loader        The <code>ClassLoader</code> to use to
+         *                                      load the named class, or null to use the
+         *                                      system class loader.
+         * @param name          The name of the class to load.
+         * @return                      A newly-created instance of the audio device class.
+         */
+        protected AudioDevice instantiate(ClassLoader loader, String name)
+                throws ClassNotFoundException, 
+                           IllegalAccessException, 
+                           InstantiationException
+        {
+                AudioDevice dev = null;
+                
+                Class cls = null;
+                if (loader==null)
+                {
+                        cls = Class.forName(name);
+                }
+                else
+                {
+                        cls = loader.loadClass(name);   
+                }
+
+                Object o = cls.newInstance();
+                dev = (AudioDevice)o;
+                
+                return dev;
+        }
+}
diff --git a/songdbj/javazoom/jl/player/FactoryRegistry.java b/songdbj/javazoom/jl/player/FactoryRegistry.java
new file mode 100644
index 0000000000..8919995802
--- /dev/null
+++ b/songdbj/javazoom/jl/player/FactoryRegistry.java
@@ -0,0 +1,129 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * The <code>FactoryRegistry</code> class stores the factories
+ * for all the audio device implementations available in the system. 
+ * <p>
+ * Instances of this class are thread-safe. 
+ * 
+ * @since 0.0.8
+ * @author Mat McGowan
+ */
+
+public class FactoryRegistry extends AudioDeviceFactory
+{
+        static private FactoryRegistry instance = null;
+        
+        static synchronized public FactoryRegistry systemRegistry()
+        {
+                if (instance==null)
+                {
+                        instance = new FactoryRegistry();
+                        instance.registerDefaultFactories();
+                }
+                return instance;
+        }
+
+        
+        protected Hashtable factories = new Hashtable();
+        
+        /**
+         * Registers an <code>AudioDeviceFactory</code> instance
+         * with this registry. 
+         */
+        public void addFactory(AudioDeviceFactory factory)
+        {       
+                factories.put(factory.getClass(), factory);                                               
+        }
+        
+        public void removeFactoryType(Class cls)
+        {
+                factories.remove(cls);
+        }
+        
+        public void removeFactory(AudioDeviceFactory factory)
+        {
+                factories.remove(factory.getClass());   
+        }
+        
+        public AudioDevice createAudioDevice() throws JavaLayerException
+        {
+                AudioDevice device = null;
+                AudioDeviceFactory[] factories = getFactoriesPriority();
+                
+                if (factories==null)
+                        throw new JavaLayerException(this+": no factories registered");
+                
+                JavaLayerException lastEx = null;
+                for (int i=0; (device==null) && (i<factories.length); i++)
+                {
+                        try
+                        {
+                                device = factories[i].createAudioDevice();
+                        }
+                        catch (JavaLayerException ex)
+                        {
+                                lastEx = ex;
+                        }
+                }
+                
+                if (device==null && lastEx!=null)
+                {
+                        throw new JavaLayerException("Cannot create AudioDevice", lastEx);      
+                }
+                
+                return device;
+        }
+        
+        
+        protected AudioDeviceFactory[] getFactoriesPriority()
+        {
+                AudioDeviceFactory[] fa = null;
+                synchronized (factories)
+                {
+                        int size = factories.size();
+                        if (size!=0)
+                        {
+                                fa = new AudioDeviceFactory[size];
+                                int idx = 0;
+                                Enumeration e = factories.elements();
+                                while (e.hasMoreElements())
+                                {
+                                        AudioDeviceFactory factory = (AudioDeviceFactory)e.nextElement();
+                                        fa[idx++] = factory;    
+                                }
+                        }
+                }
+                return fa;
+        }
+
+        protected void registerDefaultFactories()
+        {
+                addFactory(new JavaSoundAudioDeviceFactory());
+        }
+}
diff --git a/songdbj/javazoom/jl/player/JavaSoundAudioDevice.java b/songdbj/javazoom/jl/player/JavaSoundAudioDevice.java
new file mode 100644
index 0000000000..caa92cd6fc
--- /dev/null
+++ b/songdbj/javazoom/jl/player/JavaSoundAudioDevice.java
@@ -0,0 +1,215 @@
+/*
+ * 11/26/04             Buffer size modified to support JRE 1.5 optimizations.
+ *              (CPU usage < 1% under P4/2Ghz, RAM < 12MB).
+ *              jlayer@javazoom.net
+ * 11/19/04             1.0 moved to LGPL.
+ * 06/04/01             Too fast playback fixed. mdm@techie.com
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.DataLine;
+import javax.sound.sampled.Line;
+import javax.sound.sampled.LineUnavailableException;
+import javax.sound.sampled.SourceDataLine;
+
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * The <code>JavaSoundAudioDevice</code> implements an audio
+ * device by using the JavaSound API.
+ *
+ * @since 0.0.8
+ * @author Mat McGowan
+ */
+public class JavaSoundAudioDevice extends AudioDeviceBase
+{
+        private SourceDataLine  source = null;
+
+        private AudioFormat             fmt = null;
+
+        private byte[]                  byteBuf = new byte[4096];
+
+        protected void setAudioFormat(AudioFormat fmt0)
+        {
+                fmt = fmt0;
+        }
+
+        protected AudioFormat getAudioFormat()
+        {
+                if (fmt==null)
+                {
+                        Decoder decoder = getDecoder();
+                        fmt = new AudioFormat(decoder.getOutputFrequency(),
+                                                                  16,
+                                                                  decoder.getOutputChannels(),
+                                                                  true,
+                                                                  false);
+                }
+                return fmt;
+        }
+
+        protected DataLine.Info getSourceLineInfo()
+        {
+                AudioFormat fmt = getAudioFormat();
+                //DataLine.Info info = new DataLine.Info(SourceDataLine.class, fmt, 4000);
+                DataLine.Info info = new DataLine.Info(SourceDataLine.class, fmt);
+                return info;
+        }
+
+        public void open(AudioFormat fmt) throws JavaLayerException
+        {
+                if (!isOpen())
+                {
+                        setAudioFormat(fmt);
+                        openImpl();
+                        setOpen(true);
+                }
+        }
+
+        protected void openImpl()
+                throws JavaLayerException
+        {
+        }
+
+
+        // createSource fix.
+        protected void createSource() throws JavaLayerException
+    {
+        Throwable t = null;
+        try
+        {
+                        Line line = AudioSystem.getLine(getSourceLineInfo());
+            if (line instanceof SourceDataLine)
+            {
+                        source = (SourceDataLine)line;
+                //source.open(fmt, millisecondsToBytes(fmt, 2000));
+                                source.open(fmt);
+                /*
+                if (source.isControlSupported(FloatControl.Type.MASTER_GAIN))
+                {
+                                        FloatControl c = (FloatControl)source.getControl(FloatControl.Type.MASTER_GAIN);
+                    c.setValue(c.getMaximum());
+                }*/
+                source.start();
+
+            }
+        } catch (RuntimeException ex)
+          {
+                          t = ex;
+          }
+          catch (LinkageError ex)
+          {
+              t = ex;
+          }
+          catch (LineUnavailableException ex)
+          {
+              t = ex;
+          }
+                if (source==null) throw new JavaLayerException("cannot obtain source audio line", t);
+    }
+
+        public int millisecondsToBytes(AudioFormat fmt, int time)
+        {
+                return (int)(time*(fmt.getSampleRate()*fmt.getChannels()*fmt.getSampleSizeInBits())/8000.0);
+        }
+
+        protected void closeImpl()
+        {
+                if (source!=null)
+                {
+                        source.close();
+                }
+        }
+
+        protected void writeImpl(short[] samples, int offs, int len)
+                throws JavaLayerException
+        {
+                if (source==null)
+                        createSource();
+
+                byte[] b = toByteArray(samples, offs, len);
+                source.write(b, 0, len*2);
+        }
+
+        protected byte[] getByteArray(int length)
+        {
+                if (byteBuf.length < length)
+                {
+                        byteBuf = new byte[length+1024];
+                }
+                return byteBuf;
+        }
+
+        protected byte[] toByteArray(short[] samples, int offs, int len)
+        {
+                byte[] b = getByteArray(len*2);
+                int idx = 0;
+                short s;
+                while (len-- > 0)
+                {
+                        s = samples[offs++];
+                        b[idx++] = (byte)s;
+                        b[idx++] = (byte)(s>>>8);
+                }
+                return b;
+        }
+
+        protected void flushImpl()
+        {
+                if (source!=null)
+                {
+                        source.drain();
+                }
+        }
+
+        public int getPosition()
+        {
+                int pos = 0;
+                if (source!=null)
+                {
+                        pos = (int)(source.getMicrosecondPosition()/1000);
+                }
+                return pos;
+        }
+
+        /**
+         * Runs a short test by playing a short silent sound.
+         */
+        public void test()
+                throws JavaLayerException
+        {
+                try
+                {
+                        open(new AudioFormat(22050, 16, 1, true, false));
+                        short[] data = new short[22050/10];
+                        write(data, 0, data.length);
+                        flush();
+                        close();
+                }
+                catch (RuntimeException ex)
+                {
+                        throw new JavaLayerException("Device test failed: "+ex);
+                }
+
+        }
+}
diff --git a/songdbj/javazoom/jl/player/JavaSoundAudioDeviceFactory.java b/songdbj/javazoom/jl/player/JavaSoundAudioDeviceFactory.java
new file mode 100644
index 0000000000..92af492f65
--- /dev/null
+++ b/songdbj/javazoom/jl/player/JavaSoundAudioDeviceFactory.java
@@ -0,0 +1,85 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * This class is responsible for creating instances of the
+ * JavaSoundAudioDevice. The audio device implementation is loaded
+ * and tested dynamically as not all systems will have support
+ * for JavaSound, or they may have the incorrect version. 
+ */
+public class JavaSoundAudioDeviceFactory extends AudioDeviceFactory
+{
+        private boolean tested = false;
+
+        static private final String DEVICE_CLASS_NAME = "javazoom.jl.player.JavaSoundAudioDevice";
+        
+        public synchronized AudioDevice createAudioDevice()
+                throws JavaLayerException
+        {
+                if (!tested)
+                {                       
+                        testAudioDevice();
+                        tested = true;
+                }
+                
+                try
+                {                       
+                        return createAudioDeviceImpl();
+                }
+                catch (Exception ex)
+                {
+                        throw new JavaLayerException("unable to create JavaSound device: "+ex);
+                }
+                catch (LinkageError ex)
+                {
+                        throw new JavaLayerException("unable to create JavaSound device: "+ex);
+                }
+        }
+        
+        protected JavaSoundAudioDevice createAudioDeviceImpl()
+                throws JavaLayerException
+        {
+                ClassLoader loader = getClass().getClassLoader();
+                try
+                {
+                        JavaSoundAudioDevice dev = (JavaSoundAudioDevice)instantiate(loader, DEVICE_CLASS_NAME);
+                        return dev;
+                }
+                catch (Exception ex)
+                {
+                        throw new JavaLayerException("Cannot create JavaSound device", ex);
+                }
+                catch (LinkageError ex)
+                {
+                        throw new JavaLayerException("Cannot create JavaSound device", ex);
+                }
+                
+        }
+        
+        public void testAudioDevice() throws JavaLayerException
+        {
+                JavaSoundAudioDevice dev = createAudioDeviceImpl();
+                dev.test();
+        }
+}
diff --git a/songdbj/javazoom/jl/player/NullAudioDevice.java b/songdbj/javazoom/jl/player/NullAudioDevice.java
new file mode 100644
index 0000000000..4145feecd4
--- /dev/null
+++ b/songdbj/javazoom/jl/player/NullAudioDevice.java
@@ -0,0 +1,37 @@
+/*
+ * 11/19/04             1.0 moved o LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+/**
+ * The <code>NullAudioDevice</code> implements a silent, no-op
+ * audio device. This is useful for testing purposes.
+ * 
+ * @since 0.0.8
+ * @author Mat McGowan
+ */
+public class NullAudioDevice extends AudioDeviceBase
+{
+                        
+        public int getPosition()
+        {
+                return 0;
+        }
+}
diff --git a/songdbj/javazoom/jl/player/Player.java b/songdbj/javazoom/jl/player/Player.java
new file mode 100644
index 0000000000..32fb1f3051
--- /dev/null
+++ b/songdbj/javazoom/jl/player/Player.java
@@ -0,0 +1,251 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import java.io.InputStream;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.BitstreamException;
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.Header;
+import javazoom.jl.decoder.JavaLayerException;
+import javazoom.jl.decoder.SampleBuffer;
+        
+/**
+ * The <code>Player</code> class implements a simple player for playback
+ * of an MPEG audio stream. 
+ * 
+ * @author      Mat McGowan
+ * @since       0.0.8
+ */
+
+// REVIEW: the audio device should not be opened until the
+// first MPEG audio frame has been decoded. 
+public class Player
+{               
+        /**
+         * The current frame number. 
+         */
+        private int frame = 0;
+        
+        /**
+         * The MPEG audio bitstream. 
+         */
+        // javac blank final bug. 
+        /*final*/ private Bitstream             bitstream;
+        
+        /**
+         * The MPEG audio decoder. 
+         */
+        /*final*/ private Decoder               decoder; 
+        
+        /**
+         * The AudioDevice the audio samples are written to. 
+         */
+        private AudioDevice     audio;
+        
+        /**
+         * Has the player been closed?
+         */
+        private boolean         closed = false;
+        
+        /**
+         * Has the player played back all frames from the stream?
+         */
+        private boolean         complete = false;
+
+        private int                     lastPosition = 0;
+        
+        /**
+         * Creates a new <code>Player</code> instance. 
+         */
+        public Player(InputStream stream) throws JavaLayerException
+        {
+                this(stream, null);     
+        }
+        
+        public Player(InputStream stream, AudioDevice device) throws JavaLayerException
+        {
+                bitstream = new Bitstream(stream);              
+                decoder = new Decoder();
+                                
+                if (device!=null)
+                {               
+                        audio = device;
+                }
+                else
+                {                       
+                        FactoryRegistry r = FactoryRegistry.systemRegistry();
+                        audio = r.createAudioDevice();
+                }
+                audio.open(decoder);
+        }
+        
+        public void play() throws JavaLayerException
+        {
+                play(Integer.MAX_VALUE);
+        }
+        
+        /**
+         * Plays a number of MPEG audio frames. 
+         * 
+         * @param frames        The number of frames to play. 
+         * @return      true if the last frame was played, or false if there are
+         *                      more frames. 
+         */
+        public boolean play(int frames) throws JavaLayerException
+        {
+                boolean ret = true;
+                        
+                while (frames-- > 0 && ret)
+                {
+                        ret = decodeFrame();                    
+                }
+                
+                if (!ret)
+                {
+                        // last frame, ensure all data flushed to the audio device. 
+                        AudioDevice out = audio;
+                        if (out!=null)
+                        {                               
+                                out.flush();
+                                synchronized (this)
+                                {
+                                        complete = (!closed);
+                                        close();
+                                }                               
+                        }
+                }
+                return ret;
+        }
+                
+        /**
+         * Cloases this player. Any audio currently playing is stopped
+         * immediately. 
+         */
+        public synchronized void close()
+        {               
+                AudioDevice out = audio;
+                if (out!=null)
+                { 
+                        closed = true;
+                        audio = null;   
+                        // this may fail, so ensure object state is set up before
+                        // calling this method. 
+                        out.close();
+                        lastPosition = out.getPosition();
+                        try
+                        {
+                                bitstream.close();
+                        }
+                        catch (BitstreamException ex)
+                        {
+                        }
+                }
+        }
+        
+        /**
+         * Returns the completed status of this player.
+         * 
+         * @return      true if all available MPEG audio frames have been
+         *                      decoded, or false otherwise. 
+         */
+        public synchronized boolean isComplete()
+        {
+                return complete;        
+        }
+                                
+        /**
+         * Retrieves the position in milliseconds of the current audio
+         * sample being played. This method delegates to the <code>
+         * AudioDevice</code> that is used by this player to sound
+         * the decoded audio samples. 
+         */
+        public int getPosition()
+        {
+                int position = lastPosition;
+                
+                AudioDevice out = audio;                
+                if (out!=null)
+                {
+                        position = out.getPosition();   
+                }
+                return position;
+        }               
+        
+        /**
+         * Decodes a single frame.
+         * 
+         * @return true if there are no more frames to decode, false otherwise.
+         */
+        protected boolean decodeFrame() throws JavaLayerException
+        {               
+                try
+                {
+                        AudioDevice out = audio;
+                        if (out==null)
+                                return false;
+
+                        Header h = bitstream.readFrame();       
+                        
+                        if (h==null)
+                                return false;
+                                
+                        // sample buffer set when decoder constructed
+                        SampleBuffer output = (SampleBuffer)decoder.decodeFrame(h, bitstream);
+                                                                                                                                                                                                                                                                                                        
+                        synchronized (this)
+                        {
+                                out = audio;
+                                if (out!=null)
+                                {                                       
+                                        out.write(output.getBuffer(), 0, output.getBufferLength());
+                                }                               
+                        }
+                                                                                                                                                        
+                        bitstream.closeFrame();
+                }               
+                catch (RuntimeException ex)
+                {
+                        throw new JavaLayerException("Exception decoding audio frame", ex);
+                }
+/*
+                catch (IOException ex)
+                {
+                        System.out.println("exception decoding audio frame: "+ex);
+                        return false;   
+                }
+                catch (BitstreamException bitex)
+                {
+                        System.out.println("exception decoding audio frame: "+bitex);
+                        return false;   
+                }
+                catch (DecoderException decex)
+                {
+                        System.out.println("exception decoding audio frame: "+decex);
+                        return false;                           
+                }
+*/              
+                return true;
+        }
+
+        
+}
diff --git a/songdbj/javazoom/jl/player/PlayerApplet.java b/songdbj/javazoom/jl/player/PlayerApplet.java
new file mode 100644
index 0000000000..d7c7dc2ffc
--- /dev/null
+++ b/songdbj/javazoom/jl/player/PlayerApplet.java
@@ -0,0 +1,246 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import java.applet.Applet;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * A simple applet that plays an MPEG audio file. 
+ * The URL (relative to the document base)
+ * is passed as the "audioURL" parameter. 
+ * 
+ * @author      Mat McGowan
+ * @since       0.0.8
+ */
+public class PlayerApplet extends Applet implements Runnable
+{
+        static public final String AUDIO_PARAMETER = "audioURL";
+        
+        /**
+         * The Player used to play the MPEG audio file. 
+         */
+        private Player  player = null;
+        
+        /**
+         * The thread that runs the player.
+         */
+        private Thread  playerThread = null;    
+        
+        private String  fileName = null;
+        
+        
+        /**
+         * Retrieves the <code>AudioDevice</code> instance that will
+         * be used to sound the audio data. 
+         * 
+         * @return      an audio device instance that will be used to 
+         *                      sound the audio stream.
+         */
+        protected AudioDevice getAudioDevice() throws JavaLayerException
+        {
+                return FactoryRegistry.systemRegistry().createAudioDevice();
+        }
+        
+        /**
+         * Retrieves the InputStream that provides the MPEG audio
+         * stream data. 
+         * 
+         * @return      an InputStream from which the MPEG audio data
+         *                      is read, or null if an error occurs. 
+         */
+        protected InputStream getAudioStream()
+        {
+                InputStream in = null;
+                
+                try
+                {
+                        URL url = getAudioURL();
+                        if (url!=null)                  
+                                in = url.openStream();
+                }
+                catch (IOException ex)
+                {
+                        System.err.println(ex);
+                }
+                return in;
+        }
+
+        protected String getAudioFileName()
+        {
+                String urlString = fileName;
+                if (urlString==null)
+                {
+                        urlString = getParameter(AUDIO_PARAMETER);
+                }
+                return urlString;
+        }
+        
+        protected URL getAudioURL()
+        {                               
+                String urlString = getAudioFileName();
+                URL url = null;
+                if (urlString!=null)
+                {
+                        try
+                        {
+                                url = new URL(getDocumentBase(), urlString);                            
+                        }
+                        catch (Exception ex)
+                        {
+                                System.err.println(ex); 
+                        }
+                }               
+                return url;
+        }
+        
+        /**
+         * Sets the URL of the audio stream to play.
+         */
+        public void setFileName(String name)
+        {
+                fileName = name;
+        }
+        
+        public String getFileName()
+        {
+                return fileName;        
+        }
+        
+        /**
+         * Stops the audio player. If the player is already stopped
+         * this method is a no-op.  
+         */
+        protected void stopPlayer() throws JavaLayerException
+        {
+                if (player!=null)
+                {
+                        player.close();
+                        player = null;
+                        playerThread = null;
+                }
+        }
+        
+        /**
+         * Decompresses audio data from an InputStream and plays it
+         * back through an AudioDevice. The playback is run on a newly
+         * created thread. 
+         * 
+         * @param in    The InputStream that provides the MPEG audio data.
+         * @param dev   The AudioDevice to use to sound the decompressed data. 
+         * 
+         * @throws JavaLayerException if there was a problem decoding
+         *              or playing the audio data.
+         */
+        protected void play(InputStream in, AudioDevice dev) throws JavaLayerException
+        {
+                stopPlayer();
+                
+                if (in!=null && dev!=null)
+                {
+                        player = new Player(in, dev);
+                        playerThread = createPlayerThread();
+                        playerThread.start();
+                }
+        }
+        
+        /**
+         * Creates a new thread used to run the audio player.
+         * @return A new Thread that, once started, runs the audio player.
+         */
+        protected Thread createPlayerThread()
+        {
+                return new Thread(this, "Audio player thread"); 
+        }
+        
+        /**
+         * Initializes this applet.
+         */
+        public void init()
+        {               
+        }
+        
+        /**
+         * Starts this applet. An input stream and audio device 
+         * are created and passed to the play() method.
+         */
+        public void start()
+        {
+                String name = getAudioFileName();
+                try
+                {                       
+                        InputStream in = getAudioStream();
+                        AudioDevice dev = getAudioDevice();
+                        play(in, dev);
+                }
+                catch (JavaLayerException ex)
+                {
+                        synchronized (System.err)
+                        {
+                                System.err.println("Unable to play "+name);
+                                ex.printStackTrace(System.err);
+                        }
+                }
+        }       
+        
+        /**
+         * Stops this applet. If audio is currently playing, it is
+         * stopped.
+         */
+        public void stop()
+        {
+                try
+                {
+                        stopPlayer();
+                }
+                catch (JavaLayerException ex)
+                {
+                        System.err.println(ex);
+                }
+        }
+        
+        public void destroy()
+        {
+        }
+        
+        /**
+         * The run method for the audio player thread. Simply calls
+         * play() on the player to play the entire stream. 
+         */
+        public void run()
+        {                               
+                if (player!=null)
+                {
+                        try
+                        {
+                                player.play();                          
+                        }
+                        catch (JavaLayerException ex)
+                        {
+                                System.err.println("Problem playing audio: "+ex);
+                        }                       
+                }
+        }
+}
diff --git a/songdbj/javazoom/jl/player/advanced/AdvancedPlayer.java b/songdbj/javazoom/jl/player/advanced/AdvancedPlayer.java
new file mode 100644
index 0000000000..45a31e46e1
--- /dev/null
+++ b/songdbj/javazoom/jl/player/advanced/AdvancedPlayer.java
@@ -0,0 +1,242 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player.advanced;
+
+import java.io.InputStream;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.BitstreamException;
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.Header;
+import javazoom.jl.decoder.JavaLayerException;
+import javazoom.jl.decoder.SampleBuffer;
+import javazoom.jl.player.AudioDevice;
+import javazoom.jl.player.FactoryRegistry;
+
+/**
+ * a hybrid of javazoom.jl.player.Player tweeked to include <code>play(startFrame, endFrame)</code>
+ * hopefully this will be included in the api
+ */
+public class AdvancedPlayer
+{
+        /** The MPEG audio bitstream.*/
+        private Bitstream bitstream;
+        /** The MPEG audio decoder. */
+        private Decoder decoder;
+        /** The AudioDevice the audio samples are written to. */
+        private AudioDevice audio;
+        /** Has the player been closed? */
+        private boolean closed = false;
+        /** Has the player played back all frames from the stream? */
+        private boolean complete = false;
+        private int lastPosition = 0;
+        /** Listener for the playback process */
+        private PlaybackListener listener;
+
+        /**
+         * Creates a new <code>Player</code> instance.
+         */
+        public AdvancedPlayer(InputStream stream) throws JavaLayerException
+        {
+                this(stream, null);
+        }
+
+        public AdvancedPlayer(InputStream stream, AudioDevice device) throws JavaLayerException
+        {
+                bitstream = new Bitstream(stream);
+
+                if (device!=null) audio = device;
+                else audio = FactoryRegistry.systemRegistry().createAudioDevice();
+                audio.open(decoder = new Decoder());
+        }
+
+        public void play() throws JavaLayerException
+        {
+                play(Integer.MAX_VALUE);
+        }
+
+        /**
+         * Plays a number of MPEG audio frames.
+         *
+         * @param frames        The number of frames to play.
+         * @return      true if the last frame was played, or false if there are
+         *                      more frames.
+         */
+        public boolean play(int frames) throws JavaLayerException
+        {
+                boolean ret = true;
+
+                // report to listener
+                if(listener != null) listener.playbackStarted(createEvent(PlaybackEvent.STARTED));
+
+                while (frames-- > 0 && ret)
+                {
+                        ret = decodeFrame();
+                }
+
+//              if (!ret)
+                {
+                        // last frame, ensure all data flushed to the audio device.
+                        AudioDevice out = audio;
+                        if (out != null)
+                        {
+//                              System.out.println(audio.getPosition());
+                                out.flush();
+//                              System.out.println(audio.getPosition());
+                                synchronized (this)
+                                {
+                                        complete = (!closed);
+                                        close();
+                                }
+
+                                // report to listener
+                                if(listener != null) listener.playbackFinished(createEvent(out, PlaybackEvent.STOPPED));
+                        }
+                }
+                return ret;
+        }
+
+        /**
+         * Cloases this player. Any audio currently playing is stopped
+         * immediately.
+         */
+        public synchronized void close()
+        {
+                AudioDevice out = audio;
+                if (out != null)
+                {
+                        closed = true;
+                        audio = null;
+                        // this may fail, so ensure object state is set up before
+                        // calling this method.
+                        out.close();
+                        lastPosition = out.getPosition();
+                        try
+                        {
+                                bitstream.close();
+                        }
+                        catch (BitstreamException ex)
+                        {}
+                }
+        }
+
+        /**
+         * Decodes a single frame.
+         *
+         * @return true if there are no more frames to decode, false otherwise.
+         */
+        protected boolean decodeFrame() throws JavaLayerException
+        {
+                try
+                {
+                        AudioDevice out = audio;
+                        if (out == null) return false;
+
+                        Header h = bitstream.readFrame();
+                        if (h == null) return false;
+
+                        // sample buffer set when decoder constructed
+                        SampleBuffer output = (SampleBuffer) decoder.decodeFrame(h, bitstream);
+
+                        synchronized (this)
+                        {
+                                out = audio;
+                                if(out != null)
+                                {
+                                        out.write(output.getBuffer(), 0, output.getBufferLength());
+                                }
+                        }
+
+                        bitstream.closeFrame();
+                }
+                catch (RuntimeException ex)
+                {
+                        throw new JavaLayerException("Exception decoding audio frame", ex);
+                }
+                return true;
+        }
+
+        /**
+         * skips over a single frame
+         * @return false        if there are no more frames to decode, true otherwise.
+         */
+        protected boolean skipFrame() throws JavaLayerException
+        {
+                Header h = bitstream.readFrame();
+                if (h == null) return false;
+                bitstream.closeFrame();
+                return true;
+        }
+
+        /**
+         * Plays a range of MPEG audio frames
+         * @param start The first frame to play
+         * @param end           The last frame to play
+         * @return true if the last frame was played, or false if there are more frames.
+         */
+        public boolean play(final int start, final int end) throws JavaLayerException
+        {
+                boolean ret = true;
+                int offset = start;
+                while (offset-- > 0 && ret) ret = skipFrame();
+                return play(end - start);
+        }
+
+        /**
+         * Constructs a <code>PlaybackEvent</code>
+         */
+        private PlaybackEvent createEvent(int id)
+        {
+                return createEvent(audio, id);
+        }
+
+        /**
+         * Constructs a <code>PlaybackEvent</code>
+         */
+        private PlaybackEvent createEvent(AudioDevice dev, int id)
+        {
+                return new PlaybackEvent(this, id, dev.getPosition());
+        }
+
+        /**
+         * sets the <code>PlaybackListener</code>
+         */
+        public void setPlayBackListener(PlaybackListener listener)
+        {
+                this.listener = listener;
+        }
+
+        /**
+         * gets the <code>PlaybackListener</code>
+         */
+        public PlaybackListener getPlayBackListener()
+        {
+                return listener;
+        }
+
+        /**
+         * closes the player and notifies <code>PlaybackListener</code>
+         */
+        public void stop()
+        {
+                listener.playbackFinished(createEvent(PlaybackEvent.STOPPED));
+                close();
+        }
+}
\ No newline at end of file
diff --git a/songdbj/javazoom/jl/player/advanced/PlaybackEvent.java b/songdbj/javazoom/jl/player/advanced/PlaybackEvent.java
new file mode 100644
index 0000000000..08e3cae958
--- /dev/null
+++ b/songdbj/javazoom/jl/player/advanced/PlaybackEvent.java
@@ -0,0 +1,51 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player.advanced;
+
+/**
+ * An event which indicates a <code>Player</code> has performed an 'playback action'
+ * @author Paul Stanton (http://wanto.f2o.org/)
+ */
+public class PlaybackEvent
+{
+        public static int STOPPED = 1;
+        public static int STARTED = 2;
+
+        private AdvancedPlayer source;
+        private int frame;
+        private int id;
+
+        public PlaybackEvent(AdvancedPlayer source, int id, int frame)
+        {
+                this.id = id;
+                this.source = source;
+                this.frame = frame;
+        }
+
+        public int getId(){return id;}
+        public void setId(int id){this.id = id;}
+
+        public int getFrame(){return frame;}
+        public void setFrame(int frame){this.frame = frame;}
+
+        public AdvancedPlayer getSource(){return source;}
+        public void setSource(AdvancedPlayer source){this.source = source;}
+
+}
diff --git a/songdbj/javazoom/jl/player/advanced/PlaybackListener.java b/songdbj/javazoom/jl/player/advanced/PlaybackListener.java
new file mode 100644
index 0000000000..9b042988b8
--- /dev/null
+++ b/songdbj/javazoom/jl/player/advanced/PlaybackListener.java
@@ -0,0 +1,30 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player.advanced;
+
+/**
+ * Listener for javalayer Player playback
+ * @author Paul Stanton (http://wanto.f2o.org/)
+ */
+public abstract class PlaybackListener
+{
+        public void playbackStarted(PlaybackEvent evt){}
+        public void playbackFinished(PlaybackEvent evt){}
+}
diff --git a/songdbj/javazoom/jl/player/advanced/jlap.java b/songdbj/javazoom/jl/player/advanced/jlap.java
new file mode 100644
index 0000000000..beedea6716
--- /dev/null
+++ b/songdbj/javazoom/jl/player/advanced/jlap.java
@@ -0,0 +1,116 @@
+/*
+ * 11/19/04             1.0 moved to LGPL. 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player.advanced;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * This class implements a sample player using Playback listener.
+ */
+public class jlap
+{
+
+  public static void main(String[] args)
+  {
+    jlap test = new jlap();
+    if (args.length != 1)
+    {
+      test.showUsage();
+      System.exit(0);
+    }
+    else
+    {
+      try
+      {
+        test.play(args[0]);
+      }
+      catch (Exception ex)
+      {
+        System.err.println(ex.getMessage());
+        System.exit(0);
+      }
+    }
+  }
+
+  public void play(String filename) throws JavaLayerException, IOException
+  {
+    InfoListener lst = new InfoListener();
+    playMp3(new File(filename), lst);
+  }
+
+  public void showUsage()
+  {
+    System.out.println("Usage: jla <filename>");
+    System.out.println("");
+    System.out.println(" e.g. : java javazoom.jl.player.advanced.jlap localfile.mp3");
+  }
+
+  public static AdvancedPlayer playMp3(File mp3, PlaybackListener listener) throws IOException, JavaLayerException
+  {
+    return playMp3(mp3, 0, Integer.MAX_VALUE, listener);
+  }
+
+  public static AdvancedPlayer playMp3(File mp3, int start, int end, PlaybackListener listener) throws IOException, JavaLayerException
+  {
+    return playMp3(new BufferedInputStream(new FileInputStream(mp3)), start, end, listener);
+  }
+
+  public static AdvancedPlayer playMp3(final InputStream is, final int start, final int end, PlaybackListener listener) throws JavaLayerException
+  {
+    final AdvancedPlayer player = new AdvancedPlayer(is);
+    player.setPlayBackListener(listener);
+    // run in new thread
+    new Thread()
+    {
+      public void run()
+      {
+        try
+        {
+          player.play(start, end);
+        }
+        catch (Exception e)
+        {
+          throw new RuntimeException(e.getMessage());
+        }
+      }
+    }.start();
+    return player;
+  }
+
+  public class InfoListener extends PlaybackListener
+  {
+    public void playbackStarted(PlaybackEvent evt)
+    {
+      System.out.println("Play started from frame " + evt.getFrame());
+    }
+
+    public void playbackFinished(PlaybackEvent evt)
+    {
+      System.out.println("Play completed at frame " + evt.getFrame());
+      System.exit(0);
+    }
+  }
+}
\ No newline at end of file
diff --git a/songdbj/javazoom/jl/player/jlp.java b/songdbj/javazoom/jl/player/jlp.java
new file mode 100644
index 0000000000..ddb3d5ecca
--- /dev/null
+++ b/songdbj/javazoom/jl/player/jlp.java
@@ -0,0 +1,176 @@
+/*
+ * 11/19/04             1.0 moved to LGPL.
+ * 
+ * 06/04/01             Streaming support added. javalayer@javazoom.net
+ * 
+ * 29/01/00             Initial version. mdm@techie.com
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.player;
+
+import java.io.BufferedInputStream;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+import javazoom.jl.decoder.JavaLayerException;
+
+/**
+ * The <code>jlp</code> class implements a simple command-line
+ * player for MPEG audio files.
+ *
+ * @author Mat McGowan (mdm@techie.com)
+ */
+public class jlp
+{
+        private String fFilename = null;
+        private boolean remote = false;
+
+        public static void main(String[] args)
+        {
+                int retval = 0;
+                try
+                {
+                        jlp player = createInstance(args);
+                        if (player!=null)
+                                player.play();
+                }
+                catch (Exception ex)
+                {
+                        System.err.println(ex);
+                        ex.printStackTrace(System.err);
+                        retval = 1;
+                }
+                System.exit(retval);
+        }
+
+        static public jlp createInstance(String[] args)
+        {
+                jlp player = new jlp();
+                if (!player.parseArgs(args))
+                        player = null;
+                return player;
+        }
+
+        private jlp()
+        {
+        }
+
+        public jlp(String filename)
+        {
+                init(filename);
+        }
+
+        protected void init(String filename)
+        {
+                fFilename = filename;
+        }
+
+        protected boolean parseArgs(String[] args)
+        {
+                boolean parsed = false;
+                if (args.length == 1)
+                {
+                        init(args[0]);
+                        parsed = true;
+                        remote = false;
+                }
+                else if (args.length == 2)
+                {
+                        if (!(args[0].equals("-url")))
+                        {
+                                showUsage();
+                        }
+                        else
+                        {
+                                init(args[1]);
+                                parsed = true;
+                                remote = true;
+                        }
+                }
+                else
+                {
+                        showUsage();
+                }
+                return parsed;
+        }
+
+        public void showUsage()
+        {
+                System.out.println("Usage: jlp [-url] <filename>");
+                System.out.println("");
+                System.out.println(" e.g. : java javazoom.jl.player.jlp localfile.mp3");
+                System.out.println("        java javazoom.jl.player.jlp -url http://www.server.com/remotefile.mp3");
+                System.out.println("        java javazoom.jl.player.jlp -url http://www.shoutcastserver.com:8000");
+        }
+
+        public void play()
+                throws JavaLayerException
+        {
+                try
+                {
+                        System.out.println("playing "+fFilename+"...");
+                        InputStream in = null;
+                        if (remote == true) in = getURLInputStream();
+                        else in = getInputStream();
+                        AudioDevice dev = getAudioDevice();
+                        Player player = new Player(in, dev);
+                        player.play();
+                }
+                catch (IOException ex)
+                {
+                        throw new JavaLayerException("Problem playing file "+fFilename, ex);
+                }
+                catch (Exception ex)
+                {
+                        throw new JavaLayerException("Problem playing file "+fFilename, ex);
+                }
+        }
+
+        /**
+         * Playing file from URL (Streaming).
+         */
+        protected InputStream getURLInputStream()
+                throws Exception
+        {
+
+                URL url = new URL(fFilename);
+                InputStream fin = url.openStream();
+                BufferedInputStream bin = new BufferedInputStream(fin);
+                return bin;
+        }
+
+        /**
+         * Playing file from FileInputStream.
+         */
+        protected InputStream getInputStream()
+                throws IOException
+        {
+                FileInputStream fin = new FileInputStream(fFilename);
+                BufferedInputStream bin = new BufferedInputStream(fin);
+                return bin;
+        }
+
+        protected AudioDevice getAudioDevice()
+                throws JavaLayerException
+        {
+                return FactoryRegistry.systemRegistry().createAudioDevice();
+        }
+
+}
diff --git a/songdbj/javazoom/spi/PropertiesContainer.java b/songdbj/javazoom/spi/PropertiesContainer.java
new file mode 100644
index 0000000000..27ed85f904
--- /dev/null
+++ b/songdbj/javazoom/spi/PropertiesContainer.java
@@ -0,0 +1,31 @@
+/*
+ * PropertiesContainer.
+ * 
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi;
+
+import java.util.Map;
+
+public interface PropertiesContainer
+{
+        public Map properties();
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/convert/DecodedMpegAudioInputStream.java b/songdbj/javazoom/spi/mpeg/sampled/convert/DecodedMpegAudioInputStream.java
new file mode 100644
index 0000000000..e4e6fed00a
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/convert/DecodedMpegAudioInputStream.java
@@ -0,0 +1,334 @@
+/*
+ *   DecodedMpegAudioInputStream.
+ * 
+ *   JavaZOOM : mp3spi@javazoom.net 
+ *                              http://www.javazoom.net
+ *
+ *-----------------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *------------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.convert;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.BitstreamException;
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.DecoderException;
+import javazoom.jl.decoder.Equalizer;
+import javazoom.jl.decoder.Header;
+import javazoom.jl.decoder.Obuffer;
+import javazoom.spi.PropertiesContainer;
+import javazoom.spi.mpeg.sampled.file.IcyListener;
+import javazoom.spi.mpeg.sampled.file.tag.TagParseEvent;
+import javazoom.spi.mpeg.sampled.file.tag.TagParseListener;
+
+import org.tritonus.share.TDebug;
+import org.tritonus.share.sampled.convert.TAsynchronousFilteredAudioInputStream;
+
+/**
+ * Main decoder.
+ */
+public class DecodedMpegAudioInputStream extends TAsynchronousFilteredAudioInputStream implements PropertiesContainer, TagParseListener
+{
+        private InputStream m_encodedStream;
+        private Bitstream m_bitstream;
+        private Decoder m_decoder;
+        private Equalizer m_equalizer;
+        private float[] m_equalizer_values;
+        private Header m_header;
+        private DMAISObuffer m_oBuffer;
+
+        // Bytes info.
+        private long byteslength = -1;
+        private long currentByte = 0;   
+        // Frame info.
+        private int frameslength = -1;
+        private long currentFrame = 0;
+        private int currentFramesize = 0;
+        private int currentBitrate = -1;
+        // Time info.
+        private long currentMicrosecond = 0;
+        // Shoutcast stream info
+        private IcyListener shoutlst = null;
+        
+
+        private HashMap properties = null;
+
+        public DecodedMpegAudioInputStream(AudioFormat outputFormat, AudioInputStream inputStream)
+        {
+                super(outputFormat, -1);
+                if (TDebug.TraceAudioConverter) 
+                {
+                        TDebug.out(">DecodedMpegAudioInputStream(AudioFormat outputFormat, AudioInputStream inputStream)");
+                }
+                try
+                {
+                        // Try to find out inputstream length to allow skip.
+                        byteslength = inputStream.available();
+                }
+                catch (IOException e)
+                {
+                        TDebug.out("DecodedMpegAudioInputStream : Cannot run inputStream.available() : "+e.getMessage());
+                        byteslength = -1;
+                }               
+                m_encodedStream = inputStream;          
+                shoutlst = IcyListener.getInstance();
+                shoutlst.reset();
+                m_bitstream = new Bitstream(inputStream);
+                m_decoder = new Decoder(null);
+                m_equalizer = new Equalizer();
+                m_equalizer_values = new float[32];
+                for (int b=0;b<m_equalizer.getBandCount();b++)
+                {
+                        m_equalizer_values[b] = m_equalizer.getBand(b);
+                }
+                m_decoder.setEqualizer(m_equalizer);
+                m_oBuffer = new DMAISObuffer(outputFormat.getChannels());
+                m_decoder.setOutputBuffer(m_oBuffer);
+                try
+                {
+                        m_header = m_bitstream.readFrame();
+                        if ((m_header != null) && (frameslength == -1) && (byteslength > 0))  frameslength = m_header.max_number_of_frames((int)byteslength);
+                }
+                catch (BitstreamException e)
+                {
+                        TDebug.out("DecodedMpegAudioInputStream : Cannot read first frame : "+e.getMessage());
+                        byteslength = -1;
+                }
+                properties = new HashMap();
+        }
+
+        /**
+         * Return dynamic properties.
+         * 
+         * <ul>
+         * <li><b>mp3.frame</b> [Long], current frame position.
+         * <li><b>mp3.frame.bitrate</b> [Integer], bitrate of the current frame.
+         * <li><b>mp3.frame.size.bytes</b> [Integer], size in bytes of the current frame.
+         * <li><b>mp3.position.byte</b> [Long], current position in bytes in the stream.
+         * <li><b>mp3.position.microseconds</b> [Long], elapsed microseconds.
+         * <li><b>mp3.equalizer</b> float[32], interactive equalizer array, values could be in [-1.0, +1.0].
+         * <li><b>mp3.shoutcast.metadata.key</b> [String], Shoutcast meta key with matching value.
+         * <br>For instance : 
+         * <br>mp3.shoutcast.metadata.StreamTitle=Current song playing in stream.
+         * <br>mp3.shoutcast.metadata.StreamUrl=Url info.
+         * </ul>
+         */
+        public Map properties()
+        {
+                properties.put("mp3.frame",new Long(currentFrame));
+                properties.put("mp3.frame.bitrate",new Integer(currentBitrate));
+                properties.put("mp3.frame.size.bytes",new Integer(currentFramesize));
+                properties.put("mp3.position.byte",new Long(currentByte));
+                properties.put("mp3.position.microseconds",new Long(currentMicrosecond));
+                properties.put("mp3.equalizer",m_equalizer_values);
+                // Optionnal shoutcast stream meta-data.                                
+                if (shoutlst != null)
+                {
+                        String surl = shoutlst.getStreamUrl();
+                        String stitle = shoutlst.getStreamTitle();
+                        if ((stitle != null) && (stitle.trim().length()>0)) properties.put("mp3.shoutcast.metadata.StreamTitle",stitle);
+                        if ((surl != null) && (surl.trim().length()>0)) properties.put("mp3.shoutcast.metadata.StreamUrl",surl);
+                }               
+                return properties;       
+        }
+        
+        public void execute()
+        {
+                if (TDebug.TraceAudioConverter) TDebug.out("execute() : begin");
+                try
+                {
+                        // Following line hangs when FrameSize is available in AudioFormat.                     
+                        Header header = null;
+                        if (m_header == null) header = m_bitstream.readFrame();
+                        else header = m_header;                                                                                         
+                        if (TDebug.TraceAudioConverter) TDebug.out("execute() : header = "+header);
+                        if (header == null)
+                        {
+                                if (TDebug.TraceAudioConverter)
+                                {
+                                        TDebug.out("header is null (end of mpeg stream)");
+                                }
+                                getCircularBuffer().close();                            
+                                return;
+                        }                        
+                        currentFrame++;
+                        currentBitrate = header.bitrate_instant();
+                        currentFramesize = header.calculate_framesize();
+                        currentByte = currentByte + currentFramesize;
+                        currentMicrosecond = (long) (currentFrame* header.ms_per_frame()*1000.0f);
+                        for (int b=0;b<m_equalizer_values.length;b++)
+                        {
+                                m_equalizer.setBand(b,m_equalizer_values[b]);                                   
+                        }                       
+                        m_decoder.setEqualizer(m_equalizer);
+                        Obuffer decoderOutput = m_decoder.decodeFrame(header, m_bitstream);
+                        m_bitstream.closeFrame();
+                        getCircularBuffer().write(m_oBuffer.getBuffer(), 0, m_oBuffer.getCurrentBufferSize());
+                        m_oBuffer.reset();
+                        if (m_header != null) m_header = null;
+                }
+                catch (BitstreamException e)
+                {
+                        if (TDebug.TraceAudioConverter)
+                        {
+                                TDebug.out(e);
+                        }
+                }
+                catch (DecoderException e)
+                {
+                        if (TDebug.TraceAudioConverter)
+                        {
+                                TDebug.out(e);
+                        }
+                }
+                if (TDebug.TraceAudioConverter) TDebug.out("execute() : end");          
+        }
+
+        public long skip(long bytes)
+        {
+                if ((byteslength > 0) && (frameslength > 0))
+                {
+                        float ratio = bytes*1.0f/byteslength*1.0f;
+                        long bytesread = skipFrames((long) (ratio*frameslength));
+                        currentByte = currentByte + bytesread;
+                        return bytesread;                                       
+                }
+                else return -1;
+        }
+        
+        /**
+         * Skip frames.
+         * You don't need to call it severals times, it will exactly skip given frames number.
+         * @param frames
+         * @return bytes length skipped matching to frames skipped.
+         */
+        public long skipFrames(long frames)
+        {
+                if (TDebug.TraceAudioConverter) TDebug.out("skip(long frames) : begin");                
+                int framesRead = 0;
+                int bytesReads = 0;
+                try
+                {
+                        for (int i=0;i<frames;i++)
+                        {
+                                Header header = m_bitstream.readFrame();
+                                if (header != null)
+                                {
+                                        int fsize = header.calculate_framesize();                                       
+                                        bytesReads = bytesReads + fsize;
+                                } 
+                                m_bitstream.closeFrame();
+                                framesRead++;
+                        } 
+                }
+                catch (BitstreamException e)
+                {
+                        if (TDebug.TraceAudioConverter) TDebug.out(e);
+                }
+                if (TDebug.TraceAudioConverter) TDebug.out("skip(long frames) : end");
+                currentFrame = currentFrame + framesRead;
+                return bytesReads;
+        }
+        
+        private boolean isBigEndian()
+        {
+                return getFormat().isBigEndian();
+        }
+
+        public void close() throws IOException
+        {
+                super.close();
+                m_encodedStream.close();
+        }
+
+        private class DMAISObuffer extends Obuffer
+        {
+                private int m_nChannels;
+                private byte[] m_abBuffer;
+                private int[] m_anBufferPointers;
+                private boolean m_bIsBigEndian;
+                public DMAISObuffer(int nChannels)
+                {
+                        m_nChannels = nChannels;
+                        m_abBuffer = new byte[OBUFFERSIZE * nChannels];
+                        m_anBufferPointers = new int[nChannels];
+                        reset();
+                        m_bIsBigEndian = DecodedMpegAudioInputStream.this.isBigEndian();
+                }
+                public void append(int nChannel, short sValue)
+                {
+                        byte bFirstByte;
+                        byte bSecondByte;
+                        if (m_bIsBigEndian)
+                        {
+                                bFirstByte = (byte) ((sValue >>> 8) & 0xFF);
+                                bSecondByte = (byte) (sValue & 0xFF);
+                        }
+                        else // little endian
+                                {
+                                bFirstByte = (byte) (sValue & 0xFF);
+                                bSecondByte = (byte) ((sValue >>> 8) & 0xFF);
+                        }
+                        m_abBuffer[m_anBufferPointers[nChannel]] = bFirstByte;
+                        m_abBuffer[m_anBufferPointers[nChannel] + 1] = bSecondByte;
+                        m_anBufferPointers[nChannel] += m_nChannels * 2;
+                }
+                public void set_stop_flag()
+                {
+                }
+                public void close()
+                {
+                }
+                public void write_buffer(int nValue)
+                {
+                }
+                public void clear_buffer()
+                {
+                }
+                public byte[] getBuffer()
+                {
+                        return m_abBuffer;
+                }
+                public int getCurrentBufferSize()
+                {
+                        return m_anBufferPointers[0];
+                }
+                public void reset()
+                {
+                        for (int i = 0; i < m_nChannels; i++)
+                        {
+                                /*      Points to byte location,
+                                 *      implicitely assuming 16 bit
+                                 *      samples.
+                                 */
+                                m_anBufferPointers[i] = i * 2;
+                        }
+                }
+        }
+        
+        public void tagParsed(TagParseEvent tpe)
+        {
+                System.out.println("TAG:"+tpe.getTag());
+        }       
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/convert/MpegFormatConversionProvider.java b/songdbj/javazoom/spi/mpeg/sampled/convert/MpegFormatConversionProvider.java
new file mode 100644
index 0000000000..1a3d51d9ad
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/convert/MpegFormatConversionProvider.java
@@ -0,0 +1,120 @@
+/*
+ *   MpegFormatConversionProvider.
+ * 
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ * --------------------------------------------------------------------------- 
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * --------------------------------------------------------------------------
+ */
+
+
+package javazoom.spi.mpeg.sampled.convert;
+
+
+import java.util.Arrays;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+
+import javazoom.spi.mpeg.sampled.file.MpegEncoding;
+
+import org.tritonus.share.TDebug;
+import org.tritonus.share.sampled.Encodings;
+import org.tritonus.share.sampled.convert.TEncodingFormatConversionProvider;
+
+/**
+ * ConversionProvider for MPEG files.
+  */
+public class MpegFormatConversionProvider extends TEncodingFormatConversionProvider
+{
+        private static final AudioFormat.Encoding       MP3 = Encodings.getEncoding("MP3");
+        private static final AudioFormat.Encoding       PCM_SIGNED = Encodings.getEncoding("PCM_SIGNED");
+
+        private static final AudioFormat[]      INPUT_FORMATS =
+        {
+                // mono
+                new AudioFormat(MP3, -1.0F, -1, 1, -1, -1.0F, false),
+                new AudioFormat(MP3, -1.0F, -1, 1, -1, -1.0F, true),
+                // stereo
+                new AudioFormat(MP3, -1.0F, -1, 2, -1, -1.0F, false),
+                new AudioFormat(MP3, -1.0F, -1, 2, -1, -1.0F, true),
+        };
+
+
+        private static final AudioFormat[]      OUTPUT_FORMATS =
+        {
+                // mono, 16 bit signed
+                new AudioFormat(PCM_SIGNED, -1.0F, 16, 1, 2, -1.0F, false),
+                new AudioFormat(PCM_SIGNED, -1.0F, 16, 1, 2, -1.0F, true),
+                // stereo, 16 bit signed
+                new AudioFormat(PCM_SIGNED, -1.0F, 16, 2, 4, -1.0F, false),
+                new AudioFormat(PCM_SIGNED, -1.0F, 16, 2, 4, -1.0F, true),
+        };
+
+        /**     
+         * Constructor.
+         */
+        public MpegFormatConversionProvider()
+        {
+                super(Arrays.asList(INPUT_FORMATS), Arrays.asList(OUTPUT_FORMATS));
+                if (TDebug.TraceAudioConverter) 
+                {
+                        TDebug.out(">MpegFormatConversionProvider()");
+                }
+        }
+
+        public AudioInputStream getAudioInputStream(AudioFormat targetFormat, AudioInputStream audioInputStream)
+        {
+                if (TDebug.TraceAudioConverter) 
+                {
+                        TDebug.out(">MpegFormatConversionProvider.getAudioInputStream(AudioFormat targetFormat, AudioInputStream audioInputStream):");
+                }
+                return new DecodedMpegAudioInputStream(targetFormat, audioInputStream);
+        }
+
+        /**
+         * Add conversion support for any MpegEncoding source with FrameRate or FrameSize not empty.
+         * @param targetFormat
+         * @param sourceFormat
+         * @return
+         */
+        public boolean isConversionSupported(AudioFormat targetFormat, AudioFormat sourceFormat)
+        {
+                if (TDebug.TraceAudioConverter) 
+                {
+                                        TDebug.out(">MpegFormatConversionProvider.isConversionSupported(AudioFormat targetFormat, AudioFormat sourceFormat):");
+                                        TDebug.out("checking if conversion possible");
+                                        TDebug.out("from: " + sourceFormat);
+                                        TDebug.out("to: " + targetFormat);
+                }
+
+                boolean conversion = super.isConversionSupported(targetFormat, sourceFormat);
+                if (conversion == false)
+                {
+                        AudioFormat.Encoding enc = sourceFormat.getEncoding();
+                        if (enc instanceof MpegEncoding)
+                        {
+                                if ((sourceFormat.getFrameRate() != AudioSystem.NOT_SPECIFIED) || (sourceFormat.getFrameSize() != AudioSystem.NOT_SPECIFIED))
+                                {
+                                        conversion = true;
+                                }
+                        }
+                }
+                return conversion;
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/IcyListener.java b/songdbj/javazoom/spi/mpeg/sampled/file/IcyListener.java
new file mode 100644
index 0000000000..8e49e6e2ef
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/IcyListener.java
@@ -0,0 +1,131 @@
+/*
+ * IcyListener.
+ * 
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file;
+
+import javazoom.spi.mpeg.sampled.file.tag.MP3Tag;
+import javazoom.spi.mpeg.sampled.file.tag.TagParseEvent;
+import javazoom.spi.mpeg.sampled.file.tag.TagParseListener;
+
+/**
+ * This class (singleton) allow to be notified on shoutcast meta data
+ * while playing the stream (such as song title).
+ */
+public class IcyListener implements TagParseListener
+{
+        private static IcyListener instance = null;
+        private MP3Tag lastTag = null;
+        private String streamTitle = null;
+        private String streamUrl = null;
+        
+                
+        private IcyListener()
+        {
+                super();
+        }
+
+        public static synchronized IcyListener getInstance()
+        {
+                if (instance == null)
+                {
+                        instance = new IcyListener();
+                }
+                return instance;                
+        }
+        
+        /* (non-Javadoc)
+         * @see javazoom.spi.mpeg.sampled.file.tag.TagParseListener#tagParsed(javazoom.spi.mpeg.sampled.file.tag.TagParseEvent)
+         */
+        public void tagParsed(TagParseEvent tpe)
+        {               
+                lastTag = tpe.getTag();
+                String name = lastTag.getName();
+                if ((name != null) && (name.equalsIgnoreCase("streamtitle")))
+                {
+                        streamTitle = (String) lastTag.getValue();
+                }
+                else if ((name != null) && (name.equalsIgnoreCase("streamurl")))
+                {
+                        streamUrl = (String) lastTag.getValue();
+                }       
+        }
+
+        /**
+         * @return
+         */
+        public MP3Tag getLastTag()
+        {
+                return lastTag;
+        }
+
+        /**
+         * @param tag
+         */
+        public void setLastTag(MP3Tag tag)
+        {
+                lastTag = tag;
+        }
+
+        /**
+         * @return
+         */
+        public String getStreamTitle()
+        {
+                return streamTitle;
+        }
+
+        /**
+         * @return
+         */
+        public String getStreamUrl()
+        {
+                return streamUrl;
+        }
+
+        /**
+         * @param string
+         */
+        public void setStreamTitle(String string)
+        {
+                streamTitle = string;
+        }
+
+        /**
+         * @param string
+         */
+        public void setStreamUrl(String string)
+        {
+                streamUrl = string;
+        }
+        
+        /**
+         * Reset all properties.
+         */
+        public void reset()
+        {
+                lastTag = null;
+                streamTitle = null;
+                streamUrl = null;               
+        }
+
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFileFormat.java b/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFileFormat.java
new file mode 100644
index 0000000000..afdc4c5e9c
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFileFormat.java
@@ -0,0 +1,103 @@
+/*
+ * MpegAudioFileFormat.
+ *
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ *
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+package javazoom.spi.mpeg.sampled.file;
+
+import java.util.Map;
+
+import javax.sound.sampled.AudioFormat;
+
+import org.tritonus.share.sampled.file.TAudioFileFormat;
+
+/**
+ * @author JavaZOOM
+ */
+public class MpegAudioFileFormat extends TAudioFileFormat
+{
+        /**
+         * Contructor.
+         * @param type
+         * @param audioFormat
+         * @param nLengthInFrames
+         * @param nLengthInBytes
+         */
+        public MpegAudioFileFormat(Type type, AudioFormat audioFormat, int nLengthInFrames, int nLengthInBytes, Map properties)
+        {
+                super(type, audioFormat, nLengthInFrames, nLengthInBytes, properties);
+        }
+
+        /**
+         * MP3 audio file format parameters.
+         * Some parameters might be unavailable. So availability test is required before reading any parameter.
+         *
+         * <br>AudioFileFormat parameters.
+         * <ul>
+         * <li><b>duration</b> [Long], duration in microseconds.
+         * <li><b>title</b> [String], Title of the stream.
+         * <li><b>author</b> [String], Name of the artist of the stream.
+         * <li><b>album</b> [String], Name of the album of the stream.
+         * <li><b>date</b> [String], The date (year) of the recording or release of the stream.
+         * <li><b>copyright</b> [String], Copyright message of the stream.
+         * <li><b>comment</b> [String], Comment of the stream.
+         * </ul>
+         * <br>MP3 parameters.
+         * <ul>
+         * <li><b>mp3.version.mpeg</b> [String], mpeg version : 1,2 or 2.5
+         * <li><b>mp3.version.layer</b> [String], layer version 1, 2 or 3
+         * <li><b>mp3.version.encoding</b> [String], mpeg encoding : MPEG1, MPEG2-LSF, MPEG2.5-LSF
+         * <li><b>mp3.channels</b> [Integer], number of channels 1 : mono, 2 : stereo.
+         * <li><b>mp3.frequency.hz</b> [Integer], sampling rate in hz.
+         * <li><b>mp3.bitrate.nominal.bps</b> [Integer], nominal bitrate in bps.
+         * <li><b>mp3.length.bytes</b> [Integer], length in bytes.
+         * <li><b>mp3.length.frames</b> [Integer], length in frames.
+         * <li><b>mp3.framesize.bytes</b> [Integer], framesize of the first frame. framesize is not constant for VBR streams.
+         * <li><b>mp3.framerate.fps</b> [Float], framerate in frames per seconds.
+         * <li><b>mp3.header.pos</b> [Integer], position of first audio header (or ID3v2 size).
+         * <li><b>mp3.vbr</b> [Boolean], vbr flag.
+         * <li><b>mp3.vbr.scale</b> [Integer], vbr scale.
+         * <li><b>mp3.crc</b> [Boolean], crc flag.
+         * <li><b>mp3.original</b> [Boolean], original flag.
+         * <li><b>mp3.copyright</b> [Boolean], copyright flag.
+         * <li><b>mp3.padding</b> [Boolean], padding flag.
+         * <li><b>mp3.mode</b> [Integer], mode 0:STEREO 1:JOINT_STEREO 2:DUAL_CHANNEL 3:SINGLE_CHANNEL
+         * <li><b>mp3.id3tag.genre</b> [String], ID3 tag (v1 or v2) genre.
+         * <li><b>mp3.id3tag.track</b> [String], ID3 tag (v1 or v2) track info.
+         * <li><b>mp3.id3tag.encoded</b> [String], ID3 tag v2 encoded by info.
+         * <li><b>mp3.id3tag.composer</b> [String], ID3 tag v2 composer info.
+         * <li><b>mp3.id3tag.grouping</b> [String], ID3 tag v2 grouping info.
+         * <li><b>mp3.id3tag.disc</b> [String], ID3 tag v2 track info.
+         * <li><b>mp3.id3tag.v2</b> [InputStream], ID3v2 frames.
+         * <li><b>mp3.id3tag.v2.version</b> [String], ID3v2 major version (2=v2.2.0, 3=v2.3.0, 4=v2.4.0).
+         * <li><b>mp3.shoutcast.metadata.key</b> [String], Shoutcast meta key with matching value.
+         * <br>For instance :
+         * <br>mp3.shoutcast.metadata.icy-irc=#shoutcast
+         * <br>mp3.shoutcast.metadata.icy-metaint=8192
+         * <br>mp3.shoutcast.metadata.icy-genre=Trance Techno Dance
+         * <br>mp3.shoutcast.metadata.icy-url=http://www.di.fm
+         * <br>and so on ...
+         * </ul>
+         */
+        public Map properties()
+        {
+                return super.properties();
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFileReader.java b/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFileReader.java
new file mode 100644
index 0000000000..54440551a1
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFileReader.java
@@ -0,0 +1,772 @@
+/*
+ * MpegAudioFileReader.
+ *
+ * 12/31/04 : mp3spi.weak system property added to skip controls.
+ * 
+ * 11/29/04 : ID3v2.2, v2.3 & v2.4 support improved.
+ *            "mp3.id3tag.composer" (TCOM/TCM) added
+ *            "mp3.id3tag.grouping" (TIT1/TT1) added
+ *            "mp3.id3tag.disc" (TPA/TPOS) added
+ *            "mp3.id3tag.encoded" (TEN/TENC) added
+ *            "mp3.id3tag.v2.version" added
+ * 
+ * 11/28/04 : String encoding bug fix in chopSubstring method.
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file;
+
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.net.URLConnection;
+import java.security.AccessControlException;
+import java.util.HashMap;
+
+import javax.sound.sampled.AudioFileFormat;
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.UnsupportedAudioFileException;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.Header;
+import javazoom.spi.mpeg.sampled.file.tag.IcyInputStream;
+import javazoom.spi.mpeg.sampled.file.tag.MP3Tag;
+
+import org.tritonus.share.TDebug;
+import org.tritonus.share.sampled.file.TAudioFileReader;
+
+/**
+ * This class implements AudioFileReader for MP3 SPI.
+ */
+public class MpegAudioFileReader extends TAudioFileReader
+{
+        private final int               SYNC = 0xFFE00000;
+        private String weak = null;
+        private final AudioFormat.Encoding[][]  sm_aEncodings =
+        {
+                {MpegEncoding.MPEG2L1, MpegEncoding.MPEG2L2, MpegEncoding.MPEG2L3},
+                {MpegEncoding.MPEG1L1, MpegEncoding.MPEG1L2, MpegEncoding.MPEG1L3},
+                {MpegEncoding.MPEG2DOT5L1, MpegEncoding.MPEG2DOT5L2, MpegEncoding.MPEG2DOT5L3},
+
+        };
+
+        private static final int        INITAL_READ_LENGTH = 64000;
+        private static final int        MARK_LIMIT = INITAL_READ_LENGTH + 1;
+
+        private static final String[] id3v1genres = {
+          "Blues"
+          , "Classic Rock"
+          , "Country"
+          , "Dance"
+          , "Disco"
+          , "Funk"
+          , "Grunge"
+          , "Hip-Hop"
+          , "Jazz"
+          , "Metal"
+          , "New Age"
+          , "Oldies"
+          , "Other"
+          , "Pop"
+          , "R&B"
+          , "Rap"
+          , "Reggae"
+          , "Rock"
+          , "Techno"
+          , "Industrial"
+          , "Alternative"
+          , "Ska"
+          , "Death Metal"
+          , "Pranks"
+          , "Soundtrack"
+          , "Euro-Techno"
+          , "Ambient"
+          , "Trip-Hop"
+          , "Vocal"
+          , "Jazz+Funk"
+          , "Fusion"
+          , "Trance"
+          , "Classical"
+          , "Instrumental"
+          , "Acid"
+          , "House"
+          , "Game"
+          , "Sound Clip"
+          , "Gospel"
+          , "Noise"
+          , "AlternRock"
+          , "Bass"
+          , "Soul"
+          , "Punk"
+          , "Space"
+          , "Meditative"
+          , "Instrumental Pop"
+          , "Instrumental Rock"
+          , "Ethnic"
+          , "Gothic"
+          , "Darkwave"
+          , "Techno-Industrial"
+          , "Electronic"
+          , "Pop-Folk"
+          , "Eurodance"
+          , "Dream"
+          , "Southern Rock"
+          , "Comedy"
+          , "Cult"
+          , "Gangsta"
+          , "Top 40"
+          , "Christian Rap"
+          , "Pop/Funk"
+          , "Jungle"
+          , "Native American"
+          , "Cabaret"
+          , "New Wave"
+          , "Psychadelic"
+          , "Rave"
+          , "Showtunes"
+          , "Trailer"
+          , "Lo-Fi"
+          , "Tribal"
+          , "Acid Punk"
+          , "Acid Jazz"
+          , "Polka"
+          , "Retro"
+          , "Musical"
+          , "Rock & Roll"
+          , "Hard Rock"
+          , "Folk"
+          , "Folk-Rock"
+          , "National Folk"
+          , "Swing"
+          , "Fast Fusion"
+          , "Bebob"
+          , "Latin"
+          , "Revival"
+          , "Celtic"
+          , "Bluegrass"
+          , "Avantgarde"
+          , "Gothic Rock"
+          , "Progressive Rock"
+          , "Psychedelic Rock"
+          , "Symphonic Rock"
+          , "Slow Rock"
+          , "Big Band"
+          , "Chorus"
+          , "Easy Listening"
+          , "Acoustic"
+          , "Humour"
+          , "Speech"
+          , "Chanson"
+          , "Opera"
+          , "Chamber Music"
+          , "Sonata"
+          , "Symphony"
+          , "Booty Brass"
+          , "Primus"
+          , "Porn Groove"
+          , "Satire"
+          , "Slow Jam"
+          , "Club"
+          , "Tango"
+          , "Samba"
+          , "Folklore"
+          , "Ballad"
+          , "Power Ballad"
+          , "Rhythmic Soul"
+          , "Freestyle"
+          , "Duet"
+          , "Punk Rock"
+          , "Drum Solo"
+          , "A Capela"
+          , "Euro-House"
+          , "Dance Hall"
+          , "Goa"
+          , "Drum & Bass"
+          , "Club-House"
+          , "Hardcore"
+          , "Terror"
+          , "Indie"
+          , "BritPop"
+          , "Negerpunk"
+          , "Polsk Punk"
+          , "Beat"
+          , "Christian Gangsta Rap"
+          , "Heavy Metal"
+          , "Black Metal"
+          , "Crossover"
+          , "Contemporary Christian"
+          , "Christian Rock"
+          , "Merengue"
+          , "Salsa"
+          , "Thrash Metal"
+          , "Anime"
+          , "JPop"
+          , "SynthPop"
+          };
+
+        public MpegAudioFileReader()
+        {
+                super(MARK_LIMIT, true);
+                if (TDebug.TraceAudioFileReader) TDebug.out(">MpegAudioFileReader(1.9.2-FINAL)");
+        try
+        {
+                weak = System.getProperty("mp3spi.weak");
+        }
+        catch(AccessControlException e)
+        {}
+        }
+
+        /**
+         * Returns AudioFileFormat from File.
+         */
+        public AudioFileFormat getAudioFileFormat(File file) throws UnsupportedAudioFileException, IOException
+        {               
+                return super.getAudioFileFormat(file);
+        }
+        
+        /**
+         * Returns AudioFileFormat from URL.
+         */
+        public AudioFileFormat getAudioFileFormat(URL url) throws UnsupportedAudioFileException, IOException
+        {               
+                if (TDebug.TraceAudioFileReader) {TDebug.out("MpegAudioFileReader.getAudioFileFormat(URL): begin"); }
+                long lFileLengthInBytes = AudioSystem.NOT_SPECIFIED;
+                URLConnection conn = url.openConnection();
+                // Tell shoucast server (if any) that SPI support shoutcast stream.
+                conn.setRequestProperty ("Icy-Metadata", "1");          
+                InputStream     inputStream = conn.getInputStream();
+                AudioFileFormat audioFileFormat = null;
+                try
+                {
+                        audioFileFormat = getAudioFileFormat(inputStream, lFileLengthInBytes);
+                }
+                finally
+                {
+                        inputStream.close();
+                }
+                if (TDebug.TraceAudioFileReader) {TDebug.out("MpegAudioFileReader.getAudioFileFormat(URL): end"); }
+                return audioFileFormat;
+        }
+        
+        /**
+         * Returns AudioFileFormat from inputstream and medialength.
+         */
+        public AudioFileFormat getAudioFileFormat(InputStream inputStream, long mediaLength) throws UnsupportedAudioFileException, IOException
+        {               
+                if (TDebug.TraceAudioFileReader) TDebug.out(">MpegAudioFileReader.getAudioFileFormat(InputStream inputStream, long mediaLength): begin");               
+                HashMap aff_properties = new HashMap();
+                HashMap af_properties = new HashMap();
+                int mLength = (int) mediaLength;
+                int size = inputStream.available();             
+                PushbackInputStream pis = new PushbackInputStream(inputStream, MARK_LIMIT);
+                byte head[] = new byte[12];
+                pis.read(head);
+                if (TDebug.TraceAudioFileReader)
+                {
+                        TDebug.out("InputStream : "+inputStream + " =>" + new String(head));
+                }
+                /*
+                 * Check for WAV, AU, and AIFF file formats.
+                 *
+                 * Next check for Shoutcast (supported) and OGG (unsupported) streams.
+                 *
+                 * Note -- the check for WAV files will reject Broadcast WAV files.
+                 * This may be incorrect as broadcast WAV files may contain MPEG data.
+                 * Need to investigate.
+                 *
+                 */
+                if ((head[0] == 'R') && (head[1] == 'I') && (head[2] == 'F') && (head[3] == 'F') && (head[8] == 'W') && (head[9] == 'A') && (head[10] == 'V') && (head[11] == 'E'))
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("WAV stream found");
+                        if (weak == null) throw new UnsupportedAudioFileException("WAV stream found");
+                }
+                else if ((head[0] == '.') && (head[1] == 's') && (head[2] == 'n') && (head[3] == 'd'))
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("AU stream found");
+                        if (weak == null) throw new UnsupportedAudioFileException("AU stream found");
+                }
+                else if ((head[0] == 'F') && (head[1] == 'O') && (head[2] == 'R') && (head[3] == 'M') && (head[8] == 'A') && (head[9] == 'I') && (head[10] == 'F') && (head[11] == 'F'))
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("AIFF stream found");
+                        if (weak == null) throw new UnsupportedAudioFileException("AIFF stream found");
+                }
+                // Shoutcast stream ?
+                else if (((head[0] == 'I') | (head[0] == 'i')) && ((head[1] == 'C') | (head[1] == 'c')) && ((head[2] == 'Y') | (head[2] == 'y')))
+                {
+                        pis.unread(head);
+                        // Load shoutcast meta data.
+                        loadShoutcastInfo(pis, aff_properties);                 
+                }
+                // Ogg stream ?
+                else if (((head[0] == 'O') | (head[0] == 'o')) && ((head[1] == 'G') | (head[1] == 'g')) && ((head[2] == 'G') | (head[2] == 'g')))
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("Ogg stream found");
+                        if (weak == null) throw new UnsupportedAudioFileException("Ogg stream found");
+                }
+                // No, so pushback.
+                else
+                {
+                        pis.unread(head);
+                }
+                // MPEG header info.
+                int nVersion = AudioSystem.NOT_SPECIFIED;
+                int nLayer = AudioSystem.NOT_SPECIFIED;
+                int nSFIndex = AudioSystem.NOT_SPECIFIED;
+                int nMode = AudioSystem.NOT_SPECIFIED;
+                int FrameSize = AudioSystem.NOT_SPECIFIED;
+                int nFrameSize = AudioSystem.NOT_SPECIFIED;
+                int nFrequency = AudioSystem.NOT_SPECIFIED;
+                int nTotalFrames = AudioSystem.NOT_SPECIFIED;
+                float FrameRate = AudioSystem.NOT_SPECIFIED;
+                int BitRate = AudioSystem.NOT_SPECIFIED;
+                int nChannels = AudioSystem.NOT_SPECIFIED;
+                int nHeader = AudioSystem.NOT_SPECIFIED;
+                int nTotalMS = AudioSystem.NOT_SPECIFIED;
+                boolean nVBR = false;
+                AudioFormat.Encoding encoding = null;
+                try
+                {
+                        Bitstream m_bitstream = new Bitstream(pis);
+                        aff_properties.put("mp3.header.pos",new Integer(m_bitstream.header_pos()));
+                        Header m_header = m_bitstream.readFrame();
+                        // nVersion = 0 => MPEG2-LSF (Including MPEG2.5), nVersion = 1 => MPEG1
+                        nVersion = m_header.version();
+                        if (nVersion == 2) aff_properties.put("mp3.version.mpeg",Float.toString(2.5f));                 
+                        else aff_properties.put("mp3.version.mpeg",Integer.toString(2-nVersion));                       
+                        // nLayer = 1,2,3
+                        nLayer = m_header.layer();
+                        aff_properties.put("mp3.version.layer",Integer.toString(nLayer));                       
+                        nSFIndex = m_header.sample_frequency();
+                        nMode = m_header.mode();
+                        aff_properties.put("mp3.mode",new Integer(nMode));
+                        nChannels = nMode == 3 ? 1 : 2;
+                        aff_properties.put("mp3.channels",new Integer(nChannels));
+                        nVBR = m_header.vbr();                  
+                        af_properties.put("vbr",new Boolean(nVBR));
+                        aff_properties.put("mp3.vbr",new Boolean(nVBR));
+                        aff_properties.put("mp3.vbr.scale",new Integer(m_header.vbr_scale()));
+                        FrameSize = m_header.calculate_framesize();
+                        aff_properties.put("mp3.framesize.bytes",new Integer(FrameSize));
+                        if (FrameSize < 0) throw new UnsupportedAudioFileException("Invalid FrameSize : " + FrameSize);
+                        nFrequency = m_header.frequency();
+                        aff_properties.put("mp3.frequency.hz",new Integer(nFrequency));
+                        FrameRate = (float) ((1.0 / (m_header.ms_per_frame())) * 1000.0);
+                        aff_properties.put("mp3.framerate.fps",new Float(FrameRate));
+                        if (FrameRate < 0) throw new UnsupportedAudioFileException("Invalid FrameRate : " + FrameRate);
+                        if (mLength != AudioSystem.NOT_SPECIFIED)
+                        {
+                                aff_properties.put("mp3.length.bytes",new Integer(mLength));
+                                nTotalFrames = m_header.max_number_of_frames(mLength);
+                                aff_properties.put("mp3.length.frames",new Integer(nTotalFrames));
+                        }
+                        BitRate = m_header.bitrate();                   
+                        af_properties.put("bitrate",new Integer(BitRate));
+                        aff_properties.put("mp3.bitrate.nominal.bps",new Integer(BitRate));
+                        nHeader = m_header.getSyncHeader();
+                        encoding = sm_aEncodings[nVersion][nLayer - 1];
+                        aff_properties.put("mp3.version.encoding",encoding.toString());
+                        if (mLength != AudioSystem.NOT_SPECIFIED)
+                        {
+                                nTotalMS = Math.round(m_header.total_ms(mLength));
+                                aff_properties.put("duration",new Long((long)nTotalMS*1000L));
+                        }
+                        aff_properties.put("mp3.copyright",new Boolean(m_header.copyright()));
+                        aff_properties.put("mp3.original",new Boolean(m_header.original()));
+                        aff_properties.put("mp3.crc",new Boolean(m_header.checksums()));
+                        aff_properties.put("mp3.padding",new Boolean(m_header.padding()));
+                        InputStream id3v2 = m_bitstream.getRawID3v2();
+                        if (id3v2 != null)
+                        {
+                                aff_properties.put("mp3.id3tag.v2",id3v2);
+                                parseID3v2Frames(id3v2,aff_properties);
+                        } 
+                        if (TDebug.TraceAudioFileReader) TDebug.out(m_header.toString());
+                }
+                catch (Exception e)
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("not a MPEG stream:" + e.getMessage());
+                        throw new UnsupportedAudioFileException("not a MPEG stream:" + e.getMessage());
+                }
+
+                // Deeper checks ?
+                int cVersion = (nHeader >> 19) & 0x3;
+                if (cVersion == 1)
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("not a MPEG stream: wrong version");
+                        throw new UnsupportedAudioFileException("not a MPEG stream: wrong version");
+                }
+
+                int cSFIndex = (nHeader >> 10) & 0x3;
+                if (cSFIndex == 3)
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("not a MPEG stream: wrong sampling rate");
+                        throw new UnsupportedAudioFileException("not a MPEG stream: wrong sampling rate");
+                }
+                
+                // Look up for ID3v1 tag
+                if ((size == mediaLength) && (mediaLength != AudioSystem.NOT_SPECIFIED))
+                {
+                        FileInputStream fis = (FileInputStream) inputStream;
+                        byte[] id3v1 = new byte[128];
+                        long bytesSkipped = fis.skip(inputStream.available()-id3v1.length);
+                        int read = fis.read(id3v1,0,id3v1.length);
+                        if ((id3v1[0]=='T') && (id3v1[1]=='A') && (id3v1[2]=='G'))
+                        {
+                                parseID3v1Frames(id3v1, aff_properties);
+                        }
+                }               
+                
+                AudioFormat format = new MpegAudioFormat(encoding, (float) nFrequency, AudioSystem.NOT_SPECIFIED // SampleSizeInBits - The size of a sample
+                , nChannels // Channels - The number of channels
+                , -1 // The number of bytes in each frame
+                , FrameRate // FrameRate - The number of frames played or recorded per second
+                , true
+                , af_properties);
+                return new MpegAudioFileFormat(MpegFileFormatType.MP3, format, nTotalFrames, mLength,aff_properties);
+        }
+
+        /**
+         * Returns AudioInputStream from file.
+         */
+        public AudioInputStream getAudioInputStream(File file) throws UnsupportedAudioFileException, IOException
+        {
+          if (TDebug.TraceAudioFileReader) TDebug.out("getAudioInputStream(File file)");          
+          InputStream inputStream = new FileInputStream(file);
+          try
+          {             
+                return getAudioInputStream(inputStream);
+          }
+          catch (UnsupportedAudioFileException e)
+          {
+                if (inputStream != null) inputStream.close();
+                throw e;
+          }
+          catch (IOException e)
+          {
+                if (inputStream != null) inputStream.close();
+                throw e;
+          }
+        }
+
+        /**
+         * Returns AudioInputStream from url.
+         */
+        public AudioInputStream getAudioInputStream(URL url)
+                throws  UnsupportedAudioFileException, IOException
+        {
+                if (TDebug.TraceAudioFileReader) {TDebug.out("MpegAudioFileReader.getAudioInputStream(URL): begin"); }
+                long lFileLengthInBytes = AudioSystem.NOT_SPECIFIED;
+                URLConnection conn = url.openConnection();
+                // Tell shoucast server (if any) that SPI support shoutcast stream.
+                boolean isShout = false;
+                int toRead=4;
+                byte[] head = new byte[toRead];
+                
+                conn.setRequestProperty ("Icy-Metadata", "1");
+                BufferedInputStream bInputStream = new BufferedInputStream(conn.getInputStream());
+                bInputStream.mark(toRead);
+                int read = bInputStream.read(head,0,toRead);    
+                if ((read>2) && (((head[0] == 'I') | (head[0] == 'i')) && ((head[1] == 'C') | (head[1] == 'c')) && ((head[2] == 'Y') | (head[2] == 'y')))) isShout = true;
+                bInputStream.reset();
+                InputStream     inputStream = null;
+                // Is is a shoutcast server ?
+                if (isShout == true)
+                {
+                        // Yes
+                        IcyInputStream icyStream = new IcyInputStream(bInputStream);
+                        icyStream.addTagParseListener(IcyListener.getInstance());
+                        inputStream = icyStream;        
+                }
+                else
+                {
+                        // No, is Icecast 2 ?
+                        String metaint = conn.getHeaderField("icy-metaint");
+                        if (metaint != null)
+                        {
+                                // Yes, it might be icecast 2 mp3 stream.
+                                IcyInputStream icyStream = new IcyInputStream(bInputStream,metaint);
+                                icyStream.addTagParseListener(IcyListener.getInstance());
+                                inputStream = icyStream;                                        
+                        }
+                        else
+                        {
+                                // No
+                                inputStream = bInputStream;
+                        }                                       
+                } 
+                AudioInputStream audioInputStream = null;
+                try
+                {
+                        audioInputStream = getAudioInputStream(inputStream, lFileLengthInBytes);
+                }
+                catch (UnsupportedAudioFileException e)
+                {
+                        inputStream.close();
+                        throw e;
+                }
+                catch (IOException e)
+                {
+                        inputStream.close();
+                        throw e;
+                }
+                if (TDebug.TraceAudioFileReader) {TDebug.out("MpegAudioFileReader.getAudioInputStream(URL): end"); }
+                return audioInputStream;
+        }
+
+        /**
+         * Return the AudioInputStream from the given InputStream.
+         */
+        public AudioInputStream getAudioInputStream(InputStream inputStream) throws UnsupportedAudioFileException, IOException
+        {
+          if (TDebug.TraceAudioFileReader) TDebug.out("MpegAudioFileReader.getAudioInputStream(InputStream inputStream)");
+          if (!inputStream.markSupported()) inputStream = new BufferedInputStream(inputStream);           
+          return super.getAudioInputStream(inputStream);
+        }
+        
+        /**
+         * Parser ID3v1 frames
+         * @param frames
+         * @param props
+         */
+        protected void parseID3v1Frames(byte[] frames, HashMap props)
+        {
+                if (TDebug.TraceAudioFileReader) TDebug.out("Parsing ID3v1");
+                String tag = null;
+                try
+                {
+                        tag = new String(frames, 0, frames.length, "ISO-8859-1"); 
+                }
+                catch (UnsupportedEncodingException e)
+                {
+                        tag = new String(frames, 0, frames.length);
+                        if (TDebug.TraceAudioFileReader) TDebug.out("Cannot use ISO-8859-1");
+                }
+                if (TDebug.TraceAudioFileReader) TDebug.out("ID3v1 frame dump='"+tag+"'");
+                int start = 3;
+                String titlev1 = chopSubstring(tag, start, start += 30);
+                String titlev2 = (String) props.get("title"); 
+                if (((titlev2==null) || (titlev2.length()==0)) && (titlev1 != null)) props.put("title",titlev1);
+                String artistv1 = chopSubstring(tag, start, start += 30);
+                String artistv2 = (String) props.get("author"); 
+                if (((artistv2==null) || (artistv2.length()==0)) && (artistv1 != null)) props.put("author",artistv1);                           
+                String albumv1 = chopSubstring(tag, start, start += 30);
+                String albumv2 = (String) props.get("album");
+                if (((albumv2==null) || (albumv2.length()==0)) && (albumv1 != null)) props.put("album",albumv1);
+                String yearv1 = chopSubstring(tag, start, start += 4);
+                String yearv2 = (String) props.get("year");
+                if (((yearv2==null) || (yearv2.length()==0)) && (yearv1 != null)) props.put("date",yearv1);     
+                String commentv1 = chopSubstring(tag, start, start += 28);
+                String commentv2 = (String) props.get("comment");
+                if (((commentv2==null) || (commentv2.length()==0)) && (commentv1 != null)) props.put("comment",commentv1);              
+                String trackv1 = ""+((int) (frames[126] & 0xff));
+                String trackv2 = (String) props.get("mp3.id3tag.track");
+                if (((trackv2==null) || (trackv2.length()==0)) && (trackv1 != null)) props.put("mp3.id3tag.track",trackv1);
+                
+                int genrev1 = (int) (frames[127] & 0xff);
+                if ((genrev1 >=0) && (genrev1<id3v1genres.length))
+                {
+                        String genrev2 = (String) props.get("mp3.id3tag.genre");
+                        if (((genrev2==null) || (genrev2.length()==0))) props.put("mp3.id3tag.genre",id3v1genres[genrev1]);     
+                }
+                if (TDebug.TraceAudioFileReader) TDebug.out("ID3v1 parsed");            
+        }
+        
+        /**
+         * Extract 
+         * @param s
+         * @param start
+         * @param end
+         * @return
+         */
+        private String chopSubstring(String s, int start, int end) 
+        {
+                String str = null;
+                // 11/28/04 - String encoding bug fix.
+                try
+                {
+                        str = s.substring(start, end);
+                        int loc = str.indexOf('\0');    
+                        if (loc != -1) str = str.substring(0, loc);
+                }
+                catch (StringIndexOutOfBoundsException e)
+                {
+                        // Skip encoding issues.
+                        if (TDebug.TraceAudioFileReader) TDebug.out("Cannot chopSubString "+e.getMessage());
+                }
+                return str;
+        }
+        /**
+         * Parse ID3v2 frames to add album (TALB), title (TIT2), date (TYER), author (TPE1), copyright (TCOP), comment (COMM) ...
+         * @param frames
+         * @param props
+         */
+        protected void parseID3v2Frames(InputStream frames, HashMap props)
+        {
+                if (TDebug.TraceAudioFileReader) TDebug.out("Parsing ID3v2");
+                byte[] bframes = null;
+                int size = -1;
+                try
+                {
+                        size = frames.available();
+                        bframes = new byte[size];
+                        frames.mark(size);                                      
+                        frames.read(bframes);
+                        frames.reset();                                 
+                }
+                catch (IOException e)
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("Cannot parse ID3v2 :"+e.getMessage());
+                }
+
+                try
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("ID3v2 frame dump='"+new String(bframes,0,bframes.length)+"'");
+                        /* ID3 tags : http://www.unixgods.org/~tilo/ID3/docs/ID3_comparison.html */
+                        String value = null;
+                        for (int i=0;i<bframes.length-4;i++)
+                        {
+                                String code = new String(bframes,i,4);
+                                String scode = new String(bframes,i,3);
+                                // ID3v2.3 & v2.4
+                                if ((code.equals("TALB")) || (code.equals("TIT2")) || (code.equals("TYER")) || (code.equals("TPE1")) || (code.equals("TCOP")) || (code.equals("COMM")) || (code.equals("TCON")) || (code.equals("TRCK")) || (code.equals("TPOS")) || (code.equals("TDRC")) || (code.equals("TCOM")) || (code.equals("TIT1")) || (code.equals("TENC")))
+                                {
+                                        i=i+10;
+                                        size = (int) (bframes[i-6] << 24) + (bframes[i-5] << 16) + (bframes[i-4] << 8) + (bframes[i-3]);                                        
+                                        if (code.equals("COMM")) value = parseText(bframes, i, size, 5);
+                                        else value = parseText(bframes,i, size, 1);                                     
+                                        if ((value != null) && (value.length()>0))
+                                        {
+                                                if (code.equals("TALB")) props.put("album",value);
+                                                else if (code.equals("TIT2")) props.put("title",value);
+                                                else if (code.equals("TYER")) props.put("date",value);
+                                                // ID3v2.4 date fix.
+                                                else if (code.equals("TDRC")) props.put("date",value);
+                                                else if (code.equals("TPE1")) props.put("author",value);
+                                                else if (code.equals("TCOP")) props.put("copyright",value);
+                                                else if (code.equals("COMM")) props.put("comment",value);                                               
+                                                else if (code.equals("TCON")) props.put("mp3.id3tag.genre",value);
+                                                else if (code.equals("TRCK")) props.put("mp3.id3tag.track",value);
+                                                else if (code.equals("TPOS")) props.put("mp3.id3tag.disc",value);
+                                                else if (code.equals("TCOM")) props.put("mp3.id3tag.composer",value);
+                                                else if (code.equals("TIT1")) props.put("mp3.id3tag.grouping",value);
+                                                else if (code.equals("TENC")) props.put("mp3.id3tag.encoded",value);
+                                        } 
+                                        i=i+size-1;
+                                }
+                                // ID3v2.2.
+                                else if ((scode.equals("TAL")) || (scode.equals("TT2")) || (scode.equals("TP1")) || (scode.equals("TYE")) || (scode.equals("TRK")) || (scode.equals("TPA")) || (scode.equals("TCR")) || (scode.equals("TCO")) || (scode.equals("TCM")) || (scode.equals("COM")) || (scode.equals("TT1")) || (scode.equals("TEN")))
+                                {
+                                        i=i+6;
+                                        size = (int) (0x00000000) + (bframes[i-3] << 16) + (bframes[i-2] << 8) + (bframes[i-1]);                                        
+                                        if (scode.equals("COM")) value = parseText(bframes, i, size, 5);
+                                        else value = parseText(bframes,i, size, 1);                                     
+                                        if ((value != null) && (value.length()>0))
+                                        {
+                                                if (scode.equals("TAL")) props.put("album",value);
+                                                else if (scode.equals("TT2")) props.put("title",value);
+                                                else if (scode.equals("TYE")) props.put("date",value);
+                                                else if (scode.equals("TP1")) props.put("author",value);
+                                                else if (scode.equals("TCR")) props.put("copyright",value);
+                                                else if (scode.equals("COM")) props.put("comment",value);                                               
+                                                else if (scode.equals("TCO")) props.put("mp3.id3tag.genre",value);
+                                                else if (scode.equals("TRK")) props.put("mp3.id3tag.track",value);
+                                                else if (scode.equals("TPA")) props.put("mp3.id3tag.disc",value);
+                                                else if (scode.equals("TCM")) props.put("mp3.id3tag.composer",value);
+                                                else if (scode.equals("TT1")) props.put("mp3.id3tag.grouping",value);
+                                                else if (scode.equals("TEN")) props.put("mp3.id3tag.encoded",value);
+                                        } 
+                                        i=i+size-1;
+                                }
+                                else if (code.startsWith("ID3"))
+                                {
+                                        // ID3v2 Header.
+                                        int v2version = (int) (bframes[3] & 0xFF);
+                                        props.put("mp3.id3tag.v2.version",String.valueOf(v2version));
+                                        i=i+4;
+                                }
+                        }
+                }
+                catch (RuntimeException e)
+                {
+                        // Ignore all parsing errors.
+                        if (TDebug.TraceAudioFileReader) TDebug.out("Cannot parse ID3v2 :"+e.getMessage());
+                }
+                if (TDebug.TraceAudioFileReader) TDebug.out("ID3v2 parsed");
+        }
+
+        /**
+         * Parse Text Frames.
+         * @param bframes
+         * @param offset
+         * @param size
+         * @param skip
+         * @return
+         */
+        protected String parseText(byte[] bframes, int offset, int size, int skip)
+        {
+                String value = null;
+                try
+                {
+                        String[] ENC_TYPES = {"ISO-8859-1", "UTF16","UTF-16BE", "UTF-8"};
+                        value = new String(bframes,offset+skip,size-skip,ENC_TYPES[bframes[offset]]);
+                        value = chopSubstring(value,0,value.length());                          
+                }
+                catch (UnsupportedEncodingException e)
+                {
+                        if (TDebug.TraceAudioFileReader) TDebug.out("ID3v2 Encoding error :"+e.getMessage());
+                }
+                return value;
+        }
+        
+        /**
+         * Load shoutcast (ICY) info.
+         * @param input
+         * @param props
+         * @throws IOException
+         */
+        protected void loadShoutcastInfo(InputStream input, HashMap props) throws IOException
+        {
+          IcyInputStream icy = new IcyInputStream(new BufferedInputStream(input));
+          HashMap metadata = icy.getTagHash();
+          MP3Tag titleMP3Tag = icy.getTag("icy-name");
+          if (titleMP3Tag != null) props.put("title",((String) titleMP3Tag.getValue()).trim());
+          MP3Tag[] meta = icy.getTags();
+          if (meta != null)
+          {
+                  StringBuffer metaStr = new StringBuffer();
+                  for (int i=0;i<meta.length;i++)
+                  {
+                          String key = meta[i].getName();
+                          String value = ((String) icy.getTag(key).getValue()).trim();
+                          props.put("mp3.shoutcast.metadata."+key, value);                                        
+                  }
+          }
+        }
+        
+}
\ No newline at end of file
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFormat.java b/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFormat.java
new file mode 100644
index 0000000000..29a66a3d93
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/MpegAudioFormat.java
@@ -0,0 +1,67 @@
+/*
+ * MpegAudioFormat.
+ * 
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file;
+
+import java.util.Map;
+
+import javax.sound.sampled.AudioFormat;
+
+import org.tritonus.share.sampled.TAudioFormat;
+
+/**
+ * @author JavaZOOM
+ */
+public class MpegAudioFormat extends TAudioFormat
+{       
+        /**
+         * Constructor.
+         * @param encoding
+         * @param nFrequency
+         * @param SampleSizeInBits
+         * @param nChannels
+         * @param FrameSize
+         * @param FrameRate
+         * @param isBigEndian
+         * @param properties
+         */
+        public MpegAudioFormat(AudioFormat.Encoding encoding, float nFrequency, int SampleSizeInBits, int nChannels, int FrameSize, float FrameRate, boolean isBigEndian, Map properties)
+        {
+                super(encoding, nFrequency, SampleSizeInBits, nChannels, FrameSize, FrameRate, isBigEndian, properties);
+        }
+
+        /**
+         * MP3 audio format parameters. 
+         * Some parameters might be unavailable. So availability test is required before reading any parameter.  
+         *
+         * <br>AudioFormat parameters.
+         * <ul>
+         * <li><b>bitrate</b> [Integer], bitrate in bits per seconds, average bitrate for VBR enabled stream.
+         * <li><b>vbr</b> [Boolean], VBR flag.
+         * </ul>
+         */
+        public Map properties()
+        {
+                return super.properties();      
+        }       
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/MpegEncoding.java b/songdbj/javazoom/spi/mpeg/sampled/file/MpegEncoding.java
new file mode 100644
index 0000000000..6306d9ec80
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/MpegEncoding.java
@@ -0,0 +1,47 @@
+/*
+ * MpegEncoding.
+ * 
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file;
+
+import javax.sound.sampled.AudioFormat;
+
+/**     
+ * Encodings used by the MPEG audio decoder.
+ */
+public class MpegEncoding extends AudioFormat.Encoding
+{
+        public static final AudioFormat.Encoding        MPEG1L1 = new MpegEncoding("MPEG1L1");
+        public static final AudioFormat.Encoding        MPEG1L2 = new MpegEncoding("MPEG1L2");
+        public static final AudioFormat.Encoding        MPEG1L3 = new MpegEncoding("MPEG1L3");
+        public static final AudioFormat.Encoding        MPEG2L1 = new MpegEncoding("MPEG2L1");
+        public static final AudioFormat.Encoding        MPEG2L2 = new MpegEncoding("MPEG2L2");
+        public static final AudioFormat.Encoding        MPEG2L3 = new MpegEncoding("MPEG2L3");
+        public static final AudioFormat.Encoding        MPEG2DOT5L1 = new MpegEncoding("MPEG2DOT5L1");
+        public static final AudioFormat.Encoding        MPEG2DOT5L2 = new MpegEncoding("MPEG2DOT5L2");
+        public static final AudioFormat.Encoding        MPEG2DOT5L3 = new MpegEncoding("MPEG2DOT5L3");
+
+        public MpegEncoding(String strName)
+        {
+                super(strName);
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/MpegFileFormatType.java b/songdbj/javazoom/spi/mpeg/sampled/file/MpegFileFormatType.java
new file mode 100644
index 0000000000..2c59ad8621
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/MpegFileFormatType.java
@@ -0,0 +1,40 @@
+/*
+ * MpegFileFormatType.
+ * 
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ *  
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file;
+
+import javax.sound.sampled.AudioFileFormat;
+
+/**     
+ *  FileFormatTypes used by the MPEG audio decoder.
+ */
+public class MpegFileFormatType extends AudioFileFormat.Type
+{
+        public static final AudioFileFormat.Type        MPEG = new MpegFileFormatType("MPEG", "mpeg");
+        public static final AudioFileFormat.Type        MP3 = new MpegFileFormatType("MP3", "mp3");
+
+        public MpegFileFormatType(String strName, String strExtension)
+        {
+                super(strName, strExtension);
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/IcyInputStream.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/IcyInputStream.java
new file mode 100644
index 0000000000..22aa4439fe
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/IcyInputStream.java
@@ -0,0 +1,412 @@
+/*
+ * IcyInputStream.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+ 
+package javazoom.spi.mpeg.sampled.file.tag;
+
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.HashMap;
+import java.util.StringTokenizer;
+
+/** An BufferedInputStream that parses Shoutcast's "icy" metadata
+    from the stream.  Gets headers at the beginning and if the
+    "icy-metaint" tag is found, it parses and strips in-stream
+    metadata.
+    <p>
+    <b>The deal with metaint</b>: Icy streams don't try to put
+    tags between MP3 frames the way that ID3 does.  Instead, it
+    requires the client to strip metadata from the stream before
+    it hits the decoder.  You get an
+    <code>icy-metaint</code> name/val in the beginning of the
+    stream iff you sent "Icy-Metadata" with value "1" in the
+    request headers (SimpleMP3DataSource does this if the
+    "parseStreamMetadata" boolean is true).  If this is the case
+    then the value of icy-metaint is the amount of real data
+    between metadata blocks.  Each block begins with an int 
+    indicating how much metadata there is -- the block is this
+    value times 16 (it can be, and often is, 0).
+    <p>
+    Originally thought that "icy" implied Icecast, but this is
+    completely wrong -- real Icecast servers, found through
+    www.icecast.net and typified by URLs with a trailing directory 
+    (like CalArts School of Music - http://65.165.174.100:8000/som)
+    do not have the "ICY 200 OK" magic string or any of the 
+    CRLF-separated headers.  Apparently, "icy" means "Shoutcast".
+    Yep, that's weird.
+    @author Chris Adamson, invalidname@mac.com
+ */
+public class IcyInputStream
+        extends BufferedInputStream
+        implements MP3MetadataParser {
+        
+        public static boolean DEBUG = false;
+        
+        MP3TagParseSupport tagParseSupport;
+        /** inline tags are delimited by ';', also filter out
+            null bytes
+         */
+        protected static final String INLINE_TAG_SEPARATORS = ";\u0000";
+        /* looks like icy streams start start with
+           ICY 200 OK\r\n
+           then the tags are like
+           icy-notice1:<BR>This stream requires <a href="http://www.winamp.com/">Winamp</a><BR>\r\n
+           icy-notice2:SHOUTcast Distributed Network Audio Server/win32 v1.8.2<BR>\r\n
+           icy-name:Core-upt Radio\r\n
+           icy-genre:Punk Ska Emo\r\n
+           icy-url:http://www.core-uptrecords.com\r\n
+           icy-pub:1\r\n
+           icy-metaint:8192\r\n
+           icy-br:56\r\n
+           \r\n (signifies end of headers)
+           we only get icy-metaint if the http request that created
+           this stream sent the header "icy-metadata:1"
+           //
+           in in-line metadata, we read a byte that tells us how
+           many 16-byte blocks there are (presumably, we still use
+           \r\n for the separator... the block is padded out with
+           0x00's that we can ignore)
+        
+           // when server is full/down/etc, we get the following for
+           // one of the notice lines:
+           icy-notice2:This server has reached its user limit<BR>
+               or
+           icy-notice2:The resource requested is currently unavailable<BR>
+         */
+        /** Tags that have been discovered in the stream.
+         */
+        HashMap tags;
+        /** Buffer for readCRLF line... note this limits lines to
+            1024 chars (I've read that WinAmp barfs at 128, so
+            this is generous)
+         */
+        protected byte[] crlfBuffer = new byte[1024];
+        /** value of the "metaint" tag, which tells us how many bytes
+            of real data are between the metadata tags.  if -1, this stream
+            does not have metadata after the header.
+         */
+        protected int metaint = -1;
+        /** how many bytes of real data remain before the next
+            block of metadata.  Only meaningful if metaint != -1.
+         */
+        protected int bytesUntilNextMetadata = -1;
+        // TODO: comment for constructor
+        /** Reads the initial headers of the stream and adds
+            tags appropriatly.  Gets set up to find, read, 
+            and strip blocks of in-line metadata if the
+            <code>icy-metaint</code> header is found.
+         */
+        public IcyInputStream(InputStream in) throws IOException {
+                super(in);
+                tags = new HashMap();
+                tagParseSupport = new MP3TagParseSupport();
+                // read the initial tags here, including the metaint
+                // and set the counter for how far we read until
+                // the next metadata block (if any).
+                readInitialHeaders();
+                IcyTag metaIntTag = (IcyTag) getTag("icy-metaint");
+                if (DEBUG) System.out.println("METATAG:"+metaIntTag);
+                if (metaIntTag != null) {
+                        String metaIntString = metaIntTag.getValueAsString();                   
+                        try {
+                                metaint = Integer.parseInt(metaIntString.trim());
+                                if (DEBUG) System.out.println("METAINT:"+metaint);
+                                bytesUntilNextMetadata = metaint;
+                        }
+                        catch (NumberFormatException nfe) {
+                        }
+                }
+        }
+
+        /**
+         * IcyInputStream constructor for know meta-interval (Icecast 2)
+         * @param in
+         * @param metaint
+         * @throws IOException
+         */
+        public IcyInputStream(InputStream in, String metaIntString) throws IOException {
+                super(in);
+                tags = new HashMap();
+                tagParseSupport = new MP3TagParseSupport();
+                try 
+                {
+                        metaint = Integer.parseInt(metaIntString.trim());
+                        if (DEBUG) System.out.println("METAINT:"+metaint);
+                        bytesUntilNextMetadata = metaint;
+                }
+                catch (NumberFormatException nfe) {
+                }
+        }
+
+        /** Assuming we're at the top of the stream, read lines one
+            by one until we hit a completely blank \r\n.  Parse the 
+            data as IcyTags.
+         */
+        protected void readInitialHeaders() throws IOException {
+                String line = null;
+                while (!((line = readCRLFLine()).equals(""))) {
+                        int colonIndex = line.indexOf(':');
+                        // does it have a ':' separator
+                        if (colonIndex == -1)
+                                continue;
+                        IcyTag tag =
+                                new IcyTag(
+                                        line.substring(0, colonIndex),
+                                        line.substring(colonIndex + 1));
+                        //System.out.println(tag);
+                        addTag(tag);
+                }
+        }
+        /** Read everything up to the next CRLF, return it as 
+            a String.
+         */
+        protected String readCRLFLine() throws IOException {
+                int i = 0;
+                for (; i < crlfBuffer.length; i++) {
+                        byte aByte = (byte) read();
+                        if (aByte == '\r') {
+                                // possible end of line
+                                byte anotherByte = (byte) read();
+                                i++; // since we read again
+                                if (anotherByte == '\n') {
+                                        break; // break out of while
+                                }
+                                else {
+                                        // oops, not end of line - put these in array
+                                        crlfBuffer[i - 1] = aByte;
+                                        crlfBuffer[i] = anotherByte;
+                                }
+                        }
+                        else {
+                                // if not \r
+                                crlfBuffer[i] = aByte;
+                        }
+                } // for
+                // get the string from the byte[].  i is 1 too high because of
+                // read-ahead in crlf block
+                return new String(crlfBuffer, 0, i - 1);
+        }
+        /** Reads and returns a single byte.
+            If the next byte is a metadata block, then that
+            block is read, stripped, and parsed before reading
+            and returning the first byte after the metadata block.
+         */
+        public int read() throws IOException {
+                if (bytesUntilNextMetadata > 0) {
+                        bytesUntilNextMetadata--;
+                        return super.read();
+                }
+                else if (bytesUntilNextMetadata == 0) {
+                        // we need to read next metadata block
+                        readMetadata();
+                        bytesUntilNextMetadata = metaint - 1;
+                        // -1 because we read byte on next line
+                        return super.read();
+                }
+                else {
+                        // no metadata in this stream
+                        return super.read();
+                }
+        }
+        /** Reads a block of bytes.  If the next byte is known
+            to be a block of metadata, then that is read, parsed,
+            and stripped, and then a block of bytes is read and
+            returned.
+            Otherwise, it may read up to but
+            not into the next metadata block if
+            <code>bytesUntilNextMetadata &lt; length</code>
+         */
+        public int read(byte[] buf, int offset, int length) throws IOException {
+                // if not on metadata, do the usual read so long as we
+                // don't read past metadata
+                if (bytesUntilNextMetadata > 0) {
+                        int adjLength = Math.min(length, bytesUntilNextMetadata);
+                        int got = super.read(buf, offset, adjLength);
+                        bytesUntilNextMetadata -= got;
+                        return got;
+                }
+                else if (bytesUntilNextMetadata == 0) {
+                        // read/parse the metadata
+                        readMetadata();
+                        // now as above, except that we reset
+                        // bytesUntilNextMetadata differently
+                        
+                        //int adjLength = Math.min(length, bytesUntilNextMetadata);
+                        //int got = super.read(buf, offset, adjLength);
+                        //bytesUntilNextMetadata = metaint - got;
+
+                        // Chop Fix - JavaZOOM (3 lines above seem buggy)
+                        bytesUntilNextMetadata = metaint;
+                        int adjLength = Math.min(length, bytesUntilNextMetadata);
+                        int got = super.read(buf, offset, adjLength);
+                        bytesUntilNextMetadata -= got;
+                        // End fix - JavaZOOM
+                        
+                        
+                        return got;
+                }
+                else {
+                        // not even reading metadata
+                        return super.read(buf, offset, length);
+                }
+        }
+        /** trivial <code>return read (buf, 0, buf.length)</code>
+         */
+        public int read(byte[] buf) throws IOException {
+                return read(buf, 0, buf.length);
+        }
+        /** Read the next segment of metadata.  The stream <b>must</b>
+            be right on the segment, ie, the next byte to read is
+            the metadata block count.  The metadata is parsed and
+            new tags are added with addTag(), which fires events
+         */
+        protected void readMetadata() throws IOException {
+                int blockCount = super.read();
+                if (DEBUG) System.out.println("BLOCKCOUNT:"+blockCount);
+                // System.out.println ("blocks to read: " + blockCount);
+                int byteCount = (blockCount * 16); // 16 bytes per block
+                if (byteCount < 0)
+                        return; // WTF?!
+                byte[] metadataBlock = new byte[byteCount];
+                int index = 0;
+                // build an array of this metadata
+                while (byteCount > 0) {
+                        int bytesRead = super.read(metadataBlock, index, byteCount);
+                        index += bytesRead;
+                        byteCount -= bytesRead;
+                }
+                // now parse it
+                if (blockCount > 0)
+                        parseInlineIcyTags(metadataBlock);
+        } // readMetadata
+        /** Parse metadata from an in-stream "block" of bytes, add
+            a tag for each one.
+            <p>
+            Hilariously, the inline data format is totally different
+            than the top-of-stream header.  For example, here's a
+            block I saw on "Final Fantasy Radio":
+        <pre>
+        StreamTitle='Final Fantasy 8 - Nobuo Uematsu - Blue Fields';StreamUrl='';
+        </pre>
+            In other words:
+            <ol>
+            <li>Tags are delimited by semicolons
+            <li>Keys/values are delimited by equals-signs
+            <li>Values are wrapped in single-quotes
+            <li>Key names are in SentenceCase, not lowercase-dashed
+            </ol>
+         */
+        protected void parseInlineIcyTags(byte[] tagBlock) {
+                String blockString = new String(tagBlock);
+                if (DEBUG) System.out.println("BLOCKSTR:"+blockString);
+                StringTokenizer izer =
+                        new StringTokenizer(blockString, INLINE_TAG_SEPARATORS);
+                int i = 0;
+                while (izer.hasMoreTokens()) {
+                        String tagString = izer.nextToken();
+                        int separatorIdx = tagString.indexOf('=');
+                        if (separatorIdx == -1)
+                                continue; // bogus tagString if no '='
+                        // try to strip single-quotes around value, if present
+                        int valueStartIdx =
+                                (tagString.charAt(separatorIdx + 1) == '\'')
+                                        ? separatorIdx + 2
+                                        : separatorIdx + 1;
+                        int valueEndIdx =
+                                (tagString.charAt(tagString.length() - 1)) == '\''
+                                        ? tagString.length() - 1
+                                        : tagString.length();
+                        String name = tagString.substring(0, separatorIdx);
+                        String value = tagString.substring(valueStartIdx, valueEndIdx);
+                        // System.out.println (i++ + " " +  name + ":" + value);
+                        IcyTag tag = new IcyTag(name, value);
+                        addTag(tag);
+                }
+        }
+        /** adds the tag to the HashMap of tags we have encountered
+            either in-stream or as headers, replacing any previous
+            tag with this name.
+         */
+        protected void addTag(IcyTag tag) {
+                tags.put(tag.getName(), tag);
+                // fire this as an event too
+                tagParseSupport.fireTagParsed(this, tag);
+        }
+        /** Get the named tag from the HashMap of headers and
+            in-line tags.  Null if no such tag has been encountered.
+         */
+        public MP3Tag getTag(String tagName) {
+                return (MP3Tag) tags.get(tagName);
+        }
+        /** Get all tags (headers or in-stream) encountered thus far.
+         */
+        public MP3Tag[] getTags() {
+                return (MP3Tag[]) tags.values().toArray(new MP3Tag[0]);
+        }
+        /** Returns a HashMap of all headers and in-stream tags
+            parsed so far.
+         */
+        public HashMap getTagHash() {
+                return tags;
+        }
+        /** Adds a TagParseListener to be notified when this stream
+            parses MP3Tags.
+         */
+        public void addTagParseListener(TagParseListener tpl) {
+                tagParseSupport.addTagParseListener(tpl);
+        }
+        /** Removes a TagParseListener, so it won't be notified when
+            this stream parses MP3Tags.
+         */
+        public void removeTagParseListener(TagParseListener tpl) {
+                tagParseSupport.removeTagParseListener(tpl);
+        }
+        /** Quickie unit-test.
+         */
+        public static void main(String args[]) {
+                byte[] chow = new byte[200];
+                if (args.length != 1) {
+                        //System.out.println("Usage: IcyInputStream <url>");
+                        return;
+                }
+                try {
+                        URL url = new URL(args[0]);
+                        URLConnection conn = url.openConnection();
+                        conn.setRequestProperty("Icy-Metadata", "1");
+                        IcyInputStream icy =
+                                new IcyInputStream(
+                                        new BufferedInputStream(conn.getInputStream()));
+                        while (icy.available() > -1) {
+                                // icy.read();
+                                icy.read(chow, 0, chow.length);
+                        }
+                }
+                catch (Exception e) {
+                        e.printStackTrace();
+                }
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/IcyTag.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/IcyTag.java
new file mode 100644
index 0000000000..bbe70f1f3c
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/IcyTag.java
@@ -0,0 +1,42 @@
+/*
+ * IcyTag.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+/** 
+ * A tag parsed from an icecast tag. 
+ */
+public class IcyTag extends MP3Tag implements StringableTag {
+        /** Create a new tag, from the parsed name and (String) value.
+            It looks like all Icecast tags are Strings (safe to assume
+            this going forward?)
+         */
+        public IcyTag(String name, String stringValue) {
+                super(name, stringValue);
+        }
+        // so far as I know, all Icecast tags are strings
+        public String getValueAsString() {
+                return (String) getValue();
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3MetadataParser.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3MetadataParser.java
new file mode 100644
index 0000000000..81511064b8
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3MetadataParser.java
@@ -0,0 +1,50 @@
+/*
+ * MP3MetadataParser.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+
+/** An object that fires off TagParseEvents as they are parsed
+    from a stream, ServerSocket, or other metadata source
+  */
+public interface MP3MetadataParser {
+        /** Adds a TagParseListener to be notified when this object
+            parses MP3Tags.
+         */
+        public void addTagParseListener(TagParseListener tpl);
+        /** Removes a TagParseListener, so it won't be notified when
+            this object parses MP3Tags.
+         */
+        public void removeTagParseListener(TagParseListener tpl);
+        /** Get all tags (headers or in-stream) encountered thusfar.
+            This is included in this otherwise Listener-like scheme
+            because most standards are a mix of start-of-stream
+            metadata tags (like the http headers or the stuff at the
+            top of an ice stream) and inline data.  Implementations should
+            hang onto all tags they parse and provide them with this
+            call.  Callers should first use this call to get initial
+            tags, then subscribe for events as the stream continues.
+         */
+        public MP3Tag[] getTags();
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3Tag.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3Tag.java
new file mode 100644
index 0000000000..b545356240
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3Tag.java
@@ -0,0 +1,52 @@
+/*
+ * MP3Tag.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+
+/** An individual piece of mp3 metadata, as a name/value pair.
+    Abstract just so that subclasses will indicate their
+    tagging scheme (Icy, ID3, etc.).
+ */
+public abstract class MP3Tag extends Object {
+        protected String name;
+        protected Object value;
+        public MP3Tag(String name, Object value) {
+                this.name = name;
+                this.value = value;
+        }
+        public String getName() {
+                return name;
+        }
+        public Object getValue() {
+                return value;
+        }
+        public String toString() {
+                return getClass().getName()
+                        + " -- "
+                        + getName()
+                        + ":"
+                        + getValue().toString();
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3TagParseSupport.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3TagParseSupport.java
new file mode 100644
index 0000000000..1ab6525512
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/MP3TagParseSupport.java
@@ -0,0 +1,62 @@
+/*
+ * MP3TagParseSupport.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+
+import java.util.ArrayList;
+/**  
+*/
+public class MP3TagParseSupport extends Object {
+        ArrayList tagParseListeners;
+        /** trivial constructor, sets up listeners list.
+         */
+        public MP3TagParseSupport() {
+                super();
+                tagParseListeners = new ArrayList();
+        }
+        /** Adds a TagParseListener to be notified when a stream
+            parses MP3Tags.
+         */
+        public void addTagParseListener(TagParseListener tpl) {
+                tagParseListeners.add(tpl);
+        }
+        /** Removes a TagParseListener, so it won't be notified when
+            a stream parses MP3Tags.
+         */
+        public void removeTagParseListener(TagParseListener tpl) {
+                tagParseListeners.add(tpl);
+        }
+        /** Fires the given event to all registered listeners
+         */
+        public void fireTagParseEvent(TagParseEvent tpe) {
+                for (int i = 0; i < tagParseListeners.size(); i++) {
+                        TagParseListener l = (TagParseListener) tagParseListeners.get(i);
+                        l.tagParsed(tpe);
+                }
+        }
+        public void fireTagParsed(Object source, MP3Tag tag) {
+                fireTagParseEvent(new TagParseEvent(source, tag));
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/StringableTag.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/StringableTag.java
new file mode 100644
index 0000000000..685c5207f9
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/StringableTag.java
@@ -0,0 +1,36 @@
+/*
+ * StringableTag.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+
+/** Indicates that the value of a tag is a string, and
+    provides a getValueAsString() method to get it.
+    Appropriate for tags like artist, title, etc.
+ */
+public interface StringableTag {
+        /** Return the value of this tag as a string.
+         */
+        public String getValueAsString();
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/TagParseEvent.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/TagParseEvent.java
new file mode 100644
index 0000000000..97e9ec1e19
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/TagParseEvent.java
@@ -0,0 +1,44 @@
+/*
+ * TagParseEvent.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+
+import java.util.EventObject;
+/** Event to indicate that an MP3 tag was received through
+    some means (parsed in stream, received via UDP, whatever)
+    and converted into an MP3Tag object.
+ */
+public class TagParseEvent extends EventObject {
+        protected MP3Tag tag;
+        public TagParseEvent(Object source, MP3Tag tag) {
+                super(source);
+                this.tag = tag;
+        }
+        /** Get the tag that was parsed.
+         */
+        public MP3Tag getTag() {
+                return tag;
+        }
+}
diff --git a/songdbj/javazoom/spi/mpeg/sampled/file/tag/TagParseListener.java b/songdbj/javazoom/spi/mpeg/sampled/file/tag/TagParseListener.java
new file mode 100644
index 0000000000..a630827297
--- /dev/null
+++ b/songdbj/javazoom/spi/mpeg/sampled/file/tag/TagParseListener.java
@@ -0,0 +1,37 @@
+/*
+ * TagParseListener.
+ * 
+ * jicyshout : http://sourceforge.net/projects/jicyshout/
+ *  
+ * JavaZOOM : mp3spi@javazoom.net
+ *                        http://www.javazoom.net
+ * 
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.spi.mpeg.sampled.file.tag;
+
+import java.util.EventListener;
+/** EventListener to be implemented by objects that want to
+    get callbacks when MP3 tags are received.
+ */
+public interface TagParseListener extends EventListener {
+        /** Called when a tag is found (parsed from the stream,
+            received via UDP, etc.)
+         */
+        public void tagParsed(TagParseEvent tpe);
+}
diff --git a/songdbj/javazoom/spi/vorbis/sampled/convert/DecodedVorbisAudioInputStream.java b/songdbj/javazoom/spi/vorbis/sampled/convert/DecodedVorbisAudioInputStream.java
new file mode 100644
index 0000000000..b8e8577e13
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/convert/DecodedVorbisAudioInputStream.java
@@ -0,0 +1,519 @@
+/*
+ *   DecodedVorbisAudioInputStream
+ *   
+ *    JavaZOOM : vorbisspi@javazoom.net
+ *               http://www.javazoom.net
+ *
+ * ----------------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * ----------------------------------------------------------------------------
+ */
+ 
+package javazoom.spi.vorbis.sampled.convert;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+
+import javazoom.spi.PropertiesContainer;
+
+import org.tritonus.share.TDebug;
+import org.tritonus.share.sampled.convert.TAsynchronousFilteredAudioInputStream;
+
+import com.jcraft.jogg.Packet;
+import com.jcraft.jogg.Page;
+import com.jcraft.jogg.StreamState;
+import com.jcraft.jogg.SyncState;
+import com.jcraft.jorbis.Block;
+import com.jcraft.jorbis.Comment;
+import com.jcraft.jorbis.DspState;
+import com.jcraft.jorbis.Info;
+
+/**
+ * This class implements the Vorbis decoding.
+ */
+public class DecodedVorbisAudioInputStream extends TAsynchronousFilteredAudioInputStream implements PropertiesContainer
+{
+  private InputStream oggBitStream_ = null;
+
+  private SyncState oggSyncState_ = null;
+  private StreamState oggStreamState_ = null;
+  private Page oggPage_ = null;
+  private Packet oggPacket_ = null;
+  private Info vorbisInfo = null;
+  private Comment vorbisComment = null;
+  private DspState vorbisDspState = null;
+  private Block vorbisBlock = null;
+
+  static final int playState_NeedHeaders = 0;
+  static final int playState_ReadData = 1;
+  static final int playState_WriteData = 2;
+  static final int playState_Done = 3;
+  static final int playState_BufferFull = 4;
+  static final int playState_Corrupt = -1;
+  private int playState;
+
+  private int bufferMultiple_ = 4;
+  private int bufferSize_ = bufferMultiple_ * 256 * 2;
+  private int convsize = bufferSize_ * 2;
+  private byte[] convbuffer = new byte[convsize];
+  private byte[] buffer = null;
+  private int bytes = 0;
+  private float[][][] _pcmf = null;
+  private int[] _index = null;
+  private int index = 0;
+  private int i = 0;
+  // bout is now a global so that we can continue from when we have a buffer full.
+  int bout = 0;
+  
+  private HashMap properties = null;
+  private long currentBytes = 0;
+
+  /**
+   * Constructor.
+   */
+  public DecodedVorbisAudioInputStream(AudioFormat outputFormat, AudioInputStream bitStream)
+  {
+    super(outputFormat, -1);
+    this.oggBitStream_ = bitStream;
+    init_jorbis();
+    index = 0;
+    playState = playState_NeedHeaders;
+        properties = new HashMap();
+  }
+
+  /**
+   * Initializes all the jOrbis and jOgg vars that are used for song playback.
+   */
+  private void init_jorbis()
+  {
+    oggSyncState_ = new SyncState();
+    oggStreamState_ = new StreamState();
+    oggPage_ = new Page();
+    oggPacket_ = new Packet();
+    vorbisInfo = new Info();
+    vorbisComment = new Comment();
+    vorbisDspState = new DspState();
+    vorbisBlock = new Block(vorbisDspState);
+    buffer = null;
+    bytes = 0;
+        currentBytes = 0L;
+    oggSyncState_.init();
+  }
+
+  /**
+   * Return dynamic properties.
+   * 
+   * <ul>
+   * <li><b>ogg.position.byte</b> [Long], current position in bytes in the stream.
+   *</ul>
+   */
+  public Map properties()
+  {
+          properties.put("ogg.position.byte",new Long(currentBytes));
+          return properties;     
+  }
+  /**
+   * Main loop.
+   */
+  public void execute()
+  {
+    if(TDebug.TraceAudioConverter)
+    {
+      switch(playState)
+      {
+        case playState_NeedHeaders:
+          TDebug.out("playState = playState_NeedHeaders");
+          break;
+        case playState_ReadData:
+          TDebug.out("playState = playState_ReadData");
+          break;
+        case playState_WriteData:
+          TDebug.out("playState = playState_WriteData");
+          break;
+        case playState_Done:
+          TDebug.out("playState = playState_Done");
+          break;
+        case playState_BufferFull:
+          TDebug.out("playState = playState_BufferFull");
+          break;
+        case playState_Corrupt:
+          TDebug.out("playState = playState_Corrupt");
+          break;
+      }
+    }
+    // This code was developed by the jCraft group, as JOrbisPlayer.java,  slightly
+    // modified by jOggPlayer developer and adapted by JavaZOOM to suit the JavaSound
+    // SPI. Then further modified by Tom Kimpton to correctly play ogg files that
+    // would hang the player.
+    switch(playState)
+    {
+      case playState_NeedHeaders:
+        try
+        {
+          // Headers (+ Comments).
+          readHeaders();
+        }
+        catch(IOException ioe)
+        {
+          playState = playState_Corrupt;
+          return;
+        }
+        playState = playState_ReadData;
+        break;
+
+      case playState_ReadData:
+        int result;
+        index = oggSyncState_.buffer(bufferSize_);
+        buffer = oggSyncState_.data;
+        bytes = readFromStream(buffer, index, bufferSize_);
+        if(TDebug.TraceAudioConverter) TDebug.out("More data : " + bytes);
+        if(bytes == -1)
+        {
+          playState = playState_Done;
+          if(TDebug.TraceAudioConverter) TDebug.out("Ogg Stream empty. Settings playState to playState_Done.");
+          break;
+        }
+        else
+        {
+          oggSyncState_.wrote(bytes);
+          if(bytes == 0)
+          {
+            if((oggPage_.eos() != 0) || (oggStreamState_.e_o_s != 0) || (oggPacket_.e_o_s != 0))
+            {
+              if(TDebug.TraceAudioConverter) TDebug.out("oggSyncState wrote 0 bytes: settings playState to playState_Done.");
+              playState = playState_Done;
+            }
+              if(TDebug.TraceAudioConverter) TDebug.out("oggSyncState wrote 0 bytes: but stream not yet empty.");
+            break;
+          }
+        }
+
+        result = oggSyncState_.pageout(oggPage_);
+        if(result == 0)
+        {
+          if(TDebug.TraceAudioConverter) TDebug.out("Setting playState to playState_ReadData.");
+          playState = playState_ReadData;
+          break;
+        } // need more data
+        if(result == -1)
+        { // missing or corrupt data at this page position
+          if(TDebug.TraceAudioConverter) TDebug.out("Corrupt or missing data in bitstream; setting playState to playState_ReadData");
+          playState = playState_ReadData;
+          break;
+        }
+
+        oggStreamState_.pagein(oggPage_);
+
+        if(TDebug.TraceAudioConverter) TDebug.out("Setting playState to playState_WriteData.");
+        playState = playState_WriteData;
+        break;
+
+      case playState_WriteData:
+        // Decoding !
+        if(TDebug.TraceAudioConverter) TDebug.out("Decoding");
+        while(true)
+        {
+          result = oggStreamState_.packetout(oggPacket_);
+          if(result == 0)
+          {
+            if(TDebug.TraceAudioConverter) TDebug.out("Packetout returned 0, going to read state.");
+            playState = playState_ReadData;
+            break;
+          } // need more data
+          else if(result == -1)
+          { 
+                // missing or corrupt data at this page position
+            // no reason to complain; already complained above
+                        if(TDebug.TraceAudioConverter) TDebug.out("Corrupt or missing data in packetout bitstream; going to read state...");
+                        // playState = playState_ReadData;
+                        // break;
+            continue;
+          }
+          else
+          {
+            // we have a packet.  Decode it
+            if(vorbisBlock.synthesis(oggPacket_) == 0)
+            { // test for success!
+              vorbisDspState.synthesis_blockin(vorbisBlock);
+            }
+            else
+            {
+              //if(TDebug.TraceAudioConverter) TDebug.out("vorbisBlock.synthesis() returned !0, going to read state");
+              if(TDebug.TraceAudioConverter) TDebug.out("VorbisBlock.synthesis() returned !0, continuing.");
+              continue;
+            }
+
+            outputSamples();
+            if(playState == playState_BufferFull)
+              return;
+
+          } // else result != -1
+        } // while(true)
+        if(oggPage_.eos() != 0)
+        {
+          if(TDebug.TraceAudioConverter) TDebug.out("Settings playState to playState_Done.");
+          playState = playState_Done;
+        }
+        break;
+      case playState_BufferFull:
+        continueFromBufferFull();
+        break;
+
+      case playState_Corrupt:
+        if(TDebug.TraceAudioConverter) TDebug.out("Corrupt Song.");
+        // drop through to playState_Done...
+      case playState_Done:
+        oggStreamState_.clear();
+        vorbisBlock.clear();
+        vorbisDspState.clear();
+        vorbisInfo.clear();
+        oggSyncState_.clear();
+        if(TDebug.TraceAudioConverter) TDebug.out("Done Song.");
+        try
+        {
+          if(oggBitStream_ != null)
+          {
+            oggBitStream_.close();
+          }
+          getCircularBuffer().close();
+        }
+        catch(Exception e)
+        {
+          if(TDebug.TraceAudioConverter) TDebug.out(e.getMessage());
+        }
+        break;
+    } // switch
+  }
+
+  /**
+   * This routine was extracted so that when the output buffer fills up,
+   * we can break out of the loop, let the music channel drain, then
+   * continue from where we were.
+   */
+  private void outputSamples()
+  {
+    int samples;
+    while((samples = vorbisDspState.synthesis_pcmout(_pcmf, _index)) > 0)
+    {
+      float[][] pcmf = _pcmf[0];
+      bout = (samples < convsize ? samples : convsize);
+      double fVal = 0.0;
+      // convert doubles to 16 bit signed ints (host order) and
+      // interleave
+      for(i = 0; i < vorbisInfo.channels; i++)
+      {
+        int pointer = i * 2;
+        //int ptr=i;
+        int mono = _index[i];
+        for(int j = 0; j < bout; j++)
+        {
+          fVal = pcmf[i][mono + j] * 32767.;
+          int val = (int) (fVal);
+          if(val > 32767)
+          {
+            val = 32767;
+          }
+          if(val < -32768)
+          {
+            val = -32768;
+          }
+          if(val < 0)
+          {
+            val = val | 0x8000;
+          }
+          convbuffer[pointer] = (byte) (val);
+          convbuffer[pointer + 1] = (byte) (val >>> 8);
+          pointer += 2 * (vorbisInfo.channels);
+        }
+      }
+      if(TDebug.TraceAudioConverter) TDebug.out("about to write: " + 2 * vorbisInfo.channels * bout);
+      if(getCircularBuffer().availableWrite() < 2 * vorbisInfo.channels * bout)
+      {
+        if(TDebug.TraceAudioConverter) TDebug.out("Too much data in this data packet, better return, let the channel drain, and try again...");
+        playState = playState_BufferFull;
+        return;
+      }
+      getCircularBuffer().write(convbuffer, 0, 2 * vorbisInfo.channels * bout);
+      if(bytes < bufferSize_)
+        if(TDebug.TraceAudioConverter) TDebug.out("Finished with final buffer of music?");
+      if(vorbisDspState.synthesis_read(bout) != 0)
+      {
+        if(TDebug.TraceAudioConverter) TDebug.out("VorbisDspState.synthesis_read returned -1.");
+      }
+    } // while(samples...)
+    playState = playState_ReadData;
+  }
+
+  private void continueFromBufferFull()
+  {
+    if(getCircularBuffer().availableWrite() < 2 * vorbisInfo.channels * bout)
+    {
+      if(TDebug.TraceAudioConverter) TDebug.out("Too much data in this data packet, better return, let the channel drain, and try again...");
+      // Don't change play state.
+      return;
+    }
+    getCircularBuffer().write(convbuffer, 0, 2 * vorbisInfo.channels * bout);
+    // Don't change play state. Let outputSamples change play state, if necessary.
+    outputSamples();
+  }
+  /**
+   * Reads headers and comments.
+   */
+  private void readHeaders() throws IOException
+  {
+    if(TDebug.TraceAudioConverter) TDebug.out("readHeaders(");
+    index = oggSyncState_.buffer(bufferSize_);
+    buffer = oggSyncState_.data;
+    bytes = readFromStream(buffer, index, bufferSize_);
+    if(bytes == -1)
+    {
+      if(TDebug.TraceAudioConverter) TDebug.out("Cannot get any data from selected Ogg bitstream.");
+      throw new IOException("Cannot get any data from selected Ogg bitstream.");
+    }
+    oggSyncState_.wrote(bytes);
+    if(oggSyncState_.pageout(oggPage_) != 1)
+    {
+      if(bytes < bufferSize_)
+      {
+        throw new IOException("EOF");
+      }
+      if(TDebug.TraceAudioConverter) TDebug.out("Input does not appear to be an Ogg bitstream.");
+      throw new IOException("Input does not appear to be an Ogg bitstream.");
+    }
+    oggStreamState_.init(oggPage_.serialno());
+    vorbisInfo.init();
+    vorbisComment.init();
+    if(oggStreamState_.pagein(oggPage_) < 0)
+    {
+      // error; stream version mismatch perhaps
+      if(TDebug.TraceAudioConverter) TDebug.out("Error reading first page of Ogg bitstream data.");
+      throw new IOException("Error reading first page of Ogg bitstream data.");
+    }
+    if(oggStreamState_.packetout(oggPacket_) != 1)
+    {
+      // no page? must not be vorbis
+      if(TDebug.TraceAudioConverter) TDebug.out("Error reading initial header packet.");
+      throw new IOException("Error reading initial header packet.");
+    }
+    if(vorbisInfo.synthesis_headerin(vorbisComment, oggPacket_) < 0)
+    {
+      // error case; not a vorbis header
+      if(TDebug.TraceAudioConverter) TDebug.out("This Ogg bitstream does not contain Vorbis audio data.");
+      throw new IOException("This Ogg bitstream does not contain Vorbis audio data.");
+    }
+    //int i = 0;
+    i = 0;
+    while(i < 2)
+    {
+      while(i < 2)
+      {
+        int result = oggSyncState_.pageout(oggPage_);
+        if(result == 0)
+        {
+          break;
+        } // Need more data
+        if(result == 1)
+        {
+          oggStreamState_.pagein(oggPage_);
+          while(i < 2)
+          {
+            result = oggStreamState_.packetout(oggPacket_);
+            if(result == 0)
+            {
+              break;
+            }
+            if(result == -1)
+            {
+              if(TDebug.TraceAudioConverter) TDebug.out("Corrupt secondary header.  Exiting.");
+              throw new IOException("Corrupt secondary header.  Exiting.");
+            }
+            vorbisInfo.synthesis_headerin(vorbisComment, oggPacket_);
+            i++;
+          }
+        }
+      }
+      index = oggSyncState_.buffer(bufferSize_);
+      buffer = oggSyncState_.data;
+      bytes = readFromStream(buffer, index, bufferSize_);
+      if(bytes == -1)
+      {
+        break;
+      }
+      if(bytes == 0 && i < 2)
+      {
+        if(TDebug.TraceAudioConverter) TDebug.out("End of file before finding all Vorbis headers!");
+        throw new IOException("End of file before finding all Vorbis  headers!");
+      }
+      oggSyncState_.wrote(bytes);
+    }
+
+    byte[][] ptr = vorbisComment.user_comments;
+    String currComment = "";
+
+    for(int j = 0; j < ptr.length; j++)
+    {
+      if(ptr[j] == null)
+      {
+        break;
+      }
+      currComment = (new String(ptr[j], 0, ptr[j].length - 1)).trim();
+      if(TDebug.TraceAudioConverter) TDebug.out("Comment: " + currComment);
+    }
+    convsize = bufferSize_ / vorbisInfo.channels;
+    vorbisDspState.synthesis_init(vorbisInfo);
+    vorbisBlock.init(vorbisDspState);
+    _pcmf = new float[1][][];
+    _index = new int[vorbisInfo.channels];
+  }
+
+  /**
+   * Reads from the oggBitStream_ a specified number of Bytes(bufferSize_) worth
+   * starting at index and puts them in the specified buffer[].
+   *
+   * @param buffer
+   * @param index
+   * @param bufferSize_
+   * @return             the number of bytes read or -1 if error.
+   */
+  private int readFromStream(byte[] buffer, int index, int bufferSize_)
+  {
+    int bytes = 0;
+    try
+    {
+      bytes = oggBitStream_.read(buffer, index, bufferSize_);
+    }
+    catch(Exception e)
+    {
+      if(TDebug.TraceAudioConverter) TDebug.out("Cannot Read Selected Song");
+      bytes = -1;
+    }
+    currentBytes = currentBytes + bytes;
+    return bytes;
+  }
+
+  /**
+   * Close the stream.
+   */
+  public void close() throws IOException
+  {
+    super.close();
+    oggBitStream_.close();
+  }
+}
diff --git a/songdbj/javazoom/spi/vorbis/sampled/convert/VorbisFormatConversionProvider.java b/songdbj/javazoom/spi/vorbis/sampled/convert/VorbisFormatConversionProvider.java
new file mode 100644
index 0000000000..d1321f2590
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/convert/VorbisFormatConversionProvider.java
@@ -0,0 +1,244 @@
+/*
+ *   VorbisFormatConversionProvider.
+ * 
+ *   JavaZOOM : vorbisspi@javazoom.net
+ *              http://www.javazoom.net
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+ 
+package javazoom.spi.vorbis.sampled.convert;
+
+import java.util.Arrays;
+import javazoom.spi.vorbis.sampled.file.VorbisEncoding;
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+
+import org.tritonus.share.sampled.convert.TMatrixFormatConversionProvider;
+
+/**
+ * ConversionProvider for VORBIS files.
+ */
+public class VorbisFormatConversionProvider extends TMatrixFormatConversionProvider
+{
+  private static final AudioFormat[] INPUT_FORMATS =
+  {
+      new AudioFormat(VorbisEncoding.VORBISENC, 32000.0F, -1, 1, -1, -1, false), // 0
+      new AudioFormat(VorbisEncoding.VORBISENC, 32000.0F, -1, 2, -1, -1, false), // 1
+      new AudioFormat(VorbisEncoding.VORBISENC, 44100.0F, -1, 1, -1, -1, false), // 2
+      new AudioFormat(VorbisEncoding.VORBISENC, 44100.0F, -1, 2, -1, -1, false), // 3
+      new AudioFormat(VorbisEncoding.VORBISENC, 48000.0F, -1, 1, -1, -1, false), // 4
+      new AudioFormat(VorbisEncoding.VORBISENC, 48000.0F, -1, 2, -1, -1, false), // 5
+
+      new AudioFormat(VorbisEncoding.VORBISENC, 16000.0F, -1, 1, -1, -1, false), // 18
+      new AudioFormat(VorbisEncoding.VORBISENC, 16000.0F, -1, 2, -1, -1, false), // 19
+      new AudioFormat(VorbisEncoding.VORBISENC, 22050.0F, -1, 1, -1, -1, false), // 20
+      new AudioFormat(VorbisEncoding.VORBISENC, 22050.0F, -1, 2, -1, -1, false), // 21
+      new AudioFormat(VorbisEncoding.VORBISENC, 24000.0F, -1, 1, -1, -1, false), // 22
+      new AudioFormat(VorbisEncoding.VORBISENC, 24000.0F, -1, 2, -1, -1, false), // 23
+
+      new AudioFormat(VorbisEncoding.VORBISENC, 8000.0F, -1, 1, -1, -1, false), // 36
+      new AudioFormat(VorbisEncoding.VORBISENC, 8000.0F, -1, 2, -1, -1, false), // 37
+      new AudioFormat(VorbisEncoding.VORBISENC, 11025.0F, -1, 1, -1, -1, false), // 38
+      new AudioFormat(VorbisEncoding.VORBISENC, 11025.0F, -1, 2, -1, -1, false), // 39
+      new AudioFormat(VorbisEncoding.VORBISENC, 12000.0F, -1, 1, -1, -1, false), // 40
+      new AudioFormat(VorbisEncoding.VORBISENC, 12000.0F, -1, 2, -1, -1, false), // 41
+  };
+
+  private static final AudioFormat[] OUTPUT_FORMATS =
+  {
+      new AudioFormat(8000.0F, 16, 1, true, false), // 0
+      new AudioFormat(8000.0F, 16, 1, true, true), // 1
+      new AudioFormat(8000.0F, 16, 2, true, false), // 2
+      new AudioFormat(8000.0F, 16, 2, true, true), // 3
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(8000.0F, 24, 1, true, false),
+                      new AudioFormat(8000.0F, 24, 1, true, true),
+                      new AudioFormat(8000.0F, 24, 2, true, false),
+                      new AudioFormat(8000.0F, 24, 2, true, true),
+                      new AudioFormat(8000.0F, 32, 1, true, false),
+                      new AudioFormat(8000.0F, 32, 1, true, true),
+                      new AudioFormat(8000.0F, 32, 2, true, false),
+                      new AudioFormat(8000.0F, 32, 2, true, true),
+       */
+      new AudioFormat(11025.0F, 16, 1, true, false), // 4
+      new AudioFormat(11025.0F, 16, 1, true, true), // 5
+      new AudioFormat(11025.0F, 16, 2, true, false), // 6
+      new AudioFormat(11025.0F, 16, 2, true, true), // 7
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(11025.0F, 24, 1, true, false),
+                      new AudioFormat(11025.0F, 24, 1, true, true),
+                      new AudioFormat(11025.0F, 24, 2, true, false),
+                      new AudioFormat(11025.0F, 24, 2, true, true),
+                      new AudioFormat(11025.0F, 32, 1, true, false),
+                      new AudioFormat(11025.0F, 32, 1, true, true),
+                      new AudioFormat(11025.0F, 32, 2, true, false),
+                      new AudioFormat(11025.0F, 32, 2, true, true),
+       */
+      new AudioFormat(12000.0F, 16, 1, true, false), // 8
+      new AudioFormat(12000.0F, 16, 1, true, true), // 9
+      new AudioFormat(12000.0F, 16, 2, true, false), // 10
+      new AudioFormat(12000.0F, 16, 2, true, true), // 11
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(12000.0F, 24, 1, true, false),
+                      new AudioFormat(12000.0F, 24, 1, true, true),
+                      new AudioFormat(12000.0F, 24, 2, true, false),
+                      new AudioFormat(12000.0F, 24, 2, true, true),
+                      new AudioFormat(12000.0F, 32, 1, true, false),
+                      new AudioFormat(12000.0F, 32, 1, true, true),
+                      new AudioFormat(12000.0F, 32, 2, true, false),
+                      new AudioFormat(12000.0F, 32, 2, true, true),
+       */
+      new AudioFormat(16000.0F, 16, 1, true, false), // 12
+      new AudioFormat(16000.0F, 16, 1, true, true), // 13
+      new AudioFormat(16000.0F, 16, 2, true, false), // 14
+      new AudioFormat(16000.0F, 16, 2, true, true), // 15
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(16000.0F, 24, 1, true, false),
+                      new AudioFormat(16000.0F, 24, 1, true, true),
+                      new AudioFormat(16000.0F, 24, 2, true, false),
+                      new AudioFormat(16000.0F, 24, 2, true, true),
+                      new AudioFormat(16000.0F, 32, 1, true, false),
+                      new AudioFormat(16000.0F, 32, 1, true, true),
+                      new AudioFormat(16000.0F, 32, 2, true, false),
+                      new AudioFormat(16000.0F, 32, 2, true, true),
+       */
+      new AudioFormat(22050.0F, 16, 1, true, false), // 16
+      new AudioFormat(22050.0F, 16, 1, true, true), // 17
+      new AudioFormat(22050.0F, 16, 2, true, false), // 18
+      new AudioFormat(22050.0F, 16, 2, true, true), // 19
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(22050.0F, 24, 1, true, false),
+                      new AudioFormat(22050.0F, 24, 1, true, true),
+                      new AudioFormat(22050.0F, 24, 2, true, false),
+                      new AudioFormat(22050.0F, 24, 2, true, true),
+                      new AudioFormat(22050.0F, 32, 1, true, false),
+                      new AudioFormat(22050.0F, 32, 1, true, true),
+                      new AudioFormat(22050.0F, 32, 2, true, false),
+                      new AudioFormat(22050.0F, 32, 2, true, true),
+       */
+      new AudioFormat(24000.0F, 16, 1, true, false), // 20
+      new AudioFormat(24000.0F, 16, 1, true, true), // 21
+      new AudioFormat(24000.0F, 16, 2, true, false), // 22
+      new AudioFormat(24000.0F, 16, 2, true, true), // 23
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(24000.0F, 24, 1, true, false),
+                      new AudioFormat(24000.0F, 24, 1, true, true),
+                      new AudioFormat(24000.0F, 24, 2, true, false),
+                      new AudioFormat(24000.0F, 24, 2, true, true),
+                      new AudioFormat(24000.0F, 32, 1, true, false),
+                      new AudioFormat(24000.0F, 32, 1, true, true),
+                      new AudioFormat(24000.0F, 32, 2, true, false),
+                      new AudioFormat(24000.0F, 32, 2, true, true),
+       */
+      new AudioFormat(32000.0F, 16, 1, true, false), // 24
+      new AudioFormat(32000.0F, 16, 1, true, true), // 25
+      new AudioFormat(32000.0F, 16, 2, true, false), // 26
+      new AudioFormat(32000.0F, 16, 2, true, true), // 27
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(32000.0F, 24, 1, true, false),
+                      new AudioFormat(32000.0F, 24, 1, true, true),
+                      new AudioFormat(32000.0F, 24, 2, true, false),
+                      new AudioFormat(32000.0F, 24, 2, true, true),
+                      new AudioFormat(32000.0F, 32, 1, true, false),
+                      new AudioFormat(32000.0F, 32, 1, true, true),
+                      new AudioFormat(32000.0F, 32, 2, true, false),
+                      new AudioFormat(32000.0F, 32, 2, true, true),
+       */
+      new AudioFormat(44100.0F, 16, 1, true, false), // 28
+      new AudioFormat(44100.0F, 16, 1, true, true), // 29
+      new AudioFormat(44100.0F, 16, 2, true, false), // 30
+      new AudioFormat(44100.0F, 16, 2, true, true), // 31
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(44100.0F, 24, 1, true, false),
+                      new AudioFormat(44100.0F, 24, 1, true, true),
+                      new AudioFormat(44100.0F, 24, 2, true, false),
+                      new AudioFormat(44100.0F, 24, 2, true, true),
+                      new AudioFormat(44100.0F, 32, 1, true, false),
+                      new AudioFormat(44100.0F, 32, 1, true, true),
+                      new AudioFormat(44100.0F, 32, 2, true, false),
+                      new AudioFormat(44100.0F, 32, 2, true, true),
+       */
+      new AudioFormat(48000.0F, 16, 1, true, false), // 32
+      new AudioFormat(48000.0F, 16, 1, true, true), // 33
+      new AudioFormat(48000.0F, 16, 2, true, false), // 34
+      new AudioFormat(48000.0F, 16, 2, true, true), // 35
+      /*        24 and 32 bit not yet possible
+                      new AudioFormat(48000.0F, 24, 1, true, false),
+                      new AudioFormat(48000.0F, 24, 1, true, true),
+                      new AudioFormat(48000.0F, 24, 2, true, false),
+                      new AudioFormat(48000.0F, 24, 2, true, true),
+                      new AudioFormat(48000.0F, 32, 1, true, false),
+                      new AudioFormat(48000.0F, 32, 1, true, true),
+                      new AudioFormat(48000.0F, 32, 2, true, false),
+                      new AudioFormat(48000.0F, 32, 2, true, true),
+       */
+  };
+
+  private static final boolean t = true;
+  private static final boolean f = false;
+
+  /*
+   *    One row for each source format.
+   */
+  private static final boolean[][] CONVERSIONS =
+  {
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,t,t,f,f,f,f, f,f,f,f,f,f},     // 0
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,t,t,f,f, f,f,f,f,f,f},     // 1
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,t,t, f,f,f,f,f,f},     // 2
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, t,t,f,f,f,f},     // 3
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,t,t,f,f},     // 4
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,t,t},     // 5
+
+      {f,f,f,f,f,f,f,f,f,f, f,f,t,t,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 18
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,t,t,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 19
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,t,t,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 20
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,t,t, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 21
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, t,t,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 22
+      {f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,t,t,f,f,f,f,f,f, f,f,f,f,f,f},     // 23
+
+      {t,t,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 36
+      {f,f,t,t,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 37
+      {f,f,f,f,t,t,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 38
+      {f,f,f,f,f,f,t,t,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 39
+      {f,f,f,f,f,f,f,f,t,t, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 40
+      {f,f,f,f,f,f,f,f,f,f, t,t,f,f,f,f,f,f,f,f, f,f,f,f,f,f,f,f,f,f, f,f,f,f,f,f},     // 41
+
+  };
+
+  /**
+   * Constructor.
+   */
+  public VorbisFormatConversionProvider()
+  {
+    super(Arrays.asList(INPUT_FORMATS), Arrays.asList(OUTPUT_FORMATS), CONVERSIONS);
+  }
+
+  /**
+   * Returns converted AudioInputStream.
+   */
+  public AudioInputStream getAudioInputStream(AudioFormat targetFormat, AudioInputStream audioInputStream)
+  {
+    if (isConversionSupported(targetFormat, audioInputStream.getFormat()))
+    {
+      return new DecodedVorbisAudioInputStream(targetFormat, audioInputStream);
+    }
+    else
+    {
+      throw new IllegalArgumentException("conversion not supported");
+    }
+  }
+}
diff --git a/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFileFormat.java b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFileFormat.java
new file mode 100644
index 0000000000..28b7c92a2a
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFileFormat.java
@@ -0,0 +1,85 @@
+/*
+ *   VorbisAudioFileFormat.
+ * 
+ *   JavaZOOM : vorbisspi@javazoom.net
+ *              http://www.javazoom.net 
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+package javazoom.spi.vorbis.sampled.file;
+
+import java.util.Map;
+
+import javax.sound.sampled.AudioFormat;
+
+import org.tritonus.share.sampled.file.TAudioFileFormat;
+
+/**
+ * @author JavaZOOM
+ */
+public class VorbisAudioFileFormat extends TAudioFileFormat
+{
+        /**
+         * Contructor. 
+         * @param type
+         * @param audioFormat
+         * @param nLengthInFrames
+         * @param nLengthInBytes
+         */
+        public VorbisAudioFileFormat(Type type, AudioFormat audioFormat, int nLengthInFrames, int nLengthInBytes, Map properties)
+        {
+                super(type, audioFormat, nLengthInFrames, nLengthInBytes, properties);
+        }
+
+        /**
+         * Ogg Vorbis audio file format parameters. 
+         * Some parameters might be unavailable. So availability test is required before reading any parameter.  
+         *
+         * <br>AudioFileFormat parameters.
+         * <ul>
+         * <li><b>duration</b> [Long], duration in microseconds.
+         * <li><b>title</b> [String], Title of the stream.
+         * <li><b>author</b> [String], Name of the artist of the stream.
+         * <li><b>album</b> [String], Name of the album of the stream.
+         * <li><b>date</b> [String], The date (year) of the recording or release of the stream.
+         * <li><b>copyright</b> [String], Copyright message of the stream.
+         * <li><b>comment</b> [String], Comment of the stream.
+         * </ul>
+         * <br>Ogg Vorbis parameters.
+         * <ul>
+         * <li><b>ogg.length.bytes</b> [Integer], length in bytes.
+         * <li><b>ogg.bitrate.min.bps</b> [Integer], minimum bitrate.
+         * <li><b>ogg.bitrate.nominal.bps</b> [Integer], nominal bitrate.
+         * <li><b>ogg.bitrate.max.bps</b> [Integer], maximum bitrate.
+         * <li><b>ogg.channels</b> [Integer], number of channels 1 : mono, 2 : stereo.
+         * <li><b>ogg.frequency.hz</b> [Integer], sampling rate in hz.
+         * <li><b>ogg.version</b> [Integer], version.
+         * <li><b>ogg.serial</b> [Integer], serial number. 
+         * <li><b>ogg.comment.track</b> [String], track number.
+         * <li><b>ogg.comment.genre</b> [String], genre field.
+         * <li><b>ogg.comment.encodedby</b> [String], encoded by field.
+         * <li><b>ogg.comment.ext</b> [String], extended comments (indexed):
+         * <br>For instance : 
+         * <br>ogg.comment.ext.1=Something
+         * <br>ogg.comment.ext.2=Another comment 
+         * </ul>
+         */
+        public Map properties()
+        {
+                return super.properties();      
+        }       
+}
diff --git a/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFileReader.java b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFileReader.java
new file mode 100644
index 0000000000..40bc9cadee
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFileReader.java
@@ -0,0 +1,502 @@
+/*
+ *   VorbisAudioFileReader.
+ * 
+ *   JavaZOOM : vorbisspi@javazoom.net
+ *              http://www.javazoom.net 
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+ 
+package javazoom.spi.vorbis.sampled.file;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.StringTokenizer;
+
+import javax.sound.sampled.AudioFileFormat;
+import javax.sound.sampled.AudioFormat;
+import javax.sound.sampled.AudioInputStream;
+import javax.sound.sampled.AudioSystem;
+import javax.sound.sampled.UnsupportedAudioFileException;
+
+import org.tritonus.share.TDebug;
+import org.tritonus.share.sampled.file.TAudioFileReader;
+
+import com.jcraft.jogg.Packet;
+import com.jcraft.jogg.Page;
+import com.jcraft.jogg.StreamState;
+import com.jcraft.jogg.SyncState;
+import com.jcraft.jorbis.Block;
+import com.jcraft.jorbis.Comment;
+import com.jcraft.jorbis.DspState;
+import com.jcraft.jorbis.Info;
+import com.jcraft.jorbis.JOrbisException;
+import com.jcraft.jorbis.VorbisFile;
+
+/**
+ * This class implements the AudioFileReader class and provides an
+ * Ogg Vorbis file reader for use with the Java Sound Service Provider Interface.
+ */
+public class VorbisAudioFileReader extends TAudioFileReader
+{
+  private SyncState oggSyncState_ = null;
+  private StreamState oggStreamState_ = null;
+  private Page oggPage_ = null;
+  private Packet oggPacket_ = null;
+  private Info vorbisInfo = null;
+  private Comment vorbisComment = null;
+  private DspState vorbisDspState = null;
+  private Block vorbisBlock = null;
+  private int bufferMultiple_ = 4;
+  private int bufferSize_ = bufferMultiple_ * 256 * 2;
+  private int convsize = bufferSize_ * 2;
+  private byte[] convbuffer = new byte[convsize];
+  private byte[] buffer = null;
+  private int bytes = 0;
+  private int rate = 0;
+  private int channels = 0;
+
+  private int index = 0;
+  private InputStream oggBitStream_ = null;
+
+  private static final int      INITAL_READ_LENGTH = 64000;
+  private static final int      MARK_LIMIT = INITAL_READ_LENGTH + 1;
+  
+  public VorbisAudioFileReader()
+  {
+          super(MARK_LIMIT, true);
+  }
+
+  /**
+   * Return the AudioFileFormat from the given file.
+   */
+  public AudioFileFormat getAudioFileFormat(File file) throws UnsupportedAudioFileException, IOException
+  {
+        if (TDebug.TraceAudioFileReader) TDebug.out("getAudioFileFormat(File file)");
+    InputStream inputStream = null;
+    try
+    {     
+          inputStream = new BufferedInputStream(new FileInputStream(file));     
+          inputStream.mark(MARK_LIMIT);     
+          AudioFileFormat aff = getAudioFileFormat(inputStream);
+          inputStream.reset();
+      // Get Vorbis file info such as length in seconds.
+      VorbisFile vf = new VorbisFile(file.getAbsolutePath());      
+      return getAudioFileFormat(inputStream,(int) file.length(), (int) Math.round((vf.time_total(-1))*1000));
+    }
+        catch (JOrbisException e)
+        {
+                throw new IOException(e.getMessage());
+        }
+   finally
+   {
+     if (inputStream != null) inputStream.close();
+   }
+  }
+
+  /**
+   * Return the AudioFileFormat from the given URL.
+   */
+  public AudioFileFormat getAudioFileFormat(URL url) throws UnsupportedAudioFileException, IOException
+  {
+        if (TDebug.TraceAudioFileReader) TDebug.out("getAudioFileFormat(URL url)");
+    InputStream inputStream = url.openStream();
+    try
+    {
+      return getAudioFileFormat(inputStream);
+    }
+    finally
+    {
+                if (inputStream != null) inputStream.close();
+    }
+  }
+
+  /**
+   * Return the AudioFileFormat from the given InputStream.
+   */
+  public AudioFileFormat getAudioFileFormat(InputStream inputStream) throws UnsupportedAudioFileException, IOException
+  {
+        if (TDebug.TraceAudioFileReader) TDebug.out("getAudioFileFormat(InputStream inputStream)");
+        try
+        {
+                if (!inputStream.markSupported()) inputStream = new BufferedInputStream(inputStream);
+                inputStream.mark(MARK_LIMIT);
+                return getAudioFileFormat(inputStream, AudioSystem.NOT_SPECIFIED, AudioSystem.NOT_SPECIFIED);
+        }
+        finally
+        {
+                inputStream.reset();
+        }    
+  }
+
+  /**
+   * Return the AudioFileFormat from the given InputStream and length in bytes.
+   */
+  public AudioFileFormat getAudioFileFormat(InputStream inputStream, long medialength) throws UnsupportedAudioFileException, IOException
+  {
+        return getAudioFileFormat(inputStream, (int) medialength, AudioSystem.NOT_SPECIFIED);
+  }
+
+  
+  /**
+   * Return the AudioFileFormat from the given InputStream, length in bytes and length in milliseconds.
+   */
+  protected AudioFileFormat getAudioFileFormat(InputStream bitStream, int mediaLength, int totalms) throws UnsupportedAudioFileException, IOException
+  {
+        HashMap aff_properties = new HashMap();
+        HashMap af_properties = new HashMap();
+    if (totalms == AudioSystem.NOT_SPECIFIED)
+    {
+      totalms = 0;
+    }
+    if (totalms <= 0)
+    {
+      totalms = 0;
+    }
+    else
+    {
+                aff_properties.put("duration",new Long(totalms*1000));          
+    }
+    oggBitStream_ = bitStream;
+    init_jorbis();
+    index = 0;
+    try
+    {
+      readHeaders(aff_properties, af_properties);
+    }
+    catch (IOException ioe)
+    {
+      if (TDebug.TraceAudioFileReader)
+      {
+                TDebug.out(ioe.getMessage());
+      }
+      throw new UnsupportedAudioFileException(ioe.getMessage());
+    }
+
+    String dmp = vorbisInfo.toString();
+    if (TDebug.TraceAudioFileReader)
+    {
+                TDebug.out(dmp);
+    }
+    int ind = dmp.lastIndexOf("bitrate:");    
+    int minbitrate = -1;
+        int nominalbitrate = -1;
+        int maxbitrate = -1;
+    if (ind != -1)
+    {
+      dmp = dmp.substring(ind + 8, dmp.length());
+      StringTokenizer st = new StringTokenizer(dmp, ",");
+          if (st.hasMoreTokens())
+          {
+                minbitrate = Integer.parseInt(st.nextToken());
+          }
+          if (st.hasMoreTokens())
+          {
+                nominalbitrate = Integer.parseInt(st.nextToken());
+          }
+          if (st.hasMoreTokens())
+          {
+                maxbitrate = Integer.parseInt(st.nextToken());
+          }
+    }
+        if (nominalbitrate > 0) af_properties.put("bitrate",new Integer(nominalbitrate));
+        af_properties.put("vbr",new Boolean(true));
+        
+        if (minbitrate > 0)  aff_properties.put("ogg.bitrate.min.bps",new Integer(minbitrate));
+        if (maxbitrate > 0)  aff_properties.put("ogg.bitrate.max.bps",new Integer(maxbitrate));
+        if (nominalbitrate > 0) aff_properties.put("ogg.bitrate.nominal.bps",new Integer(nominalbitrate));
+        if (vorbisInfo.channels > 0) aff_properties.put("ogg.channels",new Integer(vorbisInfo.channels));
+        if (vorbisInfo.rate > 0) aff_properties.put("ogg.frequency.hz",new Integer(vorbisInfo.rate));
+        if (mediaLength > 0) aff_properties.put("ogg.length.bytes",new Integer(mediaLength));
+        aff_properties.put("ogg.version",new Integer(vorbisInfo.version));
+        
+    AudioFormat.Encoding encoding = VorbisEncoding.VORBISENC;
+    AudioFormat format = new VorbisAudioFormat(encoding, vorbisInfo.rate, AudioSystem.NOT_SPECIFIED, vorbisInfo.channels, AudioSystem.NOT_SPECIFIED, AudioSystem.NOT_SPECIFIED, true,af_properties);
+    AudioFileFormat.Type type = VorbisFileFormatType.OGG;
+        return new VorbisAudioFileFormat(VorbisFileFormatType.OGG, format, AudioSystem.NOT_SPECIFIED, mediaLength,aff_properties);
+  }
+
+  /**
+   * Return the AudioInputStream from the given InputStream.
+   */
+  public AudioInputStream getAudioInputStream(InputStream inputStream) throws UnsupportedAudioFileException, IOException
+  {
+   if (TDebug.TraceAudioFileReader) TDebug.out("getAudioInputStream(InputStream inputStream)");
+   return getAudioInputStream(inputStream, AudioSystem.NOT_SPECIFIED, AudioSystem.NOT_SPECIFIED);
+  }
+
+  /**
+   * Return the AudioInputStream from the given InputStream.
+   */
+  public AudioInputStream getAudioInputStream(InputStream inputStream, int medialength, int totalms) throws UnsupportedAudioFileException, IOException
+  {
+        if (TDebug.TraceAudioFileReader) TDebug.out("getAudioInputStream(InputStream inputStreamint medialength, int totalms)");
+        try
+        {               
+                if (!inputStream.markSupported()) inputStream = new BufferedInputStream(inputStream);
+                inputStream.mark(MARK_LIMIT);
+                AudioFileFormat audioFileFormat = getAudioFileFormat(inputStream, medialength, totalms);
+                inputStream.reset();
+                return new AudioInputStream(inputStream, audioFileFormat.getFormat(), audioFileFormat.getFrameLength());
+        }
+        catch (UnsupportedAudioFileException e)
+        {
+                inputStream.reset();
+                throw e;
+        }
+        catch (IOException e)
+        {
+                inputStream.reset();
+                throw e;
+        }
+  }
+
+  /**
+   * Return the AudioInputStream from the given File.
+   */
+  public AudioInputStream getAudioInputStream(File file) throws UnsupportedAudioFileException, IOException
+  {
+        if (TDebug.TraceAudioFileReader) TDebug.out("getAudioInputStream(File file)");
+    InputStream inputStream = new FileInputStream(file);
+    try
+    {
+      return getAudioInputStream(inputStream);
+    }
+    catch (UnsupportedAudioFileException e)
+    {
+          if (inputStream != null) inputStream.close();
+      throw e;
+    }
+    catch (IOException e)
+    {
+          if (inputStream != null) inputStream.close();
+      throw e;
+    }
+  }
+
+  /**
+   * Return the AudioInputStream from the given URL.
+   */
+  public AudioInputStream getAudioInputStream(URL url) throws UnsupportedAudioFileException, IOException
+  {
+        if (TDebug.TraceAudioFileReader) TDebug.out("getAudioInputStream(URL url)");
+    InputStream inputStream = url.openStream();
+    try
+    {
+      return getAudioInputStream(inputStream);
+    }
+    catch (UnsupportedAudioFileException e)
+    {
+          if (inputStream != null) inputStream.close();
+      throw e;
+    }
+    catch (IOException e)
+    {
+          if (inputStream != null) inputStream.close();
+      throw e;
+    }
+  }
+
+  /**
+   * Reads headers and comments.
+   */
+  private void readHeaders(HashMap aff_properties, HashMap af_properties) throws IOException
+  {
+        if(TDebug.TraceAudioConverter) TDebug.out("readHeaders(");
+        index = oggSyncState_.buffer(bufferSize_);
+        buffer = oggSyncState_.data;
+        bytes = readFromStream(buffer, index, bufferSize_);
+        if(bytes == -1)
+        {
+          if(TDebug.TraceAudioConverter) TDebug.out("Cannot get any data from selected Ogg bitstream.");
+          throw new IOException("Cannot get any data from selected Ogg bitstream.");
+        }
+        oggSyncState_.wrote(bytes);
+        if(oggSyncState_.pageout(oggPage_) != 1)
+        {
+          if(bytes < bufferSize_)
+          {
+                throw new IOException("EOF");
+          }
+          if(TDebug.TraceAudioConverter) TDebug.out("Input does not appear to be an Ogg bitstream.");
+          throw new IOException("Input does not appear to be an Ogg bitstream.");
+        }       
+        oggStreamState_.init(oggPage_.serialno());
+        vorbisInfo.init();
+        vorbisComment.init();
+        aff_properties.put("ogg.serial",new Integer(oggPage_.serialno()));
+        if(oggStreamState_.pagein(oggPage_) < 0)
+        {
+          // error; stream version mismatch perhaps
+          if(TDebug.TraceAudioConverter) TDebug.out("Error reading first page of Ogg bitstream data.");
+          throw new IOException("Error reading first page of Ogg bitstream data.");
+        }
+        if(oggStreamState_.packetout(oggPacket_) != 1)
+        {
+          // no page? must not be vorbis
+          if(TDebug.TraceAudioConverter) TDebug.out("Error reading initial header packet.");
+          throw new IOException("Error reading initial header packet.");
+        }
+        if(vorbisInfo.synthesis_headerin(vorbisComment, oggPacket_) < 0)
+        {
+          // error case; not a vorbis header
+          if(TDebug.TraceAudioConverter) TDebug.out("This Ogg bitstream does not contain Vorbis audio data.");
+          throw new IOException("This Ogg bitstream does not contain Vorbis audio data.");
+        }
+        int i = 0;
+        while(i < 2)
+        {
+          while(i < 2)
+          {
+                int result = oggSyncState_.pageout(oggPage_);
+                if(result == 0)
+                {
+                  break;
+                } // Need more data
+                if(result == 1)
+                {
+                  oggStreamState_.pagein(oggPage_);
+                  while(i < 2)
+                  {
+                        result = oggStreamState_.packetout(oggPacket_);
+                        if(result == 0)
+                        {
+                          break;
+                        }
+                        if(result == -1)
+                        {
+                          if(TDebug.TraceAudioConverter) TDebug.out("Corrupt secondary header.  Exiting.");
+                          throw new IOException("Corrupt secondary header.  Exiting.");
+                        }
+                        vorbisInfo.synthesis_headerin(vorbisComment, oggPacket_);
+                        i++;
+                  }
+                }
+          }
+          index = oggSyncState_.buffer(bufferSize_);
+          buffer = oggSyncState_.data;
+          bytes = readFromStream(buffer, index, bufferSize_);
+          if(bytes == -1)
+          {
+                break;
+          }
+          if(bytes == 0 && i < 2)
+          {
+                if(TDebug.TraceAudioConverter) TDebug.out("End of file before finding all Vorbis headers!");
+                throw new IOException("End of file before finding all Vorbis  headers!");
+          }
+          oggSyncState_.wrote(bytes);
+        }
+        // Read Ogg Vorbis comments.
+        byte[][] ptr = vorbisComment.user_comments;
+        String currComment = "";
+        int c = 0;
+        for(int j = 0; j < ptr.length; j++)
+        {
+          if(ptr[j] == null)
+          {
+                break;
+          }
+          currComment = (new String(ptr[j], 0, ptr[j].length - 1)).trim();
+          if(TDebug.TraceAudioConverter) TDebug.out(currComment);
+          if (currComment.toLowerCase().startsWith("artist"))
+          {
+                aff_properties.put("author",currComment.substring(7));          
+          }
+          else if (currComment.toLowerCase().startsWith("title"))
+          {
+                aff_properties.put("title",currComment.substring(6));           
+          }
+          else if (currComment.toLowerCase().startsWith("album"))
+          {
+                aff_properties.put("album",currComment.substring(6));           
+          }
+          else if (currComment.toLowerCase().startsWith("date"))
+          {
+                aff_properties.put("date",currComment.substring(5));
+          }
+          else if (currComment.toLowerCase().startsWith("copyright"))
+          {
+                aff_properties.put("copyright",currComment.substring(10));              
+          }
+          else if (currComment.toLowerCase().startsWith("comment"))
+          {
+                aff_properties.put("comment",currComment.substring(8));
+          }
+          else if (currComment.toLowerCase().startsWith("genre"))
+          {
+                aff_properties.put("ogg.comment.genre",currComment.substring(6));       
+          }
+          else if (currComment.toLowerCase().startsWith("tracknumber"))
+          {
+                aff_properties.put("ogg.comment.track",currComment.substring(12));      
+          }
+          else
+          {
+                c++;
+                aff_properties.put("ogg.comment.ext."+c,currComment);
+          }
+          aff_properties.put("ogg.comment.encodedby",new String(vorbisComment.vendor, 0, vorbisComment.vendor.length - 1));
+        }
+  }
+
+  /**
+   * Reads from the oggBitStream_ a specified number of Bytes(bufferSize_) worth
+   * starting at index and puts them in the specified buffer[].
+   *
+   * @return the number of bytes read or -1 if error.
+   */
+  private int readFromStream(byte[] buffer, int index, int bufferSize_)
+  {
+    int bytes = 0;
+    try
+    {
+      bytes = oggBitStream_.read(buffer, index, bufferSize_);
+    }
+    catch (Exception e)
+    {
+      if (TDebug.TraceAudioFileReader)
+      {
+        TDebug.out("Cannot Read Selected Song");
+      }
+      bytes = -1;
+    }
+    return bytes;
+  }
+
+  /**
+   * Initializes all the jOrbis and jOgg vars that are used for song playback.
+   */
+  private void init_jorbis()
+  {
+    oggSyncState_ = new SyncState();
+    oggStreamState_ = new StreamState();
+    oggPage_ = new Page();
+    oggPacket_ = new Packet();
+    vorbisInfo = new Info();
+    vorbisComment = new Comment();
+    vorbisDspState = new DspState();
+    vorbisBlock = new Block(vorbisDspState);
+    buffer = null;
+    bytes = 0;
+    oggSyncState_.init();
+  }
+}
diff --git a/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFormat.java b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFormat.java
new file mode 100644
index 0000000000..829ab2f8cd
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisAudioFormat.java
@@ -0,0 +1,66 @@
+/*
+ *   VorbisAudioFormat.
+ * 
+ *   JavaZOOM : vorbisspi@javazoom.net
+ *              http://www.javazoom.net 
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+ 
+package javazoom.spi.vorbis.sampled.file;
+
+import java.util.Map;
+
+import javax.sound.sampled.AudioFormat;
+
+import org.tritonus.share.sampled.TAudioFormat;
+
+/**
+ * @author JavaZOOM
+ */
+public class VorbisAudioFormat extends TAudioFormat
+{       
+        /**
+         * Constructor.
+         * @param encoding
+         * @param nFrequency
+         * @param SampleSizeInBits
+         * @param nChannels
+         * @param FrameSize
+         * @param FrameRate
+         * @param isBigEndian
+         * @param properties
+         */
+        public VorbisAudioFormat(AudioFormat.Encoding encoding, float nFrequency, int SampleSizeInBits, int nChannels, int FrameSize, float FrameRate, boolean isBigEndian, Map properties)
+        {
+                super(encoding, nFrequency, SampleSizeInBits, nChannels, FrameSize, FrameRate, isBigEndian, properties);
+        }
+
+        /**
+         * Ogg Vorbis audio format parameters. 
+         * Some parameters might be unavailable. So availability test is required before reading any parameter.  
+         *
+         * <br>AudioFormat parameters.
+         * <ul>
+         * <li><b>bitrate</b> [Integer], bitrate in bits per seconds, average bitrate for VBR enabled stream.
+         * <li><b>vbr</b> [Boolean], VBR flag.
+         * </ul>
+         */
+        public Map properties()
+        {
+                return super.properties();      
+        }
+}       
diff --git a/songdbj/javazoom/spi/vorbis/sampled/file/VorbisEncoding.java b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisEncoding.java
new file mode 100644
index 0000000000..7800f1556d
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisEncoding.java
@@ -0,0 +1,41 @@
+/*
+ *   VorbisEncoding.
+ * 
+ *   JavaZOOM : vorbisspi@javazoom.net
+ *              http://www.javazoom.net
+ * 
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+package javazoom.spi.vorbis.sampled.file;
+
+import javax.sound.sampled.AudioFormat;
+
+/**
+ * Encodings used by the VORBIS audio decoder.
+ */
+public class VorbisEncoding extends AudioFormat.Encoding
+{
+  public static final AudioFormat.Encoding VORBISENC = new VorbisEncoding("VORBISENC");
+
+  /**
+   * Constructors.
+   */
+  public VorbisEncoding(String name)
+  {
+    super(name);
+  }
+}
diff --git a/songdbj/javazoom/spi/vorbis/sampled/file/VorbisFileFormatType.java b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisFileFormatType.java
new file mode 100644
index 0000000000..f006bbfe1d
--- /dev/null
+++ b/songdbj/javazoom/spi/vorbis/sampled/file/VorbisFileFormatType.java
@@ -0,0 +1,41 @@
+/*
+ *   VorbisFileFormatType.
+ * 
+ *   JavaZOOM : vorbisspi@javazoom.net
+ *              http://www.javazoom.net
+ * 
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+package javazoom.spi.vorbis.sampled.file;
+
+import javax.sound.sampled.AudioFileFormat;
+
+/**
+ * FileFormatTypes used by the VORBIS audio decoder.
+ */
+public class VorbisFileFormatType extends AudioFileFormat.Type
+{
+  public static final AudioFileFormat.Type VORBIS = new VorbisFileFormatType("VORBIS", "ogg");
+  public static final AudioFileFormat.Type OGG = new VorbisFileFormatType("OGG", "ogg");
+  /**
+   * Constructor.
+   */
+  public VorbisFileFormatType(String name, String extension)
+  {
+    super(name, extension);
+  }
+}