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