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