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