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