lib/vorbisfile.c

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