lib/vorbisfile.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   7  *                                                                  *
   8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
   9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  10  *                                                                  *
  11  ********************************************************************
  12
  13  function: stdio-based convenience library for opening/seeking/decoding
  14  last mod: $Id$
  15
  16  ********************************************************************/
  17
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <math.h>
  23
  24 #include "vorbis/codec.h"
  25
  26 /* we don't need or want the static callback symbols here */
  27 #define OV_EXCLUDE_STATIC_CALLBACKS
  28 #include "vorbis/vorbisfile.h"
  29
  30 #include "os.h"
  31 #include "misc.h"
  32
  33 /* A 'chained bitstream' is a Vorbis bitstream that contains more than
  34    one logical bitstream arranged end to end (the only form of Ogg
  35    multiplexing allowed in a Vorbis bitstream; grouping [parallel
  36    multiplexing] is not allowed in Vorbis) */
  37
  38 /* A Vorbis file can be played beginning to end (streamed) without
  39    worrying ahead of time about chaining (see decoder_example.c).  If
  40    we have the whole file, however, and want random access
  41    (seeking/scrubbing) or desire to know the total length/time of a
  42    file, we need to account for the possibility of chaining. */
  43
  44 /* We can handle things a number of ways; we can determine the entire
  45    bitstream structure right off the bat, or find pieces on demand.
  46    This example determines and caches structure for the entire
  47    bitstream, but builds a virtual decoder on the fly when moving
  48    between links in the chain. */
  49
  50 /* There are also different ways to implement seeking.  Enough
  51    information exists in an Ogg bitstream to seek to
  52    sample-granularity positions in the output.  Or, one can seek by
  53    picking some portion of the stream roughly in the desired area if
  54    we only want coarse navigation through the stream. */
  55
  56 /*************************************************************************
  57  * Many, many internal helpers.  The intention is not to be confusing;
  58  * rampant duplication and monolithic function implementation would be
  59  * harder to understand anyway.  The high level functions are last.  Begin
  60  * grokking near the end of the file */
  61
  62 /* read a little more data from the file/pipe into the ogg_sync framer
  63 */
  64 #define CHUNKSIZE 65536 /* greater-than-page-size granularity seeking */
  65 #define READSIZE 2048 /* a smaller read size is needed for low-rate streaming. */
  66
  67 static long _get_data(OggVorbis_File *vf){
  68   errno=0;
  69   if(!(vf->callbacks.read_func))return(-1);
  70   if(vf->datasource){
  71     char *buffer=ogg_sync_buffer(&vf->oy,READSIZE);
  72     long bytes=(vf->callbacks.read_func)(buffer,1,READSIZE,vf->datasource);
  73     if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
  74     if(bytes==0 && errno)return(-1);
  75     return(bytes);
  76   }else
  77     return(0);
  78 }
  79
  80 /* save a tiny smidge of verbosity to make the code more readable */
  81 static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){
  82   if(vf->datasource){
  83     if(!(vf->callbacks.seek_func)||
  84        (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)
  85       return OV_EREAD;
  86     vf->offset=offset;
  87     ogg_sync_reset(&vf->oy);
  88   }else{
  89     /* shouldn't happen unless someone writes a broken callback */
  90     return OV_EFAULT;
  91   }
  92   return 0;
  93 }
  94
  95 /* The read/seek functions track absolute position within the stream */
  96
  97 /* from the head of the stream, get the next page.  boundary specifies
  98    if the function is allowed to fetch more data from the stream (and
  99    how much) or only use internally buffered data.
 100
 101    boundary: -1) unbounded search
 102               0) read no additional data; use cached only
 103               n) search for a new page beginning for n bytes
 104
 105    return:   <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
 106               n) found a page at absolute offset n */
 107
 108 static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
 109                                   ogg_int64_t boundary){
 110   if(boundary>0)boundary+=vf->offset;
 111   while(1){
 112     long more;
 113
 114     if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
 115     more=ogg_sync_pageseek(&vf->oy,og);
 116
 117     if(more<0){
 118       /* skipped n bytes */
 119       vf->offset-=more;
 120     }else{
 121       if(more==0){
 122         /* send more paramedics */
 123         if(!boundary)return(OV_FALSE);
 124         {
 125           long ret=_get_data(vf);
 126           if(ret==0)return(OV_EOF);
 127           if(ret<0)return(OV_EREAD);
 128         }
 129       }else{
 130         /* got a page.  Return the offset at the page beginning,
 131            advance the internal offset past the page end */
 132         ogg_int64_t ret=vf->offset;
 133         vf->offset+=more;
 134         return(ret);
 135
 136       }
 137     }
 138   }
 139 }
 140
 141 /* find the latest page beginning before the current stream cursor
 142    position. Much dirtier than the above as Ogg doesn't have any
 143    backward search linkage.  no 'readp' as it will certainly have to
 144    read. */
 145 /* returns offset or OV_EREAD, OV_FAULT */
 146 static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){
 147   ogg_int64_t begin=vf->offset;
 148   ogg_int64_t end=begin;
 149   ogg_int64_t ret;
 150   ogg_int64_t offset=-1;
 151
 152   while(offset==-1){
 153     begin-=CHUNKSIZE;
 154     if(begin<0)
 155       begin=0;
 156
 157     ret=_seek_helper(vf,begin);
 158     if(ret)return(ret);
 159
 160     while(vf->offset<end){
 161       memset(og,0,sizeof(*og));
 162       ret=_get_next_page(vf,og,end-vf->offset);
 163       if(ret==OV_EREAD)return(OV_EREAD);
 164       if(ret<0){
 165         break;
 166       }else{
 167         offset=ret;
 168       }
 169     }
 170   }
 171
 172   /* In a fully compliant, non-multiplexed stream, we'll still be
 173      holding the last page.  In multiplexed (or noncompliant streams),
 174      we will probably have to re-read the last page we saw */
 175   if(og->header_len==0){
 176     ret=_seek_helper(vf,offset);
 177     if(ret)return(ret);
 178
 179     ret=_get_next_page(vf,og,CHUNKSIZE);
 180     if(ret<0)
 181       /* this shouldn't be possible */
 182       return(OV_EFAULT);
 183   }
 184
 185   return(offset);
 186 }
 187
 188 static void _add_serialno(ogg_page *og,long **serialno_list, int *n){
 189   long s = ogg_page_serialno(og);
 190   (*n)++;
 191
 192   if(*serialno_list){
 193     *serialno_list = _ogg_realloc(*serialno_list, sizeof(**serialno_list)*(*n));
 194   }else{
 195     *serialno_list = _ogg_malloc(sizeof(**serialno_list));
 196   }
 197
 198   (*serialno_list)[(*n)-1] = s;
 199 }
 200
 201 /* returns nonzero if found */
 202 static int _lookup_serialno(long s, long *serialno_list, int n){
 203   if(serialno_list){
 204     while(n--){
 205       if(*serialno_list == s) return 1;
 206       serialno_list++;
 207     }
 208   }
 209   return 0;
 210 }
 211
 212 static int _lookup_page_serialno(ogg_page *og, long *serialno_list, int n){
 213   long s = ogg_page_serialno(og);
 214   return _lookup_serialno(s,serialno_list,n);
 215 }
 216
 217 /* performs the same search as _get_prev_page, but prefers pages of
 218    the specified serial number. If a page of the specified serialno is
 219    spotted during the seek-back-and-read-forward, it will return the
 220    info of last page of the matching serial number instead of the very
 221    last page.  If no page of the specified serialno is seen, it will
 222    return the info of last page and alter *serialno.  */
 223 static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf,
 224                                          long *serial_list, int serial_n,
 225                                          int *serialno, ogg_int64_t *granpos){
 226   ogg_page og;
 227   ogg_int64_t begin=vf->offset;
 228   ogg_int64_t end=begin;
 229   ogg_int64_t ret;
 230
 231   ogg_int64_t prefoffset=-1;
 232   ogg_int64_t offset=-1;
 233   ogg_int64_t ret_serialno=-1;
 234   ogg_int64_t ret_gran=-1;
 235
 236   while(offset==-1){
 237     begin-=CHUNKSIZE;
 238     if(begin<0)
 239       begin=0;
 240
 241     ret=_seek_helper(vf,begin);
 242     if(ret)return(ret);
 243
 244     while(vf->offset<end){
 245       ret=_get_next_page(vf,&og,end-vf->offset);
 246       if(ret==OV_EREAD)return(OV_EREAD);
 247       if(ret<0){
 248         break;
 249       }else{
 250         ret_serialno=ogg_page_serialno(&og);
 251         ret_gran=ogg_page_granulepos(&og);
 252         offset=ret;
 253
 254         if(ret_serialno == *serialno){
 255           prefoffset=ret;
 256           *granpos=ret_gran;
 257         }
 258
 259         if(!_lookup_serialno(ret_serialno,serial_list,serial_n)){
 260           /* we fell off the end of the link, which means we seeked
 261              back too far and shouldn't have been looking in that link
 262              to begin with.  If we found the preferred serial number,
 263              forget that we saw it. */
 264           prefoffset=-1;
 265         }
 266       }
 267     }
 268   }
 269
 270   /* we're not interested in the page... just the serialno and granpos. */
 271   if(prefoffset>=0)return(prefoffset);
 272
 273   *serialno = ret_serialno;
 274   *granpos = ret_gran;
 275   return(offset);
 276
 277 }
 278
 279 /* uses the local ogg_stream storage in vf; this is important for
 280    non-streaming input sources */
 281 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
 282                           long **serialno_list, int *serialno_n,
 283                           ogg_page *og_ptr){
 284   ogg_page og;
 285   ogg_packet op;
 286   int i,ret;
 287   int allbos=0;
 288
 289   if(!og_ptr){
 290     ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
 291     if(llret==OV_EREAD)return(OV_EREAD);
 292     if(llret<0)return(OV_ENOTVORBIS);
 293     og_ptr=&og;
 294   }
 295
 296   vorbis_info_init(vi);
 297   vorbis_comment_init(vc);
 298   vf->ready_state=OPENED;
 299
 300   /* extract the serialnos of all BOS pages + the first set of vorbis
 301      headers we see in the link */
 302
 303   while(ogg_page_bos(og_ptr)){
 304     if(serialno_list){
 305       if(_lookup_page_serialno(og_ptr,*serialno_list,*serialno_n)){
 306         /* a dupe serialnumber in an initial header packet set == invalid stream */
 307         if(*serialno_list)_ogg_free(*serialno_list);
 308         *serialno_list=0;
 309         *serialno_n=0;
 310         ret=OV_EBADHEADER;
 311         goto bail_header;
 312       }
 313
 314       _add_serialno(og_ptr,serialno_list,serialno_n);
 315     }
 316
 317     if(vf->ready_state<STREAMSET){
 318       /* we don't have a vorbis stream in this link yet, so begin
 319          prospective stream setup. We need a stream to get packets */
 320       ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
 321       ogg_stream_pagein(&vf->os,og_ptr);
 322
 323       if(ogg_stream_packetout(&vf->os,&op) > 0 &&
 324          vorbis_synthesis_idheader(&op)){
 325         /* vorbis header; continue setup */
 326         vf->ready_state=STREAMSET;
 327         if((ret=vorbis_synthesis_headerin(vi,vc,&op))){
 328           ret=OV_EBADHEADER;
 329           goto bail_header;
 330         }
 331       }
 332     }
 333
 334     /* get next page */
 335     {
 336       ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE);
 337       if(llret==OV_EREAD){
 338         ret=OV_EREAD;
 339         goto bail_header;
 340       }
 341       if(llret<0){
 342         ret=OV_ENOTVORBIS;
 343         goto bail_header;
 344       }
 345
 346       /* if this page also belongs to our vorbis stream, submit it and break */
 347       if(vf->ready_state==STREAMSET &&
 348          vf->os.serialno == ogg_page_serialno(og_ptr)){
 349         ogg_stream_pagein(&vf->os,og_ptr);
 350         break;
 351       }
 352     }
 353   }
 354
 355   if(vf->ready_state!=STREAMSET){
 356     ret = OV_ENOTVORBIS;
 357     goto bail_header;
 358   }
 359
 360   while(1){
 361
 362     i=0;
 363     while(i<2){ /* get a page loop */
 364
 365       while(i<2){ /* get a packet loop */
 366
 367         int result=ogg_stream_packetout(&vf->os,&op);
 368         if(result==0)break;
 369         if(result==-1){
 370           ret=OV_EBADHEADER;
 371           goto bail_header;
 372         }
 373
 374         if((ret=vorbis_synthesis_headerin(vi,vc,&op)))
 375           goto bail_header;
 376
 377         i++;
 378       }
 379
 380       while(i<2){
 381         if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){
 382           ret=OV_EBADHEADER;
 383           goto bail_header;
 384         }
 385
 386         /* if this page belongs to the correct stream, go parse it */
 387         if(vf->os.serialno == ogg_page_serialno(og_ptr)){
 388           ogg_stream_pagein(&vf->os,og_ptr);
 389           break;
 390         }
 391
 392         /* if we never see the final vorbis headers before the link
 393            ends, abort */
 394         if(ogg_page_bos(og_ptr)){
 395           if(allbos){
 396             ret = OV_EBADHEADER;
 397             goto bail_header;
 398           }else
 399             allbos=1;
 400         }
 401
 402         /* otherwise, keep looking */
 403       }
 404     }
 405
 406     return 0;
 407   }
 408
 409  bail_header:
 410   vorbis_info_clear(vi);
 411   vorbis_comment_clear(vc);
 412   vf->ready_state=OPENED;
 413
 414   return ret;
 415 }
 416
 417 /* Starting from current cursor position, get initial PCM offset of
 418    next page.  Consumes the page in the process without decoding
 419    audio, however this is only called during stream parsing upon
 420    seekable open. */
 421 static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){
 422   ogg_page    og;
 423   ogg_int64_t accumulated=0;
 424   long        lastblock=-1;
 425   int         result;
 426   int         serialno = vf->os.serialno;
 427
 428   while(1){
 429     ogg_packet op;
 430     if(_get_next_page(vf,&og,-1)<0)
 431       break; /* should not be possible unless the file is truncated/mangled */
 432
 433     if(ogg_page_bos(&og)) break;
 434     if(ogg_page_serialno(&og)!=serialno) continue;
 435
 436     /* count blocksizes of all frames in the page */
 437     ogg_stream_pagein(&vf->os,&og);
 438     while((result=ogg_stream_packetout(&vf->os,&op))){
 439       if(result>0){ /* ignore holes */
 440         long thisblock=vorbis_packet_blocksize(vi,&op);
 441         if(lastblock!=-1)
 442           accumulated+=(lastblock+thisblock)>>2;
 443         lastblock=thisblock;
 444       }
 445     }
 446
 447     if(ogg_page_granulepos(&og)!=-1){
 448       /* pcm offset of last packet on the first audio page */
 449       accumulated= ogg_page_granulepos(&og)-accumulated;
 450       break;
 451     }
 452   }
 453
 454   /* less than zero?  Either a corrupt file or a stream with samples
 455      trimmed off the beginning, a normal occurrence; in both cases set
 456      the offset to zero */
 457   if(accumulated<0)accumulated=0;
 458
 459   return accumulated;
 460 }
 461
 462 /* finds each bitstream link one at a time using a bisection search
 463    (has to begin by knowing the offset of the lb's initial page).
 464    Recurses for each link so it can alloc the link storage after
 465    finding them all, then unroll and fill the cache at the same time */
 466 static int _bisect_forward_serialno(OggVorbis_File *vf,
 467                                     ogg_int64_t begin,
 468                                     ogg_int64_t searched,
 469                                     ogg_int64_t end,
 470                                     ogg_int64_t endgran,
 471                                     int endserial,
 472                                     long *currentno_list,
 473                                     int  currentnos,
 474                                     long m){
 475   ogg_int64_t pcmoffset;
 476   ogg_int64_t dataoffset=searched;
 477   ogg_int64_t endsearched=end;
 478   ogg_int64_t next=end;
 479   ogg_int64_t searchgran=-1;
 480   ogg_page og;
 481   ogg_int64_t ret,last;
 482   int serialno = vf->os.serialno;
 483
 484   /* invariants:
 485      we have the headers and serialnos for the link beginning at 'begin'
 486      we have the offset and granpos of the last page in the file (potentially
 487        not a page we care about)
 488   */
 489
 490   /* Is the last page in our list of current serialnumbers? */
 491   if(_lookup_serialno(endserial,currentno_list,currentnos)){
 492
 493     /* last page is in the starting serialno list, so we've bisected
 494        down to (or just started with) a single link.  Now we need to
 495        find the last vorbis page belonging to the first vorbis stream
 496        for this link. */
 497
 498     while(endserial != serialno){
 499       endserial = serialno;
 500       vf->offset=_get_prev_page_serial(vf,currentno_list,currentnos,&endserial,&endgran);
 501     }
 502
 503     vf->links=m+1;
 504     if(vf->offsets)_ogg_free(vf->offsets);
 505     if(vf->serialnos)_ogg_free(vf->serialnos);
 506     if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
 507
 508     vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));
 509     vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));
 510     vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));
 511     vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));
 512     vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));
 513     vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));
 514
 515     vf->offsets[m+1]=end;
 516     vf->offsets[m]=begin;
 517     vf->pcmlengths[m*2+1]=(endgran<0?0:endgran);
 518
 519   }else{
 520
 521     long *next_serialno_list=NULL;
 522     int next_serialnos=0;
 523     vorbis_info vi;
 524     vorbis_comment vc;
 525
 526     /* the below guards against garbage seperating the last and
 527        first pages of two links. */
 528     while(searched<endsearched){
 529       ogg_int64_t bisect;
 530
 531       if(endsearched-searched<CHUNKSIZE){
 532         bisect=searched;
 533       }else{
 534         bisect=(searched+endsearched)/2;
 535       }
 536
 537       if(bisect != vf->offset){
 538         ret=_seek_helper(vf,bisect);
 539         if(ret)return(ret);
 540       }
 541
 542       last=_get_next_page(vf,&og,-1);
 543       if(last==OV_EREAD)return(OV_EREAD);
 544       if(last<0 || !_lookup_page_serialno(&og,currentno_list,currentnos)){
 545         endsearched=bisect;
 546         if(last>=0)next=last;
 547       }else{
 548         searched=vf->offset;
 549       }
 550     }
 551
 552     /* Bisection point found */
 553
 554     /* for the time being, fetch end PCM offset the simple way */
 555     {
 556       int testserial = serialno+1;
 557       vf->offset = next;
 558       while(testserial != serialno){
 559         testserial = serialno;
 560         vf->offset=_get_prev_page_serial(vf,currentno_list,currentnos,&testserial,&searchgran);
 561       }
 562     }
 563
 564     if(vf->offset!=next){
 565       ret=_seek_helper(vf,next);
 566       if(ret)return(ret);
 567     }
 568
 569     ret=_fetch_headers(vf,&vi,&vc,&next_serialno_list,&next_serialnos,NULL);
 570     if(ret)return(ret);
 571     serialno = vf->os.serialno;
 572     dataoffset = vf->offset;
 573
 574     /* this will consume a page, however the next bistection always
 575        starts with a raw seek */
 576     pcmoffset = _initial_pcmoffset(vf,&vi);
 577
 578     ret=_bisect_forward_serialno(vf,next,vf->offset,end,endgran,endserial,
 579                                  next_serialno_list,next_serialnos,m+1);
 580     if(ret)return(ret);
 581
 582     if(next_serialno_list)_ogg_free(next_serialno_list);
 583
 584     vf->offsets[m+1]=next;
 585     vf->serialnos[m+1]=serialno;
 586     vf->dataoffsets[m+1]=dataoffset;
 587
 588     vf->vi[m+1]=vi;
 589     vf->vc[m+1]=vc;
 590
 591     vf->pcmlengths[m*2+1]=searchgran;
 592     vf->pcmlengths[m*2+2]=pcmoffset;
 593     vf->pcmlengths[m*2+3]-=pcmoffset;
 594     if(vf->pcmlengths[m*2+3]<0)vf->pcmlengths[m*2+3]=0;
 595   }
 596   return(0);
 597 }
 598
 599 static int _make_decode_ready(OggVorbis_File *vf){
 600   if(vf->ready_state>STREAMSET)return 0;
 601   if(vf->ready_state<STREAMSET)return OV_EFAULT;
 602   if(vf->seekable){
 603     if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))
 604       return OV_EBADLINK;
 605   }else{
 606     if(vorbis_synthesis_init(&vf->vd,vf->vi))
 607       return OV_EBADLINK;
 608   }
 609   vorbis_block_init(&vf->vd,&vf->vb);
 610   vf->ready_state=INITSET;
 611   vf->bittrack=0.f;
 612   vf->samptrack=0.f;
 613   return 0;
 614 }
 615
 616 static int _open_seekable2(OggVorbis_File *vf){
 617   ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1;
 618   int endserial=vf->os.serialno;
 619   int serialno=vf->os.serialno;
 620
 621   /* we're partially open and have a first link header state in
 622      storage in vf */
 623
 624   /* fetch initial PCM offset */
 625   ogg_int64_t pcmoffset = _initial_pcmoffset(vf,vf->vi);
 626
 627   /* we can seek, so set out learning all about this file */
 628   if(vf->callbacks.seek_func && vf->callbacks.tell_func){
 629     (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
 630     vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
 631   }else{
 632     vf->offset=vf->end=-1;
 633   }
 634
 635   /* If seek_func is implemented, tell_func must also be implemented */
 636   if(vf->end==-1) return(OV_EINVAL);
 637
 638   /* Get the offset of the last page of the physical bitstream, or, if
 639      we're lucky the last vorbis page of this link as most OggVorbis
 640      files will contain a single logical bitstream */
 641   end=_get_prev_page_serial(vf,vf->serialnos+2,vf->serialnos[1],&endserial,&endgran);
 642   if(end<0)return(end);
 643
 644   /* now determine bitstream structure recursively */
 645   if(_bisect_forward_serialno(vf,0,dataoffset,vf->offset,endgran,endserial,
 646                               vf->serialnos+2,vf->serialnos[1],0)<0)return(OV_EREAD);
 647
 648   vf->offsets[0]=0;
 649   vf->serialnos[0]=serialno;
 650   vf->dataoffsets[0]=dataoffset;
 651   vf->pcmlengths[0]=pcmoffset;
 652   vf->pcmlengths[1]-=pcmoffset;
 653   if(vf->pcmlengths[1]<0)vf->pcmlengths[1]=0;
 654
 655   return(ov_raw_seek(vf,dataoffset));
 656 }
 657
 658 /* clear out the current logical bitstream decoder */
 659 static void _decode_clear(OggVorbis_File *vf){
 660   vorbis_dsp_clear(&vf->vd);
 661   vorbis_block_clear(&vf->vb);
 662   vf->ready_state=OPENED;
 663 }
 664
 665 /* fetch and process a packet.  Handles the case where we're at a
 666    bitstream boundary and dumps the decoding machine.  If the decoding
 667    machine is unloaded, it loads it.  It also keeps pcm_offset up to
 668    date (seek and read both use this.  seek uses a special hack with
 669    readp).
 670
 671    return: <0) error, OV_HOLE (lost packet) or OV_EOF
 672             0) need more data (only if readp==0)
 673             1) got a packet
 674 */
 675
 676 static int _fetch_and_process_packet(OggVorbis_File *vf,
 677                                      ogg_packet *op_in,
 678                                      int readp,
 679                                      int spanp){
 680   ogg_page og;
 681
 682   /* handle one packet.  Try to fetch it from current stream state */
 683   /* extract packets from page */
 684   while(1){
 685
 686     if(vf->ready_state==STREAMSET){
 687       int ret=_make_decode_ready(vf);
 688       if(ret<0)return ret;
 689     }
 690
 691     /* process a packet if we can. */
 692
 693     if(vf->ready_state==INITSET){
 694       int hs=vorbis_synthesis_halfrate_p(vf->vi);
 695
 696       while(1) {
 697               ogg_packet op;
 698               ogg_packet *op_ptr=(op_in?op_in:&op);
 699         int result=ogg_stream_packetout(&vf->os,op_ptr);
 700         ogg_int64_t granulepos;
 701
 702         op_in=NULL;
 703         if(result==-1)return(OV_HOLE); /* hole in the data. */
 704         if(result>0){
 705           /* got a packet.  process it */
 706           granulepos=op_ptr->granulepos;
 707           if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
 708                                                     header handling.  The
 709                                                     header packets aren't
 710                                                     audio, so if/when we
 711                                                     submit them,
 712                                                     vorbis_synthesis will
 713                                                     reject them */
 714
 715             /* suck in the synthesis data and track bitrate */
 716             {
 717               int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
 718               /* for proper use of libvorbis within libvorbisfile,
 719                  oldsamples will always be zero. */
 720               if(oldsamples)return(OV_EFAULT);
 721
 722               vorbis_synthesis_blockin(&vf->vd,&vf->vb);
 723               vf->samptrack+=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
 724               vf->bittrack+=op_ptr->bytes*8;
 725             }
 726
 727             /* update the pcm offset. */
 728             if(granulepos!=-1 && !op_ptr->e_o_s){
 729               int link=(vf->seekable?vf->current_link:0);
 730               int i,samples;
 731
 732               /* this packet has a pcm_offset on it (the last packet
 733                  completed on a page carries the offset) After processing
 734                  (above), we know the pcm position of the *last* sample
 735                  ready to be returned. Find the offset of the *first*
 736
 737                  As an aside, this trick is inaccurate if we begin
 738                  reading anew right at the last page; the end-of-stream
 739                  granulepos declares the last frame in the stream, and the
 740                  last packet of the last page may be a partial frame.
 741                  So, we need a previous granulepos from an in-sequence page
 742                  to have a reference point.  Thus the !op_ptr->e_o_s clause
 743                  above */
 744
 745               if(vf->seekable && link>0)
 746                 granulepos-=vf->pcmlengths[link*2];
 747               if(granulepos<0)granulepos=0; /* actually, this
 748                                                shouldn't be possible
 749                                                here unless the stream
 750                                                is very broken */
 751
 752               samples=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
 753
 754               granulepos-=samples;
 755               for(i=0;i<link;i++)
 756                 granulepos+=vf->pcmlengths[i*2+1];
 757               vf->pcm_offset=granulepos;
 758             }
 759             return(1);
 760           }
 761         }
 762         else
 763           break;
 764       }
 765     }
 766
 767     if(vf->ready_state>=OPENED){
 768       ogg_int64_t ret;
 769
 770       while(1){
 771         /* the loop is not strictly necessary, but there's no sense in
 772            doing the extra checks of the larger loop for the common
 773            case in a multiplexed bistream where the page is simply
 774            part of a different logical bitstream; keep reading until
 775            we get one with the correct serialno */
 776
 777         if(!readp)return(0);
 778         if((ret=_get_next_page(vf,&og,-1))<0){
 779           return(OV_EOF); /* eof. leave unitialized */
 780         }
 781
 782         /* bitrate tracking; add the header's bytes here, the body bytes
 783            are done by packet above */
 784         vf->bittrack+=og.header_len*8;
 785
 786         if(vf->ready_state==INITSET){
 787           if(vf->current_serialno!=ogg_page_serialno(&og)){
 788
 789             /* two possibilities:
 790                1) our decoding just traversed a bitstream boundary
 791                2) another stream is multiplexed into this logical section */
 792
 793             if(ogg_page_bos(&og)){
 794               /* boundary case */
 795               if(!spanp)
 796                 return(OV_EOF);
 797
 798               _decode_clear(vf);
 799
 800               if(!vf->seekable){
 801                 vorbis_info_clear(vf->vi);
 802                 vorbis_comment_clear(vf->vc);
 803               }
 804               break;
 805
 806             }else
 807               continue; /* possibility #2 */
 808           }
 809         }
 810
 811         break;
 812       }
 813     }
 814
 815     /* Do we need to load a new machine before submitting the page? */
 816     /* This is different in the seekable and non-seekable cases.
 817
 818        In the seekable case, we already have all the header
 819        information loaded and cached; we just initialize the machine
 820        with it and continue on our merry way.
 821
 822        In the non-seekable (streaming) case, we'll only be at a
 823        boundary if we just left the previous logical bitstream and
 824        we're now nominally at the header of the next bitstream
 825     */
 826
 827     if(vf->ready_state!=INITSET){
 828       int link;
 829
 830       if(vf->ready_state<STREAMSET){
 831         if(vf->seekable){
 832           long serialno = ogg_page_serialno(&og);
 833
 834           /* match the serialno to bitstream section.  We use this rather than
 835              offset positions to avoid problems near logical bitstream
 836              boundaries */
 837
 838           for(link=0;link<vf->links;link++)
 839             if(vf->serialnos[link]==serialno)break;
 840
 841           if(link==vf->links) continue; /* not the desired Vorbis
 842                                            bitstream section; keep
 843                                            trying */
 844
 845           vf->current_serialno=serialno;
 846           vf->current_link=link;
 847
 848           ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
 849           vf->ready_state=STREAMSET;
 850
 851         }else{
 852           /* we're streaming */
 853           /* fetch the three header packets, build the info struct */
 854
 855           int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);
 856           if(ret)return(ret);
 857           vf->current_serialno=vf->os.serialno;
 858           vf->current_link++;
 859           link=0;
 860         }
 861       }
 862     }
 863
 864     /* the buffered page is the data we want, and we're ready for it;
 865        add it to the stream state */
 866     ogg_stream_pagein(&vf->os,&og);
 867
 868   }
 869 }
 870
 871 /* if, eg, 64 bit stdio is configured by default, this will build with
 872    fseek64 */
 873 static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
 874   if(f==NULL)return(-1);
 875   return fseek(f,off,whence);
 876 }
 877
 878 static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial,
 879                      long ibytes, ov_callbacks callbacks){
 880   int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);
 881   long *serialno_list=NULL;
 882   int serialno_list_size=0;
 883   int ret;
 884
 885   memset(vf,0,sizeof(*vf));
 886   vf->datasource=f;
 887   vf->callbacks = callbacks;
 888
 889   /* init the framing state */
 890   ogg_sync_init(&vf->oy);
 891
 892   /* perhaps some data was previously read into a buffer for testing
 893      against other stream types.  Allow initialization from this
 894      previously read data (especially as we may be reading from a
 895      non-seekable stream) */
 896   if(initial){
 897     char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
 898     memcpy(buffer,initial,ibytes);
 899     ogg_sync_wrote(&vf->oy,ibytes);
 900   }
 901
 902   /* can we seek? Stevens suggests the seek test was portable */
 903   if(offsettest!=-1)vf->seekable=1;
 904
 905   /* No seeking yet; Set up a 'single' (current) logical bitstream
 906      entry for partial open */
 907   vf->links=1;
 908   vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
 909   vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
 910   ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
 911
 912   /* Fetch all BOS pages, store the vorbis header and all seen serial
 913      numbers, load subsequent vorbis setup headers */
 914   if((ret=_fetch_headers(vf,vf->vi,vf->vc,&serialno_list,&serialno_list_size,NULL))<0){
 915     vf->datasource=NULL;
 916     ov_clear(vf);
 917   }else{
 918     /* serial number list for first link needs to be held somewhere
 919        for second stage of seekable stream open; this saves having to
 920        seek/reread first link's serialnumber data then. */
 921     vf->serialnos=_ogg_calloc(serialno_list_size+2,sizeof(*vf->serialnos));
 922     vf->serialnos[0]=vf->current_serialno=vf->os.serialno;
 923     vf->serialnos[1]=serialno_list_size;
 924     memcpy(vf->serialnos+2,serialno_list,serialno_list_size*sizeof(*vf->serialnos));
 925
 926     vf->offsets=_ogg_calloc(1,sizeof(*vf->offsets));
 927     vf->dataoffsets=_ogg_calloc(1,sizeof(*vf->dataoffsets));
 928     vf->offsets[0]=0;
 929     vf->dataoffsets[0]=vf->offset;
 930
 931     vf->ready_state=PARTOPEN;
 932   }
 933   if(serialno_list)_ogg_free(serialno_list);
 934   return(ret);
 935 }
 936
 937 static int _ov_open2(OggVorbis_File *vf){
 938   if(vf->ready_state != PARTOPEN) return OV_EINVAL;
 939   vf->ready_state=OPENED;
 940   if(vf->seekable){
 941     int ret=_open_seekable2(vf);
 942     if(ret){
 943       vf->datasource=NULL;
 944       ov_clear(vf);
 945     }
 946     return(ret);
 947   }else
 948     vf->ready_state=STREAMSET;
 949
 950   return 0;
 951 }
 952
 953
 954 /* clear out the OggVorbis_File struct */
 955 int ov_clear(OggVorbis_File *vf){
 956   if(vf){
 957     vorbis_block_clear(&vf->vb);
 958     vorbis_dsp_clear(&vf->vd);
 959     ogg_stream_clear(&vf->os);
 960
 961     if(vf->vi && vf->links){
 962       int i;
 963       for(i=0;i<vf->links;i++){
 964         vorbis_info_clear(vf->vi+i);
 965         vorbis_comment_clear(vf->vc+i);
 966       }
 967       _ogg_free(vf->vi);
 968       _ogg_free(vf->vc);
 969     }
 970     if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
 971     if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
 972     if(vf->serialnos)_ogg_free(vf->serialnos);
 973     if(vf->offsets)_ogg_free(vf->offsets);
 974     ogg_sync_clear(&vf->oy);
 975     if(vf->datasource && vf->callbacks.close_func)
 976       (vf->callbacks.close_func)(vf->datasource);
 977     memset(vf,0,sizeof(*vf));
 978   }
 979 #ifdef DEBUG_LEAKS
 980   _VDBG_dump();
 981 #endif
 982   return(0);
 983 }
 984
 985 /* inspects the OggVorbis file and finds/documents all the logical
 986    bitstreams contained in it.  Tries to be tolerant of logical
 987    bitstream sections that are truncated/woogie.
 988
 989    return: -1) error
 990             0) OK
 991 */
 992
 993 int ov_open_callbacks(void *f,OggVorbis_File *vf,
 994     const char *initial,long ibytes,ov_callbacks callbacks){
 995   int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
 996   if(ret)return ret;
 997   return _ov_open2(vf);
 998 }
 999
1000 int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
1001   ov_callbacks callbacks = {
1002     (size_t (*)(void *, size_t, size_t, void *))  fread,
1003     (int (*)(void *, ogg_int64_t, int))              _fseek64_wrap,
1004     (int (*)(void *))                             fclose,
1005     (long (*)(void *))                            ftell
1006   };
1007
1008   return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
1009 }
1010
1011 int ov_fopen(const char *path,OggVorbis_File *vf){
1012   int ret;
1013   FILE *f = fopen(path,"rb");
1014   if(!f) return -1;
1015
1016   ret = ov_open(f,vf,NULL,0);
1017   if(ret) fclose(f);
1018   return ret;
1019 }
1020
1021
1022 /* cheap hack for game usage where downsampling is desirable; there's
1023    no need for SRC as we can just do it cheaply in libvorbis. */
1024
1025 int ov_halfrate(OggVorbis_File *vf,int flag){
1026   int i;
1027   if(vf->vi==NULL)return OV_EINVAL;
1028   if(vf->ready_state>STREAMSET){
1029     /* clear out stream state; dumping the decode machine is needed to
1030        reinit the MDCT lookups. */
1031     vorbis_dsp_clear(&vf->vd);
1032     vorbis_block_clear(&vf->vb);
1033     vf->ready_state=STREAMSET;
1034     if(vf->pcm_offset>=0){
1035       ogg_int64_t pos=vf->pcm_offset;
1036       vf->pcm_offset=-1; /* make sure the pos is dumped if unseekable */
1037       ov_pcm_seek(vf,pos);
1038     }
1039   }
1040
1041   for(i=0;i<vf->links;i++){
1042     if(vorbis_synthesis_halfrate(vf->vi+i,flag)){
1043       if(flag) ov_halfrate(vf,0);
1044       return OV_EINVAL;
1045     }
1046   }
1047   return 0;
1048 }
1049
1050 int ov_halfrate_p(OggVorbis_File *vf){
1051   if(vf->vi==NULL)return OV_EINVAL;
1052   return vorbis_synthesis_halfrate_p(vf->vi);
1053 }
1054
1055 /* Only partially open the vorbis file; test for Vorbisness, and load
1056    the headers for the first chain.  Do not seek (although test for
1057    seekability).  Use ov_test_open to finish opening the file, else
1058    ov_clear to close/free it. Same return codes as open.
1059
1060    Note that vorbisfile does _not_ take ownership of the file if the
1061    call fails; the calling applicaiton is responsible for closing the file
1062    if this call returns an error. */
1063
1064 int ov_test_callbacks(void *f,OggVorbis_File *vf,
1065     const char *initial,long ibytes,ov_callbacks callbacks)
1066 {
1067   return _ov_open1(f,vf,initial,ibytes,callbacks);
1068 }
1069
1070 int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
1071   ov_callbacks callbacks = {
1072     (size_t (*)(void *, size_t, size_t, void *))  fread,
1073     (int (*)(void *, ogg_int64_t, int))              _fseek64_wrap,
1074     (int (*)(void *))                             fclose,
1075     (long (*)(void *))                            ftell
1076   };
1077
1078   return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
1079 }
1080
1081 int ov_test_open(OggVorbis_File *vf){
1082   if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
1083   return _ov_open2(vf);
1084 }
1085
1086 /* How many logical bitstreams in this physical bitstream? */
1087 long ov_streams(OggVorbis_File *vf){
1088   return vf->links;
1089 }
1090
1091 /* Is the FILE * associated with vf seekable? */
1092 long ov_seekable(OggVorbis_File *vf){
1093   return vf->seekable;
1094 }
1095
1096 /* returns the bitrate for a given logical bitstream or the entire
1097    physical bitstream.  If the file is open for random access, it will
1098    find the *actual* average bitrate.  If the file is streaming, it
1099    returns the nominal bitrate (if set) else the average of the
1100    upper/lower bounds (if set) else -1 (unset).
1101
1102    If you want the actual bitrate field settings, get them from the
1103    vorbis_info structs */
1104
1105 long ov_bitrate(OggVorbis_File *vf,int i){
1106   if(vf->ready_state<OPENED)return(OV_EINVAL);
1107   if(i>=vf->links)return(OV_EINVAL);
1108   if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
1109   if(i<0){
1110     ogg_int64_t bits=0;
1111     int i;
1112     float br;
1113     for(i=0;i<vf->links;i++)
1114       bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
1115     /* This once read: return(rint(bits/ov_time_total(vf,-1)));
1116      * gcc 3.x on x86 miscompiled this at optimisation level 2 and above,
1117      * so this is slightly transformed to make it work.
1118      */
1119     br = bits/ov_time_total(vf,-1);
1120     return(rint(br));
1121   }else{
1122     if(vf->seekable){
1123       /* return the actual bitrate */
1124       return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
1125     }else{
1126       /* return nominal if set */
1127       if(vf->vi[i].bitrate_nominal>0){
1128         return vf->vi[i].bitrate_nominal;
1129       }else{
1130         if(vf->vi[i].bitrate_upper>0){
1131           if(vf->vi[i].bitrate_lower>0){
1132             return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
1133           }else{
1134             return vf->vi[i].bitrate_upper;
1135           }
1136         }
1137         return(OV_FALSE);
1138       }
1139     }
1140   }
1141 }
1142
1143 /* returns the actual bitrate since last call.  returns -1 if no
1144    additional data to offer since last call (or at beginning of stream),
1145    EINVAL if stream is only partially open
1146 */
1147 long ov_bitrate_instant(OggVorbis_File *vf){
1148   int link=(vf->seekable?vf->current_link:0);
1149   long ret;
1150   if(vf->ready_state<OPENED)return(OV_EINVAL);
1151   if(vf->samptrack==0)return(OV_FALSE);
1152   ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
1153   vf->bittrack=0.f;
1154   vf->samptrack=0.f;
1155   return(ret);
1156 }
1157
1158 /* Guess */
1159 long ov_serialnumber(OggVorbis_File *vf,int i){
1160   if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
1161   if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
1162   if(i<0){
1163     return(vf->current_serialno);
1164   }else{
1165     return(vf->serialnos[i]);
1166   }
1167 }
1168
1169 /* returns: total raw (compressed) length of content if i==-1
1170             raw (compressed) length of that logical bitstream for i==0 to n
1171             OV_EINVAL if the stream is not seekable (we can't know the length)
1172             or if stream is only partially open
1173 */
1174 ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
1175   if(vf->ready_state<OPENED)return(OV_EINVAL);
1176   if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1177   if(i<0){
1178     ogg_int64_t acc=0;
1179     int i;
1180     for(i=0;i<vf->links;i++)
1181       acc+=ov_raw_total(vf,i);
1182     return(acc);
1183   }else{
1184     return(vf->offsets[i+1]-vf->offsets[i]);
1185   }
1186 }
1187
1188 /* returns: total PCM length (samples) of content if i==-1 PCM length
1189             (samples) of that logical bitstream for i==0 to n
1190             OV_EINVAL if the stream is not seekable (we can't know the
1191             length) or only partially open
1192 */
1193 ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
1194   if(vf->ready_state<OPENED)return(OV_EINVAL);
1195   if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1196   if(i<0){
1197     ogg_int64_t acc=0;
1198     int i;
1199     for(i=0;i<vf->links;i++)
1200       acc+=ov_pcm_total(vf,i);
1201     return(acc);
1202   }else{
1203     return(vf->pcmlengths[i*2+1]);
1204   }
1205 }
1206
1207 /* returns: total seconds of content if i==-1
1208             seconds in that logical bitstream for i==0 to n
1209             OV_EINVAL if the stream is not seekable (we can't know the
1210             length) or only partially open
1211 */
1212 double ov_time_total(OggVorbis_File *vf,int i){
1213   if(vf->ready_state<OPENED)return(OV_EINVAL);
1214   if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1215   if(i<0){
1216     double acc=0;
1217     int i;
1218     for(i=0;i<vf->links;i++)
1219       acc+=ov_time_total(vf,i);
1220     return(acc);
1221   }else{
1222     return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
1223   }
1224 }
1225
1226 /* seek to an offset relative to the *compressed* data. This also
1227    scans packets to update the PCM cursor. It will cross a logical
1228    bitstream boundary, but only if it can't get any packets out of the
1229    tail of the bitstream we seek to (so no surprises).
1230
1231    returns zero on success, nonzero on failure */
1232
1233 int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
1234   ogg_stream_state work_os;
1235   int ret;
1236
1237   if(vf->ready_state<OPENED)return(OV_EINVAL);
1238   if(!vf->seekable)
1239     return(OV_ENOSEEK); /* don't dump machine if we can't seek */
1240
1241   if(pos<0 || pos>vf->end)return(OV_EINVAL);
1242
1243   /* is the seek position outside our current link [if any]? */
1244   if(vf->ready_state>=STREAMSET){
1245     if(pos<vf->offsets[vf->current_link] || pos>=vf->offsets[vf->current_link+1])
1246       _decode_clear(vf); /* clear out stream state */
1247   }
1248
1249   /* don't yet clear out decoding machine (if it's initialized), in
1250      the case we're in the same link.  Restart the decode lapping, and
1251      let _fetch_and_process_packet deal with a potential bitstream
1252      boundary */
1253   vf->pcm_offset=-1;
1254   ogg_stream_reset_serialno(&vf->os,
1255                             vf->current_serialno); /* must set serialno */
1256   vorbis_synthesis_restart(&vf->vd);
1257
1258   ret=_seek_helper(vf,pos);
1259   if(ret)goto seek_error;
1260
1261   /* we need to make sure the pcm_offset is set, but we don't want to
1262      advance the raw cursor past good packets just to get to the first
1263      with a granulepos.  That's not equivalent behavior to beginning
1264      decoding as immediately after the seek position as possible.
1265
1266      So, a hack.  We use two stream states; a local scratch state and
1267      the shared vf->os stream state.  We use the local state to
1268      scan, and the shared state as a buffer for later decode.
1269
1270      Unfortuantely, on the last page we still advance to last packet
1271      because the granulepos on the last page is not necessarily on a
1272      packet boundary, and we need to make sure the granpos is
1273      correct.
1274   */
1275
1276   {
1277     ogg_page og;
1278     ogg_packet op;
1279     int lastblock=0;
1280     int accblock=0;
1281     int thisblock=0;
1282     int lastflag=0;
1283     int firstflag=0;
1284     ogg_int64_t pagepos=-1;
1285
1286     ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
1287     ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
1288                                    return from not necessarily
1289                                    starting from the beginning */
1290
1291     while(1){
1292       if(vf->ready_state>=STREAMSET){
1293         /* snarf/scan a packet if we can */
1294         int result=ogg_stream_packetout(&work_os,&op);
1295
1296         if(result>0){
1297
1298           if(vf->vi[vf->current_link].codec_setup){
1299             thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1300             if(thisblock<0){
1301               ogg_stream_packetout(&vf->os,NULL);
1302               thisblock=0;
1303             }else{
1304
1305               /* We can't get a guaranteed correct pcm position out of the
1306                  last page in a stream because it might have a 'short'
1307                  granpos, which can only be detected in the presence of a
1308                  preceding page.  However, if the last page is also the first
1309                  page, the granpos rules of a first page take precedence.  Not
1310                  only that, but for first==last, the EOS page must be treated
1311                  as if its a normal first page for the stream to open/play. */
1312               if(lastflag && !firstflag)
1313                 ogg_stream_packetout(&vf->os,NULL);
1314               else
1315                 if(lastblock)accblock+=(lastblock+thisblock)>>2;
1316             }
1317
1318             if(op.granulepos!=-1){
1319               int i,link=vf->current_link;
1320               ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
1321               if(granulepos<0)granulepos=0;
1322
1323               for(i=0;i<link;i++)
1324                 granulepos+=vf->pcmlengths[i*2+1];
1325               vf->pcm_offset=granulepos-accblock;
1326               if(vf->pcm_offset<0)vf->pcm_offset=0;
1327               break;
1328             }
1329             lastblock=thisblock;
1330             continue;
1331           }else
1332             ogg_stream_packetout(&vf->os,NULL);
1333         }
1334       }
1335
1336       if(!lastblock){
1337         pagepos=_get_next_page(vf,&og,-1);
1338         if(pagepos<0){
1339           vf->pcm_offset=ov_pcm_total(vf,-1);
1340           break;
1341         }
1342       }else{
1343         /* huh?  Bogus stream with packets but no granulepos */
1344         vf->pcm_offset=-1;
1345         break;
1346       }
1347
1348       /* has our decoding just traversed a bitstream boundary? */
1349       if(vf->ready_state>=STREAMSET){
1350         if(vf->current_serialno!=ogg_page_serialno(&og)){
1351
1352           /* two possibilities:
1353              1) our decoding just traversed a bitstream boundary
1354              2) another stream is multiplexed into this logical section? */
1355
1356           if(ogg_page_bos(&og)){
1357             /* we traversed */
1358             _decode_clear(vf); /* clear out stream state */
1359             ogg_stream_clear(&work_os);
1360           } /* else, do nothing; next loop will scoop another page */
1361         }
1362       }
1363
1364       if(vf->ready_state<STREAMSET){
1365         int link;
1366         long serialno = ogg_page_serialno(&og);
1367
1368         for(link=0;link<vf->links;link++)
1369           if(vf->serialnos[link]==serialno)break;
1370
1371         if(link==vf->links) continue; /* not the desired Vorbis
1372                                          bitstream section; keep
1373                                          trying */
1374         vf->current_link=link;
1375         vf->current_serialno=serialno;
1376         ogg_stream_reset_serialno(&vf->os,serialno);
1377         ogg_stream_reset_serialno(&work_os,serialno);
1378         vf->ready_state=STREAMSET;
1379         firstflag=(pagepos<=vf->dataoffsets[link]);
1380       }
1381
1382       ogg_stream_pagein(&vf->os,&og);
1383       ogg_stream_pagein(&work_os,&og);
1384       lastflag=ogg_page_eos(&og);
1385
1386     }
1387   }
1388
1389   ogg_stream_clear(&work_os);
1390   vf->bittrack=0.f;
1391   vf->samptrack=0.f;
1392   return(0);
1393
1394  seek_error:
1395   /* dump the machine so we're in a known state */
1396   vf->pcm_offset=-1;
1397   ogg_stream_clear(&work_os);
1398   _decode_clear(vf);
1399   return OV_EBADLINK;
1400 }
1401
1402 /* Page granularity seek (faster than sample granularity because we
1403    don't do the last bit of decode to find a specific sample).
1404
1405    Seek to the last [granule marked] page preceding the specified pos
1406    location, such that decoding past the returned point will quickly
1407    arrive at the requested position. */
1408 int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
1409   int link=-1;
1410   ogg_int64_t result=0;
1411   ogg_int64_t total=ov_pcm_total(vf,-1);
1412
1413   if(vf->ready_state<OPENED)return(OV_EINVAL);
1414   if(!vf->seekable)return(OV_ENOSEEK);
1415
1416   if(pos<0 || pos>total)return(OV_EINVAL);
1417
1418   /* which bitstream section does this pcm offset occur in? */
1419   for(link=vf->links-1;link>=0;link--){
1420     total-=vf->pcmlengths[link*2+1];
1421     if(pos>=total)break;
1422   }
1423
1424   /* Search within the logical bitstream for the page with the highest
1425      pcm_pos preceding pos.  If we're looking for a position on the
1426      first page, bisection will halt without finding our position as
1427      it's before the first explicit granulepos fencepost. That case is
1428      handled separately below.
1429
1430      There is a danger here; missing pages or incorrect frame number
1431      information in the bitstream could make our task impossible.
1432      Account for that (it would be an error condition) */
1433
1434   /* new search algorithm originally by HB (Nicholas Vinen) */
1435
1436   {
1437     ogg_int64_t end=vf->offsets[link+1];
1438     ogg_int64_t begin=vf->dataoffsets[link];
1439     ogg_int64_t begintime = vf->pcmlengths[link*2];
1440     ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
1441     ogg_int64_t target=pos-total+begintime;
1442     ogg_int64_t best=-1;
1443
1444     ogg_page og;
1445     /* bisection loop */
1446     while(begin<end){
1447       ogg_int64_t bisect;
1448
1449       if(end-begin<CHUNKSIZE){
1450         bisect=begin;
1451       }else{
1452         /* take a (pretty decent) guess. */
1453         bisect=begin +
1454           (ogg_int64_t)((double)(target-begintime)*(end-begin)/(endtime-begintime))
1455           - CHUNKSIZE;
1456         if(bisect<begin+CHUNKSIZE)
1457           bisect=begin;
1458       }
1459
1460       /* only seek if the file position isn't already there */
1461       if(bisect!=vf->offset){
1462         result=_seek_helper(vf,bisect);
1463         if(result) goto seek_error;
1464       }
1465
1466       /* read loop within the bisection loop */
1467       while(begin<end){
1468         result=_get_next_page(vf,&og,end-vf->offset);
1469         if(result==OV_EREAD) goto seek_error;
1470         if(result<0){
1471           /* there is no next page! */
1472           if(bisect<=begin+1)
1473               /* No bisection left to perform.  We've either found the
1474                  best candidate already or failed. Exit loop. */
1475             end=begin;
1476           else{
1477             /* We tried to load a fraction of the last page; back up a
1478                bit and try to get the whole last page */
1479             if(bisect==0) goto seek_error;
1480             bisect-=CHUNKSIZE;
1481
1482             /* don't repeat/loop on a read we've already performed */
1483             if(bisect<=begin)bisect=begin+1;
1484
1485             /* seek and cntinue bisection */
1486             result=_seek_helper(vf,bisect);
1487             if(result) goto seek_error;
1488           }
1489         }else{
1490           ogg_int64_t granulepos;
1491
1492           /* got a page. analyze it */
1493           /* only consider pages from primary vorbis stream */
1494           if(ogg_page_serialno(&og)!=vf->serialnos[link])
1495             continue;
1496
1497           /* only consider pages with the granulepos set */
1498           granulepos=ogg_page_granulepos(&og);
1499           if(granulepos==-1)continue;
1500
1501           if(granulepos<target){
1502             /* this page is a successful candidate! Set state */
1503
1504             best=result;  /* raw offset of packet with granulepos */
1505             begin=vf->offset; /* raw offset of next page */
1506             begintime=granulepos;
1507
1508             /* if we're before our target but within a short distance,
1509                don't bisect; read forward */
1510             if(target-begintime>44100)break;
1511
1512             bisect=begin; /* *not* begin + 1 as above */
1513           }else{
1514
1515             /* This is one of our pages, but the granpos is
1516                post-target; it is not a bisection return
1517                candidate. (The only way we'd use it is if it's the
1518                first page in the stream; we handle that case later
1519                outside the bisection) */
1520             if(bisect<=begin+1){
1521               /* No bisection left to perform.  We've either found the
1522                  best candidate already or failed. Exit loop. */
1523               end=begin;
1524             }else{
1525               if(end==vf->offset){
1526                 /* bisection read to the end; use the known page
1527                    boundary (result) to update bisection, back up a
1528                    little bit, and try again */
1529                 end=result;
1530                 bisect-=CHUNKSIZE;
1531                 if(bisect<=begin)bisect=begin+1;
1532                 result=_seek_helper(vf,bisect);
1533                 if(result) goto seek_error;
1534               }else{
1535                 /* Normal bisection */
1536                 end=bisect;
1537                 endtime=granulepos;
1538                 break;
1539               }
1540             }
1541           }
1542         }
1543       }
1544     }
1545
1546     /* Out of bisection: did it 'fail?' */
1547     if(best == -1){
1548
1549       /* Check the 'looking for data in first page' special case;
1550          bisection would 'fail' because our search target was before the
1551          first PCM granule position fencepost. */
1552
1553       if(begin == vf->dataoffsets[link] &&
1554          ogg_page_serialno(&og)==vf->serialnos[link]){
1555
1556         /* Yes, this is the beginning-of-stream case. We already have
1557            our page, right at the beginning of PCM data.  Set state
1558            and return. */
1559
1560         vf->offset=result;
1561         vf->pcm_offset=total;
1562
1563         if(link!=vf->current_link){
1564           /* Different link; dump entire decode machine */
1565           _decode_clear(vf);
1566
1567           vf->current_link=link;
1568           vf->current_serialno=vf->serialnos[link];
1569           vf->ready_state=STREAMSET;
1570
1571         }else{
1572           vorbis_synthesis_restart(&vf->vd);
1573         }
1574
1575         ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1576         ogg_stream_pagein(&vf->os,&og);
1577
1578       }else
1579         goto seek_error;
1580
1581     }else{
1582
1583       /* Bisection found our page. seek to it, update pcm offset. Easier case than
1584          raw_seek, don't keep packets preceding granulepos. */
1585
1586       ogg_page og;
1587       ogg_packet op;
1588
1589       /* seek */
1590       result=_seek_helper(vf,best);
1591       vf->pcm_offset=-1;
1592       if(result) goto seek_error;
1593       result=_get_next_page(vf,&og,-1);
1594       if(result<0) goto seek_error;
1595
1596       if(link!=vf->current_link){
1597         /* Different link; dump entire decode machine */
1598         _decode_clear(vf);
1599
1600         vf->current_link=link;
1601         vf->current_serialno=vf->serialnos[link];
1602         vf->ready_state=STREAMSET;
1603
1604       }else{
1605         vorbis_synthesis_restart(&vf->vd);
1606       }
1607
1608       ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1609       ogg_stream_pagein(&vf->os,&og);
1610
1611       /* pull out all but last packet; the one with granulepos */
1612       while(1){
1613         result=ogg_stream_packetpeek(&vf->os,&op);
1614         if(result==0){
1615           /* No packet returned; we exited the bisection with 'best'
1616              pointing to a page with a granule position, so the packet
1617              finishing this page ('best') originated on a preceding
1618              page. Keep fetching previous pages until we get one with
1619              a granulepos or without the 'continued' flag set.  Then
1620              just use raw_seek for simplicity. */
1621
1622           result=_seek_helper(vf,best);
1623           if(result<0) goto seek_error;
1624
1625           /* Do not rewind past the beginning of link data; if we do,
1626              it's either a bug or a broken stream */
1627           while(result>vf->dataoffsets[link]){
1628             result=_get_prev_page(vf,&og);
1629             if(result<0) goto seek_error;
1630             if(ogg_page_serialno(&og)==vf->current_serialno &&
1631                (ogg_page_granulepos(&og)>-1 ||
1632                 !ogg_page_continued(&og))){
1633               return ov_raw_seek(vf,result);
1634             }
1635             vf->offset=result;
1636           }
1637         }
1638         if(result<0){
1639           result = OV_EBADPACKET;
1640           goto seek_error;
1641         }
1642         if(op.granulepos!=-1){
1643           vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1644           if(vf->pcm_offset<0)vf->pcm_offset=0;
1645           vf->pcm_offset+=total;
1646           break;
1647         }else
1648           result=ogg_stream_packetout(&vf->os,NULL);
1649       }
1650     }
1651   }
1652
1653   /* verify result */
1654   if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
1655     result=OV_EFAULT;
1656     goto seek_error;
1657   }
1658   vf->bittrack=0.f;
1659   vf->samptrack=0.f;
1660   return(0);
1661
1662  seek_error:
1663   /* dump machine so we're in a known state */
1664   vf->pcm_offset=-1;
1665   _decode_clear(vf);
1666   return (int)result;
1667 }
1668
1669 /* seek to a sample offset relative to the decompressed pcm stream
1670    returns zero on success, nonzero on failure */
1671
1672 int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
1673   int thisblock,lastblock=0;
1674   int ret=ov_pcm_seek_page(vf,pos);
1675   if(ret<0)return(ret);
1676   if((ret=_make_decode_ready(vf)))return ret;
1677
1678   /* discard leading packets we don't need for the lapping of the
1679      position we want; don't decode them */
1680
1681   while(1){
1682     ogg_packet op;
1683     ogg_page og;
1684
1685     int ret=ogg_stream_packetpeek(&vf->os,&op);
1686     if(ret>0){
1687       thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1688       if(thisblock<0){
1689         ogg_stream_packetout(&vf->os,NULL);
1690         continue; /* non audio packet */
1691       }
1692       if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
1693
1694       if(vf->pcm_offset+((thisblock+
1695                           vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
1696
1697       /* remove the packet from packet queue and track its granulepos */
1698       ogg_stream_packetout(&vf->os,NULL);
1699       vorbis_synthesis_trackonly(&vf->vb,&op);  /* set up a vb with
1700                                                    only tracking, no
1701                                                    pcm_decode */
1702       vorbis_synthesis_blockin(&vf->vd,&vf->vb);
1703
1704       /* end of logical stream case is hard, especially with exact
1705          length positioning. */
1706
1707       if(op.granulepos>-1){
1708         int i;
1709         /* always believe the stream markers */
1710         vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1711         if(vf->pcm_offset<0)vf->pcm_offset=0;
1712         for(i=0;i<vf->current_link;i++)
1713           vf->pcm_offset+=vf->pcmlengths[i*2+1];
1714       }
1715
1716       lastblock=thisblock;
1717
1718     }else{
1719       if(ret<0 && ret!=OV_HOLE)break;
1720
1721       /* suck in a new page */
1722       if(_get_next_page(vf,&og,-1)<0)break;
1723       if(ogg_page_bos(&og))_decode_clear(vf);
1724
1725       if(vf->ready_state<STREAMSET){
1726         long serialno=ogg_page_serialno(&og);
1727         int link;
1728
1729         for(link=0;link<vf->links;link++)
1730           if(vf->serialnos[link]==serialno)break;
1731         if(link==vf->links) continue;
1732         vf->current_link=link;
1733
1734         vf->ready_state=STREAMSET;
1735         vf->current_serialno=ogg_page_serialno(&og);
1736         ogg_stream_reset_serialno(&vf->os,serialno);
1737         ret=_make_decode_ready(vf);
1738         if(ret)return ret;
1739         lastblock=0;
1740       }
1741
1742       ogg_stream_pagein(&vf->os,&og);
1743     }
1744   }
1745
1746   vf->bittrack=0.f;
1747   vf->samptrack=0.f;
1748   /* discard samples until we reach the desired position. Crossing a
1749      logical bitstream boundary with abandon is OK. */
1750   {
1751     /* note that halfrate could be set differently in each link, but
1752        vorbisfile encoforces all links are set or unset */
1753     int hs=vorbis_synthesis_halfrate_p(vf->vi);
1754     while(vf->pcm_offset<((pos>>hs)<<hs)){
1755       ogg_int64_t target=(pos-vf->pcm_offset)>>hs;
1756       long samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
1757
1758       if(samples>target)samples=target;
1759       vorbis_synthesis_read(&vf->vd,samples);
1760       vf->pcm_offset+=samples<<hs;
1761
1762       if(samples<target)
1763         if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
1764           vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
1765     }
1766   }
1767   return 0;
1768 }
1769
1770 /* seek to a playback time relative to the decompressed pcm stream
1771    returns zero on success, nonzero on failure */
1772 int ov_time_seek(OggVorbis_File *vf,double seconds){
1773   /* translate time to PCM position and call ov_pcm_seek */
1774
1775   int link=-1;
1776   ogg_int64_t pcm_total=0;
1777   double time_total=0.;
1778
1779   if(vf->ready_state<OPENED)return(OV_EINVAL);
1780   if(!vf->seekable)return(OV_ENOSEEK);
1781   if(seconds<0)return(OV_EINVAL);
1782
1783   /* which bitstream section does this time offset occur in? */
1784   for(link=0;link<vf->links;link++){
1785     double addsec = ov_time_total(vf,link);
1786     if(seconds<time_total+addsec)break;
1787     time_total+=addsec;
1788     pcm_total+=vf->pcmlengths[link*2+1];
1789   }
1790
1791   if(link==vf->links)return(OV_EINVAL);
1792
1793   /* enough information to convert time offset to pcm offset */
1794   {
1795     ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1796     return(ov_pcm_seek(vf,target));
1797   }
1798 }
1799
1800 /* page-granularity version of ov_time_seek
1801    returns zero on success, nonzero on failure */
1802 int ov_time_seek_page(OggVorbis_File *vf,double seconds){
1803   /* translate time to PCM position and call ov_pcm_seek */
1804
1805   int link=-1;
1806   ogg_int64_t pcm_total=0;
1807   double time_total=0.;
1808
1809   if(vf->ready_state<OPENED)return(OV_EINVAL);
1810   if(!vf->seekable)return(OV_ENOSEEK);
1811   if(seconds<0)return(OV_EINVAL);
1812
1813   /* which bitstream section does this time offset occur in? */
1814   for(link=0;link<vf->links;link++){
1815     double addsec = ov_time_total(vf,link);
1816     if(seconds<time_total+addsec)break;
1817     time_total+=addsec;
1818     pcm_total+=vf->pcmlengths[link*2+1];
1819   }
1820
1821   if(link==vf->links)return(OV_EINVAL);
1822
1823   /* enough information to convert time offset to pcm offset */
1824   {
1825     ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1826     return(ov_pcm_seek_page(vf,target));
1827   }
1828 }
1829
1830 /* tell the current stream offset cursor.  Note that seek followed by
1831    tell will likely not give the set offset due to caching */
1832 ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
1833   if(vf->ready_state<OPENED)return(OV_EINVAL);
1834   return(vf->offset);
1835 }
1836
1837 /* return PCM offset (sample) of next PCM sample to be read */
1838 ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
1839   if(vf->ready_state<OPENED)return(OV_EINVAL);
1840   return(vf->pcm_offset);
1841 }
1842
1843 /* return time offset (seconds) of next PCM sample to be read */
1844 double ov_time_tell(OggVorbis_File *vf){
1845   int link=0;
1846   ogg_int64_t pcm_total=0;
1847   double time_total=0.f;
1848
1849   if(vf->ready_state<OPENED)return(OV_EINVAL);
1850   if(vf->seekable){
1851     pcm_total=ov_pcm_total(vf,-1);
1852     time_total=ov_time_total(vf,-1);
1853
1854     /* which bitstream section does this time offset occur in? */
1855     for(link=vf->links-1;link>=0;link--){
1856       pcm_total-=vf->pcmlengths[link*2+1];
1857       time_total-=ov_time_total(vf,link);
1858       if(vf->pcm_offset>=pcm_total)break;
1859     }
1860   }
1861
1862   return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
1863 }
1864
1865 /*  link:   -1) return the vorbis_info struct for the bitstream section
1866                 currently being decoded
1867            0-n) to request information for a specific bitstream section
1868
1869     In the case of a non-seekable bitstream, any call returns the
1870     current bitstream.  NULL in the case that the machine is not
1871     initialized */
1872
1873 vorbis_info *ov_info(OggVorbis_File *vf,int link){
1874   if(vf->seekable){
1875     if(link<0)
1876       if(vf->ready_state>=STREAMSET)
1877         return vf->vi+vf->current_link;
1878       else
1879       return vf->vi;
1880     else
1881       if(link>=vf->links)
1882         return NULL;
1883       else
1884         return vf->vi+link;
1885   }else{
1886     return vf->vi;
1887   }
1888 }
1889
1890 /* grr, strong typing, grr, no templates/inheritence, grr */
1891 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
1892   if(vf->seekable){
1893     if(link<0)
1894       if(vf->ready_state>=STREAMSET)
1895         return vf->vc+vf->current_link;
1896       else
1897         return vf->vc;
1898     else
1899       if(link>=vf->links)
1900         return NULL;
1901       else
1902         return vf->vc+link;
1903   }else{
1904     return vf->vc;
1905   }
1906 }
1907
1908 static int host_is_big_endian() {
1909   ogg_int32_t pattern = 0xfeedface; /* deadbeef */
1910   unsigned char *bytewise = (unsigned char *)&pattern;
1911   if (bytewise[0] == 0xfe) return 1;
1912   return 0;
1913 }
1914
1915 /* up to this point, everything could more or less hide the multiple
1916    logical bitstream nature of chaining from the toplevel application
1917    if the toplevel application didn't particularly care.  However, at
1918    the point that we actually read audio back, the multiple-section
1919    nature must surface: Multiple bitstream sections do not necessarily
1920    have to have the same number of channels or sampling rate.
1921
1922    ov_read returns the sequential logical bitstream number currently
1923    being decoded along with the PCM data in order that the toplevel
1924    application can take action on channel/sample rate changes.  This
1925    number will be incremented even for streamed (non-seekable) streams
1926    (for seekable streams, it represents the actual logical bitstream
1927    index within the physical bitstream.  Note that the accessor
1928    functions above are aware of this dichotomy).
1929
1930    ov_read_filter is exactly the same as ov_read except that it processes
1931    the decoded audio data through a filter before packing it into the
1932    requested format. This gives greater accuracy than applying a filter
1933    after the audio has been converted into integral PCM.
1934
1935    input values: buffer) a buffer to hold packed PCM data for return
1936                  length) the byte length requested to be placed into buffer
1937                  bigendianp) should the data be packed LSB first (0) or
1938                              MSB first (1)
1939                  word) word size for output.  currently 1 (byte) or
1940                        2 (16 bit short)
1941
1942    return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1943                    0) EOF
1944                    n) number of bytes of PCM actually returned.  The
1945                    below works on a packet-by-packet basis, so the
1946                    return length is not related to the 'length' passed
1947                    in, just guaranteed to fit.
1948
1949             *section) set to the logical bitstream number */
1950
1951 long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
1952                     int bigendianp,int word,int sgned,int *bitstream,
1953                     void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param){
1954   int i,j;
1955   int host_endian = host_is_big_endian();
1956   int hs;
1957
1958   float **pcm;
1959   long samples;
1960
1961   if(vf->ready_state<OPENED)return(OV_EINVAL);
1962
1963   while(1){
1964     if(vf->ready_state==INITSET){
1965       samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1966       if(samples)break;
1967     }
1968
1969     /* suck in another packet */
1970     {
1971       int ret=_fetch_and_process_packet(vf,NULL,1,1);
1972       if(ret==OV_EOF)
1973         return(0);
1974       if(ret<=0)
1975         return(ret);
1976     }
1977
1978   }
1979
1980   if(samples>0){
1981
1982     /* yay! proceed to pack data into the byte buffer */
1983
1984     long channels=ov_info(vf,-1)->channels;
1985     long bytespersample=word * channels;
1986     vorbis_fpu_control fpu;
1987     if(samples>length/bytespersample)samples=length/bytespersample;
1988
1989     if(samples <= 0)
1990       return OV_EINVAL;
1991
1992     /* Here. */
1993     if(filter)
1994       filter(pcm,channels,samples,filter_param);
1995
1996     /* a tight loop to pack each size */
1997     {
1998       int val;
1999       if(word==1){
2000         int off=(sgned?0:128);
2001         vorbis_fpu_setround(&fpu);
2002         for(j=0;j<samples;j++)
2003           for(i=0;i<channels;i++){
2004             val=vorbis_ftoi(pcm[i][j]*128.f);
2005             if(val>127)val=127;
2006             else if(val<-128)val=-128;
2007             *buffer++=val+off;
2008           }
2009         vorbis_fpu_restore(fpu);
2010       }else{
2011         int off=(sgned?0:32768);
2012
2013         if(host_endian==bigendianp){
2014           if(sgned){
2015
2016             vorbis_fpu_setround(&fpu);
2017             for(i=0;i<channels;i++) { /* It's faster in this order */
2018               float *src=pcm[i];
2019               short *dest=((short *)buffer)+i;
2020               for(j=0;j<samples;j++) {
2021                 val=vorbis_ftoi(src[j]*32768.f);
2022                 if(val>32767)val=32767;
2023                 else if(val<-32768)val=-32768;
2024                 *dest=val;
2025                 dest+=channels;
2026               }
2027             }
2028             vorbis_fpu_restore(fpu);
2029
2030           }else{
2031
2032             vorbis_fpu_setround(&fpu);
2033             for(i=0;i<channels;i++) {
2034               float *src=pcm[i];
2035               short *dest=((short *)buffer)+i;
2036               for(j=0;j<samples;j++) {
2037                 val=vorbis_ftoi(src[j]*32768.f);
2038                 if(val>32767)val=32767;
2039                 else if(val<-32768)val=-32768;
2040                 *dest=val+off;
2041                 dest+=channels;
2042               }
2043             }
2044             vorbis_fpu_restore(fpu);
2045
2046           }
2047         }else if(bigendianp){
2048
2049           vorbis_fpu_setround(&fpu);
2050           for(j=0;j<samples;j++)
2051             for(i=0;i<channels;i++){
2052               val=vorbis_ftoi(pcm[i][j]*32768.f);
2053               if(val>32767)val=32767;
2054               else if(val<-32768)val=-32768;
2055               val+=off;
2056               *buffer++=(val>>8);
2057               *buffer++=(val&0xff);
2058             }
2059           vorbis_fpu_restore(fpu);
2060
2061         }else{
2062           int val;
2063           vorbis_fpu_setround(&fpu);
2064           for(j=0;j<samples;j++)
2065             for(i=0;i<channels;i++){
2066               val=vorbis_ftoi(pcm[i][j]*32768.f);
2067               if(val>32767)val=32767;
2068               else if(val<-32768)val=-32768;
2069               val+=off;
2070               *buffer++=(val&0xff);
2071               *buffer++=(val>>8);
2072                   }
2073           vorbis_fpu_restore(fpu);
2074
2075         }
2076       }
2077     }
2078
2079     vorbis_synthesis_read(&vf->vd,samples);
2080     hs=vorbis_synthesis_halfrate_p(vf->vi);
2081     vf->pcm_offset+=(samples<<hs);
2082     if(bitstream)*bitstream=vf->current_link;
2083     return(samples*bytespersample);
2084   }else{
2085     return(samples);
2086   }
2087 }
2088
2089 long ov_read(OggVorbis_File *vf,char *buffer,int length,
2090              int bigendianp,int word,int sgned,int *bitstream){
2091   return ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, NULL, NULL);
2092 }
2093
2094 /* input values: pcm_channels) a float vector per channel of output
2095                  length) the sample length being read by the app
2096
2097    return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
2098                    0) EOF
2099                    n) number of samples of PCM actually returned.  The
2100                    below works on a packet-by-packet basis, so the
2101                    return length is not related to the 'length' passed
2102                    in, just guaranteed to fit.
2103
2104             *section) set to the logical bitstream number */
2105
2106
2107
2108 long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
2109                    int *bitstream){
2110
2111   if(vf->ready_state<OPENED)return(OV_EINVAL);
2112
2113   while(1){
2114     if(vf->ready_state==INITSET){
2115       float **pcm;
2116       long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
2117       if(samples){
2118         int hs=vorbis_synthesis_halfrate_p(vf->vi);
2119         if(pcm_channels)*pcm_channels=pcm;
2120         if(samples>length)samples=length;
2121         vorbis_synthesis_read(&vf->vd,samples);
2122         vf->pcm_offset+=samples<<hs;
2123         if(bitstream)*bitstream=vf->current_link;
2124         return samples;
2125
2126       }
2127     }
2128
2129     /* suck in another packet */
2130     {
2131       int ret=_fetch_and_process_packet(vf,NULL,1,1);
2132       if(ret==OV_EOF)return(0);
2133       if(ret<=0)return(ret);
2134     }
2135
2136   }
2137 }
2138
2139 extern const float *vorbis_window(vorbis_dsp_state *v,int W);
2140
2141 static void _ov_splice(float **pcm,float **lappcm,
2142                        int n1, int n2,
2143                        int ch1, int ch2,
2144                        const float *w1, const float *w2){
2145   int i,j;
2146   const float *w=w1;
2147   int n=n1;
2148
2149   if(n1>n2){
2150     n=n2;
2151     w=w2;
2152   }
2153
2154   /* splice */
2155   for(j=0;j<ch1 && j<ch2;j++){
2156     float *s=lappcm[j];
2157     float *d=pcm[j];
2158
2159     for(i=0;i<n;i++){
2160       float wd=w[i]*w[i];
2161       float ws=1.-wd;
2162       d[i]=d[i]*wd + s[i]*ws;
2163     }
2164   }
2165   /* window from zero */
2166   for(;j<ch2;j++){
2167     float *d=pcm[j];
2168     for(i=0;i<n;i++){
2169       float wd=w[i]*w[i];
2170       d[i]=d[i]*wd;
2171     }
2172   }
2173
2174 }
2175
2176 /* make sure vf is INITSET */
2177 static int _ov_initset(OggVorbis_File *vf){
2178   while(1){
2179     if(vf->ready_state==INITSET)break;
2180     /* suck in another packet */
2181     {
2182       int ret=_fetch_and_process_packet(vf,NULL,1,0);
2183       if(ret<0 && ret!=OV_HOLE)return(ret);
2184     }
2185   }
2186   return 0;
2187 }
2188
2189 /* make sure vf is INITSET and that we have a primed buffer; if
2190    we're crosslapping at a stream section boundary, this also makes
2191    sure we're sanity checking against the right stream information */
2192 static int _ov_initprime(OggVorbis_File *vf){
2193   vorbis_dsp_state *vd=&vf->vd;
2194   while(1){
2195     if(vf->ready_state==INITSET)
2196       if(vorbis_synthesis_pcmout(vd,NULL))break;
2197
2198     /* suck in another packet */
2199     {
2200       int ret=_fetch_and_process_packet(vf,NULL,1,0);
2201       if(ret<0 && ret!=OV_HOLE)return(ret);
2202     }
2203   }
2204   return 0;
2205 }
2206
2207 /* grab enough data for lapping from vf; this may be in the form of
2208    unreturned, already-decoded pcm, remaining PCM we will need to
2209    decode, or synthetic postextrapolation from last packets. */
2210 static void _ov_getlap(OggVorbis_File *vf,vorbis_info *vi,vorbis_dsp_state *vd,
2211                        float **lappcm,int lapsize){
2212   int lapcount=0,i;
2213   float **pcm;
2214
2215   /* try first to decode the lapping data */
2216   while(lapcount<lapsize){
2217     int samples=vorbis_synthesis_pcmout(vd,&pcm);
2218     if(samples){
2219       if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2220       for(i=0;i<vi->channels;i++)
2221         memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2222       lapcount+=samples;
2223       vorbis_synthesis_read(vd,samples);
2224     }else{
2225     /* suck in another packet */
2226       int ret=_fetch_and_process_packet(vf,NULL,1,0); /* do *not* span */
2227       if(ret==OV_EOF)break;
2228     }
2229   }
2230   if(lapcount<lapsize){
2231     /* failed to get lapping data from normal decode; pry it from the
2232        postextrapolation buffering, or the second half of the MDCT
2233        from the last packet */
2234     int samples=vorbis_synthesis_lapout(&vf->vd,&pcm);
2235     if(samples==0){
2236       for(i=0;i<vi->channels;i++)
2237         memset(lappcm[i]+lapcount,0,sizeof(**pcm)*lapsize-lapcount);
2238       lapcount=lapsize;
2239     }else{
2240       if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2241       for(i=0;i<vi->channels;i++)
2242         memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2243       lapcount+=samples;
2244     }
2245   }
2246 }
2247
2248 /* this sets up crosslapping of a sample by using trailing data from
2249    sample 1 and lapping it into the windowing buffer of sample 2 */
2250 int ov_crosslap(OggVorbis_File *vf1, OggVorbis_File *vf2){
2251   vorbis_info *vi1,*vi2;
2252   float **lappcm;
2253   float **pcm;
2254   const float *w1,*w2;
2255   int n1,n2,i,ret,hs1,hs2;
2256
2257   if(vf1==vf2)return(0); /* degenerate case */
2258   if(vf1->ready_state<OPENED)return(OV_EINVAL);
2259   if(vf2->ready_state<OPENED)return(OV_EINVAL);
2260
2261   /* the relevant overlap buffers must be pre-checked and pre-primed
2262      before looking at settings in the event that priming would cross
2263      a bitstream boundary.  So, do it now */
2264
2265   ret=_ov_initset(vf1);
2266   if(ret)return(ret);
2267   ret=_ov_initprime(vf2);
2268   if(ret)return(ret);
2269
2270   vi1=ov_info(vf1,-1);
2271   vi2=ov_info(vf2,-1);
2272   hs1=ov_halfrate_p(vf1);
2273   hs2=ov_halfrate_p(vf2);
2274
2275   lappcm=alloca(sizeof(*lappcm)*vi1->channels);
2276   n1=vorbis_info_blocksize(vi1,0)>>(1+hs1);
2277   n2=vorbis_info_blocksize(vi2,0)>>(1+hs2);
2278   w1=vorbis_window(&vf1->vd,0);
2279   w2=vorbis_window(&vf2->vd,0);
2280
2281   for(i=0;i<vi1->channels;i++)
2282     lappcm[i]=alloca(sizeof(**lappcm)*n1);
2283
2284   _ov_getlap(vf1,vi1,&vf1->vd,lappcm,n1);
2285
2286   /* have a lapping buffer from vf1; now to splice it into the lapping
2287      buffer of vf2 */
2288   /* consolidate and expose the buffer. */
2289   vorbis_synthesis_lapout(&vf2->vd,&pcm);
2290
2291 #if 0
2292   _analysis_output_always("pcmL",0,pcm[0],n1*2,0,0,0);
2293   _analysis_output_always("pcmR",0,pcm[1],n1*2,0,0,0);
2294 #endif
2295
2296   /* splice */
2297   _ov_splice(pcm,lappcm,n1,n2,vi1->channels,vi2->channels,w1,w2);
2298
2299   /* done */
2300   return(0);
2301 }
2302
2303 static int _ov_64_seek_lap(OggVorbis_File *vf,ogg_int64_t pos,
2304                            int (*localseek)(OggVorbis_File *,ogg_int64_t)){
2305   vorbis_info *vi;
2306   float **lappcm;
2307   float **pcm;
2308   const float *w1,*w2;
2309   int n1,n2,ch1,ch2,hs;
2310   int i,ret;
2311
2312   if(vf->ready_state<OPENED)return(OV_EINVAL);
2313   ret=_ov_initset(vf);
2314   if(ret)return(ret);
2315   vi=ov_info(vf,-1);
2316   hs=ov_halfrate_p(vf);
2317
2318   ch1=vi->channels;
2319   n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2320   w1=vorbis_window(&vf->vd,0);  /* window arrays from libvorbis are
2321                                    persistent; even if the decode state
2322                                    from this link gets dumped, this
2323                                    window array continues to exist */
2324
2325   lappcm=alloca(sizeof(*lappcm)*ch1);
2326   for(i=0;i<ch1;i++)
2327     lappcm[i]=alloca(sizeof(**lappcm)*n1);
2328   _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2329
2330   /* have lapping data; seek and prime the buffer */
2331   ret=localseek(vf,pos);
2332   if(ret)return ret;
2333   ret=_ov_initprime(vf);
2334   if(ret)return(ret);
2335
2336  /* Guard against cross-link changes; they're perfectly legal */
2337   vi=ov_info(vf,-1);
2338   ch2=vi->channels;
2339   n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2340   w2=vorbis_window(&vf->vd,0);
2341
2342   /* consolidate and expose the buffer. */
2343   vorbis_synthesis_lapout(&vf->vd,&pcm);
2344
2345   /* splice */
2346   _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2347
2348   /* done */
2349   return(0);
2350 }
2351
2352 int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2353   return _ov_64_seek_lap(vf,pos,ov_raw_seek);
2354 }
2355
2356 int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2357   return _ov_64_seek_lap(vf,pos,ov_pcm_seek);
2358 }
2359
2360 int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos){
2361   return _ov_64_seek_lap(vf,pos,ov_pcm_seek_page);
2362 }
2363
2364 static int _ov_d_seek_lap(OggVorbis_File *vf,double pos,
2365                            int (*localseek)(OggVorbis_File *,double)){
2366   vorbis_info *vi;
2367   float **lappcm;
2368   float **pcm;
2369   const float *w1,*w2;
2370   int n1,n2,ch1,ch2,hs;
2371   int i,ret;
2372
2373   if(vf->ready_state<OPENED)return(OV_EINVAL);
2374   ret=_ov_initset(vf);
2375   if(ret)return(ret);
2376   vi=ov_info(vf,-1);
2377   hs=ov_halfrate_p(vf);
2378
2379   ch1=vi->channels;
2380   n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2381   w1=vorbis_window(&vf->vd,0);  /* window arrays from libvorbis are
2382                                    persistent; even if the decode state
2383                                    from this link gets dumped, this
2384                                    window array continues to exist */
2385
2386   lappcm=alloca(sizeof(*lappcm)*ch1);
2387   for(i=0;i<ch1;i++)
2388     lappcm[i]=alloca(sizeof(**lappcm)*n1);
2389   _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2390
2391   /* have lapping data; seek and prime the buffer */
2392   ret=localseek(vf,pos);
2393   if(ret)return ret;
2394   ret=_ov_initprime(vf);
2395   if(ret)return(ret);
2396
2397  /* Guard against cross-link changes; they're perfectly legal */
2398   vi=ov_info(vf,-1);
2399   ch2=vi->channels;
2400   n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2401   w2=vorbis_window(&vf->vd,0);
2402
2403   /* consolidate and expose the buffer. */
2404   vorbis_synthesis_lapout(&vf->vd,&pcm);
2405
2406   /* splice */
2407   _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2408
2409   /* done */
2410   return(0);
2411 }
2412
2413 int ov_time_seek_lap(OggVorbis_File *vf,double pos){
2414   return _ov_d_seek_lap(vf,pos,ov_time_seek);
2415 }
2416
2417 int ov_time_seek_page_lap(OggVorbis_File *vf,double pos){
2418   return _ov_d_seek_lap(vf,pos,ov_time_seek_page);
2419 }