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