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