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.12 2000/01/05 03:11:05 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
  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_clear(vi);
 218   vorbis_info_init(vi);
 219
 220   i=0;
 221   while(i<3){
 222     ogg_stream_pagein(&vf->os,&og);
 223     while(i<3){
 224       int result=ogg_stream_packetout(&vf->os,&op);
 225       if(result==0)break;
 226       if(result==-1){
 227         fprintf(stderr,"Corrupt header in logical bitstream.\n");
 228         goto bail_header;
 229       }
 230       if(vorbis_info_headerin(vi,&op)){
 231         fprintf(stderr,"Illegal header in logical bitstream.\n");
 232         goto bail_header;
 233       }
 234       i++;
 235     }
 236     if(i<3)
 237       if(_get_next_page(vf,&og,1)<0){
 238         fprintf(stderr,"Missing header in logical bitstream.\n");
 239         goto bail_header;
 240       }
 241   }
 242   ogg_stream_clear(&vf->os);
 243   return 0;
 244
 245  bail_header:
 246   vorbis_info_clear(vi);
 247   ogg_stream_clear(&vf->os);
 248   return -1;
 249 }
 250
 251 /* last step of the OggVorbis_File initialization; get all the
 252    vorbis_info structs and PCM positions.  Only called by the seekable
 253    initialization (local stream storage is hacked slightly; pay
 254    attention to how that's done) */
 255 static void _prefetch_all_headers(OggVorbis_File *vf,vorbis_info *first,
 256                                   long dataoffset){
 257   ogg_page og;
 258   int i,ret;
 259
 260   vf->vi=calloc(vf->links,sizeof(vorbis_info));
 261   vf->dataoffsets=malloc(vf->links*sizeof(long));
 262   vf->pcmlengths=malloc(vf->links*sizeof(int64_t));
 263   vf->serialnos=malloc(vf->links*sizeof(long));
 264
 265   for(i=0;i<vf->links;i++){
 266     if(first && i==0){
 267       /* we already grabbed the initial header earlier.  This just
 268          saves the waste of grabbing it again */
 269       memcpy(vf->vi+i,first,sizeof(vorbis_info));
 270       memset(first,0,sizeof(vorbis_info));
 271       vf->dataoffsets[i]=dataoffset;
 272     }else{
 273
 274       /* seek to the location of the initial header */
 275
 276       _seek_helper(vf,vf->offsets[i]);
 277       if(_fetch_headers(vf,vf->vi+i,NULL)==-1){
 278         vorbis_info_clear(vf->vi+i);
 279         fprintf(stderr,"Error opening logical bitstream #%d.\n\n",i+1);
 280
 281         ogg_stream_clear(&vf->os); /* clear local storage.  This is not
 282                                       done in _fetch_headers, as that may
 283                                       be called in a non-seekable stream
 284                                       (in which case, we need to preserve
 285                                       the stream local storage) */
 286         vf->dataoffsets[i]=-1;
 287       }else
 288         vf->dataoffsets[i]=vf->offset;
 289     }
 290
 291     /* get the serial number and PCM length of this link. To do this,
 292        get the last page of the stream */
 293     {
 294       long end=vf->offsets[i+1];
 295       _seek_helper(vf,end);
 296
 297       while(1){
 298         ret=_get_prev_page(vf,&og);
 299         if(ret==-1){
 300           /* this should not be possible */
 301           fprintf(stderr,"Could not find last page of logical "
 302                   "bitstream #%d\n\n",i);
 303           vorbis_info_clear(vf->vi+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 _open_seekable(OggVorbis_File *vf){
 317   vorbis_info initial;
 318   long serialno,end;
 319   int ret;
 320   long dataoffset;
 321   ogg_page og;
 322
 323   /* is this even vorbis...? */
 324   memset(&initial,0,sizeof(vorbis_info));
 325   ret=_fetch_headers(vf,&initial,&serialno);
 326   dataoffset=vf->offset;
 327   ogg_stream_clear(&vf->os);
 328   if(ret==-1)return(-1);
 329
 330   /* we can seek, so set out learning all about this file */
 331   vf->seekable=1;
 332   fseek(vf->f,0,SEEK_END);
 333   vf->offset=vf->end=ftell(vf->f);
 334
 335   /* We get the offset for the last page of the physical bitstream.
 336      Most OggVorbis files will contain a single logical bitstream */
 337   end=_get_prev_page(vf,&og);
 338
 339   /* moer than one logical bitstream? */
 340   if(ogg_page_serialno(&og)!=serialno){
 341
 342     /* Chained bitstream. Bisect-search each logical bitstream
 343        section.  Do so based on serial number only */
 344     _bisect_forward_serialno(vf,0,0,end+1,serialno,0);
 345
 346   }else{
 347
 348     /* Only one logical bitstream */
 349     _bisect_forward_serialno(vf,0,end,end+1,serialno,0);
 350
 351   }
 352
 353   _prefetch_all_headers(vf,&initial,dataoffset);
 354   ov_raw_seek(vf,0);
 355
 356   return(0);
 357 }
 358
 359 static int _open_nonseekable(OggVorbis_File *vf){
 360   /* we cannot seek. Set up a 'single' (current) logical bitstream entry  */
 361   vf->links=1;
 362   vf->vi=malloc(sizeof(vorbis_info));
 363
 364   /* Try to fetch the headers, maintaining all the storage */
 365   if(_fetch_headers(vf,vf->vi,&vf->current_serialno)==-1)return(-1);
 366
 367   return 0;
 368 }
 369
 370 /* clear out the current logical bitstream decoder */
 371 static void _decode_clear(OggVorbis_File *vf){
 372   ogg_stream_clear(&vf->os);
 373   vorbis_dsp_clear(&vf->vd);
 374   vorbis_block_clear(&vf->vb);
 375   vf->pcm_offset=-1;
 376   vf->decode_ready=0;
 377 }
 378
 379 /* fetch and process a packet.  Handles the case where we're at a
 380    bitstream boundary and dumps the decoding machine.  If the decoding
 381    machine is unloaded, it loads it.  It also keeps pcm_offset up to
 382    date (seek and read both use this.  seek uses a special hack with
 383    readp).
 384
 385    return: -1) hole in the data (lost packet)
 386             0) need more date (only if readp==0)/eof
 387             1) got a packet
 388 */
 389
 390 static int _process_packet(OggVorbis_File *vf,int readp){
 391   ogg_page og;
 392
 393   /* handle one packet.  Try to fetch it from current stream state */
 394   /* extract packets from page */
 395   while(1){
 396
 397     /* process a packet if we can.  If the machine isn't loaded,
 398        neither is a page */
 399     if(vf->decode_ready){
 400       ogg_packet op;
 401       int result=ogg_stream_packetout(&vf->os,&op);
 402       int64_t frameno;
 403
 404       if(result==-1)return(-1); /* hole in the data. alert the toplevel */
 405       if(result>0){
 406         /* got a packet.  process it */
 407         frameno=op.frameno;
 408         if(!vorbis_synthesis(&vf->vb,&op)){ /* lazy check for lazy
 409                                                header handling.  The
 410                                                header packets aren't
 411                                                audio, so if/when we
 412                                                submit them,
 413                                                vorbis_synthesis will
 414                                                reject them */
 415           vorbis_synthesis_blockin(&vf->vd,&vf->vb);
 416
 417           /* update the pcm offset. */
 418           if(frameno!=-1){
 419             int link=(vf->seekable?vf->current_link:0);
 420             double **dummy;
 421             int i,samples;
 422
 423             /* this packet has a pcm_offset on it (the last packet
 424                completed on a page carries the offset) After processing
 425                (above), we know the pcm position of the *last* sample
 426                ready to be returned. Find the offset of the *first* */
 427
 428             samples=vorbis_synthesis_pcmout(&vf->vd,&dummy);
 429
 430             frameno-=samples;
 431             for(i=0;i<link;i++)
 432               frameno+=vf->pcmlengths[i];
 433             vf->pcm_offset=frameno;
 434           }
 435           return(1);
 436         }
 437       }
 438     }
 439
 440     if(!readp)return(0);
 441     if(_get_next_page(vf,&og,-1)<0)return(0); /* eof. leave unitialized */
 442
 443     /* has our decoding just traversed a bitstream boundary? */
 444     if(vf->decode_ready){
 445       if(vf->current_serialno!=ogg_page_serialno(&og)){
 446         _decode_clear(vf);
 447       }
 448     }
 449
 450     /* Do we need to load a new machine before submitting the page? */
 451     /* This is different in the seekable and non-seekable cases.
 452
 453        In the seekable case, we already have all the header
 454        information loaded and cached; we just initialize the machine
 455        with it and continue on our merry way.
 456
 457        In the non-seekable (streaming) case, we'll only be at a
 458        boundary if we just left the previous logical bitstream and
 459        we're now nominally at the header of the next bitstream
 460     */
 461
 462     if(!vf->decode_ready){
 463       int link;
 464       if(vf->seekable){
 465         vf->current_serialno=ogg_page_serialno(&og);
 466
 467         /* match the serialno to bitstream section.  We use this rather than
 468            offset positions to avoid problems near logical bitstream
 469            boundaries */
 470         for(link=0;link<vf->links;link++)
 471           if(vf->serialnos[link]==vf->current_serialno)break;
 472         if(link==vf->links)return(-1); /* sign of a bogus stream.  error out,
 473                                           leave machine uninitialized */
 474
 475         vf->current_link=link;
 476       }else{
 477         /* we're streaming */
 478         /* fetch the three header packets, build the info struct */
 479
 480         _fetch_headers(vf,vf->vi,&vf->current_serialno);
 481         vf->current_link++;
 482         link=0;
 483       }
 484
 485       /* reload */
 486       ogg_stream_init(&vf->os,vf->current_serialno);
 487       ogg_stream_reset(&vf->os,ogg_page_pageno(&og));
 488       vorbis_synthesis_init(&vf->vd,vf->vi+link);
 489       vorbis_block_init(&vf->vd,&vf->vb);
 490       vf->decode_ready=1;
 491     }
 492     ogg_stream_pagein(&vf->os,&og);
 493   }
 494 }
 495
 496 /**********************************************************************
 497  * The helpers are over; it's all toplevel interface from here on out */
 498
 499 /* clear out the OggVorbis_File struct */
 500 int ov_clear(OggVorbis_File *vf){
 501   if(vf){
 502     vorbis_block_clear(&vf->vb);
 503     vorbis_dsp_clear(&vf->vd);
 504     ogg_stream_clear(&vf->os);
 505
 506     if(vf->vi && vf->links){
 507       int i;
 508       for(i=0;i<vf->links;i++)
 509         vorbis_info_clear(vf->vi+i);
 510       free(vf->vi);
 511     }
 512     if(vf->dataoffsets)free(vf->dataoffsets);
 513     if(vf->pcmlengths)free(vf->pcmlengths);
 514     if(vf->serialnos)free(vf->serialnos);
 515     if(vf->offsets)free(vf->offsets);
 516     ogg_sync_clear(&vf->oy);
 517     if(vf->f)fclose(vf->f);
 518     memset(vf,0,sizeof(OggVorbis_File));
 519   }
 520   return(0);
 521 }
 522
 523 /* inspects the OggVorbis file and finds/documents all the logical
 524    bitstreams contained in it.  Tries to be tolerant of logical
 525    bitstream sections that are truncated/woogie.
 526
 527    return: -1) error
 528             0) OK
 529 */
 530
 531 int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
 532   long offset=fseek(f,0,SEEK_CUR);
 533   int ret;
 534
 535   memset(vf,0,sizeof(OggVorbis_File));
 536   vf->f=f;
 537
 538   /* init the framing state */
 539   ogg_sync_init(&vf->oy);
 540
 541   /* perhaps some data was previously read into a buffer for testing
 542      against other stream types.  Allow initialization from this
 543      previously read data (as we may be reading from a non-seekable
 544      stream) */
 545   if(initial){
 546     char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
 547     memcpy(buffer,initial,ibytes);
 548     ogg_sync_wrote(&vf->oy,ibytes);
 549   }
 550
 551   /* can we seek? Stevens suggests the seek test was portable */
 552   if(offset!=-1){
 553     ret=_open_seekable(vf);
 554   }else{
 555     ret=_open_nonseekable(vf);
 556   }
 557   if(ret){
 558     vf->f=NULL;
 559     ov_clear(vf);
 560   }else{
 561     ogg_stream_init(&vf->os,vf->current_serialno);
 562     vorbis_synthesis_init(&vf->vd,vf->vi);
 563     vorbis_block_init(&vf->vd,&vf->vb);
 564     vf->decode_ready=1;
 565   }
 566   return(ret);
 567 }
 568
 569 /* How many logical bitstreams in this physical bitstream? */
 570 long ov_streams(OggVorbis_File *vf){
 571   return vf->links;
 572 }
 573
 574 /* Is the FILE * associated with vf seekable? */
 575 long ov_seekable(OggVorbis_File *vf){
 576   return vf->seekable;
 577 }
 578
 579 /* returns the bitrate for a given logical bitstream or the entire
 580    physical bitstream.  If the file is open for random access, it will
 581    find the *actual* average bitrate.  If the file is streaming, it
 582    returns the nominal bitrate (if set) else the average of the
 583    upper/lower bounds (if set) else -1 (unset).
 584
 585    If you want the actual bitrate field settings, get them from the
 586    vorbis_info structs */
 587
 588 long ov_bitrate(OggVorbis_File *vf,int i){
 589   if(i>=vf->links)return(-1);
 590   if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
 591   if(i<0){
 592     int64_t bits;
 593     int i;
 594     for(i=0;i<vf->links;i++)
 595       bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
 596     return(rint(bits/ov_time_total(vf,-1)));
 597   }else{
 598     if(vf->seekable){
 599       /* return the actual bitrate */
 600       return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
 601     }else{
 602       /* return nominal if set */
 603       if(vf->vi[i].bitrate_nominal>0){
 604         return vf->vi[i].bitrate_nominal;
 605       }else{
 606         if(vf->vi[i].bitrate_upper>0){
 607           if(vf->vi[i].bitrate_lower>0){
 608             return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
 609           }else{
 610             return vf->vi[i].bitrate_upper;
 611           }
 612         }
 613         return(-1);
 614       }
 615     }
 616   }
 617 }
 618
 619 /* Guess */
 620 long ov_serialnumber(OggVorbis_File *vf,int i){
 621   if(i>=vf->links)return(-1);
 622   if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
 623   if(i<0){
 624     return(vf->current_serialno);
 625   }else{
 626     return(vf->serialnos[i]);
 627   }
 628 }
 629
 630 /* returns: total raw (compressed) length of content if i==-1
 631             raw (compressed) length of that logical bitstream for i==0 to n
 632             -1 if the stream is not seekable (we can't know the length)
 633 */
 634 long ov_raw_total(OggVorbis_File *vf,int i){
 635   if(!vf->seekable || i>=vf->links)return(-1);
 636   if(i<0){
 637     long acc=0;
 638     int i;
 639     for(i=0;i<vf->links;i++)
 640       acc+=ov_raw_total(vf,i);
 641     return(acc);
 642   }else{
 643     return(vf->offsets[i+1]-vf->offsets[i]);
 644   }
 645 }
 646
 647 /* returns: total PCM length (samples) of content if i==-1
 648             PCM length (samples) of that logical bitstream for i==0 to n
 649             -1 if the stream is not seekable (we can't know the length)
 650 */
 651 int64_t ov_pcm_total(OggVorbis_File *vf,int i){
 652   if(!vf->seekable || i>=vf->links)return(-1);
 653   if(i<0){
 654     int64_t acc=0;
 655     int i;
 656     for(i=0;i<vf->links;i++)
 657       acc+=ov_pcm_total(vf,i);
 658     return(acc);
 659   }else{
 660     return(vf->pcmlengths[i]);
 661   }
 662 }
 663
 664 /* returns: total seconds of content if i==-1
 665             seconds in that logical bitstream for i==0 to n
 666             -1 if the stream is not seekable (we can't know the length)
 667 */
 668 double ov_time_total(OggVorbis_File *vf,int i){
 669   if(!vf->seekable || i>=vf->links)return(-1);
 670   if(i<0){
 671     double acc=0;
 672     int i;
 673     for(i=0;i<vf->links;i++)
 674       acc+=ov_time_total(vf,i);
 675     return(acc);
 676   }else{
 677     return((float)(vf->pcmlengths[i])/vf->vi[i].rate);
 678   }
 679 }
 680
 681 /* seek to an offset relative to the *compressed* data. This also
 682    immediately sucks in and decodes pages to update the PCM cursor. It
 683    will cross a logical bitstream boundary, but only if it can't get
 684    any packets out of the tail of the bitstream we seek to (so no
 685    surprises).
 686
 687    returns zero on success, nonzero on failure */
 688
 689 int ov_raw_seek(OggVorbis_File *vf,long pos){
 690
 691   if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
 692   if(pos<0 || pos>vf->offsets[vf->links])goto seek_error;
 693
 694   /* clear out decoding machine state */
 695   _decode_clear(vf);
 696
 697   /* seek */
 698   _seek_helper(vf,pos);
 699
 700   /* we need to make sure the pcm_offset is set.  We use the
 701      _fetch_packet helper to process one packet with readp set, then
 702      call it until it returns '0' with readp not set (the last packet
 703      from a page has the 'frameno' field set, and that's how the
 704      helper updates the offset */
 705
 706   switch(_process_packet(vf,1)){
 707   case 0:
 708     /* oh, eof. There are no packets remaining.  Set the pcm offset to
 709        the end of file */
 710     vf->pcm_offset=ov_pcm_total(vf,-1);
 711     return(0);
 712   case -1:
 713     /* error! missing data or invalid bitstream structure */
 714     goto seek_error;
 715   default:
 716     /* all OK */
 717     break;
 718   }
 719
 720   while(1){
 721     switch(_process_packet(vf,0)){
 722     case 0:
 723       /* the offset is set.  If it's a bogus bitstream with no offset
 724          information, it's not but that's not our fault.  We still run
 725          gracefully, we're just missing the offset */
 726       return(0);
 727     case -1:
 728       /* error! missing data or invalid bitstream structure */
 729       goto seek_error;
 730     default:
 731       /* continue processing packets */
 732       break;
 733     }
 734   }
 735
 736  seek_error:
 737   /* dump the machine so we're in a known state */
 738   _decode_clear(vf);
 739   return -1;
 740 }
 741
 742 /* seek to a sample offset relative to the decompressed pcm stream
 743
 744    returns zero on success, nonzero on failure */
 745
 746 int ov_pcm_seek(OggVorbis_File *vf,int64_t pos){
 747   int link=-1;
 748   int64_t total=ov_pcm_total(vf,-1);
 749
 750   if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
 751   if(pos<0 || pos>total)goto seek_error;
 752
 753   /* which bitstream section does this pcm offset occur in? */
 754   for(link=vf->links-1;link>=0;link--){
 755     total-=vf->pcmlengths[link];
 756     if(pos>=total)break;
 757   }
 758
 759   /* search within the logical bitstream for the page with the highest
 760      pcm_pos preceeding (or equal to) pos.  There is a danger here;
 761      missing pages or incorrect frame number information in the
 762      bitstream could make our task impossible.  Account for that (it
 763      would be an error condition) */
 764   {
 765     int64_t target=pos-total;
 766     long end=vf->offsets[link+1];
 767     long begin=vf->offsets[link];
 768     long best=begin;
 769
 770     ogg_page og;
 771     while(begin<end){
 772       long bisect;
 773       long ret;
 774
 775       if(end-begin<CHUNKSIZE){
 776         bisect=begin;
 777       }else{
 778         bisect=(end+begin)/2;
 779       }
 780
 781       _seek_helper(vf,bisect);
 782       ret=_get_next_page(vf,&og,end-bisect);
 783
 784       if(ret==-1){
 785         end=bisect;
 786       }else{
 787         int64_t frameno=ogg_page_frameno(&og);
 788         if(frameno<target){
 789           best=ret;  /* raw offset of packet with frameno */
 790           begin=vf->offset; /* raw offset of next packet */
 791         }else{
 792           end=bisect;
 793         }
 794       }
 795     }
 796
 797     /* found our page. seek to it (call raw_seek). */
 798
 799     if(ov_raw_seek(vf,best))goto seek_error;
 800   }
 801
 802   /* verify result */
 803   if(vf->pcm_offset>=pos)goto seek_error;
 804   if(pos>ov_pcm_total(vf,-1))goto seek_error;
 805
 806   /* discard samples until we reach the desired position. Crossing a
 807      logical bitstream boundary with abandon is OK. */
 808   while(vf->pcm_offset<pos){
 809     double **pcm;
 810     long target=pos-vf->pcm_offset;
 811     long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
 812
 813     if(samples>target)samples=target;
 814     vorbis_synthesis_read(&vf->vd,samples);
 815     vf->pcm_offset+=samples;
 816
 817     if(samples<target)
 818       if(_process_packet(vf,1)==0)
 819         vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
 820   }
 821   return 0;
 822
 823  seek_error:
 824   /* dump machine so we're in a known state */
 825   _decode_clear(vf);
 826   return -1;
 827 }
 828
 829 /* seek to a playback time relative to the decompressed pcm stream
 830    returns zero on success, nonzero on failure */
 831 int ov_time_seek(OggVorbis_File *vf,double seconds){
 832   /* translate time to PCM position and call ov_pcm_seek */
 833
 834   int link=-1;
 835   int64_t pcm_total=ov_pcm_total(vf,-1);
 836   double time_total=ov_time_total(vf,-1);
 837
 838   if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
 839   if(seconds<0 || seconds>time_total)goto seek_error;
 840
 841   /* which bitstream section does this time offset occur in? */
 842   for(link=vf->links-1;link>=0;link--){
 843     pcm_total-=vf->pcmlengths[link];
 844     time_total-=ov_time_total(vf,link);
 845     if(seconds>=time_total)break;
 846   }
 847
 848   /* enough information to convert time offset to pcm offset */
 849   {
 850     int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
 851     return(ov_pcm_seek(vf,target));
 852   }
 853
 854  seek_error:
 855   /* dump machine so we're in a known state */
 856   _decode_clear(vf);
 857   return -1;
 858 }
 859
 860 /* tell the current stream offset cursor.  Note that seek followed by
 861    tell will likely not give the set offset due to caching */
 862 long ov_raw_tell(OggVorbis_File *vf){
 863   return(vf->offset);
 864 }
 865
 866 /* return PCM offset (sample) of next PCM sample to be read */
 867 int64_t ov_pcm_tell(OggVorbis_File *vf){
 868   return(vf->pcm_offset);
 869 }
 870
 871 /* return time offset (seconds) of next PCM sample to be read */
 872 double ov_time_tell(OggVorbis_File *vf){
 873   /* translate time to PCM position and call ov_pcm_seek */
 874
 875   int link=-1;
 876   int64_t pcm_total=0;
 877   double time_total=0.;
 878
 879   if(vf->seekable){
 880     pcm_total=ov_pcm_total(vf,-1);
 881     time_total=ov_time_total(vf,-1);
 882
 883     /* which bitstream section does this time offset occur in? */
 884     for(link=vf->links-1;link>=0;link--){
 885       pcm_total-=vf->pcmlengths[link];
 886       time_total-=ov_time_total(vf,link);
 887       if(vf->pcm_offset>pcm_total)break;
 888     }
 889   }
 890
 891   return(time_total+(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
 892 }
 893
 894 /*  link:   -1) return the vorbis_info struct for the bitstream section
 895                 currently being decoded
 896            0-n) to request information for a specific bitstream section
 897
 898     In the case of a non-seekable bitstream, any call returns the
 899     current bitstream.  NULL in the case that the machine is not
 900     initialized */
 901
 902 vorbis_info *ov_info(OggVorbis_File *vf,int link){
 903   if(vf->seekable){
 904     if(link<0)
 905       if(vf->decode_ready)
 906         return vf->vi+vf->current_link;
 907       else
 908         return NULL;
 909     else
 910       if(link>=vf->links)
 911         return NULL;
 912       else
 913         return vf->vi+link;
 914   }else{
 915     if(vf->decode_ready)
 916       return vf->vi;
 917     else
 918       return NULL;
 919   }
 920 }
 921
 922 /* up to this point, everything could more or less hide the multiple
 923    logical bitstream nature of chaining from the toplevel application
 924    if the toplevel application didn't particularly care.  However, at
 925    the point that we actually read audio back, the multiple-section
 926    nature must surface: Multiple bitstream sections do not necessarily
 927    have to have the same number of channels or sampling rate.
 928
 929    ov_read returns the sequential logical bitstream number currently
 930    being decoded along with the PCM data in order that the toplevel
 931    application can take action on channel/sample rate changes.  This
 932    number will be incremented even for streamed (non-seekable) streams
 933    (for seekable streams, it represents the actual logical bitstream
 934    index within the physical bitstream.  Note that the accessor
 935    functions above are aware of this dichotomy).
 936
 937    input values: buffer) a buffer to hold packed PCM data for return
 938                  length) the byte length requested to be placed into buffer
 939                  bigendianp) should the data be packed LSB first (0) or
 940                              MSB first (1)
 941                  word) word size for output.  currently 1 (byte) or
 942                        2 (16 bit short)
 943
 944    return values: -1) error/hole in data
 945                    0) EOF
 946                    n) number of bytes of PCM actually returned.  The
 947                    below works on a packet-by-packet basis, so the
 948                    return length is not related to the 'length' passed
 949                    in, just guaranteed to fit.
 950
 951             *section) set to the logical bitstream number */
 952
 953 long ov_read(OggVorbis_File *vf,char *buffer,int length,
 954                     int bigendianp,int word,int sgned,int *bitstream){
 955   int i,j;
 956
 957   while(1){
 958     if(vf->decode_ready){
 959       double **pcm;
 960       long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
 961       if(samples){
 962         /* yay! proceed to pack data into the byte buffer */
 963
 964         long channels=ov_info(vf,-1)->channels;
 965         long bytespersample=word * channels;
 966         if(samples>length/bytespersample)samples=length/bytespersample;
 967
 968         /* a tight loop to pack each size */
 969         {
 970           if(word==1){
 971             int off=(sgned?0:128);
 972             for(j=0;j<samples;j++)
 973               for(i=0;i<channels;i++){
 974                 int val=rint(pcm[i][j]*128.);
 975                 if(val>127)val=127;
 976                 if(val<-128)val=-128;
 977                 *buffer++=val+off;
 978               }
 979           }else{
 980             int off=(sgned?0:32768);
 981
 982             if(bigendianp){
 983               for(j=0;j<samples;j++)
 984                 for(i=0;i<channels;i++){
 985                   int val=rint(pcm[i][j]*32768.);
 986                   if(val>32767)val=32767;
 987                   if(val<-32768)val=-32768;
 988                   val+=off;
 989                   *buffer++=(val>>8);
 990                   *buffer++=(val&0xff);
 991                 }
 992             }else{
 993               for(j=0;j<samples;j++)
 994                 for(i=0;i<channels;i++){
 995                   int val=rint(pcm[i][j]*32768.);
 996                   if(val>32767)val=32767;
 997                   if(val<-32768)val=-32768;
 998                   val+=off;
 999                   *buffer++=(val&0xff);
1000                   *buffer++=(val>>8);
1001                 }
1002
1003             }
1004           }
1005         }
1006
1007         vorbis_synthesis_read(&vf->vd,samples);
1008         vf->pcm_offset+=samples;
1009         if(bitstream)*bitstream=vf->current_link;
1010         return(samples*bytespersample);
1011       }
1012     }
1013
1014     /* suck in another packet */
1015     switch(_process_packet(vf,1)){
1016     case 0:
1017       return(0);
1018     case -1:
1019       return -1;
1020     default:
1021       break;
1022     }
1023   }
1024 }
1025
1026
1027
1028