/********************************************************************

 *                                                                  *

 * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *

 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *

 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *

 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *

 *                                                                  *

 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2015             *

 * by the Xiph.Org Foundation http://www.xiph.org/                  *

 *                                                                  *

 ********************************************************************

 function: stdio-based convenience library for opening/seeking/decoding

 last mod: $Id: vorbisfile.c 19457 2015-03-03 00:15:29Z giles $

 ********************************************************************/

#include <stdlib.h>

#include <stdio.h>

#include <errno.h>

#include <string.h>

#include <math.h>

#include "vorbis/codec.h"

/* we don't need or want the static callback symbols here */

#define OV_EXCLUDE_STATIC_CALLBACKS

#include "vorbis/vorbisfile.h"

#include "os.h"

#include "misc.h"

/* A 'chained bitstream' is a Vorbis bitstream that contains more than

   one logical bitstream arranged end to end (the only form of Ogg

   multiplexing allowed in a Vorbis bitstream; grouping [parallel

   multiplexing] is not allowed in Vorbis) */

/* A Vorbis file can be played beginning to end (streamed) without

   worrying ahead of time about chaining (see decoder_example.c).  If

   we have the whole file, however, and want random access

   (seeking/scrubbing) or desire to know the total length/time of a

   file, we need to account for the possibility of chaining. */

/* We can handle things a number of ways; we can determine the entire

   bitstream structure right off the bat, or find pieces on demand.

   This example determines and caches structure for the entire

   bitstream, but builds a virtual decoder on the fly when moving

   between links in the chain. */

/* There are also different ways to implement seeking.  Enough

   information exists in an Ogg bitstream to seek to

   sample-granularity positions in the output.  Or, one can seek by

   picking some portion of the stream roughly in the desired area if

   we only want coarse navigation through the stream. */

/*************************************************************************

 * Many, many internal helpers.  The intention is not to be confusing;

 * rampant duplication and monolithic function implementation would be

 * harder to understand anyway.  The high level functions are last.  Begin

 * grokking near the end of the file */

/* read a little more data from the file/pipe into the ogg_sync framer

*/

#define CHUNKSIZE 65536 /* greater-than-page-size granularity seeking */

#define READSIZE 2048 /* a smaller read size is needed for low-rate streaming. */

static long _get_data(OggVorbis_File *vf){

  errno=0;

  if(!(vf->callbacks.read_func))return(-1);

  if(vf->datasource){

    char *buffer=ogg_sync_buffer(&vf->oy,READSIZE);

    long bytes=(vf->callbacks.read_func)(buffer,1,READSIZE,vf->datasource);

    if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);

    if(bytes==0 && errno)return(-1);

    return(bytes);

  }else

    return(0);

}

/* save a tiny smidge of verbosity to make the code more readable */

static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){

  if(vf->datasource){

    /* only seek if the file position isn't already there */

    if(vf->offset != offset){

      if(!(vf->callbacks.seek_func)||

         (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)

        return OV_EREAD;

      vf->offset=offset;

      ogg_sync_reset(&vf->oy);

    }

  }else{

    /* shouldn't happen unless someone writes a broken callback */

    return OV_EFAULT;

  }

  return 0;

}

/* The read/seek functions track absolute position within the stream */

/* from the head of the stream, get the next page.  boundary specifies

   if the function is allowed to fetch more data from the stream (and

   how much) or only use internally buffered data.

   boundary: -1) unbounded search

              0) read no additional data; use cached only

              n) search for a new page beginning for n bytes

   return:   <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)

              n) found a page at absolute offset n */

static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,

                                  ogg_int64_t boundary){

  if(boundary>0)boundary+=vf->offset;

  while(1){

    long more;

    if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);

    more=ogg_sync_pageseek(&vf->oy,og);

    if(more<0){

      /* skipped n bytes */

      vf->offset-=more;

    }else{

      if(more==0){

        /* send more paramedics */

        if(!boundary)return(OV_FALSE);

        {

          long ret=_get_data(vf);

          if(ret==0)return(OV_EOF);

          if(ret<0)return(OV_EREAD);

        }

      }else{

        /* got a page.  Return the offset at the page beginning,

           advance the internal offset past the page end */

        ogg_int64_t ret=vf->offset;

        vf->offset+=more;

        return(ret);

      }

    }

  }

}

/* find the latest page beginning before the passed in position. Much

   dirtier than the above as Ogg doesn't have any backward search

   linkage.  no 'readp' as it will certainly have to read. */

/* returns offset or OV_EREAD, OV_FAULT */

static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_int64_t begin,ogg_page *og){

  ogg_int64_t end = begin;

  ogg_int64_t ret;

  ogg_int64_t offset=-1;

  while(offset==-1){

    begin-=CHUNKSIZE;

    if(begin<0)

      begin=0;

    ret=_seek_helper(vf,begin);

    if(ret)return(ret);

    while(vf->offset

      memset(og,0,sizeof(*og));

      ret=_get_next_page(vf,og,end-vf->offset);

      if(ret==OV_EREAD)return(OV_EREAD);

      if(ret<0){

        break;

      }else{

        offset=ret;

      }

    }

  }

  /* In a fully compliant, non-multiplexed stream, we'll still be

     holding the last page.  In multiplexed (or noncompliant streams),

     we will probably have to re-read the last page we saw */

  if(og->header_len==0){

    ret=_seek_helper(vf,offset);

    if(ret)return(ret);

    ret=_get_next_page(vf,og,CHUNKSIZE);

    if(ret<0)

      /* this shouldn't be possible */

      return(OV_EFAULT);

  }

  return(offset);

}

static void _add_serialno(ogg_page *og,long **serialno_list, int *n){

  long s = ogg_page_serialno(og);

  (*n)++;

  if(*serialno_list){

    *serialno_list = _ogg_realloc(*serialno_list, sizeof(**serialno_list)*(*n));

  }else{

    *serialno_list = _ogg_malloc(sizeof(**serialno_list));

  }

  (*serialno_list)[(*n)-1] = s;

}

/* returns nonzero if found */

static int _lookup_serialno(long s, long *serialno_list, int n){

  if(serialno_list){

    while(n--){

      if(*serialno_list == s) return 1;

      serialno_list++;

    }

  }

  return 0;

}

static int _lookup_page_serialno(ogg_page *og, long *serialno_list, int n){

  long s = ogg_page_serialno(og);

  return _lookup_serialno(s,serialno_list,n);

}

/* performs the same search as _get_prev_page, but prefers pages of

   the specified serial number. If a page of the specified serialno is

   spotted during the seek-back-and-read-forward, it will return the

   info of last page of the matching serial number instead of the very

   last page.  If no page of the specified serialno is seen, it will

   return the info of last page and alter *serialno.  */

static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf, ogg_int64_t begin,

                                         long *serial_list, int serial_n,

                                         int *serialno, ogg_int64_t *granpos){

  ogg_page og;

  ogg_int64_t end=begin;

  ogg_int64_t ret;

  ogg_int64_t prefoffset=-1;

  ogg_int64_t offset=-1;

  ogg_int64_t ret_serialno=-1;

  ogg_int64_t ret_gran=-1;

  while(offset==-1){

    begin-=CHUNKSIZE;

    if(begin<0)

      begin=0;

    ret=_seek_helper(vf,begin);

    if(ret)return(ret);

    while(vf->offset

      ret=_get_next_page(vf,&og,end-vf->offset);

      if(ret==OV_EREAD)return(OV_EREAD);

      if(ret<0){

        break;

      }else{

        ret_serialno=ogg_page_serialno(&og);

        ret_gran=ogg_page_granulepos(&og);

        offset=ret;

        if(ret_serialno == *serialno){

          prefoffset=ret;

          *granpos=ret_gran;

        }

        if(!_lookup_serialno(ret_serialno,serial_list,serial_n)){

          /* we fell off the end of the link, which means we seeked

             back too far and shouldn't have been looking in that link

             to begin with.  If we found the preferred serial number,

             forget that we saw it. */

          prefoffset=-1;

        }

      }

    }

  }

  /* we're not interested in the page... just the serialno and granpos. */

  if(prefoffset>=0)return(prefoffset);

  *serialno = ret_serialno;

  *granpos = ret_gran;

  return(offset);

}

/* uses the local ogg_stream storage in vf; this is important for

   non-streaming input sources */

static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,

                          long **serialno_list, int *serialno_n,

                          ogg_page *og_ptr){

  ogg_page og;

  ogg_packet op;

  int i,ret;

  int allbos=0;

  if(!og_ptr){

    ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);

    if(llret==OV_EREAD)return(OV_EREAD);

    if(llret<0)return(OV_ENOTVORBIS);

    og_ptr=&og;

  }

  vorbis_info_init(vi);

  vorbis_comment_init(vc);

  vf->ready_state=OPENED;

  /* extract the serialnos of all BOS pages + the first set of vorbis

     headers we see in the link */

  while(ogg_page_bos(og_ptr)){

    if(serialno_list){

      if(_lookup_page_serialno(og_ptr,*serialno_list,*serialno_n)){

        /* a dupe serialnumber in an initial header packet set == invalid stream */

        if(*serialno_list)_ogg_free(*serialno_list);

        *serialno_list=0;

        *serialno_n=0;

        ret=OV_EBADHEADER;

        goto bail_header;

      }

      _add_serialno(og_ptr,serialno_list,serialno_n);

    }

    if(vf->ready_state

      /* we don't have a vorbis stream in this link yet, so begin

         prospective stream setup. We need a stream to get packets */

      ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));

      ogg_stream_pagein(&vf->os,og_ptr);

      if(ogg_stream_packetout(&vf->os,&op) > 0 &&

         vorbis_synthesis_idheader(&op)){

        /* vorbis header; continue setup */

        vf->ready_state=STREAMSET;

        if((ret=vorbis_synthesis_headerin(vi,vc,&op))){

          ret=OV_EBADHEADER;

          goto bail_header;

        }

      }

    }

    /* get next page */

    {

      ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE);

      if(llret==OV_EREAD){

        ret=OV_EREAD;

        goto bail_header;

      }

      if(llret<0){

        ret=OV_ENOTVORBIS;

        goto bail_header;

      }

      /* if this page also belongs to our vorbis stream, submit it and break */

      if(vf->ready_state==STREAMSET &&

         vf->os.serialno == ogg_page_serialno(og_ptr)){

        ogg_stream_pagein(&vf->os,og_ptr);

        break;

      }

    }

  }

  if(vf->ready_state!=STREAMSET){

    ret = OV_ENOTVORBIS;

    goto bail_header;

  }

  while(1){

    i=0;

    while(i<2){ /* get a page loop */

      while(i<2){ /* get a packet loop */

        int result=ogg_stream_packetout(&vf->os,&op);

        if(result==0)break;

        if(result==-1){

          ret=OV_EBADHEADER;

          goto bail_header;

        }

        if((ret=vorbis_synthesis_headerin(vi,vc,&op)))

          goto bail_header;

        i++;

      }

      while(i<2){

        if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){

          ret=OV_EBADHEADER;

          goto bail_header;

        }

        /* if this page belongs to the correct stream, go parse it */

        if(vf->os.serialno == ogg_page_serialno(og_ptr)){

          ogg_stream_pagein(&vf->os,og_ptr);

          break;

        }

        /* if we never see the final vorbis headers before the link

           ends, abort */

        if(ogg_page_bos(og_ptr)){

          if(allbos){

            ret = OV_EBADHEADER;

            goto bail_header;

          }else

            allbos=1;

        }

        /* otherwise, keep looking */

      }

    }

    return 0;

  }

 bail_header:

  vorbis_info_clear(vi);

  vorbis_comment_clear(vc);

  vf->ready_state=OPENED;

  return ret;

}

/* Starting from current cursor position, get initial PCM offset of

   next page.  Consumes the page in the process without decoding

   audio, however this is only called during stream parsing upon

   seekable open. */

static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){

  ogg_page    og;

  ogg_int64_t accumulated=0;

  long        lastblock=-1;

  int         result;

  int         serialno = vf->os.serialno;

  while(1){

    ogg_packet op;

    if(_get_next_page(vf,&og,-1)<0)

      break; /* should not be possible unless the file is truncated/mangled */

    if(ogg_page_bos(&og)) break;

    if(ogg_page_serialno(&og)!=serialno) continue;

    /* count blocksizes of all frames in the page */

    ogg_stream_pagein(&vf->os,&og);

    while((result=ogg_stream_packetout(&vf->os,&op))){

      if(result>0){ /* ignore holes */

        long thisblock=vorbis_packet_blocksize(vi,&op);

        if(thisblock>=0){

          if(lastblock!=-1)

            accumulated+=(lastblock+thisblock)>>2;

          lastblock=thisblock;

        }

      }

    }

    if(ogg_page_granulepos(&og)!=-1){

      /* pcm offset of last packet on the first audio page */

      accumulated= ogg_page_granulepos(&og)-accumulated;

      break;

    }

  }

  /* less than zero?  Either a corrupt file or a stream with samples

     trimmed off the beginning, a normal occurrence; in both cases set

     the offset to zero */

  if(accumulated<0)accumulated=0;

  return accumulated;

}

/* finds each bitstream link one at a time using a bisection search

   (has to begin by knowing the offset of the lb's initial page).

   Recurses for each link so it can alloc the link storage after

   finding them all, then unroll and fill the cache at the same time */

static int _bisect_forward_serialno(OggVorbis_File *vf,

                                    ogg_int64_t begin,

                                    ogg_int64_t searched,

                                    ogg_int64_t end,

                                    ogg_int64_t endgran,

                                    int endserial,

                                    long *currentno_list,

                                    int  currentnos,

                                    long m){

  ogg_int64_t pcmoffset;

  ogg_int64_t dataoffset=searched;

  ogg_int64_t endsearched=end;

  ogg_int64_t next=end;

  ogg_int64_t searchgran=-1;

  ogg_page og;

  ogg_int64_t ret,last;

  int serialno = vf->os.serialno;

  /* invariants:

     we have the headers and serialnos for the link beginning at 'begin'

     we have the offset and granpos of the last page in the file (potentially

       not a page we care about)

  */

  /* Is the last page in our list of current serialnumbers? */

  if(_lookup_serialno(endserial,currentno_list,currentnos)){

    /* last page is in the starting serialno list, so we've bisected

       down to (or just started with) a single link.  Now we need to

       find the last vorbis page belonging to the first vorbis stream

       for this link. */

    searched = end;

    while(endserial != serialno){

      endserial = serialno;

      searched=_get_prev_page_serial(vf,searched,currentno_list,currentnos,&endserial,&endgran);

    }

    vf->links=m+1;

    if(vf->offsets)_ogg_free(vf->offsets);

    if(vf->serialnos)_ogg_free(vf->serialnos);

    if(vf->dataoffsets)_ogg_free(vf->dataoffsets);

    vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));

    vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));

    vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));

    vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));

    vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));

    vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));

    vf->offsets[m+1]=end;

    vf->offsets[m]=begin;

    vf->pcmlengths[m*2+1]=(endgran<0?0:endgran);

  }else{

    /* last page is not in the starting stream's serial number list,

       so we have multiple links.  Find where the stream that begins

       our bisection ends. */

    long *next_serialno_list=NULL;

    int next_serialnos=0;

    vorbis_info vi;

    vorbis_comment vc;

    int testserial = serialno+1;

    /* the below guards against garbage seperating the last and

       first pages of two links. */

    while(searched

      ogg_int64_t bisect;

      if(endsearched-searched

        bisect=searched;

      }else{

        bisect=(searched+endsearched)/2;

      }

      ret=_seek_helper(vf,bisect);

      if(ret)return(ret);

      last=_get_next_page(vf,&og,-1);

      if(last==OV_EREAD)return(OV_EREAD);

      if(last<0 || !_lookup_page_serialno(&og,currentno_list,currentnos)){

        endsearched=bisect;

        if(last>=0)next=last;

      }else{

        searched=vf->offset;

      }

    }

    /* Bisection point found */

    /* for the time being, fetch end PCM offset the simple way */

    searched = next;

    while(testserial != serialno){

      testserial = serialno;

      searched = _get_prev_page_serial(vf,searched,currentno_list,currentnos,&testserial,&searchgran);

    }

    ret=_seek_helper(vf,next);

    if(ret)return(ret);

    ret=_fetch_headers(vf,&vi,&vc,&next_serialno_list,&next_serialnos,NULL);

    if(ret)return(ret);

    serialno = vf->os.serialno;

    dataoffset = vf->offset;

    /* this will consume a page, however the next bisection always

       starts with a raw seek */

    pcmoffset = _initial_pcmoffset(vf,&vi;;

    ret=_bisect_forward_serialno(vf,next,vf->offset,end,endgran,endserial,

                                 next_serialno_list,next_serialnos,m+1);

    if(ret)return(ret);

    if(next_serialno_list)_ogg_free(next_serialno_list);

    vf->offsets[m+1]=next;

    vf->serialnos[m+1]=serialno;

    vf->dataoffsets[m+1]=dataoffset;

    vf->vi[m+1]=vi;

    vf->vc[m+1]=vc;

    vf->pcmlengths[m*2+1]=searchgran;

    vf->pcmlengths[m*2+2]=pcmoffset;

    vf->pcmlengths[m*2+3]-=pcmoffset;

    if(vf->pcmlengths[m*2+3]<0)vf->pcmlengths[m*2+3]=0;

  }

  return(0);

}

static int _make_decode_ready(OggVorbis_File *vf){

  if(vf->ready_state>STREAMSET)return 0;

  if(vf->ready_state

  if(vf->seekable){

    if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))

      return OV_EBADLINK;

  }else{

    if(vorbis_synthesis_init(&vf->vd,vf->vi))

      return OV_EBADLINK;

  }

  vorbis_block_init(&vf->vd,&vf->vb);

  vf->ready_state=INITSET;

  vf->bittrack=0.f;

  vf->samptrack=0.f;

  return 0;

}

static int _open_seekable2(OggVorbis_File *vf){

  ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1;

  int endserial=vf->os.serialno;

  int serialno=vf->os.serialno;

  /* we're partially open and have a first link header state in

     storage in vf */

  /* fetch initial PCM offset */

  ogg_int64_t pcmoffset = _initial_pcmoffset(vf,vf->vi);

  /* we can seek, so set out learning all about this file */

  if(vf->callbacks.seek_func && vf->callbacks.tell_func){

    (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);

    vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);

  }else{

    vf->offset=vf->end=-1;

  }

  /* If seek_func is implemented, tell_func must also be implemented */

  if(vf->end==-1) return(OV_EINVAL);

  /* Get the offset of the last page of the physical bitstream, or, if

     we're lucky the last vorbis page of this link as most OggVorbis

     files will contain a single logical bitstream */

  end=_get_prev_page_serial(vf,vf->end,vf->serialnos+2,vf->serialnos[1],&endserial,&endgran);

  if(end<0)return(end);

  /* now determine bitstream structure recursively */

  if(_bisect_forward_serialno(vf,0,dataoffset,end,endgran,endserial,

                              vf->serialnos+2,vf->serialnos[1],0)<0)return(OV_EREAD);

  vf->offsets[0]=0;

  vf->serialnos[0]=serialno;

  vf->dataoffsets[0]=dataoffset;

  vf->pcmlengths[0]=pcmoffset;

  vf->pcmlengths[1]-=pcmoffset;

  if(vf->pcmlengths[1]<0)vf->pcmlengths[1]=0;

  return(ov_raw_seek(vf,dataoffset));

}

/* clear out the current logical bitstream decoder */

static void _decode_clear(OggVorbis_File *vf){

  vorbis_dsp_clear(&vf->vd);

  vorbis_block_clear(&vf->vb);

  vf->ready_state=OPENED;

}

/* 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: <0) error, OV_HOLE (lost packet) or OV_EOF

            0) need more data (only if readp==0)

            1) got a packet

*/

static int _fetch_and_process_packet(OggVorbis_File *vf,

                                     ogg_packet *op_in,

                                     int readp,

                                     int spanp){

  ogg_page og;

  /* handle one packet.  Try to fetch it from current stream state */

  /* extract packets from page */

  while(1){

    if(vf->ready_state==STREAMSET){

      int ret=_make_decode_ready(vf);

      if(ret<0)return ret;

    }

    /* process a packet if we can. */

    if(vf->ready_state==INITSET){

      int hs=vorbis_synthesis_halfrate_p(vf->vi);

      while(1) {

              ogg_packet op;

              ogg_packet *op_ptr=(op_in?op_in:&op);

        int result=ogg_stream_packetout(&vf->os,op_ptr);

        ogg_int64_t granulepos;

        op_in=NULL;

        if(result==-1)return(OV_HOLE); /* hole in the data. */

        if(result>0){

          /* got a packet.  process it */

          granulepos=op_ptr->granulepos;

          if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy

                                                    header handling.  The

                                                    header packets aren't

                                                    audio, so if/when we

                                                    submit them,

                                                    vorbis_synthesis will

                                                    reject them */

            /* suck in the synthesis data and track bitrate */

            {

              int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);

              /* for proper use of libvorbis within libvorbisfile,

                 oldsamples will always be zero. */

              if(oldsamples)return(OV_EFAULT);

              vorbis_synthesis_blockin(&vf->vd,&vf->vb);

              vf->samptrack+=(vorbis_synthesis_pcmout(&vf->vd,NULL)<

              vf->bittrack+=op_ptr->bytes*8;

            }

            /* update the pcm offset. */

            if(granulepos!=-1 && !op_ptr->e_o_s){

              int link=(vf->seekable?vf->current_link:0);

              int i,samples;

              /* this packet has a pcm_offset on it (the last packet

                 completed on a page carries the offset) After processing

                 (above), we know the pcm position of the *last* sample

                 ready to be returned. Find the offset of the *first*

                 As an aside, this trick is inaccurate if we begin

                 reading anew right at the last page; the end-of-stream

                 granulepos declares the last frame in the stream, and the

                 last packet of the last page may be a partial frame.

                 So, we need a previous granulepos from an in-sequence page

                 to have a reference point.  Thus the !op_ptr->e_o_s clause

                 above */

              if(vf->seekable && link>0)

                granulepos-=vf->pcmlengths[link*2];

              if(granulepos<0)granulepos=0; /* actually, this

                                               shouldn't be possible

                                               here unless the stream

                                               is very broken */

              samples=(vorbis_synthesis_pcmout(&vf->vd,NULL)<

              granulepos-=samples;

              for(i=0;i

                granulepos+=vf->pcmlengths[i*2+1];

              vf->pcm_offset=granulepos;

            }

            return(1);

          }

        }

        else

          break;

      }

    }

    if(vf->ready_state>=OPENED){

      ogg_int64_t ret;

      while(1){

        /* the loop is not strictly necessary, but there's no sense in

           doing the extra checks of the larger loop for the common

           case in a multiplexed bistream where the page is simply

           part of a different logical bitstream; keep reading until

           we get one with the correct serialno */

        if(!readp)return(0);

        if((ret=_get_next_page(vf,&og,-1))<0){

          return(OV_EOF); /* eof. leave unitialized */

        }

        /* bitrate tracking; add the header's bytes here, the body bytes

           are done by packet above */

        vf->bittrack+=og.header_len*8;

        if(vf->ready_state==INITSET){

          if(vf->current_serialno!=ogg_page_serialno(&og)){

            /* two possibilities:

               1) our decoding just traversed a bitstream boundary

               2) another stream is multiplexed into this logical section */

            if(ogg_page_bos(&og)){

              /* boundary case */

              if(!spanp)

                return(OV_EOF);

              _decode_clear(vf);

              if(!vf->seekable){

                vorbis_info_clear(vf->vi);

                vorbis_comment_clear(vf->vc);

              }

              break;

            }else

              continue; /* possibility #2 */

          }

        }

        break;

      }

    }

    /* Do we need to load a new machine before submitting the page? */

    /* This is different in the seekable and non-seekable cases.

       In the seekable case, we already have all the header

       information loaded and cached; we just initialize the machine

       with it and continue on our merry way.

       In the non-seekable (streaming) case, we'll only be at a

       boundary if we just left the previous logical bitstream and

       we're now nominally at the header of the next bitstream

    */

    if(vf->ready_state!=INITSET){

      int link;

      if(vf->ready_state

        if(vf->seekable){

          long serialno = ogg_page_serialno(&og);

          /* match the serialno to bitstream section.  We use this rather than

             offset positions to avoid problems near logical bitstream

             boundaries */

          for(link=0;link<vf->links;link++)

            if(vf->serialnos[link]==serialno)break;

          if(link==vf->links) continue; /* not the desired Vorbis

                                           bitstream section; keep

                                           trying */

          vf->current_serialno=serialno;

          vf->current_link=link;

          ogg_stream_reset_serialno(&vf->os,vf->current_serialno);

          vf->ready_state=STREAMSET;

        }else{

          /* we're streaming */

          /* fetch the three header packets, build the info struct */

          int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);

          if(ret)return(ret);

          vf->current_serialno=vf->os.serialno;

          vf->current_link++;

          link=0;

        }

      }

    }

    /* the buffered page is the data we want, and we're ready for it;

       add it to the stream state */

    ogg_stream_pagein(&vf->os,&og);

  }

}

/* if, eg, 64 bit stdio is configured by default, this will build with

   fseek64 */

static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){

  if(f==NULL)return(-1);

  return fseek(f,off,whence);

}

static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial,

                     long ibytes, ov_callbacks callbacks){

  int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);

  long *serialno_list=NULL;