lib/vorbisfile.c

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