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