lib/vorbisfile.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE Ogg Vorbis SOFTWARE CODEC SOURCE CODE.  *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
   5  * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
   6  * PLEASE READ THESE TERMS DISTRIBUTING.                            *
   7  *                                                                  *
   8  * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-2000             *
   9  * by Monty <monty@xiph.org> and The XIPHOPHORUS Company            *
  10  * http://www.xiph.org/                                             *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  function: stdio-based convenience library for opening/seeking/decoding
  15  last mod: $Id: vorbisfile.c,v 1.16 2000/03/10 13:21:18 xiphmont Exp $
  16
  17  ********************************************************************/
  18
  19 #include <stdlib.h>
  20 #include <stdio.h>
  21 #include <math.h>
  22 #include "vorbis/codec.h"
  23 #include "vorbis/vorbisfile.h"
  24
  25 #include "os.h"
  26 #include "misc.h"
  27
  28 /* A 'chained bitstream' is a Vorbis bitstream that contains more than
  29    one logical bitstream arranged end to end (the only form of Ogg
  30    multiplexing allowed in a Vorbis bitstream; grouping [parallel
  31    multiplexing] is not allowed in Vorbis) */
  32
  33 /* A Vorbis file can be played beginning to end (streamed) without
  34    worrying ahead of time about chaining (see decoder_example.c).  If
  35    we have the whole file, however, and want random access
  36    (seeking/scrubbing) or desire to know the total length/time of a
  37    file, we need to account for the possibility of chaining. */
  38
  39 /* We can handle things a number of ways; we can determine the entire
  40    bitstream structure right off the bat, or find pieces on demand.
  41    This example determines and caches structure for the entire
  42    bitstream, but builds a virtual decoder on the fly when moving
  43    between links in the chain. */
  44
  45 /* There are also different ways to implement seeking.  Enough
  46    information exists in an Ogg bitstream to seek to
  47    sample-granularity positions in the output.  Or, one can seek by
  48    picking some portion of the stream roughly in the desired area if
  49    we only want course navigation through the stream. */
  50
  51 /*************************************************************************
  52  * Many, many internal helpers.  The intention is not to be confusing;
  53  * rampant duplication and monolithic function implementation would be
  54  * harder to understand anyway.  The high level functions are last.  Begin
  55  * grokking near the end of the file */
  56
  57 /* read a little more data from the file/pipe into the ogg_sync framer */
  58 #define CHUNKSIZE 4096
  59 static long _get_data(OggVorbis_File *vf){
  60   char *buffer=ogg_sync_buffer(&vf->oy,4096);
  61   long bytes=fread(buffer,1,4096,vf->f);
  62   ogg_sync_wrote(&vf->oy,bytes);
  63   return(bytes);
  64 }
  65
  66 /* save a tiny smidge of verbosity to make the code more readable */
  67 static void _seek_helper(OggVorbis_File *vf,long offset){
  68   fseek(vf->f,offset,SEEK_SET);
  69   vf->offset=offset;
  70   ogg_sync_reset(&vf->oy);
  71 }
  72
  73 /* The read/seek functions track absolute position within the stream */
  74
  75 /* from the head of the stream, get the next page.  boundary specifies
  76    if the function is allowed to fetch more data from the stream (and
  77    how much) or only use internally buffered data.
  78
  79    boundary: -1) unbounded search
  80               0) read no additional data; use cached only
  81               n) search for a new page beginning for n bytes
  82
  83    return:   -1) did not find a page
  84               n) found a page at absolute offset n */
  85
  86 static long _get_next_page(OggVorbis_File *vf,ogg_page *og,int boundary){
  87   if(boundary>0)boundary+=vf->offset;
  88   while(1){
  89     long more;
  90
  91     if(boundary>0 && vf->offset>=boundary)return(-1);
  92     more=ogg_sync_pageseek(&vf->oy,og);
  93
  94     if(more<0){
  95       /* skipped n bytes */
  96       vf->offset-=more;
  97     }else{
  98       if(more==0){
  99         /* send more paramedics */
 100         if(!boundary)return(-1);
 101         if(_get_data(vf)<=0)return(-1);
 102       }else{
 103         /* got a page.  Return the offset at the page beginning,
 104            advance the internal offset past the page end */
 105         long ret=vf->offset;
 106         vf->offset+=more;
 107         return(ret);
 108
 109       }
 110     }
 111   }
 112 }
 113
 114 /* find the latest page beginning before the current stream cursor
 115    position. Much dirtier than the above as Ogg doesn't have any
 116    backward search linkage.  no 'readp' as it will certainly have to
 117    read. */
 118 static long _get_prev_page(OggVorbis_File *vf,ogg_page *og){
 119   long begin=vf->offset;
 120   long ret;
 121   int offset=-1;
 122
 123   while(offset==-1){
 124     begin-=CHUNKSIZE;
 125     _seek_helper(vf,begin);
 126     while(vf->offset<begin+CHUNKSIZE){
 127       ret=_get_next_page(vf,og,begin+CHUNKSIZE-vf->offset);
 128       if(ret==-1){
 129         break;
 130       }else{
 131         offset=ret;
 132       }
 133     }
 134   }
 135
 136   /* we have the offset.  Actually snork and hold the page now */
 137   _seek_helper(vf,offset);
 138   ret=_get_next_page(vf,og,CHUNKSIZE);
 139   if(ret==-1){
 140     /* this shouldn't be possible */
 141     fprintf(stderr,"Missed page fencepost at end of logical bitstream. "
 142             "Exiting.\n");
 143     exit(1);
 144   }
 145   return(offset);
 146 }
 147
 148 /* finds each bitstream link one at a time using a bisection search
 149    (has to begin by knowing the offset of the lb's initial page).
 150    Recurses for each link so it can alloc the link storage after
 151    finding them all, then unroll and fill the cache at the same time */
 152 static void _bisect_forward_serialno(OggVorbis_File *vf,
 153                                      long begin,
 154                                      long searched,
 155                                      long end,
 156                                      long currentno,
 157                                      long m){
 158   long endsearched=end;
 159   long next=end;
 160   ogg_page og;
 161   long ret;
 162
 163   /* the below guards against garbage seperating the last and
 164      first pages of two links. */
 165   while(searched<endsearched){
 166     long bisect;
 167
 168     if(endsearched-searched<CHUNKSIZE){
 169       bisect=searched;
 170     }else{
 171       bisect=(searched+endsearched)/2;
 172     }
 173
 174     _seek_helper(vf,bisect);
 175     ret=_get_next_page(vf,&og,-1);
 176     if(ret<0 || ogg_page_serialno(&og)!=currentno){
 177       endsearched=bisect;
 178       if(ret>=0)next=ret;
 179     }else{
 180       searched=ret+og.header_len+og.body_len;
 181     }
 182   }
 183
 184   _seek_helper(vf,next);
 185   ret=_get_next_page(vf,&og,-1);
 186
 187   if(searched>=end || ret==-1){
 188     vf->links=m+1;
 189     vf->offsets=malloc((m+2)*sizeof(long));
 190     vf->offsets[m+1]=searched;
 191   }else{
 192     _bisect_forward_serialno(vf,next,vf->offset,
 193                              end,ogg_page_serialno(&og),m+1);
 194   }
 195
 196   vf->offsets[m]=begin;
 197 }
 198
 199 /* uses the local ogg_stream storage in vf; this is important for
 200    non-streaming input sources */
 201 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
 202                           long *serialno){
 203   ogg_page og;
 204   ogg_packet op;
 205   int i,ret;
 206
 207   ret=_get_next_page(vf,&og,CHUNKSIZE);
 208   if(ret==-1){
 209     fprintf(stderr,"Did not find initial header for bitstream.\n");
 210     return -1;
 211   }
 212
 213   if(serialno)*serialno=ogg_page_serialno(&og);
 214   ogg_stream_init(&vf->os,ogg_page_serialno(&og));
 215
 216   /* extract the initial header from the first page and verify that the
 217      Ogg bitstream is in fact Vorbis data */
 218
 219   vorbis_info_init(vi);
 220   vorbis_comment_init(vc);
 221
 222   i=0;
 223   while(i<3){
 224     ogg_stream_pagein(&vf->os,&og);
 225     while(i<3){
 226       int result=ogg_stream_packetout(&vf->os,&op);
 227       if(result==0)break;
 228       if(result==-1){
 229         fprintf(stderr,"Corrupt header in logical bitstream.\n");
 230         goto bail_header;
 231       }
 232       if(vorbis_synthesis_headerin(vi,vc,&op)){
 233         fprintf(stderr,"Illegal header in logical bitstream.\n");
 234         goto bail_header;
 235       }
 236       i++;
 237     }
 238     if(i<3)
 239       if(_get_next_page(vf,&og,1)<0){
 240         fprintf(stderr,"Missing header in logical bitstream.\n");
 241         goto bail_header;
 242       }
 243   }
 244   return 0;
 245
 246  bail_header:
 247   vorbis_info_clear(vi);
 248   vorbis_comment_clear(vc);
 249   ogg_stream_clear(&vf->os);
 250   return -1;
 251 }
 252
 253 /* last step of the OggVorbis_File initialization; get all the
 254    vorbis_info structs and PCM positions.  Only called by the seekable
 255    initialization (local stream storage is hacked slightly; pay
 256    attention to how that's done) */
 257 static void _prefetch_all_headers(OggVorbis_File *vf,vorbis_info *first_i,
 258                                   vorbis_comment *first_c,
 259                                   long dataoffset){
 260   ogg_page og;
 261   int i,ret;
 262
 263   vf->vi=calloc(vf->links,sizeof(vorbis_info));
 264   vf->vc=calloc(vf->links,sizeof(vorbis_info));
 265   vf->dataoffsets=malloc(vf->links*sizeof(long));
 266   vf->pcmlengths=malloc(vf->links*sizeof(int64_t));
 267   vf->serialnos=malloc(vf->links*sizeof(long));
 268
 269   for(i=0;i<vf->links;i++){
 270     if(first_i && first_c && i==0){
 271       /* we already grabbed the initial header earlier.  This just
 272          saves the waste of grabbing it again */
 273       memcpy(vf->vi+i,first_i,sizeof(vorbis_info));
 274       memcpy(vf->vc+i,first_c,sizeof(vorbis_comment));
 275       vf->dataoffsets[i]=dataoffset;
 276     }else{
 277
 278       /* seek to the location of the initial header */
 279
 280       _seek_helper(vf,vf->offsets[i]);
 281       if(_fetch_headers(vf,vf->vi+i,vf->vc+i,NULL)==-1){
 282         fprintf(stderr,"Error opening logical bitstream #%d.\n\n",i+1);
 283         vf->dataoffsets[i]=-1;
 284       }else{
 285         vf->dataoffsets[i]=vf->offset;
 286         ogg_stream_clear(&vf->os);
 287       }
 288     }
 289
 290     /* get the serial number and PCM length of this link. To do this,
 291        get the last page of the stream */
 292     {
 293       long end=vf->offsets[i+1];
 294       _seek_helper(vf,end);
 295
 296       while(1){
 297         ret=_get_prev_page(vf,&og);
 298         if(ret==-1){
 299           /* this should not be possible */
 300           fprintf(stderr,"Could not find last page of logical "
 301                   "bitstream #%d\n\n",i);
 302           vorbis_info_clear(vf->vi+i);
 303           vorbis_comment_clear(vf->vc+i);
 304           break;
 305         }
 306         if(ogg_page_frameno(&og)!=-1){
 307           vf->serialnos[i]=ogg_page_serialno(&og);
 308           vf->pcmlengths[i]=ogg_page_frameno(&og);
 309           break;
 310         }
 311       }
 312     }
 313   }
 314 }
 315
 316 static int _make_decode_ready(OggVorbis_File *vf){
 317   if(vf->decode_ready)exit(1);
 318   vorbis_synthesis_init(&vf->vd,vf->vi);
 319   vorbis_block_init(&vf->vd,&vf->vb);
 320   vf->decode_ready=1;
 321   return(0);
 322 }
 323
 324 static int _open_seekable(OggVorbis_File *vf){
 325   vorbis_info initial_i;
 326   vorbis_comment initial_c;
 327   long serialno,end;
 328   int ret;
 329   long dataoffset;
 330   ogg_page og;
 331
 332   /* is this even vorbis...? */
 333   ret=_fetch_headers(vf,&initial_i,&initial_c,&serialno);
 334   dataoffset=vf->offset;
 335   ogg_stream_clear(&vf->os);
 336   if(ret==-1)return(-1);
 337
 338   /* we can seek, so set out learning all about this file */
 339   vf->seekable=1;
 340   fseek(vf->f,0,SEEK_END);
 341   vf->offset=vf->end=ftell(vf->f);
 342
 343   /* We get the offset for the last page of the physical bitstream.
 344      Most OggVorbis files will contain a single logical bitstream */
 345   end=_get_prev_page(vf,&og);
 346
 347   /* moer than one logical bitstream? */
 348   if(ogg_page_serialno(&og)!=serialno){
 349
 350     /* Chained bitstream. Bisect-search each logical bitstream
 351        section.  Do so based on serial number only */
 352     _bisect_forward_serialno(vf,0,0,end+1,serialno,0);
 353
 354   }else{
 355
 356     /* Only one logical bitstream */
 357     _bisect_forward_serialno(vf,0,end,end+1,serialno,0);
 358
 359   }
 360
 361   _prefetch_all_headers(vf,&initial_i,&initial_c,dataoffset);
 362   ov_raw_seek(vf,0);
 363
 364   return(0);
 365 }
 366
 367 static int _open_nonseekable(OggVorbis_File *vf){
 368   /* we cannot seek. Set up a 'single' (current) logical bitstream entry  */
 369   vf->links=1;
 370   vf->vi=malloc(sizeof(vorbis_info));
 371   vf->vc=malloc(sizeof(vorbis_info));
 372
 373   /* Try to fetch the headers, maintaining all the storage */
 374   if(_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno)==-1)return(-1);
 375   _make_decode_ready(vf);
 376
 377   return 0;
 378 }
 379
 380 /* clear out the current logical bitstream decoder */
 381 static void _decode_clear(OggVorbis_File *vf){
 382   ogg_stream_clear(&vf->os);
 383   vorbis_dsp_clear(&vf->vd);
 384   vorbis_block_clear(&vf->vb);
 385   vf->pcm_offset=-1;
 386   vf->decode_ready=0;
 387 }
 388
 389 /* fetch and process a packet.  Handles the case where we're at a
 390    bitstream boundary and dumps the decoding machine.  If the decoding
 391    machine is unloaded, it loads it.  It also keeps pcm_offset up to
 392    date (seek and read both use this.  seek uses a special hack with
 393    readp).
 394
 395    return: -1) hole in the data (lost packet)
 396             0) need more date (only if readp==0)/eof
 397             1) got a packet
 398 */
 399
 400 static int _process_packet(OggVorbis_File *vf,int readp){
 401   ogg_page og;
 402
 403   /* handle one packet.  Try to fetch it from current stream state */
 404   /* extract packets from page */
 405   while(1){
 406
 407     /* process a packet if we can.  If the machine isn't loaded,
 408        neither is a page */
 409     if(vf->decode_ready){
 410       ogg_packet op;
 411       int result=ogg_stream_packetout(&vf->os,&op);
 412       int64_t frameno;
 413
 414       if(result==-1)return(-1); /* hole in the data. alert the toplevel */
 415       if(result>0){
 416         /* got a packet.  process it */
 417         frameno=op.frameno;
 418         if(!vorbis_synthesis(&vf->vb,&op)){ /* lazy check for lazy
 419                                                header handling.  The
 420                                                header packets aren't
 421                                                audio, so if/when we
 422                                                submit them,
 423                                                vorbis_synthesis will
 424                                                reject them */
 425           vorbis_synthesis_blockin(&vf->vd,&vf->vb);
 426
 427           /* update the pcm offset. */
 428           if(frameno!=-1){
 429             int link=(vf->seekable?vf->current_link:0);
 430             double **dummy;
 431             int i,samples;
 432
 433             /* this packet has a pcm_offset on it (the last packet
 434                completed on a page carries the offset) After processing
 435                (above), we know the pcm position of the *last* sample
 436                ready to be returned. Find the offset of the *first* */
 437
 438             samples=vorbis_synthesis_pcmout(&vf->vd,&dummy);
 439
 440             frameno-=samples;
 441             for(i=0;i<link;i++)
 442               frameno+=vf->pcmlengths[i];
 443             vf->pcm_offset=frameno;
 444           }
 445           return(1);
 446         }
 447       }
 448     }
 449
 450     if(!readp)return(0);
 451     if(_get_next_page(vf,&og,-1)<0)return(0); /* eof. leave unitialized */
 452
 453     /* has our decoding just traversed a bitstream boundary? */
 454     if(vf->decode_ready){
 455       if(vf->current_serialno!=ogg_page_serialno(&og)){
 456         _decode_clear(vf);
 457       }
 458     }
 459
 460     /* Do we need to load a new machine before submitting the page? */
 461     /* This is different in the seekable and non-seekable cases.
 462
 463        In the seekable case, we already have all the header
 464        information loaded and cached; we just initialize the machine
 465        with it and continue on our merry way.
 466
 467        In the non-seekable (streaming) case, we'll only be at a
 468        boundary if we just left the previous logical bitstream and
 469        we're now nominally at the header of the next bitstream
 470     */
 471
 472     if(!vf->decode_ready){
 473       int link;
 474       if(vf->seekable){
 475         vf->current_serialno=ogg_page_serialno(&og);
 476
 477         /* match the serialno to bitstream section.  We use this rather than
 478            offset positions to avoid problems near logical bitstream
 479            boundaries */
 480         for(link=0;link<vf->links;link++)
 481           if(vf->serialnos[link]==vf->current_serialno)break;
 482         if(link==vf->links)return(-1); /* sign of a bogus stream.  error out,
 483                                           leave machine uninitialized */
 484
 485         vf->current_link=link;
 486
 487         ogg_stream_init(&vf->os,vf->current_serialno);
 488         ogg_stream_reset(&vf->os,ogg_page_pageno(&og));
 489
 490       }else{
 491         /* we're streaming */
 492         /* fetch the three header packets, build the info struct */
 493
 494         _fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno);
 495         vf->current_link++;
 496         link=0;
 497       }
 498
 499       _make_decode_ready(vf);
 500     }
 501     ogg_stream_pagein(&vf->os,&og);
 502   }
 503 }
 504
 505 /**********************************************************************
 506  * The helpers are over; it's all toplevel interface from here on out */
 507
 508 /* clear out the OggVorbis_File struct */
 509 int ov_clear(OggVorbis_File *vf){
 510   if(vf){
 511     vorbis_block_clear(&vf->vb);
 512     vorbis_dsp_clear(&vf->vd);
 513     ogg_stream_clear(&vf->os);
 514
 515     if(vf->vi && vf->links){
 516       int i;
 517       for(i=0;i<vf->links;i++){
 518         vorbis_info_clear(vf->vi+i);
 519         vorbis_comment_clear(vf->vc+i);
 520       }
 521       free(vf->vi);
 522       free(vf->vc);
 523     }
 524     if(vf->dataoffsets)free(vf->dataoffsets);
 525     if(vf->pcmlengths)free(vf->pcmlengths);
 526     if(vf->serialnos)free(vf->serialnos);
 527     if(vf->offsets)free(vf->offsets);
 528     ogg_sync_clear(&vf->oy);
 529     if(vf->f)fclose(vf->f);
 530     memset(vf,0,sizeof(OggVorbis_File));
 531   }
 532   _VDBG_dump();
 533   return(0);
 534 }
 535
 536 /* inspects the OggVorbis file and finds/documents all the logical
 537    bitstreams contained in it.  Tries to be tolerant of logical
 538    bitstream sections that are truncated/woogie.
 539
 540    return: -1) error
 541             0) OK
 542 */
 543
 544 int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
 545   long offset=fseek(f,0,SEEK_CUR);
 546   int ret;
 547
 548   memset(vf,0,sizeof(OggVorbis_File));
 549   vf->f=f;
 550
 551   /* init the framing state */
 552   ogg_sync_init(&vf->oy);
 553
 554   /* perhaps some data was previously read into a buffer for testing
 555      against other stream types.  Allow initialization from this
 556      previously read data (as we may be reading from a non-seekable
 557      stream) */
 558   if(initial){
 559     char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
 560     memcpy(buffer,initial,ibytes);
 561     ogg_sync_wrote(&vf->oy,ibytes);
 562   }
 563
 564   /* can we seek? Stevens suggests the seek test was portable */
 565   if(offset!=-1){
 566     ret=_open_seekable(vf);
 567   }else{
 568     ret=_open_nonseekable(vf);
 569   }
 570   if(ret){
 571     vf->f=NULL;
 572     ov_clear(vf);
 573   }
 574   return(ret);
 575 }
 576
 577 /* How many logical bitstreams in this physical bitstream? */
 578 long ov_streams(OggVorbis_File *vf){
 579   return vf->links;
 580 }
 581
 582 /* Is the FILE * associated with vf seekable? */
 583 long ov_seekable(OggVorbis_File *vf){
 584   return vf->seekable;
 585 }
 586
 587 /* returns the bitrate for a given logical bitstream or the entire
 588    physical bitstream.  If the file is open for random access, it will
 589    find the *actual* average bitrate.  If the file is streaming, it
 590    returns the nominal bitrate (if set) else the average of the
 591    upper/lower bounds (if set) else -1 (unset).
 592
 593    If you want the actual bitrate field settings, get them from the
 594    vorbis_info structs */
 595
 596 long ov_bitrate(OggVorbis_File *vf,int i){
 597   if(i>=vf->links)return(-1);
 598   if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
 599   if(i<0){
 600     int64_t bits=0;
 601     int i;
 602     for(i=0;i<vf->links;i++)
 603       bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
 604     return(rint(bits/ov_time_total(vf,-1)));
 605   }else{
 606     if(vf->seekable){
 607       /* return the actual bitrate */
 608       return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
 609     }else{
 610       /* return nominal if set */
 611       if(vf->vi[i].bitrate_nominal>0){
 612         return vf->vi[i].bitrate_nominal;
 613       }else{
 614         if(vf->vi[i].bitrate_upper>0){
 615           if(vf->vi[i].bitrate_lower>0){
 616             return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
 617           }else{
 618             return vf->vi[i].bitrate_upper;
 619           }
 620         }
 621         return(-1);
 622       }
 623     }
 624   }
 625 }
 626
 627 /* Guess */
 628 long ov_serialnumber(OggVorbis_File *vf,int i){
 629   if(i>=vf->links)return(-1);
 630   if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
 631   if(i<0){
 632     return(vf->current_serialno);
 633   }else{
 634     return(vf->serialnos[i]);
 635   }
 636 }
 637
 638 /* returns: total raw (compressed) length of content if i==-1
 639             raw (compressed) length of that logical bitstream for i==0 to n
 640             -1 if the stream is not seekable (we can't know the length)
 641 */
 642 long ov_raw_total(OggVorbis_File *vf,int i){
 643   if(!vf->seekable || i>=vf->links)return(-1);
 644   if(i<0){
 645     long acc=0;
 646     int i;
 647     for(i=0;i<vf->links;i++)
 648       acc+=ov_raw_total(vf,i);
 649     return(acc);
 650   }else{
 651     return(vf->offsets[i+1]-vf->offsets[i]);
 652   }
 653 }
 654
 655 /* returns: total PCM length (samples) of content if i==-1
 656             PCM length (samples) of that logical bitstream for i==0 to n
 657             -1 if the stream is not seekable (we can't know the length)
 658 */
 659 int64_t ov_pcm_total(OggVorbis_File *vf,int i){
 660   if(!vf->seekable || i>=vf->links)return(-1);
 661   if(i<0){
 662     int64_t acc=0;
 663     int i;
 664     for(i=0;i<vf->links;i++)
 665       acc+=ov_pcm_total(vf,i);
 666     return(acc);
 667   }else{
 668     return(vf->pcmlengths[i]);
 669   }
 670 }
 671
 672 /* returns: total seconds of content if i==-1
 673             seconds in that logical bitstream for i==0 to n
 674             -1 if the stream is not seekable (we can't know the length)
 675 */
 676 double ov_time_total(OggVorbis_File *vf,int i){
 677   if(!vf->seekable || i>=vf->links)return(-1);
 678   if(i<0){
 679     double acc=0;
 680     int i;
 681     for(i=0;i<vf->links;i++)
 682       acc+=ov_time_total(vf,i);
 683     return(acc);
 684   }else{
 685     return((float)(vf->pcmlengths[i])/vf->vi[i].rate);
 686   }
 687 }
 688
 689 /* seek to an offset relative to the *compressed* data. This also
 690    immediately sucks in and decodes pages to update the PCM cursor. It
 691    will cross a logical bitstream boundary, but only if it can't get
 692    any packets out of the tail of the bitstream we seek to (so no
 693    surprises).
 694
 695    returns zero on success, nonzero on failure */
 696
 697 int ov_raw_seek(OggVorbis_File *vf,long pos){
 698
 699   if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
 700   if(pos<0 || pos>vf->offsets[vf->links])goto seek_error;
 701
 702   /* clear out decoding machine state */
 703   _decode_clear(vf);
 704
 705   /* seek */
 706   _seek_helper(vf,pos);
 707
 708   /* we need to make sure the pcm_offset is set.  We use the
 709      _fetch_packet helper to process one packet with readp set, then
 710      call it until it returns '0' with readp not set (the last packet
 711      from a page has the 'frameno' field set, and that's how the
 712      helper updates the offset */
 713
 714   switch(_process_packet(vf,1)){
 715   case 0:
 716     /* oh, eof. There are no packets remaining.  Set the pcm offset to
 717        the end of file */
 718     vf->pcm_offset=ov_pcm_total(vf,-1);
 719     return(0);
 720   case -1:
 721     /* error! missing data or invalid bitstream structure */
 722     goto seek_error;
 723   default:
 724     /* all OK */
 725     break;
 726   }
 727
 728   while(1){
 729     switch(_process_packet(vf,0)){
 730     case 0:
 731       /* the offset is set.  If it's a bogus bitstream with no offset
 732          information, it's not but that's not our fault.  We still run
 733          gracefully, we're just missing the offset */
 734       return(0);
 735     case -1:
 736       /* error! missing data or invalid bitstream structure */
 737       goto seek_error;
 738     default:
 739       /* continue processing packets */
 740       break;
 741     }
 742   }
 743
 744  seek_error:
 745   /* dump the machine so we're in a known state */
 746   _decode_clear(vf);
 747   return -1;
 748 }
 749
 750 /* seek to a sample offset relative to the decompressed pcm stream
 751
 752    returns zero on success, nonzero on failure */
 753
 754 int ov_pcm_seek(OggVorbis_File *vf,int64_t pos){
 755   int link=-1;
 756   int64_t total=ov_pcm_total(vf,-1);
 757
 758   if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
 759   if(pos<0 || pos>total)goto seek_error;
 760
 761   /* which bitstream section does this pcm offset occur in? */
 762   for(link=vf->links-1;link>=0;link--){
 763     total-=vf->pcmlengths[link];
 764     if(pos>=total)break;
 765   }
 766
 767   /* search within the logical bitstream for the page with the highest
 768      pcm_pos preceeding (or equal to) pos.  There is a danger here;
 769      missing pages or incorrect frame number information in the
 770      bitstream could make our task impossible.  Account for that (it
 771      would be an error condition) */
 772   {
 773     int64_t target=pos-total;
 774     long end=vf->offsets[link+1];
 775     long begin=vf->offsets[link];
 776     long best=begin;
 777
 778     ogg_page og;
 779     while(begin<end){
 780       long bisect;
 781       long ret;
 782
 783       if(end-begin<CHUNKSIZE){
 784         bisect=begin;
 785       }else{
 786         bisect=(end+begin)/2;
 787       }
 788
 789       _seek_helper(vf,bisect);
 790       ret=_get_next_page(vf,&og,end-bisect);
 791
 792       if(ret==-1){
 793         end=bisect;
 794       }else{
 795         int64_t frameno=ogg_page_frameno(&og);
 796         if(frameno<target){
 797           best=ret;  /* raw offset of packet with frameno */
 798           begin=vf->offset; /* raw offset of next packet */
 799         }else{
 800           end=bisect;
 801         }
 802       }
 803     }
 804
 805     /* found our page. seek to it (call raw_seek). */
 806
 807     if(ov_raw_seek(vf,best))goto seek_error;
 808   }
 809
 810   /* verify result */
 811   if(vf->pcm_offset>=pos)goto seek_error;
 812   if(pos>ov_pcm_total(vf,-1))goto seek_error;
 813
 814   /* discard samples until we reach the desired position. Crossing a
 815      logical bitstream boundary with abandon is OK. */
 816   while(vf->pcm_offset<pos){
 817     double **pcm;
 818     long target=pos-vf->pcm_offset;
 819     long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
 820
 821     if(samples>target)samples=target;
 822     vorbis_synthesis_read(&vf->vd,samples);
 823     vf->pcm_offset+=samples;
 824
 825     if(samples<target)
 826       if(_process_packet(vf,1)==0)
 827         vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
 828   }
 829   return 0;
 830
 831  seek_error:
 832   /* dump machine so we're in a known state */
 833   _decode_clear(vf);
 834   return -1;
 835 }
 836
 837 /* seek to a playback time relative to the decompressed pcm stream
 838    returns zero on success, nonzero on failure */
 839 int ov_time_seek(OggVorbis_File *vf,double seconds){
 840   /* translate time to PCM position and call ov_pcm_seek */
 841
 842   int link=-1;
 843   int64_t pcm_total=ov_pcm_total(vf,-1);
 844   double time_total=ov_time_total(vf,-1);
 845
 846   if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
 847   if(seconds<0 || seconds>time_total)goto seek_error;
 848
 849   /* which bitstream section does this time offset occur in? */
 850   for(link=vf->links-1;link>=0;link--){
 851     pcm_total-=vf->pcmlengths[link];
 852     time_total-=ov_time_total(vf,link);
 853     if(seconds>=time_total)break;
 854   }
 855
 856   /* enough information to convert time offset to pcm offset */
 857   {
 858     int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
 859     return(ov_pcm_seek(vf,target));
 860   }
 861
 862  seek_error:
 863   /* dump machine so we're in a known state */
 864   _decode_clear(vf);
 865   return -1;
 866 }
 867
 868 /* tell the current stream offset cursor.  Note that seek followed by
 869    tell will likely not give the set offset due to caching */
 870 long ov_raw_tell(OggVorbis_File *vf){
 871   return(vf->offset);
 872 }
 873
 874 /* return PCM offset (sample) of next PCM sample to be read */
 875 int64_t ov_pcm_tell(OggVorbis_File *vf){
 876   return(vf->pcm_offset);
 877 }
 878
 879 /* return time offset (seconds) of next PCM sample to be read */
 880 double ov_time_tell(OggVorbis_File *vf){
 881   /* translate time to PCM position and call ov_pcm_seek */
 882
 883   int link=-1;
 884   int64_t pcm_total=0;
 885   double time_total=0.;
 886
 887   if(vf->seekable){
 888     pcm_total=ov_pcm_total(vf,-1);
 889     time_total=ov_time_total(vf,-1);
 890
 891     /* which bitstream section does this time offset occur in? */
 892     for(link=vf->links-1;link>=0;link--){
 893       pcm_total-=vf->pcmlengths[link];
 894       time_total-=ov_time_total(vf,link);
 895       if(vf->pcm_offset>pcm_total)break;
 896     }
 897   }
 898
 899   return(time_total+(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
 900 }
 901
 902 /*  link:   -1) return the vorbis_info struct for the bitstream section
 903                 currently being decoded
 904            0-n) to request information for a specific bitstream section
 905
 906     In the case of a non-seekable bitstream, any call returns the
 907     current bitstream.  NULL in the case that the machine is not
 908     initialized */
 909
 910 vorbis_info *ov_info(OggVorbis_File *vf,int link){
 911   if(vf->seekable){
 912     if(link<0)
 913       if(vf->decode_ready)
 914         return vf->vi+vf->current_link;
 915       else
 916         return NULL;
 917     else
 918       if(link>=vf->links)
 919         return NULL;
 920       else
 921         return vf->vi+link;
 922   }else{
 923     if(vf->decode_ready)
 924       return vf->vi;
 925     else
 926       return NULL;
 927   }
 928 }
 929
 930 /* grr, strong typing, grr, no templates/inheritence, grr */
 931 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
 932   if(vf->seekable){
 933     if(link<0)
 934       if(vf->decode_ready)
 935         return vf->vc+vf->current_link;
 936       else
 937         return NULL;
 938     else
 939       if(link>=vf->links)
 940         return NULL;
 941       else
 942         return vf->vc+link;
 943   }else{
 944     if(vf->decode_ready)
 945       return vf->vc;
 946     else
 947       return NULL;
 948   }
 949 }
 950
 951 /* up to this point, everything could more or less hide the multiple
 952    logical bitstream nature of chaining from the toplevel application
 953    if the toplevel application didn't particularly care.  However, at
 954    the point that we actually read audio back, the multiple-section
 955    nature must surface: Multiple bitstream sections do not necessarily
 956    have to have the same number of channels or sampling rate.
 957
 958    ov_read returns the sequential logical bitstream number currently
 959    being decoded along with the PCM data in order that the toplevel
 960    application can take action on channel/sample rate changes.  This
 961    number will be incremented even for streamed (non-seekable) streams
 962    (for seekable streams, it represents the actual logical bitstream
 963    index within the physical bitstream.  Note that the accessor
 964    functions above are aware of this dichotomy).
 965
 966    input values: buffer) a buffer to hold packed PCM data for return
 967                  length) the byte length requested to be placed into buffer
 968                  bigendianp) should the data be packed LSB first (0) or
 969                              MSB first (1)
 970                  word) word size for output.  currently 1 (byte) or
 971                        2 (16 bit short)
 972
 973    return values: -1) error/hole in data
 974                    0) EOF
 975                    n) number of bytes of PCM actually returned.  The
 976                    below works on a packet-by-packet basis, so the
 977                    return length is not related to the 'length' passed
 978                    in, just guaranteed to fit.
 979
 980             *section) set to the logical bitstream number */
 981
 982 long ov_read(OggVorbis_File *vf,char *buffer,int length,
 983                     int bigendianp,int word,int sgned,int *bitstream){
 984   int i,j;
 985
 986   while(1){
 987     if(vf->decode_ready){
 988       double **pcm;
 989       long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
 990       if(samples){
 991         /* yay! proceed to pack data into the byte buffer */
 992
 993         long channels=ov_info(vf,-1)->channels;
 994         long bytespersample=word * channels;
 995         if(samples>length/bytespersample)samples=length/bytespersample;
 996
 997         /* a tight loop to pack each size */
 998         {
 999           if(word==1){
1000             int off=(sgned?0:128);
1001             for(j=0;j<samples;j++)
1002               for(i=0;i<channels;i++){
1003                 int val=rint(pcm[i][j]*128.);
1004                 if(val>127)val=127;
1005                 if(val<-128)val=-128;
1006                 *buffer++=val+off;
1007               }
1008           }else{
1009             int off=(sgned?0:32768);
1010
1011             if(bigendianp){
1012               for(j=0;j<samples;j++)
1013                 for(i=0;i<channels;i++){
1014                   int val=rint(pcm[i][j]*32768.);
1015                   if(val>32767)val=32767;
1016                   if(val<-32768)val=-32768;
1017                   val+=off;
1018                   *buffer++=(val>>8);
1019                   *buffer++=(val&0xff);
1020                 }
1021             }else{
1022               for(j=0;j<samples;j++)
1023                 for(i=0;i<channels;i++){
1024                   int val=rint(pcm[i][j]*32768.);
1025                   if(val>32767)val=32767;
1026                   if(val<-32768)val=-32768;
1027                   val+=off;
1028                   *buffer++=(val&0xff);
1029                   *buffer++=(val>>8);
1030                 }
1031
1032             }
1033           }
1034         }
1035
1036         vorbis_synthesis_read(&vf->vd,samples);
1037         vf->pcm_offset+=samples;
1038         if(bitstream)*bitstream=vf->current_link;
1039         return(samples*bytespersample);
1040       }
1041     }
1042
1043     /* suck in another packet */
1044     switch(_process_packet(vf,1)){
1045     case 0:
1046       return(0);
1047     case -1:
1048       return -1;
1049     default:
1050       break;
1051     }
1052   }
1053 }
1054
1055
1056
1057