Logo Search packages:      
Sourcecode: libjorbis-java version File versions  Download package

DecodeExample.java

/* JOrbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk<ymnk@jcraft.com>
 *   
 * Many thanks to 
 *   Monty <monty@xiph.org> and 
 *   The XIPHOPHORUS Company http://www.xiph.org/ .
 * JOrbis has been based on their awesome works, Vorbis codec.
 *   
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public License
 * as published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
   
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

package com.jcraft.jorbis;

import com.jcraft.jogg.*;

// Takes a vorbis bitstream from stdin and writes raw stereo PCM to
// stdout.  Decodes simple and chained OggVorbis files from beginning
// to end.  Vorbisfile.a is somewhat more complex than the code below.

class DecodeExample{
  static int convsize=4096*2;
  static byte[] convbuffer=new byte[convsize]; // take 8k out of the data segment, not the stack

  public static void main(String[] arg){    
    java.io.InputStream input=System.in;
    if(arg.length>0){
      try{
        input=new java.io.FileInputStream(arg[0]);
      }
      catch(Exception e){
        System.err.println(e);
      }
    }

    SyncState oy=new SyncState(); // sync and verify incoming physical bitstream
    StreamState os=new StreamState(); // take physical pages, weld into a logical stream of packets
    Page og=new Page(); // one Ogg bitstream page.  Vorbis packets are inside
    Packet op=new Packet(); // one raw packet of data for decode
  
    Info vi=new Info();  // struct that stores all the static vorbis bitstream settings
    Comment vc=new Comment(); // struct that stores all the bitstream user comments
    DspState vd=new DspState(); // central working state for the packet->PCM decoder
    Block vb=new Block(vd); // local working space for packet->PCM decode
  
    byte[] buffer;
    int bytes=0;

    // Decode setup

    oy.init(); // Now we can read pages
  
    while(true){ // we repeat if the bitstream is chained
      int eos=0;

      // grab some data at the head of the stream.  We want the first page
      // (which is guaranteed to be small and only contain the Vorbis
      // stream initial header) We need the first page to get the stream
      // serialno.

      // submit a 4k block to libvorbis' Ogg layer
      int index=oy.buffer(4096);
      buffer=oy.data;
      try{
        bytes=input.read(buffer, index, 4096);
      }
      catch(Exception e){
        System.err.println(e);
        System.exit(-1);
      }
      oy.wrote(bytes);
    
      // Get the first page.
      if(oy.pageout(og)!=1){
        // have we simply run out of data?  If so, we're done.
        if(bytes<4096)break;
      
        // error case.  Must not be Vorbis data
        System.err.println("Input does not appear to be an Ogg bitstream.");
        System.exit(1);
      }
  
      // Get the serial number and set up the rest of decode.
      // serialno first; use it to set up a logical stream
      os.init(og.serialno());
    
      // extract the initial header from the first page and verify that the
      // Ogg bitstream is in fact Vorbis data
    
      // I handle the initial header first instead of just having the code
      // read all three Vorbis headers at once because reading the initial
      // header is an easy way to identify a Vorbis bitstream and it's
      // useful to see that functionality seperated out.
    
      vi.init();
      vc.init();
      if(os.pagein(og)<0){ 
        // error; stream version mismatch perhaps
        System.err.println("Error reading first page of Ogg bitstream data.");
        System.exit(1);
      }
    
      if(os.packetout(op)!=1){ 
        // no page? must not be vorbis
        System.err.println("Error reading initial header packet.");
        System.exit(1);
      }

      if(vi.synthesis_headerin(vc,op)<0){ 
        // error case; not a vorbis header
        System.err.println("This Ogg bitstream does not contain Vorbis audio data.");
        System.exit(1);
      }

      // At this point, we're sure we're Vorbis.  We've set up the logical
      // (Ogg) bitstream decoder.  Get the comment and codebook headers and
      // set up the Vorbis decoder
    
      // The next two packets in order are the comment and codebook headers.
      // They're likely large and may span multiple pages.  Thus we reead
      // and submit data until we get our two pacakets, watching that no
      // pages are missing.  If a page is missing, error out; losing a
      // header page is the only place where missing data is fatal. */
    
      int i=0;
      while(i<2){
        while(i<2){

        int result=oy.pageout(og);
        if(result==0) break; // Need more data
        // Don't complain about missing or corrupt data yet.  We'll
        // catch it at the packet output phase

        if(result==1){
            os.pagein(og); // we can ignore any errors here
                         // as they'll also become apparent
                       // at packetout
          while(i<2){
            result=os.packetout(op);
            if(result==0)break;
            if(result==-1){
              // Uh oh; data at some point was corrupted or missing!
            // We can't tolerate that in a header.  Die.
              System.err.println("Corrupt secondary header.  Exiting.");
              System.exit(1);
            }
            vi.synthesis_headerin(vc,op);
            i++;
          }
        }
        }
        // no harm in not checking before adding more
        index=oy.buffer(4096);
        buffer=oy.data; 
        try{
          bytes=input.read(buffer, index, 4096);
      }
        catch(Exception e){
          System.err.println(e);
          System.exit(1);
      }
        if(bytes==0 && i<2){
        System.err.println("End of file before finding all Vorbis headers!");
          System.exit(1);
      }
      oy.wrote(bytes);
      }
    
      // Throw the comments plus a few lines about the bitstream we're
      // decoding
      {
         byte[][] ptr=vc.user_comments;
         for(int j=0; j<ptr.length;j++){
           if(ptr[j]==null) break;
           System.err.println(new String(ptr[j], 0, ptr[j].length-1));
       } 
       System.err.println("\nBitstream is "+vi.channels+" channel, "+vi.rate+"Hz");
       System.err.println("Encoded by: "+new String(vc.vendor, 0, vc.vendor.length-1)+"\n");
      }
    
      convsize=4096/vi.channels;

      // OK, got and parsed all three headers. Initialize the Vorbis
      //  packet->PCM decoder.
      vd.synthesis_init(vi); // central decode state
      vb.init(vd);           // local state for most of the decode
                             // so multiple block decodes can
                             // proceed in parallel.  We could init
                             // multiple vorbis_block structures
                             // for vd here

      float[][][] _pcm=new float[1][][];
      int[] _index=new int[vi.channels];
      // The rest is just a straight decode loop until end of stream
      while(eos==0){
        while(eos==0){

        int result=oy.pageout(og);
        if(result==0)break; // need more data
        if(result==-1){ // missing or corrupt data at this page position
          System.err.println("Corrupt or missing data in bitstream; continuing...");
        }
        else{
            os.pagein(og); // can safely ignore errors at
                         // this point
          while(true){
            result=os.packetout(op);

            if(result==0)break; // need more data
            if(result==-1){ // missing or corrupt data at this page position
                         // no reason to complain; already complained above
            }
              else{
                // we have a packet.  Decode it
              int samples;
              if(vb.synthesis(op)==0){ // test for success!
              vd.synthesis_blockin(vb);
            }

              // **pcm is a multichannel float vector.  In stereo, for
              // example, pcm[0] is left, and pcm[1] is right.  samples is
              // the size of each channel.  Convert the float values
              // (-1.<=range<=1.) to whatever PCM format and write it out

              while((samples=vd.synthesis_pcmout(_pcm, _index))>0){
                float[][] pcm=_pcm[0];
                  boolean clipflag=false;
              int bout=(samples<convsize?samples:convsize);
            
              // convert floats to 16 bit signed ints (host order) and
              // interleave
              for(i=0;i<vi.channels;i++){
                int ptr=i*2;
                //int ptr=i;
                int mono=_index[i];
                for(int j=0;j<bout;j++){
                  int val=(int)(pcm[i][mono+j]*32767.);
//                short val=(short)(pcm[i][mono+j]*32767.);
//                int val=(int)Math.round(pcm[i][mono+j]*32767.);
                  // might as well guard against clipping
                  if(val>32767){
                    val=32767;
                    clipflag=true;
                  }
                  if(val<-32768){
                    val=-32768;
                    clipflag=true;
                  }
                      if(val<0) val=val|0x8000;
                  convbuffer[ptr]=(byte)(val);
                  convbuffer[ptr+1]=(byte)(val>>>8);
                  ptr+=2*(vi.channels);
                }
              }
            
              //if(clipflag)
                  //  System.err.println("Clipping in frame "+vd.sequence);
            
              System.out.write(convbuffer, 0, 2*vi.channels*bout);
            
              vd.synthesis_read(bout); // tell libvorbis how
                                       // many samples we
                                     // actually consumed
              }       
            }
          }
          if(og.eos()!=0)eos=1;
        }
        }
        if(eos==0){
        index=oy.buffer(4096);
        buffer=oy.data;
        try{
            bytes=input.read(buffer,index,4096);
        }
        catch(Exception e){
          System.err.println(e);
          System.exit(1);
        }
        oy.wrote(bytes);
        if(bytes==0)eos=1;
        }
      }

      // clean up this logical bitstream; before exit we see if we're
      // followed by another [chained]

      os.clear();
  
      // ogg_page and ogg_packet structs always point to storage in
      // libvorbis.  They're never freed or manipulated directly
    
      vb.clear();
      vd.clear();
      vi.clear();  // must be called last
    }

    // OK, clean up the framer
    oy.clear();
    System.err.println("Done.");
  }
}


Generated by  Doxygen 1.6.0   Back to index