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