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