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