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