20 files changed, 3354 insertions, 0 deletions

diff --git a/songdbj/de/jarnbjo/vorbis/AudioPacket.java b/songdbj/de/jarnbjo/vorbis/AudioPacket.java
new file mode 100644
index 0000000000..90a54073c1
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/AudioPacket.java
@@ -0,0 +1,328 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+class AudioPacket {
+
+   private int modeNumber;
+   private Mode mode;
+   private Mapping mapping;
+   private int n; // block size
+   private boolean blockFlag, previousWindowFlag, nextWindowFlag;
+
+   private int windowCenter, leftWindowStart, leftWindowEnd, leftN, rightWindowStart, rightWindowEnd, rightN;
+   private float[] window;
+   private float[][] pcm;
+   private int[][] pcmInt;
+
+   private Floor[] channelFloors;
+   private boolean[] noResidues;
+
+   private final static float[][] windows=new float[8][];
+
+   protected AudioPacket(final VorbisStream vorbis, final BitInputStream source) throws VorbisFormatException, IOException {
+
+      final SetupHeader sHeader=vorbis.getSetupHeader();
+      final IdentificationHeader iHeader=vorbis.getIdentificationHeader();
+      final Mode[] modes=sHeader.getModes();
+      final Mapping[] mappings=sHeader.getMappings();
+      final Residue[] residues=sHeader.getResidues();
+      final int channels=iHeader.getChannels();
+
+      if(source.getInt(1)!=0) {
+         throw new VorbisFormatException("Packet type mismatch when trying to create an audio packet.");
+      }
+
+      modeNumber=source.getInt(Util.ilog(modes.length-1));
+
+      try {
+         mode=modes[modeNumber];
+      }
+      catch(ArrayIndexOutOfBoundsException e) {
+         throw new VorbisFormatException("Reference to invalid mode in audio packet.");
+      }
+
+      mapping=mappings[mode.getMapping()];
+
+      final int[] magnitudes=mapping.getMagnitudes();
+      final int[] angles=mapping.getAngles();
+
+      blockFlag=mode.getBlockFlag();
+
+      final int blockSize0=iHeader.getBlockSize0();
+      final int blockSize1=iHeader.getBlockSize1();
+
+      n=blockFlag?blockSize1:blockSize0;
+
+      if(blockFlag) {
+         previousWindowFlag=source.getBit();
+         nextWindowFlag=source.getBit();
+      }
+
+      windowCenter=n/2;
+
+      if(blockFlag && !previousWindowFlag) {
+         leftWindowStart=n/4-blockSize0/4;
+         leftWindowEnd=n/4+blockSize0/4;
+         leftN=blockSize0/2;
+      }
+      else {
+         leftWindowStart=0;
+         leftWindowEnd=n/2;
+         leftN=windowCenter;
+      }
+
+      if(blockFlag && !nextWindowFlag) {
+         rightWindowStart=n*3/4-blockSize0/4;
+         rightWindowEnd=n*3/4+blockSize0/4;
+         rightN=blockSize0/2;
+      }
+      else {
+         rightWindowStart=windowCenter;
+         rightWindowEnd=n;
+         rightN=n/2;
+      }
+
+      window=getComputedWindow();//new double[n];
+
+      channelFloors=new Floor[channels];
+      noResidues=new boolean[channels];
+
+      pcm=new float[channels][n];
+      pcmInt=new int[channels][n];
+
+      boolean allFloorsEmpty=true;
+
+      for(int i=0; i<channels; i++) {
+         int submapNumber=mapping.getMux()[i];
+         int floorNumber=mapping.getSubmapFloors()[submapNumber];
+         Floor decodedFloor=sHeader.getFloors()[floorNumber].decodeFloor(vorbis, source);
+         channelFloors[i]=decodedFloor;
+         noResidues[i]=decodedFloor==null;
+         if(decodedFloor!=null) {
+            allFloorsEmpty=false;
+         }
+      }
+
+      if(allFloorsEmpty) {
+         return;
+      }
+
+      for(int i=0; i<magnitudes.length; i++) {
+         if(!noResidues[magnitudes[i]] ||
+            !noResidues[angles[i]]) {
+
+            noResidues[magnitudes[i]]=false;
+            noResidues[angles[i]]=false;
+         }
+      }
+
+      Residue[] decodedResidues=new Residue[mapping.getSubmaps()];
+
+      for(int i=0; i<mapping.getSubmaps(); i++) {
+         int ch=0;
+         boolean[] doNotDecodeFlags=new boolean[channels];
+         for(int j=0; j<channels; j++) {
+            if(mapping.getMux()[j]==i) {
+               doNotDecodeFlags[ch++]=noResidues[j];
+            }
+         }
+         int residueNumber=mapping.getSubmapResidues()[i];
+         Residue residue=residues[residueNumber];
+
+         residue.decodeResidue(vorbis, source, mode, ch, doNotDecodeFlags, pcm);
+      }
+
+
+      for(int i=mapping.getCouplingSteps()-1; i>=0; i--) {
+         double newA=0, newM=0;
+         final float[] magnitudeVector=pcm[magnitudes[i]];
+         final float[] angleVector=pcm[angles[i]];
+         for(int j=0; j<magnitudeVector.length; j++) {
+            float a=angleVector[j];
+            float m=magnitudeVector[j];
+            if(a>0) {
+               //magnitudeVector[j]=m;
+               angleVector[j]=m>0?m-a:m+a;
+            }
+            else {
+               magnitudeVector[j]=m>0?m+a:m-a;
+               angleVector[j]=m;
+            }
+         }
+      }
+
+      for(int i=0; i<channels; i++) {
+         if(channelFloors[i]!=null) {
+            channelFloors[i].computeFloor(pcm[i]);
+         }
+      }
+
+      // perform an inverse mdct to all channels
+
+      for(int i=0; i<channels; i++) {
+         MdctFloat mdct=blockFlag?iHeader.getMdct1():iHeader.getMdct0();
+         mdct.imdct(pcm[i], window, pcmInt[i]);
+      }
+
+   }
+
+   private float[] getComputedWindow() {
+      int ix=(blockFlag?4:0)+(previousWindowFlag?2:0)+(nextWindowFlag?1:0);
+      float[] w=windows[ix];
+      if(w==null) {
+         w=new float[n];
+
+         for(int i=0;i<leftN;i++){
+                 float x=(float)((i+.5)/leftN*Math.PI/2.);
+                 x=(float)Math.sin(x);
+                 x*=x;
+                 x*=(float)Math.PI/2.;
+                 x=(float)Math.sin(x);
+                 w[i+leftWindowStart]=x;
+              }
+
+         for(int i=leftWindowEnd; i<rightWindowStart; w[i++]=1.0f);
+
+              for(int i=0;i<rightN;i++){
+                 float x=(float)((rightN-i-.5)/rightN*Math.PI/2.);
+                 x=(float)Math.sin(x);
+                 x*=x;
+                 x*=(float)Math.PI/2.;
+                 x=(float)Math.sin(x);
+                 w[i+rightWindowStart]=x;
+              }
+
+         windows[ix]=w;
+      }
+      return w;
+   }
+
+   protected int getNumberOfSamples() {
+      return rightWindowStart-leftWindowStart;
+   }
+
+   protected int getPcm(final AudioPacket previousPacket, final int[][] buffer) {
+      int channels=pcm.length;
+      int val;
+
+      // copy left window flank and mix with right window flank from
+      // the previous audio packet
+      for(int i=0; i<channels; i++) {
+         int j1=0, j2=previousPacket.rightWindowStart;
+         final int[] ppcm=previousPacket.pcmInt[i];
+         final int[] tpcm=pcmInt[i];
+         final int[] target=buffer[i];
+
+         for(int j=leftWindowStart; j<leftWindowEnd; j++) {
+            val=ppcm[j2++]+tpcm[j];
+            if(val>32767) val=32767;
+            if(val<-32768) val=-32768;
+            target[j1++]=val;
+         }
+      }
+
+      // use System.arraycopy to copy the middle part (if any)
+      // of the window
+      if(leftWindowEnd+1<rightWindowStart) {
+         for(int i=0; i<channels; i++) {
+            System.arraycopy(pcmInt[i], leftWindowEnd, buffer[i], leftWindowEnd-leftWindowStart, rightWindowStart-leftWindowEnd);
+         }
+      }
+
+      return rightWindowStart-leftWindowStart;
+   }
+
+   protected void getPcm(final AudioPacket previousPacket, final byte[] buffer) {
+      int channels=pcm.length;
+      int val;
+
+      // copy left window flank and mix with right window flank from
+      // the previous audio packet
+      for(int i=0; i<channels; i++) {
+         int ix=0, j2=previousPacket.rightWindowStart;
+         final int[] ppcm=previousPacket.pcmInt[i];
+         final int[] tpcm=pcmInt[i];
+         for(int j=leftWindowStart; j<leftWindowEnd; j++) {
+            val=ppcm[j2++]+tpcm[j];
+            if(val>32767) val=32767;
+            if(val<-32768) val=-32768;
+            buffer[ix+(i*2)+1]=(byte)(val&0xff);
+            buffer[ix+(i*2)]=(byte)((val>>8)&0xff);
+            ix+=channels*2;
+         }
+
+         ix=(leftWindowEnd-leftWindowStart)*channels*2;
+         for(int j=leftWindowEnd; j<rightWindowStart; j++) {
+            val=tpcm[j];
+            if(val>32767) val=32767;
+            if(val<-32768) val=-32768;
+            buffer[ix+(i*2)+1]=(byte)(val&0xff);
+            buffer[ix+(i*2)]=(byte)((val>>8)&0xff);
+            ix+=channels*2;
+         }
+      }
+   }
+
+   protected float[] getWindow() {
+      return window;
+   }
+
+   protected int getLeftWindowStart() {
+      return leftWindowStart;
+   }
+
+   protected int getLeftWindowEnd() {
+      return leftWindowEnd;
+   }
+
+   protected int getRightWindowStart() {
+      return rightWindowStart;
+   }
+
+   protected int getRightWindowEnd() {
+      return rightWindowEnd;
+   }
+
+   public int[][] getPcm() {
+      return pcmInt;
+   }
+
+   public float[][] getFreqencyDomain() {
+      return pcm;
+   }
+}
diff --git a/songdbj/de/jarnbjo/vorbis/CodeBook.java b/songdbj/de/jarnbjo/vorbis/CodeBook.java
new file mode 100644
index 0000000000..c865b120ca
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/CodeBook.java
@@ -0,0 +1,275 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.3  2003/04/10 19:49:04  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+import de.jarnbjo.util.io.BitInputStream;
+import de.jarnbjo.util.io.HuffmanNode;
+
+class CodeBook {
+
+   private HuffmanNode huffmanRoot;
+   private int dimensions, entries;
+
+   private int[] entryLengths;
+   private float[][] valueVector;
+
+   protected CodeBook(BitInputStream source) throws VorbisFormatException, IOException {
+
+      // check sync
+      if(source.getInt(24)!=0x564342) {
+         throw new VorbisFormatException("The code book sync pattern is not correct.");
+      }
+
+      dimensions=source.getInt(16);
+      entries=source.getInt(24);
+
+      entryLengths=new int[entries];
+
+      boolean ordered=source.getBit();
+
+      if(ordered) {
+         int cl=source.getInt(5)+1;
+         for(int i=0; i<entryLengths.length; ) {
+            int num=source.getInt(Util.ilog(entryLengths.length-i));
+            if(i+num>entryLengths.length) {
+               throw new VorbisFormatException("The codebook entry length list is longer than the actual number of entry lengths.");
+            }
+            Arrays.fill(entryLengths, i, i+num, cl);
+            cl++;
+            i+=num;
+         }
+      }
+      else {
+         // !ordered
+         boolean sparse=source.getBit();
+
+         if(sparse) {
+            for(int i=0; i<entryLengths.length; i++) {
+               if(source.getBit()) {
+                  entryLengths[i]=source.getInt(5)+1;
+               }
+               else {
+                  entryLengths[i]=-1;
+               }
+            }
+         }
+         else {
+            // !sparse
+            for(int i=0; i<entryLengths.length; i++) {
+               entryLengths[i]=source.getInt(5)+1;
+            }
+         }
+      }
+
+      if (!createHuffmanTree(entryLengths)) {
+         throw new VorbisFormatException("An exception was thrown when building the codebook Huffman tree.");
+      }
+
+      int codeBookLookupType=source.getInt(4);
+
+      switch(codeBookLookupType) {
+      case 0:
+         // codebook has no scalar vectors to be calculated
+         break;
+      case 1:
+      case 2:
+         float codeBookMinimumValue=Util.float32unpack(source.getInt(32));
+         float codeBookDeltaValue=Util.float32unpack(source.getInt(32));
+
+         int codeBookValueBits=source.getInt(4)+1;
+         boolean codeBookSequenceP=source.getBit();
+
+         int codeBookLookupValues=0;
+
+         if(codeBookLookupType==1) {
+            codeBookLookupValues=Util.lookup1Values(entries, dimensions);
+         }
+         else {
+            codeBookLookupValues=entries*dimensions;
+         }
+
+         int codeBookMultiplicands[]=new int[codeBookLookupValues];
+
+         for(int i=0; i<codeBookMultiplicands.length; i++) {
+            codeBookMultiplicands[i]=source.getInt(codeBookValueBits);
+         }
+
+         valueVector=new float[entries][dimensions];
+
+         if(codeBookLookupType==1) {
+            for(int i=0; i<entries; i++) {
+               float last=0;
+               int indexDivisor=1;
+               for(int j=0; j<dimensions; j++) {
+                  int multiplicandOffset=
+                     (i/indexDivisor)%codeBookLookupValues;
+                  valueVector[i][j]=
+                     codeBookMultiplicands[multiplicandOffset]*codeBookDeltaValue+codeBookMinimumValue+last;
+                  if(codeBookSequenceP) {
+                     last=valueVector[i][j];
+                  }
+                  indexDivisor*=codeBookLookupValues;
+               }
+            }
+         }
+         else {
+            throw new UnsupportedOperationException();
+            /** @todo implement */
+         }
+         break;
+      default:
+         throw new VorbisFormatException("Unsupported codebook lookup type: "+codeBookLookupType);
+      }
+   }
+
+   private static long totalTime=0;
+
+   private boolean createHuffmanTree(int[] entryLengths) {
+      huffmanRoot=new HuffmanNode();
+      for(int i=0; i<entryLengths.length; i++) {
+         int el=entryLengths[i];
+         if(el>0) {
+            if(!huffmanRoot.setNewValue(el, i)) {
+               return false;
+            }
+         }
+      }
+      return true;
+   }
+
+   protected int getDimensions() {
+      return dimensions;
+   }
+
+   protected int getEntries() {
+      return entries;
+   }
+
+   protected HuffmanNode getHuffmanRoot() {
+      return huffmanRoot;
+   }
+
+   //public float[] readVQ(ReadableBitChannel source) throws IOException {
+   //   return valueVector[readInt(source)];
+   //}
+
+   protected int readInt(final BitInputStream source) throws IOException {
+      return source.getInt(huffmanRoot);
+      /*
+      HuffmanNode node;
+      for(node=huffmanRoot; node.value==null; node=source.getBit()?node.o1:node.o0);
+      return node.value.intValue();
+      */
+   }
+
+   protected void readVvAdd(float[][] a, BitInputStream source, int offset, int length)
+      throws VorbisFormatException, IOException {
+
+      int i,j;//k;//entry;
+      int chptr=0;
+      int ch=a.length;
+
+      if(ch==0) {
+         return;
+      }
+
+      int lim=(offset+length)/ch;
+
+      for(i=offset/ch;i<lim;){
+         final float[] ve=valueVector[source.getInt(huffmanRoot)];
+         for(j=0;j<dimensions;j++){
+            a[chptr++][i]+=ve[j];
+            if(chptr==ch){
+               chptr=0;
+               i++;
+                 }
+         }
+      }
+   }
+
+   /*
+   public void readVAdd(double[] a, ReadableBitChannel source, int offset, int length)
+      throws FormatException, IOException {
+
+      int i,j,entry;
+      int t;
+
+      if(dimensions>8){
+         for(i=0;i<length;){
+            entry = readInt(source);
+            //if(entry==-1)return(-1);
+                 //t=entry*dimensions;
+                 for(j=0;j<dimensions;){
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 }
+         }
+      }
+      else{
+         for(i=0;i<length;){
+                 entry=readInt(source);
+                 //if(entry==-1)return(-1);
+                 //t=entry*dim;
+                 j=0;
+                 switch(dimensions){
+                 case 8:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 7:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 6:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 5:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 4:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 3:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 2:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 1:
+                    a[offset+(i++)]+=valueVector[entry][j++];//valuelist[t+(j++)];
+                 case 0:
+                    break;
+                 }
+         }
+      }
+   }
+   */
+
+
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/CommentHeader.java b/songdbj/de/jarnbjo/vorbis/CommentHeader.java
new file mode 100644
index 0000000000..dd00ebca38
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/CommentHeader.java
@@ -0,0 +1,244 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.*;
+
+import java.util.*;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+/**
+ */
+
+public class CommentHeader {
+
+   public static final String TITLE = "TITLE";
+   public static final String ARTIST = "ARTIST";
+   public static final String ALBUM = "ALBUM";
+   public static final String TRACKNUMBER = "TRACKNUMBER";
+   public static final String VERSION = "VERSION";
+   public static final String PERFORMER = "PERFORMER";
+   public static final String COPYRIGHT = "COPYRIGHT";
+   public static final String LICENSE = "LICENSE";
+   public static final String ORGANIZATION = "ORGANIZATION";
+   public static final String DESCRIPTION = "DESCRIPTION";
+   public static final String GENRE = "GENRE";
+   public static final String DATE = "DATE";
+   public static final String LOCATION = "LOCATION";
+   public static final String CONTACT = "CONTACT";
+   public static final String ISRC = "ISRC";
+
+   private String vendor;
+   private HashMap comments=new HashMap();
+   private boolean framingBit;
+
+   private static final long HEADER = 0x736962726f76L; // 'vorbis'
+
+   public CommentHeader(BitInputStream source) throws VorbisFormatException, IOException {
+      if(source.getLong(48)!=HEADER) {
+         throw new VorbisFormatException("The identification header has an illegal leading.");
+      }
+
+      vendor=getString(source);
+
+      int ucLength=source.getInt(32);
+
+      for(int i=0; i<ucLength; i++) {
+         String comment=getString(source);
+         int ix=comment.indexOf('=');
+         String key=comment.substring(0, ix);
+         String value=comment.substring(ix+1);
+         //comments.put(key, value);
+         addComment(key, value);
+      }
+
+      framingBit=source.getInt(8)!=0;
+   }
+
+   private void addComment(String key, String value) {
+      key = key.toUpperCase();      // Comment keys are case insensitive
+      ArrayList al=(ArrayList)comments.get(key);
+      if(al==null) {
+         al=new ArrayList();
+         comments.put(key, al);
+      }
+      al.add(value);
+   }
+
+   public String getVendor() {
+      return vendor;
+   }
+
+   public String getComment(String key) {
+      ArrayList al=(ArrayList)comments.get(key);
+      return al==null?(String)null:(String)al.get(0);
+   }
+
+   public String[] getComments(String key) {
+      ArrayList al=(ArrayList)comments.get(key);
+      return al==null?new String[0]:(String[])al.toArray(new String[al.size()]);
+   }
+
+   public String getTitle() {
+      return getComment(TITLE);
+   }
+
+   public String[] getTitles() {
+      return getComments(TITLE);
+   }
+
+   public String getVersion() {
+      return getComment(VERSION);
+   }
+
+   public String[] getVersions() {
+      return getComments(VERSION);
+   }
+
+   public String getAlbum() {
+      return getComment(ALBUM);
+   }
+
+   public String[] getAlbums() {
+      return getComments(ALBUM);
+   }
+
+   public String getTrackNumber() {
+      return getComment(TRACKNUMBER);
+   }
+
+   public String[] getTrackNumbers() {
+      return getComments(TRACKNUMBER);
+   }
+
+   public String getArtist() {
+      return getComment(ARTIST);
+   }
+
+   public String[] getArtists() {
+      return getComments(ARTIST);
+   }
+
+   public String getPerformer() {
+      return getComment(PERFORMER);
+   }
+
+   public String[] getPerformers() {
+      return getComments(PERFORMER);
+   }
+
+   public String getCopyright() {
+      return getComment(COPYRIGHT);
+   }
+
+   public String[] getCopyrights() {
+      return getComments(COPYRIGHT);
+   }
+
+   public String getLicense() {
+      return getComment(LICENSE);
+   }
+
+   public String[] getLicenses() {
+      return getComments(LICENSE);
+   }
+
+   public String getOrganization() {
+      return getComment(ORGANIZATION);
+   }
+
+   public String[] getOrganizations() {
+      return getComments(ORGANIZATION);
+   }
+
+   public String getDescription() {
+      return getComment(DESCRIPTION);
+   }
+
+   public String[] getDescriptions() {
+      return getComments(DESCRIPTION);
+   }
+
+   public String getGenre() {
+      return getComment(GENRE);
+   }
+
+   public String[] getGenres() {
+      return getComments(GENRE);
+   }
+
+   public String getDate() {
+      return getComment(DATE);
+   }
+
+   public String[] getDates() {
+      return getComments(DATE);
+   }
+
+   public String getLocation() {
+      return getComment(LOCATION);
+   }
+
+   public String[] getLocations() {
+      return getComments(LOCATION);
+   }
+
+   public String getContact() {
+      return getComment(CONTACT);
+   }
+
+   public String[] getContacts() {
+      return getComments(CONTACT);
+   }
+
+   public String getIsrc() {
+      return getComment(ISRC);
+   }
+
+   public String[] getIsrcs() {
+      return getComments(ISRC);
+   }
+
+
+   private String getString(BitInputStream source) throws IOException, VorbisFormatException {
+
+      int length=source.getInt(32);
+
+      byte[] strArray=new byte[length];
+
+      for(int i=0; i<length; i++) {
+         strArray[i]=(byte)source.getInt(8);
+      }
+
+      return new String(strArray, "UTF-8");
+   }
+
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Floor.java b/songdbj/de/jarnbjo/vorbis/Floor.java
new file mode 100644
index 0000000000..5be2798dfb
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Floor.java
@@ -0,0 +1,124 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.3  2003/04/10 19:49:04  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+
+public abstract class Floor {
+
+  public final static float[] DB_STATIC_TABLE={
+      1.0649863e-07f, 1.1341951e-07f, 1.2079015e-07f, 1.2863978e-07f,
+      1.3699951e-07f, 1.4590251e-07f, 1.5538408e-07f, 1.6548181e-07f,
+      1.7623575e-07f, 1.8768855e-07f, 1.9988561e-07f, 2.128753e-07f,
+      2.2670913e-07f, 2.4144197e-07f, 2.5713223e-07f, 2.7384213e-07f,
+      2.9163793e-07f, 3.1059021e-07f, 3.3077411e-07f, 3.5226968e-07f,
+      3.7516214e-07f, 3.9954229e-07f, 4.2550680e-07f, 4.5315863e-07f,
+      4.8260743e-07f, 5.1396998e-07f, 5.4737065e-07f, 5.8294187e-07f,
+      6.2082472e-07f, 6.6116941e-07f, 7.0413592e-07f, 7.4989464e-07f,
+      7.9862701e-07f, 8.5052630e-07f, 9.0579828e-07f, 9.6466216e-07f,
+      1.0273513e-06f, 1.0941144e-06f, 1.1652161e-06f, 1.2409384e-06f,
+      1.3215816e-06f, 1.4074654e-06f, 1.4989305e-06f, 1.5963394e-06f,
+      1.7000785e-06f, 1.8105592e-06f, 1.9282195e-06f, 2.0535261e-06f,
+      2.1869758e-06f, 2.3290978e-06f, 2.4804557e-06f, 2.6416497e-06f,
+      2.8133190e-06f, 2.9961443e-06f, 3.1908506e-06f, 3.3982101e-06f,
+      3.6190449e-06f, 3.8542308e-06f, 4.1047004e-06f, 4.3714470e-06f,
+      4.6555282e-06f, 4.9580707e-06f, 5.2802740e-06f, 5.6234160e-06f,
+      5.9888572e-06f, 6.3780469e-06f, 6.7925283e-06f, 7.2339451e-06f,
+      7.7040476e-06f, 8.2047000e-06f, 8.7378876e-06f, 9.3057248e-06f,
+      9.9104632e-06f, 1.0554501e-05f, 1.1240392e-05f, 1.1970856e-05f,
+      1.2748789e-05f, 1.3577278e-05f, 1.4459606e-05f, 1.5399272e-05f,
+      1.6400004e-05f, 1.7465768e-05f, 1.8600792e-05f, 1.9809576e-05f,
+      2.1096914e-05f, 2.2467911e-05f, 2.3928002e-05f, 2.5482978e-05f,
+      2.7139006e-05f, 2.8902651e-05f, 3.0780908e-05f, 3.2781225e-05f,
+      3.4911534e-05f, 3.7180282e-05f, 3.9596466e-05f, 4.2169667e-05f,
+      4.4910090e-05f, 4.7828601e-05f, 5.0936773e-05f, 5.4246931e-05f,
+      5.7772202e-05f, 6.1526565e-05f, 6.5524908e-05f, 6.9783085e-05f,
+      7.4317983e-05f, 7.9147585e-05f, 8.4291040e-05f, 8.9768747e-05f,
+      9.5602426e-05f, 0.00010181521f, 0.00010843174f, 0.00011547824f,
+      0.00012298267f, 0.00013097477f, 0.00013948625f, 0.00014855085f,
+      0.00015820453f, 0.00016848555f, 0.00017943469f, 0.00019109536f,
+      0.00020351382f, 0.00021673929f, 0.00023082423f, 0.00024582449f,
+      0.00026179955f, 0.00027881276f, 0.00029693158f, 0.00031622787f,
+      0.00033677814f, 0.00035866388f, 0.00038197188f, 0.00040679456f,
+      0.00043323036f, 0.00046138411f, 0.00049136745f, 0.00052329927f,
+      0.00055730621f, 0.00059352311f, 0.00063209358f, 0.00067317058f,
+      0.00071691700f, 0.00076350630f, 0.00081312324f, 0.00086596457f,
+      0.00092223983f, 0.00098217216f, 0.0010459992f, 0.0011139742f,
+      0.0011863665f, 0.0012634633f, 0.0013455702f, 0.0014330129f,
+      0.0015261382f, 0.0016253153f, 0.0017309374f, 0.0018434235f,
+      0.0019632195f, 0.0020908006f, 0.0022266726f, 0.0023713743f,
+      0.0025254795f, 0.0026895994f, 0.0028643847f, 0.0030505286f,
+      0.0032487691f, 0.0034598925f, 0.0036847358f, 0.0039241906f,
+      0.0041792066f, 0.0044507950f, 0.0047400328f, 0.0050480668f,
+      0.0053761186f, 0.0057254891f, 0.0060975636f, 0.0064938176f,
+      0.0069158225f, 0.0073652516f, 0.0078438871f, 0.0083536271f,
+      0.0088964928f, 0.009474637f, 0.010090352f, 0.010746080f,
+      0.011444421f, 0.012188144f, 0.012980198f, 0.013823725f,
+      0.014722068f, 0.015678791f, 0.016697687f, 0.017782797f,
+      0.018938423f, 0.020169149f, 0.021479854f, 0.022875735f,
+      0.024362330f, 0.025945531f, 0.027631618f, 0.029427276f,
+      0.031339626f, 0.033376252f, 0.035545228f, 0.037855157f,
+      0.040315199f, 0.042935108f, 0.045725273f, 0.048696758f,
+      0.051861348f, 0.055231591f, 0.058820850f, 0.062643361f,
+      0.066714279f, 0.071049749f, 0.075666962f, 0.080584227f,
+      0.085821044f, 0.091398179f, 0.097337747f, 0.10366330f,
+      0.11039993f, 0.11757434f, 0.12521498f, 0.13335215f,
+      0.14201813f, 0.15124727f, 0.16107617f, 0.17154380f,
+      0.18269168f, 0.19456402f, 0.20720788f, 0.22067342f,
+      0.23501402f, 0.25028656f, 0.26655159f, 0.28387361f,
+      0.30232132f, 0.32196786f, 0.34289114f, 0.36517414f,
+      0.38890521f, 0.41417847f, 0.44109412f, 0.46975890f,
+      0.50028648f, 0.53279791f, 0.56742212f, 0.60429640f,
+      0.64356699f, 0.68538959f, 0.72993007f, 0.77736504f,
+      0.82788260f, 0.88168307f, 0.9389798f, 1.0f};
+
+   static Floor createInstance(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+
+      int type=source.getInt(16);
+      switch(type) {
+      case 0:
+         return new Floor0(source, header);
+      case 1:
+         return new Floor1(source, header);
+      default:
+         throw new VorbisFormatException("Floor type "+type+" is not supported.");
+      }
+   }
+
+   abstract int getType();
+   abstract Floor decodeFloor(VorbisStream vorbis, BitInputStream source) throws VorbisFormatException, IOException;
+   abstract void computeFloor(float[] vector);
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Floor0.java b/songdbj/de/jarnbjo/vorbis/Floor0.java
new file mode 100644
index 0000000000..4e94b27b73
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Floor0.java
@@ -0,0 +1,74 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+class Floor0 extends Floor {
+
+   private int order, rate, barkMapSize, amplitudeBits, amplitudeOffset;
+   private int bookList[];
+
+   protected Floor0(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+
+      order=source.getInt(8);
+      rate=source.getInt(16);
+      barkMapSize=source.getInt(16);
+      amplitudeBits=source.getInt(6);
+      amplitudeOffset=source.getInt(8);
+
+      int bookCount=source.getInt(4)+1;
+      bookList=new int[bookCount];
+
+      for(int i=0; i<bookList.length; i++) {
+         bookList[i]=source.getInt(8);
+         if(bookList[i]>header.getCodeBooks().length) {
+            throw new VorbisFormatException("A floor0_book_list entry is higher than the code book count.");
+         }
+      }
+   }
+
+   protected int getType() {
+      return 0;
+   }
+
+   protected Floor decodeFloor(VorbisStream vorbis, BitInputStream source) throws VorbisFormatException, IOException {
+      /** @todo implement */
+      throw new UnsupportedOperationException();
+   }
+
+   protected void computeFloor(float[] vector) {
+      /** @todo implement */
+      throw new UnsupportedOperationException();
+   }
+
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Floor1.java b/songdbj/de/jarnbjo/vorbis/Floor1.java
new file mode 100644
index 0000000000..69a118b44e
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Floor1.java
@@ -0,0 +1,324 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$multip
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+import java.util.*;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+
+class Floor1 extends Floor implements Cloneable {
+
+   private int[] partitionClassList;
+   private int maximumClass, multiplier, rangeBits;
+   private int[] classDimensions;
+   private int[] classSubclasses;
+   private int[] classMasterbooks;
+   private int[][] subclassBooks;
+   private int[] xList;
+   private int[] yList;
+   private int[] lowNeighbours, highNeighbours;
+   //private boolean[] step2Flags;
+
+   private static final int[] RANGES = {256, 128, 86, 64};
+
+   private Floor1() {
+   }
+
+   protected Floor1(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+
+      maximumClass=-1;
+      int partitions=source.getInt(5);
+      partitionClassList=new int[partitions];
+
+      for(int i=0; i<partitionClassList.length; i++) {
+         partitionClassList[i]=source.getInt(4);
+         if(partitionClassList[i]>maximumClass) {
+            maximumClass=partitionClassList[i];
+         }
+      }
+
+
+      classDimensions=new int[maximumClass+1];
+      classSubclasses=new int[maximumClass+1];
+      classMasterbooks=new int[maximumClass+1];
+      subclassBooks=new int[maximumClass+1][];
+
+      int xListLength=2;
+
+      for(int i=0; i<=maximumClass; i++) {
+         classDimensions[i]=source.getInt(3)+1;
+         xListLength+=classDimensions[i];
+         classSubclasses[i]=source.getInt(2);
+
+         if(classDimensions[i] > header.getCodeBooks().length ||
+            classSubclasses[i] > header.getCodeBooks().length) {
+            throw new VorbisFormatException("There is a class dimension or class subclasses entry higher than the number of codebooks in the setup header.");
+         }
+         if(classSubclasses[i]!=0) {
+            classMasterbooks[i]=source.getInt(8);
+         }
+         subclassBooks[i]=new int[1<<classSubclasses[i]];
+         for(int j=0; j<subclassBooks[i].length; j++) {
+            subclassBooks[i][j]=source.getInt(8)-1;
+         }
+      }
+
+      multiplier=source.getInt(2)+1;
+      rangeBits=source.getInt(4);
+
+      //System.out.println("multiplier: "+multiplier);
+      //System.out.println("rangeBits: "+rangeBits);
+
+      //System.out.println("xListLength: "+xListLength);
+
+      int floorValues=0;
+
+      ArrayList alXList=new ArrayList();
+
+      alXList.add(new Integer(0));
+      alXList.add(new Integer(1<<rangeBits));
+
+      //System.out.println("partitions: "+partitions);
+      //System.out.println("classDimensions.length: "+classDimensions.length);
+
+      for(int i=0; i<partitions; i++) {
+         for(int j=0; j<classDimensions[partitionClassList[i]]; j++) {
+            alXList.add(new Integer(source.getInt(rangeBits)));
+         }
+      }
+
+      xList=new int[alXList.size()];
+      lowNeighbours=new int[xList.length];
+      highNeighbours=new int[xList.length];
+
+      Iterator iter=alXList.iterator();
+      for(int i=0; i<xList.length; i++) {
+         xList[i]=((Integer)iter.next()).intValue();
+      }
+
+      for(int i=0; i<xList.length; i++) {
+         lowNeighbours[i]=Util.lowNeighbour(xList, i);
+         highNeighbours[i]=Util.highNeighbour(xList, i);
+      }
+   }
+
+   protected int getType() {
+      return 1;
+   }
+
+   protected Floor decodeFloor(VorbisStream vorbis, BitInputStream source) throws VorbisFormatException, IOException {
+
+   //System.out.println("decodeFloor");
+      if(!source.getBit()) {
+         //System.out.println("null");
+         return null;
+      }
+
+      Floor1 clone=(Floor1)clone();
+
+      clone.yList=new int[xList.length];
+
+      int range=RANGES[multiplier-1];
+
+      clone.yList[0]=source.getInt(Util.ilog(range-1));
+      clone.yList[1]=source.getInt(Util.ilog(range-1));
+
+      int offset=2;
+
+      for(int i=0; i<partitionClassList.length; i++) {
+         int cls=partitionClassList[i];
+         int cdim=classDimensions[cls];
+         int cbits=classSubclasses[cls];
+         int csub=(1<<cbits)-1;
+         int cval=0;
+         if(cbits>0) {
+            cval=source.getInt(vorbis.getSetupHeader().getCodeBooks()[classMasterbooks[cls]].getHuffmanRoot());
+            //cval=vorbis.getSetupHeader().getCodeBooks()[classMasterbooks[cls]].readInt(source);
+            //System.out.println("cval: "+cval);
+         }
+         //System.out.println("0: "+cls+" "+cdim+" "+cbits+" "+csub+" "+cval);
+         for(int j=0; j<cdim; j++) {
+            //System.out.println("a: "+cls+" "+cval+" "+csub);
+            int book=subclassBooks[cls][cval&csub];
+            cval>>>=cbits;
+            if(book>=0) {
+               clone.yList[j+offset]=source.getInt(vorbis.getSetupHeader().getCodeBooks()[book].getHuffmanRoot());
+               //clone.yList[j+offset]=vorbis.getSetupHeader().getCodeBooks()[book].readInt(source);
+               //System.out.println("b: "+(j+offset)+" "+book+" "+clone.yList[j+offset]);
+               //System.out.println("");
+            }
+            else {
+               clone.yList[j+offset]=0;
+            }
+         }
+         offset+=cdim;
+      }
+
+      //System.out.println("");
+      //for(int i=0; i<clone.xList.length; i++) {
+      //   System.out.println(i+" = "+clone.xList[i]);
+      //}
+
+      //System.out.println("");
+      //for(int i=0; i<clone.yList.length; i++) {
+      //   System.out.println(i+" = "+clone.yList[i]);
+      //}
+
+      //System.out.println("offset: "+offset);
+      //System.out.println("yList.length: "+clone.yList.length);
+
+      //System.exit(0);
+
+      return clone;
+   }
+
+   protected void computeFloor(final float[] vector) {
+
+      int n=vector.length;
+      final int values=xList.length;
+      final boolean[] step2Flags=new boolean[values];
+
+      final int range=RANGES[multiplier-1];
+
+      for(int i=2; i<values; i++) {
+         final int lowNeighbourOffset=lowNeighbours[i];//Util.lowNeighbour(xList, i);
+         final int highNeighbourOffset=highNeighbours[i];//Util.highNeighbour(xList, i);
+         final int predicted=Util.renderPoint(
+            xList[lowNeighbourOffset], xList[highNeighbourOffset],
+            yList[lowNeighbourOffset], yList[highNeighbourOffset],
+            xList[i]);
+         final int val=yList[i];
+         final int highRoom=range-predicted;
+         final int lowRoom=predicted;
+         final int room=highRoom<lowRoom?highRoom*2:lowRoom*2;
+         if(val!=0) {
+            step2Flags[lowNeighbourOffset]=true;
+            step2Flags[highNeighbourOffset]=true;
+            step2Flags[i]=true;
+            if(val>=room) {
+               yList[i]=highRoom>lowRoom?
+                  val-lowRoom+predicted:
+                  -val+highRoom+predicted-1;
+            }
+            else {
+               yList[i]=(val&1)==1?
+                  predicted-((val+1)>>1):
+                  predicted+(val>>1);
+            }
+         }
+         else {
+            step2Flags[i]=false;
+            yList[i]=predicted;
+         }
+      }
+
+      final int[] xList2=new int[values];
+
+      System.arraycopy(xList, 0, xList2, 0, values);
+      sort(xList2, yList, step2Flags);
+
+      int hx=0, hy=0, lx=0, ly=yList[0]*multiplier;
+
+      float[] vector2=new float[vector.length];
+      float[] vector3=new float[vector.length];
+      Arrays.fill(vector2, 1.0f);
+      System.arraycopy(vector, 0, vector3, 0, vector.length);
+
+      for(int i=1; i<values; i++) {
+         if(step2Flags[i]) {
+            hy=yList[i]*multiplier;
+            hx=xList2[i];
+            Util.renderLine(lx, ly, hx, hy, vector);
+            Util.renderLine(lx, ly, hx, hy, vector2);
+            lx=hx;
+            ly=hy;
+         }
+      }
+
+      final float r=DB_STATIC_TABLE[hy];
+      for(; hx<n/2; vector[hx++]=r);
+   }
+
+   public Object clone() {
+      Floor1 clone=new Floor1();
+      clone.classDimensions=classDimensions;
+      clone.classMasterbooks=classMasterbooks;
+      clone.classSubclasses=classSubclasses;
+      clone.maximumClass=maximumClass;
+      clone.multiplier=multiplier;
+      clone.partitionClassList=partitionClassList;
+      clone.rangeBits=rangeBits;
+      clone.subclassBooks=subclassBooks;
+      clone.xList=xList;
+      clone.yList=yList;
+      clone.lowNeighbours=lowNeighbours;
+      clone.highNeighbours=highNeighbours;
+      return clone;
+   }
+
+   private final static void sort(int x[], int y[], boolean b[]) {
+      int off=0;
+      int len=x.length;
+      int lim=len+off;
+      int itmp;
+      boolean btmp;
+        // Insertion sort on smallest arrays
+      for (int i=off; i<lim; i++) {
+         for (int j=i; j>off && x[j-1]>x[j]; j--) {
+            itmp=x[j];
+            x[j]=x[j-1];
+            x[j-1]=itmp;
+            itmp=y[j];
+            y[j]=y[j-1];
+            y[j-1]=itmp;
+            btmp=b[j];
+            b[j]=b[j-1];
+            b[j-1]=btmp;
+            //swap(x, j, j-1);
+            //swap(y, j, j-1);
+            //swap(b, j, j-1);
+         }
+      }
+        }
+
+   private final static void swap(int x[], int a, int b) {
+           int t = x[a];
+           x[a] = x[b];
+           x[b] = t;
+   }
+
+   private final static void swap(boolean x[], int a, int b) {
+           boolean t = x[a];
+           x[a] = x[b];
+           x[b] = t;
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/IdentificationHeader.java b/songdbj/de/jarnbjo/vorbis/IdentificationHeader.java
new file mode 100644
index 0000000000..1e18163385
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/IdentificationHeader.java
@@ -0,0 +1,120 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.3  2003/03/31 00:20:16  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+/**
+ */
+
+public class IdentificationHeader {
+
+   private int version, channels, sampleRate, bitrateMaximum, bitrateNominal, bitrateMinimum, blockSize0, blockSize1;
+   private boolean framingFlag;
+   private MdctFloat[] mdct=new MdctFloat[2];
+   //private MdctLong[] mdctInt=new MdctLong[2];
+
+   private static final long HEADER = 0x736962726f76L; // 'vorbis'
+
+   public IdentificationHeader(BitInputStream source) throws VorbisFormatException, IOException {
+      //equalizer=new Equalizer();
+      //equalizer.pack();
+      //equalizer.show();
+
+      long leading=source.getLong(48);
+      if(leading!=HEADER) {
+         throw new VorbisFormatException("The identification header has an illegal leading.");
+      }
+      version=source.getInt(32);
+      channels=source.getInt(8);
+      sampleRate=source.getInt(32);
+      bitrateMaximum=source.getInt(32);
+      bitrateNominal=source.getInt(32);
+      bitrateMinimum=source.getInt(32);
+      int bs=source.getInt(8);
+      blockSize0=1<<(bs&0xf);
+      blockSize1=1<<(bs>>4);
+
+      mdct[0]=new MdctFloat(blockSize0);
+      mdct[1]=new MdctFloat(blockSize1);
+      //mdctInt[0]=new MdctLong(blockSize0);
+      //mdctInt[1]=new MdctLong(blockSize1);
+
+      framingFlag=source.getInt(8)!=0;
+   }
+
+   public int getSampleRate() {
+      return sampleRate;
+   }
+
+   public int getMaximumBitrate() {
+      return bitrateMaximum;
+   }
+
+   public int getNominalBitrate() {
+      return bitrateNominal;
+   }
+
+   public int getMinimumBitrate() {
+      return bitrateMinimum;
+   }
+
+   public int getChannels() {
+      return channels;
+   }
+
+   public int getBlockSize0() {
+      return blockSize0;
+   }
+
+   public int getBlockSize1() {
+      return blockSize1;
+   }
+
+   protected MdctFloat getMdct0() {
+      return mdct[0];
+   }
+
+   protected MdctFloat getMdct1() {
+      return mdct[1];
+   }
+
+   public int getVersion() {
+      return version;
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Mapping.java b/songdbj/de/jarnbjo/vorbis/Mapping.java
new file mode 100644
index 0000000000..24a2eaa19a
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Mapping.java
@@ -0,0 +1,59 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+abstract class Mapping {
+
+   protected static Mapping createInstance(VorbisStream vorbis, BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+
+      int type=source.getInt(16);
+      switch(type) {
+      case 0:
+         //System.out.println("mapping type 0");
+         return new Mapping0(vorbis, source, header);
+      default:
+         throw new VorbisFormatException("Mapping type "+type+" is not supported.");
+      }
+   }
+
+   protected abstract int getType();
+   protected abstract int[] getAngles();
+   protected abstract int[] getMagnitudes() ;
+   protected abstract int[] getMux();
+   protected abstract int[] getSubmapFloors();
+   protected abstract int[] getSubmapResidues();
+   protected abstract int getCouplingSteps();
+   protected abstract int getSubmaps();
+
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Mapping0.java b/songdbj/de/jarnbjo/vorbis/Mapping0.java
new file mode 100644
index 0000000000..e8fde4686f
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Mapping0.java
@@ -0,0 +1,146 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+class Mapping0 extends Mapping {
+
+   private int[] magnitudes, angles, mux, submapFloors, submapResidues;
+
+   protected Mapping0(VorbisStream vorbis, BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+
+      int submaps=1;
+
+      if(source.getBit()) {
+         submaps=source.getInt(4)+1;
+      }
+
+      //System.out.println("submaps: "+submaps);
+
+      int channels=vorbis.getIdentificationHeader().getChannels();
+      int ilogChannels=Util.ilog(channels-1);
+
+      //System.out.println("ilogChannels: "+ilogChannels);
+
+      if(source.getBit()) {
+         int couplingSteps=source.getInt(8)+1;
+         magnitudes=new int[couplingSteps];
+         angles=new int[couplingSteps];
+
+         for(int i=0; i<couplingSteps; i++) {
+            magnitudes[i]=source.getInt(ilogChannels);
+            angles[i]=source.getInt(ilogChannels);
+            if(magnitudes[i]==angles[i] || magnitudes[i]>=channels || angles[i]>=channels) {
+               System.err.println(magnitudes[i]);
+               System.err.println(angles[i]);
+               throw new VorbisFormatException("The channel magnitude and/or angle mismatch.");
+            }
+         }
+      }
+      else {
+         magnitudes=new int[0];
+         angles=new int[0];
+      }
+
+      if(source.getInt(2)!=0) {
+         throw new VorbisFormatException("A reserved mapping field has an invalid value.");
+      }
+
+      mux=new int[channels];
+      if(submaps>1) {
+         for(int i=0; i<channels; i++) {
+            mux[i]=source.getInt(4);
+            if(mux[i]>submaps) {
+               throw new VorbisFormatException("A mapping mux value is higher than the number of submaps");
+            }
+         }
+      }
+      else {
+         for(int i=0; i<channels; i++) {
+            mux[i]=0;
+         }
+      }
+
+      submapFloors=new int[submaps];
+      submapResidues=new int[submaps];
+
+      int floorCount=header.getFloors().length;
+      int residueCount=header.getResidues().length;
+
+      for(int i=0; i<submaps; i++) {
+         source.getInt(8); // discard time placeholder
+         submapFloors[i]=source.getInt(8);
+         submapResidues[i]=source.getInt(8);
+
+         if(submapFloors[i]>floorCount) {
+            throw new VorbisFormatException("A mapping floor value is higher than the number of floors.");
+         }
+
+         if(submapResidues[i]>residueCount) {
+            throw new VorbisFormatException("A mapping residue value is higher than the number of residues.");
+         }
+      }
+   }
+
+   protected int getType() {
+      return 0;
+   }
+
+   protected int[] getAngles() {
+      return angles;
+   }
+
+   protected int[] getMagnitudes() {
+      return magnitudes;
+   }
+
+   protected int[] getMux() {
+      return mux;
+   }
+
+   protected int[] getSubmapFloors() {
+      return submapFloors;
+   }
+
+   protected int[] getSubmapResidues() {
+      return submapResidues;
+   }
+
+   protected int getCouplingSteps() {
+      return angles.length;
+   }
+
+   protected int getSubmaps() {
+      return submapFloors.length;
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/MdctFloat.java b/songdbj/de/jarnbjo/vorbis/MdctFloat.java
new file mode 100644
index 0000000000..4f354b259b
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/MdctFloat.java
@@ -0,0 +1,321 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 12:09:45  shred
+ * *** empty log message ***
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.3  2003/04/10 19:49:04  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+class MdctFloat {
+  static private final float cPI3_8=0.38268343236508977175f;
+  static private final float cPI2_8=0.70710678118654752441f;
+  static private final float cPI1_8=0.92387953251128675613f;
+
+  private int n;
+  private int log2n;
+
+  private float[] trig;
+  private int[] bitrev;
+
+  private float[] equalizer;
+
+  private float scale;
+
+  private int itmp1, itmp2, itmp3, itmp4, itmp5, itmp6, itmp7, itmp8, itmp9;
+  private float dtmp1, dtmp2, dtmp3, dtmp4, dtmp5, dtmp6, dtmp7, dtmp8, dtmp9;
+
+  protected MdctFloat(int n) {
+    bitrev=new int[n/4];
+    trig=new float[n+n/4];
+
+    int n2=n>>>1;
+    log2n=(int)Math.rint(Math.log(n)/Math.log(2));
+    this.n=n;
+
+    int AE=0;
+    int AO=1;
+    int BE=AE+n/2;
+    int BO=BE+1;
+    int CE=BE+n/2;
+    int CO=CE+1;
+    // trig lookups...
+    for(int i=0;i<n/4;i++){
+      trig[AE+i*2]=(float)Math.cos((Math.PI/n)*(4*i));
+      trig[AO+i*2]=(float)-Math.sin((Math.PI/n)*(4*i));
+      trig[BE+i*2]=(float)Math.cos((Math.PI/(2*n))*(2*i+1));
+      trig[BO+i*2]=(float)Math.sin((Math.PI/(2*n))*(2*i+1));
+    }
+    for(int i=0;i<n/8;i++){
+      trig[CE+i*2]=(float)Math.cos((Math.PI/n)*(4*i+2));
+      trig[CO+i*2]=(float)-Math.sin((Math.PI/n)*(4*i+2));
+    }
+
+    {
+      int mask=(1<<(log2n-1))-1;
+      int msb=1<<(log2n-2);
+      for(int i=0;i<n/8;i++){
+  int acc=0;
+  for(int j=0;msb>>>j!=0;j++)
+    if(((msb>>>j)&i)!=0)acc|=1<<j;
+  bitrev[i*2]=((~acc)&mask);
+//  bitrev[i*2]=((~acc)&mask)-1;
+  bitrev[i*2+1]=acc;
+      }
+    }
+    scale=4.f/n;
+  }
+
+  //void clear(){
+  //}
+
+  //void forward(float[] in, float[] out){
+  //}
+
+   private float[] _x=new float[1024];
+   private float[] _w=new float[1024];
+
+   protected void setEqualizer(float[] equalizer) {
+      this.equalizer=equalizer;
+   }
+
+   protected float[] getEqualizer() {
+      return equalizer;
+   }
+
+   protected synchronized void imdct(final float[] frq, final float[] window, final int[] pcm) {//, float[] out){
+
+      float[] in=frq;//, out=buf;
+      if(_x.length<n/2){_x=new float[n/2];}
+      if(_w.length<n/2){_w=new float[n/2];}
+      final float[] x=_x;
+      final float[] w=_w;
+      int n2=n>>1;
+      int n4=n>>2;
+      int n8=n>>3;
+
+      if(equalizer!=null) {
+         for(int i=0; i<n; i++) {
+            frq[i]*=equalizer[i];
+         }
+      }
+
+      // rotate + step 1
+      {
+         int inO=-1;
+         int xO=0;
+         int A=n2;
+
+         int i;
+         for(i=0;i<n8;i++) {
+            dtmp1=in[inO+=2];
+            dtmp2=in[inO+=2];
+            dtmp3=trig[--A];
+            dtmp4=trig[--A];
+           x[xO++]=-dtmp2*dtmp3 - dtmp1*dtmp4;
+           x[xO++]= dtmp1*dtmp3 - dtmp2*dtmp4;
+           //A-=2;
+           //x[xO++]=-in[inO+2]*trig[A+1] - in[inO]*trig[A];
+           //x[xO++]= in[inO]*trig[A+1] - in[inO+2]*trig[A];
+           //inO+=4;
+         }
+
+         inO=n2;//-4;
+
+         for(i=0;i<n8;i++) {
+            dtmp1=in[inO-=2];
+            dtmp2=in[inO-=2];
+            dtmp3=trig[--A];
+            dtmp4=trig[--A];
+           x[xO++]=dtmp2*dtmp3 + dtmp1*dtmp4;
+           x[xO++]=dtmp2*dtmp4 - dtmp1*dtmp3;
+           //A-=2;
+           //x[xO++]=in[inO]*trig[A+1] + in[inO+2]*trig[A];
+           //x[xO++]=in[inO]*trig[A] - in[inO+2]*trig[A+1];
+           //inO-=4;
+         }
+      }
+
+      float[] xxx=kernel(x,w,n,n2,n4,n8);
+      int xx=0;
+
+      // step 8
+
+      {
+         int B=n2;
+         int o1=n4,o2=o1-1;
+         int o3=n4+n2,o4=o3-1;
+
+         for(int i=0;i<n4;i++){
+            dtmp1=xxx[xx++];
+            dtmp2=xxx[xx++];
+            dtmp3=trig[B++];
+            dtmp4=trig[B++];
+
+           float temp1= (dtmp1* dtmp4 - dtmp2 * dtmp3);
+           float temp2=-(dtmp1 * dtmp3 + dtmp2 * dtmp4);
+
+            /*
+           float temp1= (xxx[xx] * trig[B+1] - xxx[xx+1] * trig[B]);//*32767.0f;
+           float temp2=-(xxx[xx] * trig[B] + xxx[xx+1] * trig[B+1]);//*32767.0f;
+            */
+
+            //if(temp1>32767.0f) temp1=32767.0f;
+            //if(temp1<-32768.0f) temp1=-32768.0f;
+            //if(temp2>32767.0f) temp2=32767.0f;
+            //if(temp2<-32768.0f) temp2=-32768.0f;
+
+           pcm[o1]=(int)(-temp1*window[o1]);
+           pcm[o2]=(int)( temp1*window[o2]);
+           pcm[o3]=(int)( temp2*window[o3]);
+           pcm[o4]=(int)( temp2*window[o4]);
+
+           o1++;
+           o2--;
+           o3++;
+           o4--;
+           //xx+=2;
+           //B+=2;
+         }
+      }
+   }
+
+   private float[] kernel(float[] x, float[] w,
+                         int n, int n2, int n4, int n8){
+      // step 2
+
+      int xA=n4;
+      int xB=0;
+      int w2=n4;
+      int A=n2;
+
+      for(int i=0;i<n4;){
+         float x0=x[xA] - x[xB];
+         float x1;
+         w[w2+i]=x[xA++]+x[xB++];
+
+         x1=x[xA]-x[xB];
+         A-=4;
+
+         w[i++]=   x0 * trig[A] + x1 * trig[A+1];
+         w[i]=     x1 * trig[A] - x0 * trig[A+1];
+
+         w[w2+i]=x[xA++]+x[xB++];
+         i++;
+      }
+
+      // step 3
+
+      {
+         for(int i=0;i<log2n-3;i++){
+            int k0=n>>>(i+2);
+           int k1=1<<(i+3);
+           int wbase=n2-2;
+
+           A=0;
+           float[] temp;
+
+           for(int r=0;r<(k0>>>2);r++){
+               int w1=wbase;
+               w2=w1-(k0>>1);
+               float AEv= trig[A],wA;
+               float AOv= trig[A+1],wB;
+               wbase-=2;
+
+               k0++;
+               for(int s=0;s<(2<<i);s++){
+                  dtmp1=w[w1];
+                  dtmp2=w[w2];
+                  wB=dtmp1-dtmp2;
+                  x[w1]=dtmp1+dtmp2;
+                  dtmp1=w[++w1];
+                  dtmp2=w[++w2];
+                  wA=dtmp1-dtmp2;
+                  x[w1]=dtmp1+dtmp2;
+                  x[w2]  =wA*AEv  - wB*AOv;
+                  x[w2-1]=wB*AEv  + wA*AOv;
+
+                  /*
+                  wB     =w[w1]   -w[w2];
+                  x[w1]  =w[w1]   +w[w2];
+
+                  wA     =w[++w1] -w[++w2];
+                  x[w1]  =w[w1]   +w[w2];
+
+                  x[w2]  =wA*AEv  - wB*AOv;
+                  x[w2-1]=wB*AEv  + wA*AOv;
+                  */
+
+                  w1-=k0;
+                  w2-=k0;
+              }
+              k0--;
+              A+=k1;
+           }
+
+           temp=w;
+           w=x;
+           x=temp;
+         }
+      }
+
+      // step 4, 5, 6, 7
+      {
+         int C=n;
+         int bit=0;
+         int x1=0;
+         int x2=n2-1;
+
+         for(int i=0;i<n8;i++) {
+            int t1=bitrev[bit++];
+            int t2=bitrev[bit++];
+
+            float wA=w[t1]-w[t2+1];
+            float wB=w[t1-1]+w[t2];
+            float wC=w[t1]+w[t2+1];
+            float wD=w[t1-1]-w[t2];
+
+            float wACE=wA* trig[C];
+            float wBCE=wB* trig[C++];
+            float wACO=wA* trig[C];
+            float wBCO=wB* trig[C++];
+
+            x[x1++]=( wC+wACO+wBCE)*16383.0f;
+            x[x2--]=(-wD+wBCO-wACE)*16383.0f;
+            x[x1++]=( wD+wBCO-wACE)*16383.0f;
+            x[x2--]=( wC-wACO-wBCE)*16383.0f;
+         }
+      }
+      return x;
+   }
+
+}
+
diff --git a/songdbj/de/jarnbjo/vorbis/Mode.java b/songdbj/de/jarnbjo/vorbis/Mode.java
new file mode 100644
index 0000000000..ab88944a25
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Mode.java
@@ -0,0 +1,75 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.*;
+
+import de.jarnbjo.util.io.*;
+
+class Mode {
+
+   private boolean blockFlag;
+   private int windowType, transformType, mapping;
+
+   protected Mode(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+      blockFlag=source.getBit();
+      windowType=source.getInt(16);
+      transformType=source.getInt(16);
+      mapping=source.getInt(8);
+
+      if(windowType!=0) {
+         throw new VorbisFormatException("Window type = "+windowType+", != 0");
+      }
+
+      if(transformType!=0) {
+         throw new VorbisFormatException("Transform type = "+transformType+", != 0");
+      }
+
+      if(mapping>header.getMappings().length) {
+         throw new VorbisFormatException("Mode mapping number is higher than total number of mappings.");
+      }
+   }
+
+   protected boolean getBlockFlag() {
+      return blockFlag;
+   }
+
+   protected int getWindowType() {
+      return windowType;
+   }
+
+   protected int getTransformType() {
+      return transformType;
+   }
+
+   protected int getMapping() {
+      return mapping;
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Residue.java b/songdbj/de/jarnbjo/vorbis/Residue.java
new file mode 100644
index 0000000000..78c28fa5ed
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Residue.java
@@ -0,0 +1,260 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.3  2003/04/04 08:33:02  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+import java.util.HashMap;
+
+import de.jarnbjo.util.io.*;
+
+
+abstract class Residue {
+
+   protected int begin, end;
+   protected int partitionSize; // grouping
+   protected int classifications; // partitions
+   protected int classBook; // groupbook
+   protected int[] cascade; // secondstages
+   protected int[][] books;
+   protected HashMap looks=new HashMap();
+
+   protected Residue() {
+   }
+
+   protected Residue(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+      begin=source.getInt(24);
+      end=source.getInt(24);
+      partitionSize=source.getInt(24)+1;
+      classifications=source.getInt(6)+1;
+      classBook=source.getInt(8);
+
+      cascade=new int[classifications];
+
+      int acc=0;
+
+      for(int i=0; i<classifications; i++) {
+         int highBits=0, lowBits=0;
+         lowBits=source.getInt(3);
+         if(source.getBit()) {
+            highBits=source.getInt(5);
+         }
+         cascade[i]=(highBits<<3)|lowBits;
+         acc+=Util.icount(cascade[i]);
+      }
+
+      books=new int[classifications][8];
+
+      for(int i=0; i<classifications; i++) {
+         for(int j=0; j<8; j++) {
+            if((cascade[i]&(1<<j))!=0) {
+               books[i][j]=source.getInt(8);
+               if(books[i][j]>header.getCodeBooks().length) {
+                  throw new VorbisFormatException("Reference to invalid codebook entry in residue header.");
+               }
+            }
+         }
+      }
+   }
+
+
+   protected static Residue createInstance(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+
+      int type=source.getInt(16);
+      switch(type) {
+      case 0:
+         //System.out.println("residue type 0");
+         return new Residue0(source, header);
+      case 1:
+         //System.out.println("residue type 1");
+         return new Residue2(source, header);
+      case 2:
+         //System.out.println("residue type 2");
+         return new Residue2(source, header);
+      default:
+         throw new VorbisFormatException("Residue type "+type+" is not supported.");
+      }
+   }
+
+   protected abstract int getType();
+   protected abstract void decodeResidue(VorbisStream vorbis, BitInputStream source, Mode mode, int ch, boolean[] doNotDecodeFlags, float[][] vectors) throws VorbisFormatException, IOException;
+   //public abstract double[][] getDecodedVectors();
+
+   protected int getBegin() {
+      return begin;
+   }
+
+   protected int getEnd() {
+      return end;
+   }
+
+   protected int getPartitionSize() {
+      return partitionSize;
+   }
+
+   protected int getClassifications() {
+      return classifications;
+   }
+
+   protected int getClassBook() {
+      return classBook;
+   }
+
+   protected int[] getCascade() {
+      return cascade;
+   }
+
+   protected int[][] getBooks() {
+      return books;
+   }
+
+   protected final void fill(Residue clone) {
+      clone.begin=begin;
+      clone.books=books;
+      clone.cascade=cascade;
+      clone.classBook=classBook;
+      clone.classifications=classifications;
+      clone.end=end;
+      clone.partitionSize=partitionSize;
+   }
+
+   protected Look getLook(VorbisStream source, Mode key) {
+      //return new Look(source, key);
+      Look look=(Look)looks.get(key);
+      if(look==null) {
+         look=new Look(source, key);
+         looks.put(key, look);
+      }
+      return look;
+   }
+
+
+   class Look  {
+      int map;
+      int parts;
+      int stages;
+      CodeBook[] fullbooks;
+      CodeBook phrasebook;
+      int[][] partbooks;
+      int partvals;
+      int[][] decodemap;
+      int postbits;
+      int phrasebits;
+      int frames;
+
+      protected Look (VorbisStream source, Mode mode) {
+         int dim=0, acc=0, maxstage=0;
+
+         map=mode.getMapping();
+         parts=Residue.this.getClassifications();
+         fullbooks=source.getSetupHeader().getCodeBooks();
+         phrasebook=fullbooks[Residue.this.getClassBook()];
+         dim=phrasebook.getDimensions();
+
+         partbooks=new int[parts][];
+
+         for(int j=0;j<parts;j++) {
+            int stages=Util.ilog(Residue.this.getCascade()[j]);
+            if(stages!=0) {
+               if(stages>maxstage) {
+                  maxstage=stages;
+               }
+               partbooks[j]=new int[stages];
+               for(int k=0; k<stages; k++){
+                  if((Residue.this.getCascade()[j]&(1<<k))!=0){
+                     partbooks[j][k]=Residue.this.getBooks()[j][k];
+                  }
+                    }
+            }
+         }
+
+         partvals=(int)Math.rint(Math.pow(parts, dim));
+         stages=maxstage;
+
+         decodemap=new int[partvals][];
+
+         for(int j=0;j<partvals;j++){
+            int val=j;
+            int mult=partvals/parts;
+            decodemap[j]=new int[dim];
+
+            for(int k=0;k<dim;k++){
+               int deco=val/mult;
+               val-=deco*mult;
+               mult/=parts;
+               decodemap[j][k]=deco;
+            }
+         }
+      }
+
+      protected int[][] getDecodeMap() {
+         return decodemap;
+      }
+
+      protected int getFrames() {
+         return frames;
+      }
+
+      protected int getMap() {
+         return map;
+      }
+
+      protected int[][] getPartBooks() {
+         return partbooks;
+      }
+
+      protected int getParts() {
+         return parts;
+      }
+
+      protected int getPartVals() {
+         return partvals;
+      }
+
+      protected int getPhraseBits() {
+         return phrasebits;
+      }
+
+      protected CodeBook getPhraseBook() {
+         return phrasebook;
+      }
+
+      protected int getPostBits() {
+         return postbits;
+      }
+
+      protected int getStages() {
+         return stages;
+      }
+   }
+
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Residue0.java b/songdbj/de/jarnbjo/vorbis/Residue0.java
new file mode 100644
index 0000000000..7dc0dfa765
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Residue0.java
@@ -0,0 +1,53 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+class Residue0 extends Residue {
+
+   protected Residue0(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+      super(source, header);
+   }
+
+   protected int getType() {
+      return 0;
+   }
+
+   protected void decodeResidue(VorbisStream vorbis, BitInputStream source, Mode mode, int ch, boolean[] doNotDecodeFlags, float[][] vectors) throws VorbisFormatException, IOException {
+      /** @todo implement */
+      throw new UnsupportedOperationException();
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Residue1.java b/songdbj/de/jarnbjo/vorbis/Residue1.java
new file mode 100644
index 0000000000..f31147c072
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Residue1.java
@@ -0,0 +1,55 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+class Residue1 extends Residue {
+
+   protected Residue1(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+      super(source, header);
+   }
+
+   protected int getType() {
+      return 1;
+   }
+
+   protected void decodeResidue(VorbisStream vorbis, BitInputStream source, Mode mode, int ch, boolean[] doNotDecodeFlags, float[][] vectors) throws VorbisFormatException, IOException {
+      /** @todo implement */
+      throw new UnsupportedOperationException();
+   }
+
+
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Residue2.java b/songdbj/de/jarnbjo/vorbis/Residue2.java
new file mode 100644
index 0000000000..666d2cd017
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Residue2.java
@@ -0,0 +1,123 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+import de.jarnbjo.util.io.BitInputStream;
+
+class Residue2 extends Residue {
+
+   private double[][] decodedVectors;
+
+   private Residue2() {
+   }
+
+   protected Residue2(BitInputStream source, SetupHeader header) throws VorbisFormatException, IOException {
+      super(source, header);
+   }
+
+   protected int getType() {
+      return 2;
+   }
+
+   protected void decodeResidue(VorbisStream vorbis, BitInputStream source, Mode mode, int ch, boolean[] doNotDecodeFlags, float[][] vectors) throws VorbisFormatException, IOException {
+
+      Look look=getLook(vorbis, mode);
+
+      CodeBook codeBook=vorbis.getSetupHeader().getCodeBooks()[getClassBook()];
+
+      int classvalsPerCodeword=codeBook.getDimensions();
+      int nToRead=getEnd()-getBegin();
+      int partitionsToRead=nToRead/getPartitionSize(); // partvals
+
+      int samplesPerPartition=getPartitionSize();
+      int partitionsPerWord=look.getPhraseBook().getDimensions();
+
+      int partWords=(partitionsToRead+partitionsPerWord-1)/partitionsPerWord;
+
+      int realCh=0;
+      for(int i=0; i<doNotDecodeFlags.length; i++) {
+         if(!doNotDecodeFlags[i]) {
+            realCh++;
+         }
+      }
+
+      float[][] realVectors=new float[realCh][];
+
+      realCh=0;
+      for(int i=0; i<doNotDecodeFlags.length; i++) {
+         if(!doNotDecodeFlags[i]) {
+            realVectors[realCh++]=vectors[i];
+         }
+      }
+
+      int[][] partword=new int[partWords][];
+      for(int s=0;s<look.getStages();s++){
+         for(int i=0,l=0;i<partitionsToRead;l++){
+            if(s==0){
+                    //int temp=look.getPhraseBook().readInt(source);
+                    int temp=source.getInt(look.getPhraseBook().getHuffmanRoot());
+                    if(temp==-1){
+                       throw new VorbisFormatException("");
+                    }
+                    partword[l]=look.getDecodeMap()[temp];
+                    if(partword[l]==null){
+                       throw new VorbisFormatException("");
+                    }
+                 }
+
+            for(int k=0;k<partitionsPerWord && i<partitionsToRead;k++,i++){
+               int offset=begin+i*samplesPerPartition;
+                    if((cascade[partword[l][k]]&(1<<s))!=0){
+                  CodeBook stagebook=vorbis.getSetupHeader().getCodeBooks()[look.getPartBooks()[partword[l][k]][s]];
+                       if(stagebook!=null){
+                     stagebook.readVvAdd(realVectors, source, offset, samplesPerPartition);
+                  }
+                    }
+                 }
+         }
+      }
+   }
+
+
+   public Object clone() {
+      Residue2 clone=new Residue2();
+      fill(clone);
+      return clone;
+   }
+
+   protected double[][] getDecodedVectors() {
+      return decodedVectors;
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/SetupHeader.java b/songdbj/de/jarnbjo/vorbis/SetupHeader.java
new file mode 100644
index 0000000000..56e400f348
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/SetupHeader.java
@@ -0,0 +1,131 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.*;
+
+import de.jarnbjo.util.io.*;
+
+class SetupHeader {
+
+   private static final long HEADER = 0x736962726f76L; // 'vorbis'
+
+   private CodeBook[] codeBooks;
+   private Floor[] floors;
+   private Residue[] residues;
+   private Mapping[] mappings;
+   private Mode[] modes;
+
+   public SetupHeader(VorbisStream vorbis, BitInputStream source) throws VorbisFormatException, IOException {
+
+      if(source.getLong(48)!=HEADER) {
+         throw new VorbisFormatException("The setup header has an illegal leading.");
+      }
+
+      // read code books
+
+      int codeBookCount=source.getInt(8)+1;
+      codeBooks=new CodeBook[codeBookCount];
+
+      for(int i=0; i<codeBooks.length; i++) {
+         codeBooks[i]=new CodeBook(source);
+      }
+
+      // read the time domain transformations,
+      // these should all be 0
+
+      int timeCount=source.getInt(6)+1;
+      for(int i=0; i<timeCount; i++) {
+         if(source.getInt(16)!=0) {
+            throw new VorbisFormatException("Time domain transformation != 0");
+         }
+      }
+
+      // read floor entries
+
+      int floorCount=source.getInt(6)+1;
+      floors=new Floor[floorCount];
+
+      for(int i=0; i<floorCount; i++) {
+         floors[i]=Floor.createInstance(source, this);
+      }
+
+      // read residue entries
+
+      int residueCount=source.getInt(6)+1;
+      residues=new Residue[residueCount];
+
+      for(int i=0; i<residueCount; i++) {
+         residues[i]=Residue.createInstance(source, this);
+      }
+
+      // read mapping entries
+
+      int mappingCount=source.getInt(6)+1;
+      mappings=new Mapping[mappingCount];
+
+      for(int i=0; i<mappingCount; i++) {
+         mappings[i]=Mapping.createInstance(vorbis, source, this);
+      }
+
+      // read mode entries
+
+      int modeCount=source.getInt(6)+1;
+      modes=new Mode[modeCount];
+
+      for(int i=0; i<modeCount; i++) {
+         modes[i]=new Mode(source, this);
+      }
+
+      if(!source.getBit()) {
+         throw new VorbisFormatException("The setup header framing bit is incorrect.");
+      }
+   }
+
+   public CodeBook[] getCodeBooks() {
+      return codeBooks;
+   }
+
+   public Floor[] getFloors() {
+      return floors;
+   }
+
+   public Residue[] getResidues() {
+      return residues;
+   }
+
+   public Mapping[] getMappings() {
+      return mappings;
+   }
+
+   public Mode[] getModes() {
+      return modes;
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/Util.java b/songdbj/de/jarnbjo/vorbis/Util.java
new file mode 100644
index 0000000000..7e31c9495e
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/Util.java
@@ -0,0 +1,127 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.3  2003/04/10 19:49:04  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+final public class Util {
+
+   public static final int ilog(int x) {
+      int res=0;
+      for(; x>0; x>>=1, res++);
+      return res;
+   }
+
+   public static final float float32unpack(int x) {
+      float mantissa=x&0x1fffff;
+      float e=(x&0x7fe00000)>>21;
+      if((x&0x80000000)!=0) {
+         mantissa=-mantissa;
+      }
+      return mantissa*(float)Math.pow(2.0, e-788.0);
+   }
+
+   public static final int lookup1Values(int a, int b) {
+      int res=(int)Math.pow(Math.E, Math.log(a)/b);
+      return intPow(res+1, b)<=a?res+1:res;
+   }
+
+   public static final int intPow(int base, int e) {
+      int res=1;
+      for(; e>0; e--, res*=base);
+      return res;
+   }
+
+   public static final boolean isBitSet(int value, int bit) {
+      return (value&(1<<bit))!=0;
+   }
+
+   public static final int icount(int value) {
+      int res=0;
+      while(value>0) {
+         res+=value&1;
+         value>>=1;
+      }
+      return res;
+   }
+
+   public static final int lowNeighbour(int[] v, int x) {
+      int max=-1, n=0;
+      for(int i=0; i<v.length && i<x; i++) {
+         if(v[i]>max && v[i]<v[x]) {
+            max=v[i];
+            n=i;
+         }
+      }
+      return n;
+   }
+
+   public static final int highNeighbour(int[] v, int x) {
+      int min=Integer.MAX_VALUE, n=0;
+      for(int i=0; i<v.length && i<x; i++) {
+         if(v[i]<min && v[i]>v[x]) {
+            min=v[i];
+            n=i;
+         }
+      }
+      return n;
+   }
+
+   public static final int renderPoint(int x0, int x1, int y0, int y1, int x) {
+      int dy=y1-y0;
+      int ady=dy<0?-dy:dy;
+      int off=(ady*(x-x0))/(x1-x0);
+      return dy<0?y0-off:y0+off;
+   }
+
+   public static final void renderLine(final int x0, final int y0, final int x1, final int y1, final float[] v) {
+      final int dy=y1-y0;
+      final int adx=x1-x0;
+      final int base=dy/adx;
+      final int sy=dy<0?base-1:base+1;
+      int x=x0;
+      int y=y0;
+      int err=0;
+      final int ady=(dy<0?-dy:dy)-(base>0?base*adx:-base*adx);
+
+      v[x]*=Floor.DB_STATIC_TABLE[y];
+      for(x=x0+1; x<x1; x++) {
+         err+=ady;
+         if(err>=adx) {
+            err-=adx;
+            v[x]*=Floor.DB_STATIC_TABLE[y+=sy];
+         }
+         else {
+            v[x]*=Floor.DB_STATIC_TABLE[y+=base];
+         }
+      }
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/VorbisAudioFileReader.java b/songdbj/de/jarnbjo/vorbis/VorbisAudioFileReader.java
new file mode 100644
index 0000000000..b1bc999947
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/VorbisAudioFileReader.java
@@ -0,0 +1,217 @@
+package de.jarnbjo.vorbis;
+
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2004/09/21 06:39:06  shred
+ * Importe reorganisiert, damit Eclipse Ruhe gibt. ;-)
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ *
+ */
+ 
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.RandomAccessFile;
+import java.net.URL;
+import java.util.Collection;
+
+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 javax.sound.sampled.spi.AudioFileReader;
+
+import de.jarnbjo.ogg.BasicStream;
+import de.jarnbjo.ogg.EndOfOggStreamException;
+import de.jarnbjo.ogg.FileStream;
+import de.jarnbjo.ogg.LogicalOggStream;
+import de.jarnbjo.ogg.OggFormatException;
+import de.jarnbjo.ogg.PhysicalOggStream;
+import de.jarnbjo.ogg.UncachedUrlStream;
+
+public class VorbisAudioFileReader extends AudioFileReader {
+        
+        public VorbisAudioFileReader() {
+        }
+        
+        public AudioFileFormat getAudioFileFormat(File file) throws IOException, UnsupportedAudioFileException {
+                try {
+                        return getAudioFileFormat(new FileStream(new RandomAccessFile(file, "r")));     
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());        
+                }
+        }
+        
+        public AudioFileFormat getAudioFileFormat(InputStream stream) throws IOException, UnsupportedAudioFileException {
+                try {
+                        return getAudioFileFormat(new BasicStream(stream));     
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());        
+                }               
+        }
+        
+        public AudioFileFormat getAudioFileFormat(URL url) throws IOException, UnsupportedAudioFileException {
+                try {
+                        return getAudioFileFormat(new UncachedUrlStream(url));  
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());        
+                }               
+        }
+        
+        private AudioFileFormat getAudioFileFormat(PhysicalOggStream oggStream)  throws IOException, UnsupportedAudioFileException {
+                try {
+                        Collection streams=oggStream.getLogicalStreams();
+                        if(streams.size()!=1) {
+                                throw new UnsupportedAudioFileException("Only Ogg files with one logical Vorbis stream are supported.");        
+                        }
+                        
+                        LogicalOggStream los=(LogicalOggStream)streams.iterator().next();
+                        if(los.getFormat()!=LogicalOggStream.FORMAT_VORBIS) {
+                                throw new UnsupportedAudioFileException("Only Ogg files with one logical Vorbis stream are supported.");        
+                        }
+
+                        VorbisStream vs=new VorbisStream(los);
+                        
+                AudioFormat audioFormat=new AudioFormat(
+                (float)vs.getIdentificationHeader().getSampleRate(),
+                16,
+                vs.getIdentificationHeader().getChannels(),
+                true, true);
+                        
+                        return new AudioFileFormat(VorbisFormatType.getInstance(), audioFormat, AudioSystem.NOT_SPECIFIED);
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());
+                }
+                catch(VorbisFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());
+                }
+        }
+        
+        
+        
+        public AudioInputStream getAudioInputStream(File file) throws IOException, UnsupportedAudioFileException {
+                try {
+                        return getAudioInputStream(new FileStream(new RandomAccessFile(file, "r")));    
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());        
+                }
+        }
+        
+        public AudioInputStream getAudioInputStream(InputStream stream) throws IOException, UnsupportedAudioFileException {
+                try {
+                        return getAudioInputStream(new BasicStream(stream));    
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());        
+                }               
+        }
+        
+        public AudioInputStream getAudioInputStream(URL url) throws IOException, UnsupportedAudioFileException {
+                try {
+                        return getAudioInputStream(new UncachedUrlStream(url)); 
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());        
+                }               
+        }
+        
+        private AudioInputStream getAudioInputStream(PhysicalOggStream oggStream)  throws IOException, UnsupportedAudioFileException {
+                try {
+                        Collection streams=oggStream.getLogicalStreams();
+                        if(streams.size()!=1) {
+                                throw new UnsupportedAudioFileException("Only Ogg files with one logical Vorbis stream are supported.");        
+                        }
+                        
+                        LogicalOggStream los=(LogicalOggStream)streams.iterator().next();
+                        if(los.getFormat()!=LogicalOggStream.FORMAT_VORBIS) {
+                                throw new UnsupportedAudioFileException("Only Ogg files with one logical Vorbis stream are supported.");        
+                        }
+
+                        VorbisStream vs=new VorbisStream(los);
+
+                AudioFormat audioFormat=new AudioFormat(
+                (float)vs.getIdentificationHeader().getSampleRate(),
+                16,
+                vs.getIdentificationHeader().getChannels(),
+                true, true);
+                        
+                return new AudioInputStream(new VorbisInputStream(vs), audioFormat, -1);
+                }
+                catch(OggFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());
+                }
+                catch(VorbisFormatException e) {
+                        throw new UnsupportedAudioFileException(e.getMessage());
+                }
+        }
+        
+        
+        public static class VorbisFormatType extends AudioFileFormat.Type {
+                
+                private static final VorbisFormatType instance=new VorbisFormatType();
+                
+                private VorbisFormatType() {
+                        super("VORBIS", "ogg");
+                }
+                
+                public static AudioFileFormat.Type getInstance() {
+                        return instance;
+                }
+        }
+        
+        public static class VorbisInputStream extends InputStream {
+
+        private VorbisStream source;
+        private byte[] buffer=new byte[8192];
+
+        public VorbisInputStream(VorbisStream source) {
+                this.source=source;
+        }
+
+        public int read() throws IOException {
+                return 0;
+        }
+
+        public int read(byte[] buffer) throws IOException {
+                return read(buffer, 0, buffer.length);
+        }
+
+        public int read(byte[] buffer, int offset, int length) throws IOException {
+                try {
+                return source.readPcm(buffer, offset, length);
+                }
+                catch(EndOfOggStreamException e) {
+                return -1;
+                }
+        }
+        }
+
+        
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/VorbisFormatException.java b/songdbj/de/jarnbjo/vorbis/VorbisFormatException.java
new file mode 100644
index 0000000000..5214298378
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/VorbisFormatException.java
@@ -0,0 +1,51 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.2  2005/02/09 23:10:47  shred
+ * Serial UID für jarnbjo
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+ 
+package de.jarnbjo.vorbis;
+
+import java.io.IOException;
+
+/**
+ * Exception thrown when trying to read a corrupted Vorbis stream.
+ */
+
+public class VorbisFormatException extends IOException {
+  private static final long serialVersionUID = 3616453405694834743L;
+
+  public VorbisFormatException() {
+      super();
+   }
+
+   public VorbisFormatException(String message) {
+      super(message);
+   }
+}
\ No newline at end of file
diff --git a/songdbj/de/jarnbjo/vorbis/VorbisStream.java b/songdbj/de/jarnbjo/vorbis/VorbisStream.java
new file mode 100644
index 0000000000..36659c7106
--- /dev/null
+++ b/songdbj/de/jarnbjo/vorbis/VorbisStream.java
@@ -0,0 +1,247 @@
+/*
+ * $ProjectName$
+ * $ProjectRevision$
+ * -----------------------------------------------------------
+ * $Id$
+ * -----------------------------------------------------------
+ *
+ * $Author$
+ *
+ * Description:
+ *
+ * Copyright 2002-2003 Tor-Einar Jarnbjo
+ * -----------------------------------------------------------
+ *
+ * Change History
+ * -----------------------------------------------------------
+ * $Log$
+ * Revision 1.1  2005/07/11 15:42:36  hcl
+ * Songdb java version, source. only 1.5 compatible
+ *
+ * Revision 1.1.1.1  2004/04/04 22:09:12  shred
+ * First Import
+ *
+ * Revision 1.4  2003/04/10 19:49:04  jarnbjo
+ * no message
+ *
+ * Revision 1.3  2003/03/31 00:20:16  jarnbjo
+ * no message
+ *
+ * Revision 1.2  2003/03/16 01:11:12  jarnbjo
+ * no message
+ *
+ *
+ */
+
+package de.jarnbjo.vorbis;
+
+import java.io.*;
+import java.util.*;
+
+import de.jarnbjo.ogg.*;
+import de.jarnbjo.util.io.*;
+
+/**
+ */
+
+public class VorbisStream {
+
+   private LogicalOggStream oggStream;
+   private IdentificationHeader identificationHeader;
+   private CommentHeader commentHeader;
+   private SetupHeader setupHeader;
+
+   private AudioPacket lastAudioPacket, nextAudioPacket;
+   private LinkedList audioPackets=new LinkedList();
+   private byte[] currentPcm;
+   private int currentPcmIndex;
+   private int currentPcmLimit;
+
+   private static final int IDENTIFICATION_HEADER = 1;
+   private static final int COMMENT_HEADER = 3;
+   private static final int SETUP_HEADER = 5;
+
+   private int bitIndex=0;
+   private byte lastByte=(byte)0;
+   private boolean initialized=false;
+
+   private Object streamLock=new Object();
+   private int pageCounter=0;
+
+   private int currentBitRate=0;
+
+   private long currentGranulePosition;
+
+   public static final int BIG_ENDIAN = 0;
+   public static final int LITTLE_ENDIAN = 1;
+
+   public VorbisStream() {
+   }
+
+   public VorbisStream(LogicalOggStream oggStream) throws VorbisFormatException, IOException {
+      this.oggStream=oggStream;
+
+      for(int i=0; i<3; i++) {
+         BitInputStream source=new ByteArrayBitInputStream(oggStream.getNextOggPacket());
+         int headerType=source.getInt(8);
+         switch(headerType) {
+         case IDENTIFICATION_HEADER:
+            identificationHeader=new IdentificationHeader(source);
+            break;
+         case COMMENT_HEADER:
+            commentHeader=new CommentHeader(source);
+            break;
+         case SETUP_HEADER:
+            setupHeader=new SetupHeader(this, source);
+            break;
+         }
+      }
+
+      if(identificationHeader==null) {
+         throw new VorbisFormatException("The file has no identification header.");
+      }
+
+      if(commentHeader==null) {
+         throw new VorbisFormatException("The file has no commentHeader.");
+      }
+
+      if(setupHeader==null) {
+         throw new VorbisFormatException("The file has no setup header.");
+      }
+
+      //currentPcm=new int[identificationHeader.getChannels()][16384];
+      currentPcm=new byte[identificationHeader.getChannels()*identificationHeader.getBlockSize1()*2];
+      //new BufferThread().start();
+   }
+
+   public IdentificationHeader getIdentificationHeader() {
+      return identificationHeader;
+   }
+
+   public CommentHeader getCommentHeader() {
+      return commentHeader;
+   }
+
+   protected SetupHeader getSetupHeader() {
+      return setupHeader;
+   }
+
+   public boolean isOpen() {
+      return oggStream.isOpen();
+   }
+
+   public void close() throws IOException {
+      oggStream.close();
+   }
+
+
+   public int readPcm(byte[] buffer, int offset, int length) throws IOException {
+      synchronized (streamLock) {
+         final int channels=identificationHeader.getChannels();
+
+         if(lastAudioPacket==null) {
+            lastAudioPacket=getNextAudioPacket();
+         }
+         if(currentPcm==null || currentPcmIndex>=currentPcmLimit) {
+            AudioPacket ap=getNextAudioPacket();
+            try {
+               ap.getPcm(lastAudioPacket, currentPcm);
+               currentPcmLimit=ap.getNumberOfSamples()*identificationHeader.getChannels()*2;
+            }
+            catch(ArrayIndexOutOfBoundsException e) {
+               return 0;
+            }
+            currentPcmIndex=0;
+            lastAudioPacket=ap;
+         }
+         int written=0;
+         int i=0;
+         int arrIx=0;
+         for(i=currentPcmIndex; i<currentPcmLimit && arrIx<length; i++) {
+            buffer[offset+arrIx++]=currentPcm[i];
+            written++;
+         }
+         currentPcmIndex=i;
+         return written;
+      }
+   }
+
+
+   private AudioPacket getNextAudioPacket() throws VorbisFormatException, IOException {
+      pageCounter++;
+      byte[] data=oggStream.getNextOggPacket();
+      AudioPacket res=null;
+      while(res==null) {
+         try {
+            res=new AudioPacket(this, new ByteArrayBitInputStream(data));
+         }
+         catch(ArrayIndexOutOfBoundsException e) {
+            // ignore and continue with next packet
+         }
+      }
+      currentGranulePosition+=res.getNumberOfSamples();
+      currentBitRate=data.length*8*identificationHeader.getSampleRate()/res.getNumberOfSamples();
+      return res;
+   }
+
+   public long getCurrentGranulePosition() {
+      return currentGranulePosition;
+   }
+
+   public int getCurrentBitRate() {
+      return currentBitRate;
+   }
+
+   public byte[] processPacket(byte[] packet) throws VorbisFormatException, IOException {
+      if(packet.length==0) {
+         throw new VorbisFormatException("Cannot decode a vorbis packet with length = 0");
+      }
+      if(((int)packet[0]&1)==1) {
+         // header packet
+         BitInputStream source=new ByteArrayBitInputStream(packet);
+         switch(source.getInt(8)) {
+         case IDENTIFICATION_HEADER:
+            identificationHeader=new IdentificationHeader(source);
+            break;
+         case COMMENT_HEADER:
+            commentHeader=new CommentHeader(source);
+            break;
+         case SETUP_HEADER:
+            setupHeader=new SetupHeader(this, source);
+            break;
+         }
+         return null;
+      }
+      else {
+         // audio packet
+         if(identificationHeader==null ||
+            commentHeader==null ||
+            setupHeader==null) {
+
+            throw new VorbisFormatException("Cannot decode audio packet before all three header packets have been decoded.");
+         }
+
+         AudioPacket ap=new AudioPacket(this, new ByteArrayBitInputStream(packet));
+         currentGranulePosition+=ap.getNumberOfSamples();
+
+         if(lastAudioPacket==null) {
+            lastAudioPacket=ap;
+            return null;
+         }
+
+         byte[] res=new byte[identificationHeader.getChannels()*ap.getNumberOfSamples()*2];
+
+         try {
+            ap.getPcm(lastAudioPacket, res);
+         }
+         catch(IndexOutOfBoundsException e) {
+            java.util.Arrays.fill(res, (byte)0);
+         }
+
+         lastAudioPacket=ap;
+
+         return res;
+      }
+   }
+
+}
\ No newline at end of file