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