/* 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.jogg;

public class StreamState{
  byte[] body_data;    /* bytes from packet bodies */
  int body_storage;    /* storage elements allocated */
  int body_fill;       /* elements stored; fill mark */
private  int body_returned;   /* elements of fill returned */


  int[] lacing_vals;    /* The values that will go to the segment table */
  long[] granule_vals;  /* pcm_pos values for headers. Not compact
			   this way, but it is simple coupled to the
			   lacing fifo */
  int lacing_storage;
  int lacing_fill;
  int lacing_packet;
  int lacing_returned;

  byte[] header=new byte[282];      /* working space for header encode */
  int header_fill;

  public int e_o_s;   /* set when we have buffered the last packet in the
			 logical bitstream */
  int b_o_s;          /* set after we've written the initial page
			 of a logical bitstream */
  int serialno;
  int pageno;
  long packetno;      /* sequence number for decode; the framing
                         knows where there's a hole in the data,
                         but we need coupling so that the codec
                         (which is in a seperate abstraction
                         layer) also knows about the gap */
  long granulepos;

  public StreamState(){
    init();
  }

  StreamState(int serialno){
    this();
    init(serialno);
  }
  void init(){
    body_storage=16*1024;
    body_data=new byte[body_storage];
    lacing_storage=1024;
    lacing_vals=new int[lacing_storage];
    granule_vals=new long[lacing_storage];
  }
  public void init(int serialno){
    if(body_data==null){ init(); }
    else{
      for(int i=0; i<body_data.length; i++) body_data[i]=0;
      for(int i=0; i<lacing_vals.length; i++) lacing_vals[i]=0;
      for(int i=0; i<granule_vals.length; i++) granule_vals[i]=0;
    }
    this.serialno=serialno;
  }
  public void clear(){
    body_data=null;
    lacing_vals=null;
    granule_vals=null;
    //memset(os,0,sizeof(ogg_stream_state));    
  }
  void destroy(){
    clear();
  }
  void body_expand(int needed){
    if(body_storage<=body_fill+needed){
      body_storage+=(needed+1024);
      byte[] foo=new byte[body_storage];
      System.arraycopy(body_data, 0, foo, 0, body_data.length);
      body_data=foo;
//System.out.println("expand: body_fill="+body_fill+", body_storage="+body_data.length);
    }
  }
  void lacing_expand(int needed){
    if(lacing_storage<=lacing_fill+needed){
      lacing_storage+=(needed+32);
      int[] foo=new int[lacing_storage];
      System.arraycopy(lacing_vals, 0, foo, 0, lacing_vals.length);
      lacing_vals=foo;

      long[] bar=new long[lacing_storage];
      System.arraycopy(granule_vals, 0, bar, 0, granule_vals.length);
      granule_vals=bar;
    }
  }

  /* submit data to the internal buffer of the framing engine */
  public int packetin(Packet op){
    int lacing_val=op.bytes/255+1;

    if(body_returned!=0){
      /* advance packet data according to the body_returned pointer. We
         had to keep it around to return a pointer into the buffer last
         call */
    
      body_fill-=body_returned;
      if(body_fill!=0){
//        memmove(os->body_data,os->body_data+os->body_returned,
//  	        os->body_fill*sizeof(char));
        System.arraycopy(body_data, body_returned, body_data, 0, body_fill);
      }
      body_returned=0;
    }

    /* make sure we have the buffer storage */
    body_expand(op.bytes);
    lacing_expand(lacing_val);

  /* Copy in the submitted packet.  Yes, the copy is a waste; this is
     the liability of overly clean abstraction for the time being.  It
     will actually be fairly easy to eliminate the extra copy in the
     future */

    System.arraycopy(op.packet_base, op.packet, body_data, body_fill, op.bytes);
    body_fill+=op.bytes;
//System.out.println("add: "+body_fill);

  /* Store lacing vals for this packet */
    int j;
    for(j=0;j<lacing_val-1;j++){
      lacing_vals[lacing_fill+j]=255;
      granule_vals[lacing_fill+j]=granulepos;
    }
    lacing_vals[lacing_fill+j]=(op.bytes)%255;
    granulepos=granule_vals[lacing_fill+j]=op.granulepos;

  /* flag the first segment as the beginning of the packet */
    lacing_vals[lacing_fill]|= 0x100;

    lacing_fill+=lacing_val;

  /* for the sake of completeness */
    packetno++;

    if(op.e_o_s!=0)e_o_s=1;
    return(0);
  }

  public int packetout(Packet op){

  /* The last part of decode. We have the stream broken into packet
     segments.  Now we need to group them into packets (or return the
     out of sync markers) */

    int ptr=lacing_returned;

    if(lacing_packet<=ptr){
      return(0);
    }

    if((lacing_vals[ptr]&0x400)!=0){
    /* We lost sync here; let the app know */
      lacing_returned++;

    /* we need to tell the codec there's a gap; it might need to
       handle previous packet dependencies. */
      packetno++;
      return(-1);
    }

  /* Gather the whole packet. We'll have no holes or a partial packet */
    {
      int size=lacing_vals[ptr]&0xff;
      int bytes=0;

      op.packet_base=body_data;
      op.packet=body_returned;
      op.e_o_s=lacing_vals[ptr]&0x200; /* last packet of the stream? */
      op.b_o_s=lacing_vals[ptr]&0x100; /* first packet of the stream? */
      bytes+=size;

      while(size==255){
	int val=lacing_vals[++ptr];
	size=val&0xff;
	if((val&0x200)!=0)op.e_o_s=0x200;
	bytes+=size;
      }

      op.packetno=packetno;
      op.granulepos=granule_vals[ptr];
      op.bytes=bytes;

//System.out.println(this+" # body_returned="+body_returned);
      body_returned+=bytes;
//System.out.println(this+"## body_returned="+body_returned);

      lacing_returned=ptr+1;
    }
    packetno++;
    return(1);
  }


  // add the incoming page to the stream state; we decompose the page
  // into packet segments here as well.

  public int pagein(Page og){
    byte[] header_base=og.header_base;
    int header=og.header;
    byte[] body_base=og.body_base;
    int body=og.body;
    int bodysize=og.body_len;
    int segptr=0;

    int version=og.version();
    int continued=og.continued();
    int bos=og.bos();
    int eos=og.eos();
    long granulepos=og.granulepos();
    int _serialno=og.serialno();
    int _pageno=og.pageno();
    int segments=header_base[header+26]&0xff;

    // clean up 'returned data'
    {
      int lr=lacing_returned;
      int br=body_returned;

      // body data

//System.out.println("br="+br+", body_fill="+body_fill);

      if(br!=0){
        body_fill-=br;
        if(body_fill!=0){
	  System.arraycopy(body_data, br, body_data, 0, body_fill);
	}
	body_returned=0;
      }

//System.out.println("?? br="+br+", body_fill="+body_fill+" body_returned="+body_returned);

      if(lr!=0){
        // segment table
	if((lacing_fill-lr)!=0){
	  System.arraycopy(lacing_vals, lr, lacing_vals, 0, lacing_fill-lr);
	  System.arraycopy(granule_vals, lr, granule_vals, 0, lacing_fill-lr);
	}
	lacing_fill-=lr;
	lacing_packet-=lr;
	lacing_returned=0;
      }
    }

    // check the serial number
    if(_serialno!=serialno)return(-1);
    if(version>0)return(-1);

    lacing_expand(segments+1);

    // are we in sequence?
    if(_pageno!=pageno){
      int i;

      // unroll previous partial packet (if any)
      for(i=lacing_packet;i<lacing_fill;i++){
	body_fill-=lacing_vals[i]&0xff;
//System.out.println("??");
      }
      lacing_fill=lacing_packet;

      // make a note of dropped data in segment table
      if(pageno!=-1){
	lacing_vals[lacing_fill++]=0x400;
	lacing_packet++;
      }

      // are we a 'continued packet' page?  If so, we'll need to skip
      // some segments
      if(continued!=0){
	bos=0;
	for(;segptr<segments;segptr++){
	  int val=(header_base[header+27+segptr]&0xff);
	  body+=val;
	  bodysize-=val;
	  if(val<255){
	    segptr++;
	    break;
	  }
	}
      }
    }

//System.out.println("bodysize="+bodysize);

    if(bodysize!=0){
      body_expand(bodysize);
      System.arraycopy(body_base, body, body_data, body_fill, bodysize);
      body_fill+=bodysize;
    }

//System.out.println("bodyfill="+body_fill);

    {
      int saved=-1;
      while(segptr<segments){
	int val=(header_base[header+27+segptr]&0xff);
	lacing_vals[lacing_fill]=val;
	granule_vals[lacing_fill]=-1;
      
	if(bos!=0){
	  lacing_vals[lacing_fill]|=0x100;
	  bos=0;
	}
      
	if(val<255)saved=lacing_fill;
      
	lacing_fill++;
	segptr++;
      
	if(val<255)lacing_packet=lacing_fill;
      }
  
    /* set the granulepos on the last pcmval of the last full packet */
      if(saved!=-1){
	granule_vals[saved]=granulepos;
      }
    }

    if(eos!=0){
      e_o_s=1;
      if(lacing_fill>0)
	lacing_vals[lacing_fill-1]|=0x200;
    }

    pageno=_pageno+1;
    return(0);
  }


/* This will flush remaining packets into a page (returning nonzero),
   even if there is not enough data to trigger a flush normally
   (undersized page). If there are no packets or partial packets to
   flush, ogg_stream_flush returns 0.  Note that ogg_stream_flush will
   try to flush a normal sized page like ogg_stream_pageout; a call to
   ogg_stream_flush does not gurantee that all packets have flushed.
   Only a return value of 0 from ogg_stream_flush indicates all packet
   data is flushed into pages.

   ogg_stream_page will flush the last page in a stream even if it's
   undersized; you almost certainly want to use ogg_stream_pageout
   (and *not* ogg_stream_flush) unless you need to flush an undersized
   page in the middle of a stream for some reason. */

  public int flush(Page og){

//System.out.println(this+" ---body_returned: "+body_returned);

    int i;
    int vals=0;
    int maxvals=(lacing_fill>255?255:lacing_fill);
    int bytes=0;
    int acc=0;
    long granule_pos=granule_vals[0];

    if(maxvals==0)return(0);
  
    /* construct a page */
    /* decide how many segments to include */
  
    /* If this is the initial header case, the first page must only include
       the initial header packet */
    if(b_o_s==0){  /* 'initial header page' case */
      granule_pos=0;
      for(vals=0;vals<maxvals;vals++){
        if((lacing_vals[vals]&0x0ff)<255){
	  vals++;
	  break;
        }
      }
    }
    else{
      for(vals=0;vals<maxvals;vals++){
        if(acc>4096)break;
        acc+=(lacing_vals[vals]&0x0ff);
        granule_pos=granule_vals[vals];
      }
    }

    /* construct the header in temp storage */
    System.arraycopy("OggS".getBytes(), 0, header, 0, 4);
  
    /* stream structure version */
    header[4]=0x00;

    /* continued packet flag? */
    header[5]=0x00;
    if((lacing_vals[0]&0x100)==0)header[5]|=0x01;
    /* first page flag? */
    if(b_o_s==0) header[5]|=0x02;
    /* last page flag? */
    if(e_o_s!=0 && lacing_fill==vals) header[5]|=0x04;
    b_o_s=1;

    /* 64 bits of PCM position */
    for(i=6;i<14;i++){
      header[i]=(byte)granule_pos;
      granule_pos>>>=8;
    }

    /* 32 bits of stream serial number */
    {
      int _serialno=serialno;
      for(i=14;i<18;i++){
        header[i]=(byte)_serialno;
        _serialno>>>=8;
      }
    }

    /* 32 bits of page counter (we have both counter and page header
       because this val can roll over) */
    if(pageno==-1)pageno=0;       /* because someone called
				     stream_reset; this would be a
				     strange thing to do in an
				     encode stream, but it has
				     plausible uses */
    {
      int _pageno=pageno++;
      for(i=18;i<22;i++){
        header[i]=(byte)_pageno;
        _pageno>>>=8;
      }
    }
  
    /* zero for computation; filled in later */
    header[22]=0;
    header[23]=0;
    header[24]=0;
    header[25]=0;
  
    /* segment table */
    header[26]=(byte)vals;
    for(i=0;i<vals;i++){
      header[i+27]=(byte)lacing_vals[i];
      bytes+=(header[i+27]&0xff);
    }
  
    /* set pointers in the ogg_page struct */
    og.header_base=header;
    og.header=0;
    og.header_len=header_fill=vals+27;
    og.body_base=body_data;
    og.body=body_returned;
    og.body_len=bytes;

    /* advance the lacing data and set the body_returned pointer */
  
//System.out.println("###body_returned: "+body_returned);

    lacing_fill-=vals;
    System.arraycopy(lacing_vals, vals, lacing_vals, 0, lacing_fill*4);
    System.arraycopy(granule_vals, vals, granule_vals, 0, lacing_fill*8);
    body_returned+=bytes;

//System.out.println("####body_returned: "+body_returned);
  
    /* calculate the checksum */
  
    og.checksum();

    /* done */
    return(1);
  }


/* This constructs pages from buffered packet segments.  The pointers
returned are to static buffers; do not free. The returned buffers are
good only until the next call (using the same ogg_stream_state) */
  public int pageout(Page og){
//    if(body_returned!=0){
//    /* advance packet data according to the body_returned pointer. We
//       had to keep it around to return a pointer into the buffer last
//       call */
//
//      body_fill-=body_returned;
//      if(body_fill!=0){ // overlap?
//	System.arraycopy(body_data, body_returned, body_data, 0, body_fill);
//      }
//      body_returned=0;
//    }
//
//System.out.println("pageout: e_o_s="+e_o_s+" lacing_fill="+lacing_fill+" body_fill="+body_fill+", lacing_fill="+lacing_fill+" b_o_s="+b_o_s);
//
//    if((e_o_s!=0&&lacing_fill!=0) ||  /* 'were done, now flush' case */
//       body_fill > 4096 ||          /* 'page nominal size' case */
//       lacing_fill>=255 ||          /* 'segment table full' case */
//       (lacing_fill!=0&&b_o_s==0)){  /* 'initial header page' case */
//      int vals=0,bytes=0;
//      int maxvals=(lacing_fill>255?255:lacing_fill);
//      long acc=0;
//      long pcm_pos=granule_vals[0];
//
//    /* construct a page */
//    /* decide how many segments to include */
//
//    /* If this is the initial header case, the first page must only include
//       the initial header packet */
//      if(b_o_s==0){  /* 'initial header page' case */
//        pcm_pos=0;
//        for(vals=0;vals<maxvals;vals++){
//  	  if((lacing_vals[vals]&0x0ff)<255){
// 	    vals++;
//	    break;
//	  }
//        }
//      }
//      else{
//        for(vals=0;vals<maxvals;vals++){
//	  if(acc>4096)break;
//	  acc+=lacing_vals[vals]&0x0ff;
//	  pcm_pos=granule_vals[vals];
//        }
//      }
//
//    /* construct the header in temp storage */
//      System.arraycopy("OggS".getBytes(), 0, header, 0, 4);
//
//    /* stream structure version */
//      header[4]=0x00;
//    
//    /* continued packet flag? */
//      header[5]=0x00;
//      if((lacing_vals[0]&0x100)==0)header[5]|=0x01;
//    /* first page flag? */
//      if(b_o_s==0)header[5]|=0x02;
//    /* last page flag? */
//      if(e_o_s!=0 && lacing_fill==vals)header[5]|=0x04;
//      b_o_s=1;
//
//    /* 64 bits of PCM position */
//      for(int i=6;i<14;i++){
//        header[i]=(byte)pcm_pos;
//        pcm_pos>>>=8;
//      }
//
//    /* 32 bits of stream serial number */
//      {
//        int serialn=serialno;
//        for(int i=14;i<18;i++){
//  	  header[i]=(byte)serialn;
//	  serialn>>>=8;
//        }
//      }
//
//
///* 32 bits of page counter (we have both counter and page header
//       because this val can roll over) */
//      if(pageno==-1)pageno=0; /* because someone called
//                                       stream_reset; this would be a
//                                       strange thing to do in an
//                                       encode stream, but it has
//                                       plausible uses */
//      {
//        int pagen=pageno++;
//        for(int i=18;i<22;i++){
//	  header[i]=(byte)pagen;
//	  pagen>>>=8;
//        }
//      }
//
//    /* zero for computation; filled in later */
//      header[22]=0;
//      header[23]=0;
//      header[24]=0;
//      header[25]=0;
//
//    /* segment table */
//      header[26]=(byte)vals;
//      for(int i=0;i<vals;i++){
//        header[i+27]=(byte)lacing_vals[i];
//        bytes+=header[i+27]&0xff;
////      bytes+=header[i+27]=(lacing_vals[i]&0xff);
//      }
//      
//    /* advance the lacing data and set the body_returned pointer */
//
//      lacing_fill-=vals;
//      System.arraycopy(lacing_vals, vals, lacing_vals, 0, lacing_fill);
//      System.arraycopy(granule_vals, vals, granule_vals, 0, lacing_fill);
//      body_returned=bytes;
//
//    /* set pointers in the ogg_page struct */
//      og.header_base=header;
//      og.header=0;
//      og.header_len=header_fill=vals+27;
//
//      og.body_base=body_data;
//      og.body=0;
//      og.body_len=bytes;
//
//    /* calculate the checksum */
//
//      og.checksum();
//      return(1);
//    }
//    /* not enough data to construct a page and not end of stream */
//    return(0);
//System.out.println("pageout: "+body_returned);
    if((e_o_s!=0&&lacing_fill!=0) ||  /* 'were done, now flush' case */
        body_fill-body_returned> 4096 ||     /* 'page nominal size' case */
        lacing_fill>=255 ||          /* 'segment table full' case */
        (lacing_fill!=0&&b_o_s==0)){  /* 'initial header page' case */
      return flush(og);
    }
    return 0;
  }

  public int eof(){
    return e_o_s;
  }

  public int reset(){
    body_fill=0;
    body_returned=0;

    lacing_fill=0;
    lacing_packet=0;
    lacing_returned=0;

    header_fill=0;

    e_o_s=0;
    b_o_s=0;
    pageno=-1;
    packetno=0;
    granulepos=0;
    return(0);
  }
}