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.59 2002/03/07 03:41:03 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   return;
 400 }
 401
 402 static int _open_seekable2(OggVorbis_File *vf){
 403   long serialno=vf->current_serialno,end;
 404   ogg_int64_t dataoffset=vf->offset;
 405   ogg_page og;
 406
 407   /* we're partially open and have a first link header state in
 408      storage in vf */
 409   /* we can seek, so set out learning all about this file */
 410   (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
 411   vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
 412
 413   /* We get the offset for the last page of the physical bitstream.
 414      Most OggVorbis files will contain a single logical bitstream */
 415   end=_get_prev_page(vf,&og);
 416   if(end<0)return(end);
 417
 418   /* more than one logical bitstream? */
 419   if(ogg_page_serialno(&og)!=serialno){
 420
 421     /* Chained bitstream. Bisect-search each logical bitstream
 422        section.  Do so based on serial number only */
 423     if(_bisect_forward_serialno(vf,0,0,end+1,serialno,0)<0)return(OV_EREAD);
 424
 425   }else{
 426
 427     /* Only one logical bitstream */
 428     if(_bisect_forward_serialno(vf,0,end,end+1,serialno,0))return(OV_EREAD);
 429
 430   }
 431
 432   /* the initial header memory is referenced by vf after; don't free it */
 433   _prefetch_all_headers(vf,dataoffset);
 434   return(ov_raw_seek(vf,0));
 435 }
 436
 437 /* clear out the current logical bitstream decoder */
 438 static void _decode_clear(OggVorbis_File *vf){
 439   vorbis_dsp_clear(&vf->vd);
 440   vorbis_block_clear(&vf->vb);
 441   vf->ready_state=OPENED;
 442
 443   vf->bittrack=0.f;
 444   vf->samptrack=0.f;
 445 }
 446
 447 /* fetch and process a packet.  Handles the case where we're at a
 448    bitstream boundary and dumps the decoding machine.  If the decoding
 449    machine is unloaded, it loads it.  It also keeps pcm_offset up to
 450    date (seek and read both use this.  seek uses a special hack with
 451    readp).
 452
 453    return: <0) error, OV_HOLE (lost packet) or OV_EOF
 454             0) need more data (only if readp==0)
 455             1) got a packet
 456 */
 457
 458 static int _fetch_and_process_packet(OggVorbis_File *vf,
 459                                      ogg_packet *op_in,
 460                                      int readp){
 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               granulepos-=vf->pcmlengths[link*2];
 520               if(granulepos<0)granulepos=0; /* actually, this
 521                                                shouldn't be possible
 522                                                here unless the stream
 523                                                is very broken */
 524
 525               samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
 526
 527               granulepos-=samples;
 528               for(i=0;i<link;i++)
 529                 granulepos+=vf->pcmlengths[i*2+1];
 530               vf->pcm_offset=granulepos;
 531             }
 532             return(1);
 533           }
 534         }
 535         else
 536           break;
 537       }
 538     }
 539
 540     if(vf->ready_state>=OPENED){
 541       if(!readp)return(0);
 542       if(_get_next_page(vf,&og,-1)<0)return(OV_EOF); /* eof.
 543                                                         leave unitialized */
 544       /* bitrate tracking; add the header's bytes here, the body bytes
 545          are done by packet above */
 546       vf->bittrack+=og.header_len*8;
 547
 548       /* has our decoding just traversed a bitstream boundary? */
 549       if(vf->ready_state==INITSET){
 550         if(vf->current_serialno!=ogg_page_serialno(&og)){
 551           _decode_clear(vf);
 552
 553           if(!vf->seekable){
 554             vorbis_info_clear(vf->vi);
 555             vorbis_comment_clear(vf->vc);
 556           }
 557         }
 558       }
 559     }
 560
 561     /* Do we need to load a new machine before submitting the page? */
 562     /* This is different in the seekable and non-seekable cases.
 563
 564        In the seekable case, we already have all the header
 565        information loaded and cached; we just initialize the machine
 566        with it and continue on our merry way.
 567
 568        In the non-seekable (streaming) case, we'll only be at a
 569        boundary if we just left the previous logical bitstream and
 570        we're now nominally at the header of the next bitstream
 571     */
 572
 573     if(vf->ready_state!=INITSET){
 574       int link;
 575
 576       if(vf->ready_state<STREAMSET){
 577         if(vf->seekable){
 578           vf->current_serialno=ogg_page_serialno(&og);
 579
 580           /* match the serialno to bitstream section.  We use this rather than
 581              offset positions to avoid problems near logical bitstream
 582              boundaries */
 583           for(link=0;link<vf->links;link++)
 584             if(vf->serialnos[link]==vf->current_serialno)break;
 585           if(link==vf->links)return(OV_EBADLINK); /* sign of a bogus
 586                                                      stream.  error out,
 587                                                      leave machine
 588                                                      uninitialized */
 589
 590           vf->current_link=link;
 591
 592           ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
 593           vf->ready_state=STREAMSET;
 594
 595         }else{
 596           /* we're streaming */
 597           /* fetch the three header packets, build the info struct */
 598
 599           int ret=_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno,&og);
 600           if(ret)return(ret);
 601           vf->current_link++;
 602           link=0;
 603         }
 604       }
 605
 606       _make_decode_ready(vf);
 607     }
 608     ogg_stream_pagein(&vf->os,&og);
 609   }
 610 }
 611
 612 /* if, eg, 64 bit stdio is configured by default, this will build with
 613    fseek64 */
 614 static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
 615   if(f==NULL)return(-1);
 616   return fseek(f,off,whence);
 617 }
 618
 619 static int _ov_open1(void *f,OggVorbis_File *vf,char *initial,
 620                      long ibytes, ov_callbacks callbacks){
 621   int offsettest=(f?callbacks.seek_func(f,0,SEEK_CUR):-1);
 622   int ret;
 623
 624   memset(vf,0,sizeof(*vf));
 625   vf->datasource=f;
 626   vf->callbacks = callbacks;
 627
 628   /* init the framing state */
 629   ogg_sync_init(&vf->oy);
 630
 631   /* perhaps some data was previously read into a buffer for testing
 632      against other stream types.  Allow initialization from this
 633      previously read data (as we may be reading from a non-seekable
 634      stream) */
 635   if(initial){
 636     char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
 637     memcpy(buffer,initial,ibytes);
 638     ogg_sync_wrote(&vf->oy,ibytes);
 639   }
 640
 641   /* can we seek? Stevens suggests the seek test was portable */
 642   if(offsettest!=-1)vf->seekable=1;
 643
 644   /* No seeking yet; Set up a 'single' (current) logical bitstream
 645      entry for partial open */
 646   vf->links=1;
 647   vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
 648   vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
 649   ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
 650
 651   /* Try to fetch the headers, maintaining all the storage */
 652   if((ret=_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno,NULL))<0){
 653     vf->datasource=NULL;
 654     ov_clear(vf);
 655   }else if(vf->ready_state < PARTOPEN)
 656     vf->ready_state=PARTOPEN;
 657   return(ret);
 658 }
 659
 660 static int _ov_open2(OggVorbis_File *vf){
 661   if(vf->ready_state < OPENED)
 662     vf->ready_state=OPENED;
 663   if(vf->seekable){
 664     int ret=_open_seekable2(vf);
 665     if(ret){
 666       vf->datasource=NULL;
 667       ov_clear(vf);
 668     }
 669     return(ret);
 670   }
 671   return 0;
 672 }
 673
 674
 675 /* clear out the OggVorbis_File struct */
 676 int ov_clear(OggVorbis_File *vf){
 677   if(vf){
 678     vorbis_block_clear(&vf->vb);
 679     vorbis_dsp_clear(&vf->vd);
 680     ogg_stream_clear(&vf->os);
 681
 682     if(vf->vi && vf->links){
 683       int i;
 684       for(i=0;i<vf->links;i++){
 685         vorbis_info_clear(vf->vi+i);
 686         vorbis_comment_clear(vf->vc+i);
 687       }
 688       _ogg_free(vf->vi);
 689       _ogg_free(vf->vc);
 690     }
 691     if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
 692     if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
 693     if(vf->serialnos)_ogg_free(vf->serialnos);
 694     if(vf->offsets)_ogg_free(vf->offsets);
 695     ogg_sync_clear(&vf->oy);
 696     if(vf->datasource)(vf->callbacks.close_func)(vf->datasource);
 697     memset(vf,0,sizeof(*vf));
 698   }
 699 #ifdef DEBUG_LEAKS
 700   _VDBG_dump();
 701 #endif
 702   return(0);
 703 }
 704
 705 /* inspects the OggVorbis file and finds/documents all the logical
 706    bitstreams contained in it.  Tries to be tolerant of logical
 707    bitstream sections that are truncated/woogie.
 708
 709    return: -1) error
 710             0) OK
 711 */
 712
 713 int ov_open_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
 714     ov_callbacks callbacks){
 715   int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
 716   if(ret)return ret;
 717   return _ov_open2(vf);
 718 }
 719
 720 int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
 721   ov_callbacks callbacks = {
 722     (size_t (*)(void *, size_t, size_t, void *))  fread,
 723     (int (*)(void *, ogg_int64_t, int))              _fseek64_wrap,
 724     (int (*)(void *))                             fclose,
 725     (long (*)(void *))                            ftell
 726   };
 727
 728   return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
 729 }
 730
 731 /* Only partially open the vorbis file; test for Vorbisness, and load
 732    the headers for the first chain.  Do not seek (although test for
 733    seekability).  Use ov_test_open to finish opening the file, else
 734    ov_clear to close/free it. Same return codes as open. */
 735
 736 int ov_test_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
 737     ov_callbacks callbacks)
 738 {
 739   return _ov_open1(f,vf,initial,ibytes,callbacks);
 740 }
 741
 742 int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
 743   ov_callbacks callbacks = {
 744     (size_t (*)(void *, size_t, size_t, void *))  fread,
 745     (int (*)(void *, ogg_int64_t, int))              _fseek64_wrap,
 746     (int (*)(void *))                             fclose,
 747     (long (*)(void *))                            ftell
 748   };
 749
 750   return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
 751 }
 752
 753 int ov_test_open(OggVorbis_File *vf){
 754   if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
 755   return _ov_open2(vf);
 756 }
 757
 758 /* How many logical bitstreams in this physical bitstream? */
 759 long ov_streams(OggVorbis_File *vf){
 760   return vf->links;
 761 }
 762
 763 /* Is the FILE * associated with vf seekable? */
 764 long ov_seekable(OggVorbis_File *vf){
 765   return vf->seekable;
 766 }
 767
 768 /* returns the bitrate for a given logical bitstream or the entire
 769    physical bitstream.  If the file is open for random access, it will
 770    find the *actual* average bitrate.  If the file is streaming, it
 771    returns the nominal bitrate (if set) else the average of the
 772    upper/lower bounds (if set) else -1 (unset).
 773
 774    If you want the actual bitrate field settings, get them from the
 775    vorbis_info structs */
 776
 777 long ov_bitrate(OggVorbis_File *vf,int i){
 778   if(vf->ready_state<OPENED)return(OV_EINVAL);
 779   if(i>=vf->links)return(OV_EINVAL);
 780   if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
 781   if(i<0){
 782     ogg_int64_t bits=0;
 783     int i;
 784     for(i=0;i<vf->links;i++)
 785       bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
 786     return(rint(bits/ov_time_total(vf,-1)));
 787   }else{
 788     if(vf->seekable){
 789       /* return the actual bitrate */
 790       return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
 791     }else{
 792       /* return nominal if set */
 793       if(vf->vi[i].bitrate_nominal>0){
 794         return vf->vi[i].bitrate_nominal;
 795       }else{
 796         if(vf->vi[i].bitrate_upper>0){
 797           if(vf->vi[i].bitrate_lower>0){
 798             return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
 799           }else{
 800             return vf->vi[i].bitrate_upper;
 801           }
 802         }
 803         return(OV_FALSE);
 804       }
 805     }
 806   }
 807 }
 808
 809 /* returns the actual bitrate since last call.  returns -1 if no
 810    additional data to offer since last call (or at beginning of stream),
 811    EINVAL if stream is only partially open
 812 */
 813 long ov_bitrate_instant(OggVorbis_File *vf){
 814   int link=(vf->seekable?vf->current_link:0);
 815   long ret;
 816   if(vf->ready_state<OPENED)return(OV_EINVAL);
 817   if(vf->samptrack==0)return(OV_FALSE);
 818   ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
 819   vf->bittrack=0.f;
 820   vf->samptrack=0.f;
 821   return(ret);
 822 }
 823
 824 /* Guess */
 825 long ov_serialnumber(OggVorbis_File *vf,int i){
 826   if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
 827   if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
 828   if(i<0){
 829     return(vf->current_serialno);
 830   }else{
 831     return(vf->serialnos[i]);
 832   }
 833 }
 834
 835 /* returns: total raw (compressed) length of content if i==-1
 836             raw (compressed) length of that logical bitstream for i==0 to n
 837             OV_EINVAL if the stream is not seekable (we can't know the length)
 838             or if stream is only partially open
 839 */
 840 ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
 841   if(vf->ready_state<OPENED)return(OV_EINVAL);
 842   if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
 843   if(i<0){
 844     ogg_int64_t acc=0;
 845     int i;
 846     for(i=0;i<vf->links;i++)
 847       acc+=ov_raw_total(vf,i);
 848     return(acc);
 849   }else{
 850     return(vf->offsets[i+1]-vf->offsets[i]);
 851   }
 852 }
 853
 854 /* returns: total PCM length (samples) of content if i==-1 PCM length
 855             (samples) of that logical bitstream for i==0 to n
 856             OV_EINVAL if the stream is not seekable (we can't know the
 857             length) or only partially open
 858 */
 859 ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
 860   if(vf->ready_state<OPENED)return(OV_EINVAL);
 861   if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
 862   if(i<0){
 863     ogg_int64_t acc=0;
 864     int i;
 865     for(i=0;i<vf->links;i++)
 866       acc+=ov_pcm_total(vf,i);
 867     return(acc);
 868   }else{
 869     return(vf->pcmlengths[i*2+1]);
 870   }
 871 }
 872
 873 /* returns: total seconds of content if i==-1
 874             seconds in that logical bitstream for i==0 to n
 875             OV_EINVAL if the stream is not seekable (we can't know the
 876             length) or only partially open
 877 */
 878 double ov_time_total(OggVorbis_File *vf,int i){
 879   if(vf->ready_state<OPENED)return(OV_EINVAL);
 880   if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
 881   if(i<0){
 882     double acc=0;
 883     int i;
 884     for(i=0;i<vf->links;i++)
 885       acc+=ov_time_total(vf,i);
 886     return(acc);
 887   }else{
 888     return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
 889   }
 890 }
 891
 892 /* seek to an offset relative to the *compressed* data. This also
 893    scans packets to update the PCM cursor. It will cross a logical
 894    bitstream boundary, but only if it can't get any packets out of the
 895    tail of the bitstream we seek to (so no surprises).
 896
 897    returns zero on success, nonzero on failure */
 898
 899 int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
 900   ogg_stream_state work_os;
 901
 902   if(vf->ready_state<OPENED)return(OV_EINVAL);
 903   if(!vf->seekable)
 904     return(OV_ENOSEEK); /* don't dump machine if we can't seek */
 905
 906   if(pos<0 || pos>vf->end)return(OV_EINVAL);
 907
 908   /* clear out decoding machine state */
 909   vf->pcm_offset=-1;
 910   _decode_clear(vf);
 911
 912   _seek_helper(vf,pos);
 913
 914   /* we need to make sure the pcm_offset is set, but we don't want to
 915      advance the raw cursor past good packets just to get to the first
 916      with a granulepos.  That's not equivalent behavior to beginning
 917      decoding as immediately after the seek position as possible.
 918
 919      So, a hack.  We use two stream states; a local scratch state and
 920      a the shared vf->os stream state.  We use the local state to
 921      scan, and the shared state as a buffer for later decode.
 922
 923      Unfortuantely, on the last page we still advance to last packet
 924      because the granulepos on the last page is not necessarily on a
 925      packet boundary, and we need to make sure the granpos is
 926      correct.
 927   */
 928
 929   {
 930     ogg_page og;
 931     ogg_packet op;
 932     int lastblock=0;
 933     int accblock=0;
 934     int thisblock;
 935     int eosflag;
 936
 937     ogg_stream_init(&work_os,-1); /* get the memory ready */
 938
 939     while(1){
 940       if(vf->ready_state==STREAMSET){
 941         /* snarf/scan a packet if we can */
 942         int result=ogg_stream_packetout(&work_os,&op);
 943
 944         if(result>0){
 945
 946           if(vf->vi[vf->current_link].codec_setup)
 947             thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
 948           if(eosflag)
 949             ogg_stream_packetout(&vf->os,NULL);
 950           else
 951             if(lastblock)accblock+=(lastblock+thisblock)>>2;
 952
 953           if(op.granulepos!=-1){
 954             int i,link=vf->current_link;
 955             ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
 956             if(granulepos<0)granulepos=0;
 957
 958             for(i=0;i<link;i++)
 959               granulepos+=vf->pcmlengths[i*2+1];
 960             vf->pcm_offset=granulepos-accblock;
 961             break;
 962           }
 963           lastblock=thisblock;
 964           continue;
 965         }
 966       }
 967
 968       if(!lastblock){
 969         if(_get_next_page(vf,&og,-1)<0){
 970           vf->pcm_offset=ov_pcm_total(vf,-1);
 971           break;
 972         }
 973       }else{
 974         /* huh?  Bogus stream with packets but no granulepos */
 975         vf->pcm_offset=-1;
 976         break;
 977       }
 978
 979       /* has our decoding just traversed a bitstream boundary? */
 980       if(vf->ready_state==STREAMSET)
 981         if(vf->current_serialno!=ogg_page_serialno(&og)){
 982         _decode_clear(vf); /* clear out stream state */
 983         ogg_stream_clear(&work_os);
 984       }
 985
 986       if(vf->ready_state<STREAMSET){
 987         int link;
 988
 989         vf->current_serialno=ogg_page_serialno(&og);
 990         for(link=0;link<vf->links;link++)
 991           if(vf->serialnos[link]==vf->current_serialno)break;
 992         if(link==vf->links)goto seek_error; /* sign of a bogus stream.
 993                                                error out, leave
 994                                                machine uninitialized */
 995         vf->current_link=link;
 996
 997         ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
 998         ogg_stream_reset_serialno(&work_os,vf->current_serialno);
 999         vf->ready_state=STREAMSET;
1000
1001       }
1002
1003       ogg_stream_pagein(&vf->os,&og);
1004       ogg_stream_pagein(&work_os,&og);
1005       eosflag=ogg_page_eos(&og);
1006     }
1007   }
1008
1009   ogg_stream_clear(&work_os);
1010   return(0);
1011
1012  seek_error:
1013   /* dump the machine so we're in a known state */
1014   vf->pcm_offset=-1;
1015   ogg_stream_clear(&work_os);
1016   _decode_clear(vf);
1017   return OV_EBADLINK;
1018 }
1019
1020 /* Page granularity seek (faster than sample granularity because we
1021    don't do the last bit of decode to find a specific sample).
1022
1023    Seek to the last [granule marked] page preceeding the specified pos
1024    location, such that decoding past the returned point will quickly
1025    arrive at the requested position. */
1026 int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
1027   int link=-1,ret=0;
1028   ogg_int64_t result;
1029   ogg_int64_t total=ov_pcm_total(vf,-1);
1030
1031   if(vf->ready_state<OPENED)return(OV_EINVAL);
1032   if(!vf->seekable)return(OV_ENOSEEK);
1033
1034   if(pos<0 || pos>total)return(OV_EINVAL);
1035
1036   /* which bitstream section does this pcm offset occur in? */
1037   for(link=vf->links-1;link>=0;link--){
1038     total-=vf->pcmlengths[link*2+1];
1039     if(pos>=total)break;
1040   }
1041
1042   /* search within the logical bitstream for the page with the highest
1043      pcm_pos preceeding (or equal to) pos.  There is a danger here;
1044      missing pages or incorrect frame number information in the
1045      bitstream could make our task impossible.  Account for that (it
1046      would be an error condition) */
1047
1048   /* new search algorithm by HB (Nicholas Vinen) */
1049   {
1050     ogg_int64_t end=vf->offsets[link+1];
1051     ogg_int64_t begin=vf->offsets[link];
1052     ogg_int64_t begintime = vf->pcmlengths[link*2];
1053     ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
1054     ogg_int64_t target=pos-total+begintime;
1055     ogg_int64_t best=begin;
1056
1057     ogg_page og;
1058     while(begin<end){
1059       ogg_int64_t bisect;
1060
1061       if(end-begin<CHUNKSIZE){
1062         bisect=begin;
1063       }else{
1064         /* take a (pretty decent) guess. */
1065         bisect=begin +
1066           (target-begintime)*(end-begin)/(endtime-begintime) - CHUNKSIZE;
1067         if(bisect<=begin)
1068           bisect=begin+1;
1069       }
1070
1071       _seek_helper(vf,bisect);
1072
1073       while(begin<end){
1074         result=_get_next_page(vf,&og,end-vf->offset);
1075         if(result==OV_EREAD) goto seek_error;
1076         if(result<0){
1077           if(bisect<=begin+1)
1078             end=begin; /* found it */
1079           else{
1080             if(bisect==0)goto seek_error;
1081             bisect-=CHUNKSIZE;
1082             if(bisect<=begin)bisect=begin+1;
1083             _seek_helper(vf,bisect);
1084           }
1085         }else{
1086           ogg_int64_t granulepos=ogg_page_granulepos(&og);
1087           if(granulepos==-1)continue;
1088           if(granulepos<target){
1089             best=result;  /* raw offset of packet with granulepos */
1090             begin=vf->offset; /* raw offset of next page */
1091             begintime=granulepos;
1092
1093             if(target-begintime>44100)break;
1094             bisect=begin; /* *not* begin + 1 */
1095           }else{
1096             if(bisect<=begin+1)
1097               end=begin;  /* found it */
1098             else{
1099               if(end==vf->offset){ /* we're pretty close - we'd be stuck in */
1100                 end=result;
1101                 bisect-=CHUNKSIZE; /* an endless loop otherwise. */
1102                 if(bisect<=begin)bisect=begin+1;
1103                 _seek_helper(vf,bisect);
1104               }else{
1105                 end=result;
1106                 endtime=granulepos;
1107                 break;
1108               }
1109             }
1110           }
1111         }
1112       }
1113     }
1114
1115     /* found our page. seek to it, update pcm offset. Easier case than
1116        raw_seek, don't keep packets preceeding granulepos. */
1117     {
1118       ogg_page og;
1119       ogg_packet op;
1120       /* clear out decoding machine state */
1121       _decode_clear(vf);
1122       /* seek */
1123       _seek_helper(vf,best);
1124
1125       if(_get_next_page(vf,&og,-1)<0)return(OV_EOF); /* shouldn't happen */
1126       vf->current_serialno=ogg_page_serialno(&og);
1127       vf->current_link=link;
1128
1129       ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1130       vf->ready_state=STREAMSET;
1131       ogg_stream_pagein(&vf->os,&og);
1132
1133       /* pull out all but last packet; the one with granulepos */
1134       while(1){
1135         result=ogg_stream_packetpeek(&vf->os,&op);
1136         if(result==0){
1137           /* !!! the packet finishing this page originated on a
1138              preceeding page. Keep fetching previous pages until we
1139              get one with a granulepos or without the 'continued' flag
1140              set.  Then just use raw_seek for simplicity. */
1141
1142           _decode_clear(vf);
1143           _seek_helper(vf,best);
1144
1145           while(1){
1146             result=_get_prev_page(vf,&og);
1147             if(result<0)goto seek_error;
1148             if(ogg_page_granulepos(&og)>-1 ||
1149                !ogg_page_continued(&og)){
1150               return ov_raw_seek(vf,result);
1151             }
1152             vf->offset=result;
1153           }
1154         }
1155         if(result<0)goto seek_error;
1156         if(op.granulepos!=-1){
1157           vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1158           if(vf->pcm_offset<0)vf->pcm_offset=0;
1159           vf->pcm_offset+=total;
1160           break;
1161         }else
1162           result=ogg_stream_packetout(&vf->os,NULL);
1163       }
1164     }
1165   }
1166
1167   /* verify result */
1168   if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
1169     ret=OV_EFAULT;
1170     goto seek_error;
1171   }
1172   return(0);
1173
1174  seek_error:
1175   /* dump machine so we're in a known state */
1176   vf->pcm_offset=-1;
1177   _decode_clear(vf);
1178   return ret;
1179 }
1180
1181 /* seek to a sample offset relative to the decompressed pcm stream
1182    returns zero on success, nonzero on failure */
1183
1184 int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
1185   int thisblock,lastblock=0;
1186   int ret=ov_pcm_seek_page(vf,pos);
1187   if(ret<0)return(ret);
1188   _make_decode_ready(vf);
1189
1190   /* discard leading packets we don't need for the lapping of the
1191      position we want; don't decode them */
1192
1193   while(1){
1194     ogg_packet op;
1195     ogg_page og;
1196
1197     int ret=ogg_stream_packetpeek(&vf->os,&op);
1198     if(ret>0){
1199       thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1200       if(thisblock<0)thisblock=0; /* non audio packet */
1201       if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
1202
1203       if(vf->pcm_offset+((thisblock+
1204                           vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
1205
1206       /* remove the packet from packet queue and track its granulepos */
1207       ogg_stream_packetout(&vf->os,NULL);
1208       vorbis_synthesis_trackonly(&vf->vb,&op);  /* set up a vb with
1209                                                    only tracking, no
1210                                                    pcm_decode */
1211       vorbis_synthesis_blockin(&vf->vd,&vf->vb);
1212
1213       /* end of logical stream case is hard, especially with exact
1214          length positioning. */
1215
1216       if(op.granulepos>-1){
1217         int i;
1218         /* always believe the stream markers */
1219         vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1220         if(vf->pcm_offset<0)vf->pcm_offset=0;
1221         for(i=0;i<vf->current_link;i++)
1222           vf->pcm_offset+=vf->pcmlengths[i*2+1];
1223       }
1224
1225       lastblock=thisblock;
1226
1227     }else{
1228       if(ret<0 && ret!=OV_HOLE)break;
1229
1230       /* suck in a new page */
1231       if(_get_next_page(vf,&og,-1)<0)break;
1232       if(vf->current_serialno!=ogg_page_serialno(&og))_decode_clear(vf);
1233
1234       if(vf->ready_state<STREAMSET){
1235         int link;
1236
1237         vf->current_serialno=ogg_page_serialno(&og);
1238         for(link=0;link<vf->links;link++)
1239           if(vf->serialnos[link]==vf->current_serialno)break;
1240         if(link==vf->links)return(OV_EBADLINK);
1241         vf->current_link=link;
1242
1243         ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1244         vf->ready_state=STREAMSET;
1245         _make_decode_ready(vf);
1246         lastblock=0;
1247       }
1248
1249       ogg_stream_pagein(&vf->os,&og);
1250     }
1251   }
1252
1253   /* discard samples until we reach the desired position. Crossing a
1254      logical bitstream boundary with abandon is OK. */
1255   while(vf->pcm_offset<pos){
1256     float **pcm;
1257     ogg_int64_t target=pos-vf->pcm_offset;
1258     long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1259
1260     if(samples>target)samples=target;
1261     vorbis_synthesis_read(&vf->vd,samples);
1262     vf->pcm_offset+=samples;
1263
1264     if(samples<target)
1265       if(_fetch_and_process_packet(vf,NULL,1)<=0)
1266         vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
1267   }
1268   return 0;
1269 }
1270
1271 /* seek to a playback time relative to the decompressed pcm stream
1272    returns zero on success, nonzero on failure */
1273 int ov_time_seek(OggVorbis_File *vf,double seconds){
1274   /* translate time to PCM position and call ov_pcm_seek */
1275
1276   int link=-1;
1277   ogg_int64_t pcm_total=ov_pcm_total(vf,-1);
1278   double time_total=ov_time_total(vf,-1);
1279
1280   if(vf->ready_state<OPENED)return(OV_EINVAL);
1281   if(!vf->seekable)return(OV_ENOSEEK);
1282   if(seconds<0 || seconds>time_total)return(OV_EINVAL);
1283
1284   /* which bitstream section does this time offset occur in? */
1285   for(link=vf->links-1;link>=0;link--){
1286     pcm_total-=vf->pcmlengths[link*2+1];
1287     time_total-=ov_time_total(vf,link);
1288     if(seconds>=time_total)break;
1289   }
1290
1291   /* enough information to convert time offset to pcm offset */
1292   {
1293     ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1294     return(ov_pcm_seek(vf,target));
1295   }
1296 }
1297
1298 /* page-granularity version of ov_time_seek
1299    returns zero on success, nonzero on failure */
1300 int ov_time_seek_page(OggVorbis_File *vf,double seconds){
1301   /* translate time to PCM position and call ov_pcm_seek */
1302
1303   int link=-1;
1304   ogg_int64_t pcm_total=ov_pcm_total(vf,-1);
1305   double time_total=ov_time_total(vf,-1);
1306
1307   if(vf->ready_state<OPENED)return(OV_EINVAL);
1308   if(!vf->seekable)return(OV_ENOSEEK);
1309   if(seconds<0 || seconds>time_total)return(OV_EINVAL);
1310
1311   /* which bitstream section does this time offset occur in? */
1312   for(link=vf->links-1;link>=0;link--){
1313     pcm_total-=vf->pcmlengths[link*2+1];
1314     time_total-=ov_time_total(vf,link);
1315     if(seconds>=time_total)break;
1316   }
1317
1318   /* enough information to convert time offset to pcm offset */
1319   {
1320     ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1321     return(ov_pcm_seek_page(vf,target));
1322   }
1323 }
1324
1325 /* tell the current stream offset cursor.  Note that seek followed by
1326    tell will likely not give the set offset due to caching */
1327 ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
1328   if(vf->ready_state<OPENED)return(OV_EINVAL);
1329   return(vf->offset);
1330 }
1331
1332 /* return PCM offset (sample) of next PCM sample to be read */
1333 ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
1334   if(vf->ready_state<OPENED)return(OV_EINVAL);
1335   return(vf->pcm_offset);
1336 }
1337
1338 /* return time offset (seconds) of next PCM sample to be read */
1339 double ov_time_tell(OggVorbis_File *vf){
1340   /* translate time to PCM position and call ov_pcm_seek */
1341
1342   int link=-1;
1343   ogg_int64_t pcm_total=0;
1344   double time_total=0.f;
1345
1346   if(vf->ready_state<OPENED)return(OV_EINVAL);
1347   if(vf->seekable){
1348     pcm_total=ov_pcm_total(vf,-1);
1349     time_total=ov_time_total(vf,-1);
1350
1351     /* which bitstream section does this time offset occur in? */
1352     for(link=vf->links-1;link>=0;link--){
1353       pcm_total-=vf->pcmlengths[link*2+1];
1354       time_total-=ov_time_total(vf,link);
1355       if(vf->pcm_offset>=pcm_total)break;
1356     }
1357   }
1358
1359   return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
1360 }
1361
1362 /*  link:   -1) return the vorbis_info struct for the bitstream section
1363                 currently being decoded
1364            0-n) to request information for a specific bitstream section
1365
1366     In the case of a non-seekable bitstream, any call returns the
1367     current bitstream.  NULL in the case that the machine is not
1368     initialized */
1369
1370 vorbis_info *ov_info(OggVorbis_File *vf,int link){
1371   if(vf->seekable){
1372     if(link<0)
1373       if(vf->ready_state>=STREAMSET)
1374         return vf->vi+vf->current_link;
1375       else
1376       return vf->vi;
1377     else
1378       if(link>=vf->links)
1379         return NULL;
1380       else
1381         return vf->vi+link;
1382   }else{
1383     return vf->vi;
1384   }
1385 }
1386
1387 /* grr, strong typing, grr, no templates/inheritence, grr */
1388 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
1389   if(vf->seekable){
1390     if(link<0)
1391       if(vf->ready_state>=STREAMSET)
1392         return vf->vc+vf->current_link;
1393       else
1394         return vf->vc;
1395     else
1396       if(link>=vf->links)
1397         return NULL;
1398       else
1399         return vf->vc+link;
1400   }else{
1401     return vf->vc;
1402   }
1403 }
1404
1405 static int host_is_big_endian() {
1406   ogg_int32_t pattern = 0xfeedface; /* deadbeef */
1407   unsigned char *bytewise = (unsigned char *)&pattern;
1408   if (bytewise[0] == 0xfe) return 1;
1409   return 0;
1410 }
1411
1412 /* up to this point, everything could more or less hide the multiple
1413    logical bitstream nature of chaining from the toplevel application
1414    if the toplevel application didn't particularly care.  However, at
1415    the point that we actually read audio back, the multiple-section
1416    nature must surface: Multiple bitstream sections do not necessarily
1417    have to have the same number of channels or sampling rate.
1418
1419    ov_read returns the sequential logical bitstream number currently
1420    being decoded along with the PCM data in order that the toplevel
1421    application can take action on channel/sample rate changes.  This
1422    number will be incremented even for streamed (non-seekable) streams
1423    (for seekable streams, it represents the actual logical bitstream
1424    index within the physical bitstream.  Note that the accessor
1425    functions above are aware of this dichotomy).
1426
1427    input values: buffer) a buffer to hold packed PCM data for return
1428                  length) the byte length requested to be placed into buffer
1429                  bigendianp) should the data be packed LSB first (0) or
1430                              MSB first (1)
1431                  word) word size for output.  currently 1 (byte) or
1432                        2 (16 bit short)
1433
1434    return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1435                    0) EOF
1436                    n) number of bytes of PCM actually returned.  The
1437                    below works on a packet-by-packet basis, so the
1438                    return length is not related to the 'length' passed
1439                    in, just guaranteed to fit.
1440
1441             *section) set to the logical bitstream number */
1442
1443 long ov_read(OggVorbis_File *vf,char *buffer,int length,
1444                     int bigendianp,int word,int sgned,int *bitstream){
1445   int i,j;
1446   int host_endian = host_is_big_endian();
1447
1448   float **pcm;
1449   long samples;
1450
1451   if(vf->ready_state<OPENED)return(OV_EINVAL);
1452
1453   while(1){
1454     if(vf->ready_state>=STREAMSET){
1455       samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1456       if(samples)break;
1457     }
1458
1459     /* suck in another packet */
1460     {
1461       int ret=_fetch_and_process_packet(vf,NULL,1);
1462       if(ret==OV_EOF)return(0);
1463       if(ret<=0)return(ret);
1464     }
1465
1466   }
1467
1468   if(samples>0){
1469
1470     /* yay! proceed to pack data into the byte buffer */
1471
1472     long channels=ov_info(vf,-1)->channels;
1473     long bytespersample=word * channels;
1474     vorbis_fpu_control fpu;
1475     if(samples>length/bytespersample)samples=length/bytespersample;
1476
1477     /* a tight loop to pack each size */
1478     {
1479       int val;
1480       if(word==1){
1481         int off=(sgned?0:128);
1482         vorbis_fpu_setround(&fpu);
1483         for(j=0;j<samples;j++)
1484           for(i=0;i<channels;i++){
1485             val=vorbis_ftoi(pcm[i][j]*128.f);
1486             if(val>127)val=127;
1487             else if(val<-128)val=-128;
1488             *buffer++=val+off;
1489           }
1490         vorbis_fpu_restore(fpu);
1491       }else{
1492         int off=(sgned?0:32768);
1493
1494         if(host_endian==bigendianp){
1495           if(sgned){
1496
1497             vorbis_fpu_setround(&fpu);
1498             for(i=0;i<channels;i++) { /* It's faster in this order */
1499               float *src=pcm[i];
1500               short *dest=((short *)buffer)+i;
1501               for(j=0;j<samples;j++) {
1502                 val=vorbis_ftoi(src[j]*32768.f);
1503                 if(val>32767)val=32767;
1504                 else if(val<-32768)val=-32768;
1505                 *dest=val;
1506                 dest+=channels;
1507               }
1508             }
1509             vorbis_fpu_restore(fpu);
1510
1511           }else{
1512
1513             vorbis_fpu_setround(&fpu);
1514             for(i=0;i<channels;i++) {
1515               float *src=pcm[i];
1516               short *dest=((short *)buffer)+i;
1517               for(j=0;j<samples;j++) {
1518                 val=vorbis_ftoi(src[j]*32768.f);
1519                 if(val>32767)val=32767;
1520                 else if(val<-32768)val=-32768;
1521                 *dest=val+off;
1522                 dest+=channels;
1523               }
1524             }
1525             vorbis_fpu_restore(fpu);
1526
1527           }
1528         }else if(bigendianp){
1529
1530           vorbis_fpu_setround(&fpu);
1531           for(j=0;j<samples;j++)
1532             for(i=0;i<channels;i++){
1533               val=vorbis_ftoi(pcm[i][j]*32768.f);
1534               if(val>32767)val=32767;
1535               else if(val<-32768)val=-32768;
1536               val+=off;
1537               *buffer++=(val>>8);
1538               *buffer++=(val&0xff);
1539             }
1540           vorbis_fpu_restore(fpu);
1541
1542         }else{
1543           int val;
1544           vorbis_fpu_setround(&fpu);
1545           for(j=0;j<samples;j++)
1546             for(i=0;i<channels;i++){
1547               val=vorbis_ftoi(pcm[i][j]*32768.f);
1548               if(val>32767)val=32767;
1549               else if(val<-32768)val=-32768;
1550               val+=off;
1551               *buffer++=(val&0xff);
1552               *buffer++=(val>>8);
1553                 }
1554           vorbis_fpu_restore(fpu);
1555
1556         }
1557       }
1558     }
1559
1560     vorbis_synthesis_read(&vf->vd,samples);
1561     vf->pcm_offset+=samples;
1562     if(bitstream)*bitstream=vf->current_link;
1563     return(samples*bytespersample);
1564   }else{
1565     return(samples);
1566   }
1567 }
1568
1569 /* input values: pcm_channels) a float vector per channel of output
1570                  length) the sample length being read by the app
1571
1572    return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1573                    0) EOF
1574                    n) number of samples of PCM actually returned.  The
1575                    below works on a packet-by-packet basis, so the
1576                    return length is not related to the 'length' passed
1577                    in, just guaranteed to fit.
1578
1579             *section) set to the logical bitstream number */
1580
1581
1582
1583 long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
1584                    int *bitstream){
1585
1586   if(vf->ready_state<OPENED)return(OV_EINVAL);
1587
1588   while(1){
1589     if(vf->ready_state>=STREAMSET){
1590       float **pcm;
1591       long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1592       if(samples){
1593         if(pcm_channels)*pcm_channels=pcm;
1594         if(samples>length)samples=length;
1595         vorbis_synthesis_read(&vf->vd,samples);
1596         vf->pcm_offset+=samples;
1597         if(bitstream)*bitstream=vf->current_link;
1598         return samples;
1599
1600       }
1601     }
1602
1603     /* suck in another packet */
1604     {
1605       int ret=_fetch_and_process_packet(vf,NULL,1);
1606       if(ret==OV_EOF)return(0);
1607       if(ret<=0)return(ret);
1608     }
1609
1610   }
1611 }
1612