vorbisfile.java.new

java ogg player library. for play back ogg audio

/* JOrbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk<[e-mail]>
 *   
 * Many thanks to 
 *   Monty <[e-mail]> 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.*;
import java.io.InputStream;

public class VorbisFile{
  static final int CHUNKSIZE=4096;
  static final int SEEK_SET=0;

  InputStream datasource;
  boolean seekable=false;
  long offset;
  long end;
  
  SyncState oy=new SyncState();

  int links;
  Comment[] vc;
  Info[] vi;

  long[] offsets;
  long[] dataoffsets;
  int[] serialnos;
  long[] pcmlengths;



  // Decoding working state local storage
  long pcm_offset;
  boolean decode_ready=false;
  int current_serialno;
  int current_link;

  float bittrack;
  float samptrack;

  StreamState os=new StreamState(); // take physical pages, weld into a logical
                                    // stream of packets
  DspState vd=new DspState(); // central working state for 
                              // the packet->PCM decoder
  Block vb=new Block(vd);     // local working space for packet->PCM decode

  //ov_callbacks callbacks;

  public VorbisFile(String file) throws JOrbisException {
    super();
    InputStream is=null;
    try{ is=new java.io.BufferedInputStream(new java.io.FileInputStream(file));}
    catch(Exception e){
      throw new JOrbisException("VorbisFile: "+e.toString());
    }
    int ret=open(is, null, 0);
    if(ret==-1){
      throw new JOrbisException("VorbisFile: open return -1");
    }
  }

  public VorbisFile(InputStream is, byte[] initial, int ibytes)
    throws JOrbisException {
    super();
    int ret=open(is, initial, ibytes);
    if(ret==-1){
    }
  }

  private int get_data(){
    int index=oy.buffer(CHUNKSIZE);
    byte[] buffer=oy.data;
//  int bytes=callbacks.read_func(buffer, index, 1, CHUNKSIZE, datasource);
    int bytes=0;
    try{
      bytes=datasource.read(buffer, index, CHUNKSIZE);
    }
    catch(Exception e){System.err.println(e);}
    oy.wrote(bytes);
    return bytes;
  }

  private void seek_helper(int offst){
    //callbacks.seek_func(datasource, offst, SEEK_SET);
    fseek64_wrap(datasource, offst, SEEK_SET);
    this.offset=offst;
    oy.reset();
  }

  private int get_next_page(Page page, int boundary){
    if(boundary>0) boundary+=offset;
    while(true){
      int more;
      if(boundary>0 && offset>=boundary)return -1;
      more=oy.pageseek(page);
      if(more<0){offset-=more;}
      else{
	if(more==0){
	  if(boundary==0)return -1;
	  if(get_data()<=0)return -1;
	}
	else{
	  int ret=(int)offset; //!!!
	  offset+=more;
	  return ret;
	}
      }
    }
  }

  private int get_prev_page(Page page){
    int begin=(int)offset; //!!!
    int ret;
    int offst=-1;
    while(offst==-1){
      begin-=CHUNKSIZE;
      seek_helper(begin);
      while(offset<begin+CHUNKSIZE){
	ret=get_next_page(page, begin+CHUNKSIZE-((int)offset));
	if(ret==-1){ break; }
	else{ offst=ret; }
      }
    }
    seek_helper((int)offset); //!!!
    ret=get_next_page(page, CHUNKSIZE);
    if(ret==-1){
      System.err.println("Missed page fencepost at end of logical bitstream Exiting");
      System.exit(1);
    }
    return offst;
  }

  void bisect_forward_serialno(int begin, int searched, int end, int currentno, int m){
    int endsearched=end;
    int next=end;
    Page page=new Page();
    int ret;
    while(searched<endsearched){
      int bisect;
      if(endsearched-searched<CHUNKSIZE){
	bisect=searched;
      }
      else{
	bisect=(searched+endsearched)/2;
      }

      seek_helper(bisect);
      ret=get_next_page(page, -1);
      if(ret<0 || page.serialno()!=currentno){
	endsearched=bisect;
	if(ret>=0)next=ret;
      }
      else{
	searched=ret+page.header_len+page.body_len;
      }
    }
    seek_helper(next);
    ret=get_next_page(page, -1);

    if(searched>=end || ret==-1){
      links=m+1;
      offsets=new long[m+2];
      offsets[m+1]=searched;
    }
    else{
      bisect_forward_serialno(next, (int)offset, end, page.serialno(), m+1);
    }
    offsets[m]=begin;
  }

  // uses the local ogg_stream storage in vf; this is important for
  // non-streaming input sources
  int fetch_headers(Info vi, Comment vc, int[] serialno){
    //System.err.println("fetch_headers");
    Page og=new Page();
    Packet op=new Packet();
    int ret;

    ret=get_next_page(og, CHUNKSIZE);
    if(ret==-1){
      System.err.println("Did not find initial header for bitstream.");
      return -1;
    }
  
    if(serialno!=null)serialno[0]=og.serialno();

    os.init(og.serialno());
  
    // extract the initial header from the first page and verify that the
    // Ogg bitstream is in fact Vorbis data
  
    vi.init();
    vc.init();
  
    int i=0;
    while(i<3){
      os.pagein(og);
      while(i<3){
	int result=os.packetout(op);
	if(result==0)break;
	if(result==-1){
	  System.err.println("Corrupt header in logical bitstream.");
	  //goto bail_header;
	  vi.clear();
	  vc.clear();
	  os.clear();
	   return -1;
	}
	if(vi.synthesis_headerin(vc, op)!=0){
	  System.err.println("Illegal header in logical bitstream.");
	  //goto bail_header;
	  vi.clear();
	  vc.clear();
	  os.clear();
	  return -1;
	}
	i++;
      }
      if(i<3)
	if(get_next_page(og, 1)<0){
	  System.err.println("Missing header in logical bitstream.");
	  //goto bail_header;
	  vi.clear();
	  vc.clear();
	  os.clear();
	  return -1;
	}
    }
    return 0; 

//  bail_header:
//    vorbis_info_clear(vi);
//    vorbis_comment_clear(vc);
//    ogg_stream_clear(&vf->os);
//    return -1;
  }

  // last step of the OggVorbis_File initialization; get all the
  // vorbis_info structs and PCM positions.  Only called by the seekable
  // initialization (local stream storage is hacked slightly; pay
  // attention to how that's done)
  void prefetch_all_headers(Info first_i,Comment first_c, int dataoffset){
    Page og=new Page();
    int ret;
  
    vi=new Info[links];
    vc=new Comment[links];
    dataoffsets=new long[links];
    pcmlengths=new long[links];
    serialnos=new int[links];
  
    for(int i=0;i<links;i++){
      if(first_i!=null && first_c!=null && i==0){
	// we already grabbed the initial header earlier.  This just
	// saves the waste of grabbing it again
	// !!!!!!!!!!!!!
	vi[i]=first_i;
	//memcpy(vf->vi+i,first_i,sizeof(vorbis_info));
	vc[i]=first_c;
	//memcpy(vf->vc+i,first_c,sizeof(vorbis_comment));
	dataoffsets[i]=dataoffset;
      }
      else{
	// seek to the location of the initial header
	seek_helper((int)offsets[i]); //!!!
	if(fetch_headers(vi[i], vc[i], null)==-1){
	  System.err.println("Error opening logical bitstream #"+(i+1)+"\n");
	  dataoffsets[i]=-1;
	}
	else{
	  dataoffsets[i]=offset;
	  os.clear();
	}
      }

      // get the serial number and PCM length of this link. To do this,
      // get the last page of the stream
      {
	int end=(int)offsets[i+1]; //!!!
	seek_helper(end);

	while(true){
	  ret=get_prev_page(og);
	  if(ret==-1){
	    // this should not be possible
	    System.err.println("Could not find last page of logical "+
			       "bitstream #"+(i)+"\n");
	    vi[i].clear();
	    vc[i].clear();
	    break;
	  }
	  if(og.granulepos()!=-1){
	    serialnos[i]=og.serialno();
	    pcmlengths[i]=og.granulepos();
	    break;
	  }
	}
      }
    }
  }

  int make_decode_ready(){
    if(decode_ready)System.exit(1);
    vd.synthesis_init(vi[0]);
    vb.init(vd);
    decode_ready=true;
    return(0);
  }

  int open_seekable(){
    Info initial_i=new Info();
    Comment initial_c=new Comment();
    int serialno,end;
    int ret;
    int dataoffset;
    Page og=new Page();
System.out.println("open_seekable");  
    // is this even vorbis...?
    int[] foo=new int[1];
    ret=fetch_headers(initial_i, initial_c, foo);
    serialno=foo[0];
    dataoffset=(int)offset; //!!
    os.clear();
    if(ret==-1)return(-1);
  
    // we can seek, so set out learning all about this file
    seekable=true;
    //(callbacks.seek_func)(datasource, 0, SEEK_END);
    fseek64_wrap(datasource, (int)offset, SEEK_SET);
    //offset=end=(callbacks.tell_func)(datasource);
    end=(int)offset;
  
    // We get the offset for the last page of the physical bitstream.
    // Most OggVorbis files will contain a single logical bitstream
    end=get_prev_page(og);

    // moer than one logical bitstream?
    if(og.serialno()!=serialno){
      // Chained bitstream. Bisect-search each logical bitstream
      // section.  Do so based on serial number only
      bisect_forward_serialno(0,0,end+1,serialno,0);
    }
    else{
      // Only one logical bitstream
      bisect_forward_serialno(0,end,end+1,serialno,0);
    }
    prefetch_all_headers(initial_i, initial_c, dataoffset);

System.out.println("?");  
    return(raw_seek(0));
  }

  int open_nonseekable(){
    //System.err.println("open_nonseekable");
    // we cannot seek. Set up a 'single' (current) logical bitstream entry
    links=1;
    vi=new Info[links]; vi[0]=new Info(); // ??
    vc=new Comment[links]; vc[0]=new Comment(); // ?? bug?

    // Try to fetch the headers, maintaining all the storage
    int[]foo=new int[1];
    if(fetch_headers(vi[0], vc[0], foo)==-1)return(-1);
    current_serialno=foo[0];
    make_decode_ready();
    return 0;
  }

  // clear out the current logical bitstream decoder
  void decode_clear(){
    os.clear();
    vd.clear();
    vb.clear();
    decode_ready=false;
    bittrack=0.f;
    samptrack=0.f;
  }

  // fetch and process a packet.  Handles the case where we're at a
  // bitstream boundary and dumps the decoding machine.  If the decoding
  // machine is unloaded, it loads it.  It also keeps pcm_offset up to
  // date (seek and read both use this.  seek uses a special hack with
  // readp). 
  //
  // return: -1) hole in the data (lost packet) 
  //          0) need more date (only if readp==0)/eof
  //          1) got a packet 

  int process_packet(int readp){
System.out.println("porcess_packet:"+ readp+" , decode_ready="+decode_ready);
    Page og=new Page();

    // handle one packet.  Try to fetch it from current stream state
    // extract packets from page