lib/vorbisfile.c

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