com.jcraft.jogg.SyncState Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of sound Show documentation
Etyl's default sound module
The newest version!
/* -*-mode:java; c-basic-offset:2; indent-tabs-mode:nil -*- */
/* JOrbis
 * Copyright (C) 2000 ymnk, JCraft,Inc.
 *  
 * Written by: 2000 ymnk
 *   
 * Many thanks to 
 *   Monty  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;

// DECODING PRIMITIVES: packet streaming layer

// This has two layers to place more of the multi-serialno and paging
// control in the application's hands.  First, we expose a data buffer
// using ogg_decode_buffer().  The app either copies into the
// buffer, or passes it directly to read(), etc.  We then call
// ogg_decode_wrote() to tell how many bytes we just added.
//
// Pages are returned (pointers into the buffer in ogg_sync_state)
// by ogg_decode_stream().  The page is then submitted to
// ogg_decode_page() along with the appropriate
// ogg_stream_state* (ie, matching serialno).  We then get raw
// packets out calling ogg_stream_packet() with a
// ogg_stream_state.  See the 'frame-prog.txt' docs for details and
// example code.

public class SyncState{

  public byte[] data;
  int storage;
  int fill;
  int returned;

  int unsynced;
  int headerbytes;
  int bodybytes;

  public int clear(){
    data=null;
    return (0);
  }

  public int buffer(int size){
    // first, clear out any space that has been previously returned
    if(returned!=0){
      fill-=returned;
      if(fill>0){
        System.arraycopy(data, returned, data, 0, fill);
      }
      returned=0;
    }

    if(size>storage-fill){
      // We need to extend the internal buffer
      int newsize=size+fill+4096; // an extra page to be nice
      if(data!=null){
        byte[] foo=new byte[newsize];
        System.arraycopy(data, 0, foo, 0, data.length);
        data=foo;
      }
      else{
        data=new byte[newsize];
      }
      storage=newsize;
    }

    return (fill);
  }

  public int wrote(int bytes){
    if(fill+bytes>storage)
      return (-1);
    fill+=bytes;
    return (0);
  }

  // sync the stream.  This is meant to be useful for finding page
  // boundaries.
  //
  // return values for this:
  // -n) skipped n bytes
  //  0) page not ready; more data (no bytes skipped)
  //  n) page synced at current location; page length n bytes
  private Page pageseek=new Page();
  private byte[] chksum=new byte[4];

  public int pageseek(Page og){
    int page=returned;
    int next;
    int bytes=fill-returned;

    if(headerbytes==0){
      int _headerbytes, i;
      if(bytes<27)
        return (0); // not enough for a header

      /* verify capture pattern */
      if(data[page]!='O'||data[page+1]!='g'||data[page+2]!='g'
          ||data[page+3]!='S'){
        headerbytes=0;
        bodybytes=0;

        // search for possible capture
        next=0;
        for(int ii=0; iibytes)
      return (0);

    // The whole test page is buffered.  Verify the checksum
    synchronized(chksum){
      // Grab the checksum bytes, set the header field to zero

      System.arraycopy(data, page+22, chksum, 0, 4);
      data[page+22]=0;
      data[page+23]=0;
      data[page+24]=0;
      data[page+25]=0;

      // set up a temp page struct and recompute the checksum
      Page log=pageseek;
      log.header_base=data;
      log.header=page;
      log.header_len=headerbytes;

      log.body_base=data;
      log.body=page+headerbytes;
      log.body_len=bodybytes;
      log.checksum();

      // Compare
      if(chksum[0]!=data[page+22]||chksum[1]!=data[page+23]
          ||chksum[2]!=data[page+24]||chksum[3]!=data[page+25]){
        // D'oh.  Mismatch! Corrupt page (or miscapture and not a page at all)
        // replace the computed checksum with the one actually read in
        System.arraycopy(chksum, 0, data, page+22, 4);
        // Bad checksum. Lose sync */

        headerbytes=0;
        bodybytes=0;
        // search for possible capture
        next=0;
        for(int ii=0; ii0){
        // have a page
        return (1);
      }
      if(ret==0){
        // need more data
        return (0);
      }

      // head did not start a synced page... skipped some bytes
      if(unsynced==0){
        unsynced=1;
        return (-1);
      }
      // loop. keep looking
    }
  }

  // clear things to an initial state.  Good to call, eg, before seeking
  public int reset(){
    fill=0;
    returned=0;
    unsynced=0;
    headerbytes=0;
    bodybytes=0;
    return (0);
  }

  public void init(){
  }

  public int getDataOffset(){
    return returned;
  }

  public int getBufferOffset(){
    return fill;
  }
}