1 /********************************************************************
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. *
8 * THE OggSQUISH SOURCE CODE IS (C) COPYRIGHT 1994-1999 *
9 * by 1999 Monty <monty@xiph.org> and The XIPHOPHORUS Company *
10 * http://www.xiph.org/ *
12 ********************************************************************
14 function: stdio-based convenience library for opening/seeking/decoding
15 author: Monty <xiphmont@mit.edu>
16 modifications by: Monty
17 last modification date: Nov 16 1999
19 ********************************************************************/
26 #include "vorbisfile.h"
28 /* A 'chained bitstream' is a Vorbis bitstream that contains more than
29 one logical bitstream arranged end to end (the only form of Ogg
30 multiplexing allowed in a Vorbis bitstream; grouping [parallel
31 multiplexing] is not allowed in Vorbis) */
33 /* A Vorbis file can be played beginning to end (streamed) without
34 worrying ahead of time about chaining (see decoder_example.c). If
35 we have the whole file, however, and want random access
36 (seeking/scrubbing) or desire to know the total length/time of a
37 file, we need to account for the possibility of chaining. */
39 /* We can handle things a number of ways; we can determine the entire
40 bitstream structure right off the bat, or find pieces on demand.
41 This example determines and caches structure for the entire
42 bitstream, but builds a virtual decoder on the fly when moving
43 between links in the chain. */
45 /* There are also different ways to implement seeking. Enough
46 information exists in an Ogg bitstream to seek to
47 sample-granularity positions in the output. Or, one can seek by
48 picking some portion of the stream roughly in the desired area if
49 we only want course navigation through the stream. */
51 /*************************************************************************
52 * Many, many internal helpers. The intention is not to be confusing;
53 * rampant duplication and monolithic function implementation would be
54 * harder to understand anyway. The high level functions are last. Begin
55 * grokking near the end of the file */
57 /* read a little more data from the file/pipe into the ogg_sync framer */
58 #define CHUNKSIZE 4096
59 static long _get_data(OggVorbis_File *vf){
60 char *buffer=ogg_sync_buffer(&vf->oy,4096);
61 long bytes=fread(buffer,1,4096,vf->f);
62 ogg_sync_wrote(&vf->oy,bytes);
66 /* save a tiny smidge of verbosity to make the code more readable */
67 static void _seek_helper(OggVorbis_File *vf,long offset){
68 fseek(vf->f,offset,SEEK_SET);
70 ogg_sync_reset(&vf->oy);
73 /* The read/seek functions track absolute position within the stream */
75 /* from the head of the stream, get the next page. boundary specifies
76 if the function is allowed to fetch more data from the stream (and
77 how much) or only use internally buffered data.
79 boundary: -1) unbounded search
80 0) read no additional data; use cached only
81 n) search for a new page beginning for n bytes
83 return: -1) did not find a page
84 n) found a page at absolute offset n */
86 static long _get_next_page(OggVorbis_File *vf,ogg_page *og,int boundary){
87 if(boundary>0)boundary+=vf->offset;
91 if(boundary>0 && vf->offset>=boundary)return(-1);
92 more=ogg_sync_pageseek(&vf->oy,og);
99 /* send more paramedics */
100 if(!boundary)return(-1);
101 if(_get_data(vf)<=0)return(-1);
103 /* got a page. Return the offset at the page beginning,
104 advance the internal offset past the page end */
114 /* find the latest page beginning before the current stream cursor
115 position. Much dirtier than the above as Ogg doesn't have any
116 backward search linkage. no 'readp' as it will certainly have to
118 static long _get_prev_page(OggVorbis_File *vf,ogg_page *og){
119 long begin=vf->offset;
125 _seek_helper(vf,begin);
126 while(vf->offset<begin+CHUNKSIZE){
127 ret=_get_next_page(vf,og,begin+CHUNKSIZE-vf->offset);
136 /* we have the offset. Actually snork and hold the page now */
137 _seek_helper(vf,offset);
138 ret=_get_next_page(vf,og,CHUNKSIZE);
140 /* this shouldn't be possible */
141 fprintf(stderr,"Missed page fencepost at end of logical bitstream. "
148 /* finds each bitstream link one at a time using a bisection search
149 (has to begin by knowing the offset of the lb's initial page).
150 Recurses for each link so it can alloc the link storage after
151 finding them all, then unroll and fill the cache at the same time */
152 static void _bisect_forward_serialno(OggVorbis_File *vf,
158 long endsearched=end;
163 /* the below guards against garbage seperating the last and
164 first pages of two links. */
165 while(searched<endsearched){
168 if(endsearched-searched<CHUNKSIZE){
171 bisect=(searched+endsearched)/2;
174 _seek_helper(vf,bisect);
175 ret=_get_next_page(vf,&og,-1);
176 if(ret<0 || ogg_page_serialno(&og)!=currentno){
180 searched=ret+og.header_len+og.body_len;
184 _seek_helper(vf,next);
185 ret=_get_next_page(vf,&og,-1);
187 if(searched>=end || ret==-1){
189 vf->offsets=malloc((m+2)*sizeof(long));
190 vf->offsets[m+1]=searched;
192 _bisect_forward_serialno(vf,next,vf->offset,
193 end,ogg_page_serialno(&og),m+1);
196 vf->offsets[m]=begin;
199 /* uses the local ogg_stream storage in vf; this is important for
200 non-streaming input sources */
201 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,long *serialno){
206 ret=_get_next_page(vf,&og,CHUNKSIZE);
208 fprintf(stderr,"Did not find initial header for bitstream.\n");
212 if(serialno)*serialno=ogg_page_serialno(&og);
213 ogg_stream_init(&vf->os,ogg_page_serialno(&og));
215 /* extract the initial header from the first page and verify that the
216 Ogg bitstream is in fact Vorbis data */
218 vorbis_info_clear(vi);
219 vorbis_info_init(vi);
223 ogg_stream_pagein(&vf->os,&og);
225 int result=ogg_stream_packetout(&vf->os,&op);
228 fprintf(stderr,"Corrupt header in logical bitstream.\n");
231 if(vorbis_info_headerin(vi,&op)){
232 fprintf(stderr,"Illegal header in logical bitstream.\n");
238 if(_get_next_page(vf,&og,1)<0){
239 fprintf(stderr,"Missing header in logical bitstream.\n");
243 ogg_stream_clear(&vf->os);
247 vorbis_info_clear(vi);
248 ogg_stream_clear(&vf->os);
252 /* last step of the OggVorbis_File initialization; get all the
253 vorbis_info structs and PCM positions. Only called by the seekable
254 initialization (local stream storage is hacked slightly; pay
255 attention to how that's done) */
256 static void _prefetch_all_headers(OggVorbis_File *vf,vorbis_info *first,
261 vf->vi=calloc(vf->links,sizeof(vorbis_info));
262 vf->dataoffsets=malloc(vf->links*sizeof(long));
263 vf->pcmlengths=malloc(vf->links*sizeof(size64));
264 vf->serialnos=malloc(vf->links*sizeof(long));
266 for(i=0;i<vf->links;i++){
268 /* we already grabbed the initial header earlier. This just
269 saves the waste of grabbing it again */
270 memcpy(vf->vi+i,first,sizeof(vorbis_info));
271 memset(first,0,sizeof(vorbis_info));
272 vf->dataoffsets[i]=dataoffset;
275 /* seek to the location of the initial header */
277 _seek_helper(vf,vf->offsets[i]);
278 if(_fetch_headers(vf,vf->vi+i,NULL)==-1){
279 vorbis_info_clear(vf->vi+i);
280 fprintf(stderr,"Error opening logical bitstream #%d.\n\n",i+1);
282 ogg_stream_clear(&vf->os); /* clear local storage. This is not
283 done in _fetch_headers, as that may
284 be called in a non-seekable stream
285 (in which case, we need to preserve
286 the stream local storage) */
287 vf->dataoffsets[i]=-1;
289 vf->dataoffsets[i]=vf->offset;
292 /* get the serial number and PCM length of this link. To do this,
293 get the last page of the stream */
295 long end=vf->offsets[i+1];
296 _seek_helper(vf,end);
299 ret=_get_prev_page(vf,&og);
301 /* this should not be possible */
302 fprintf(stderr,"Could not find last page of logical "
303 "bitstream #%d\n\n",i);
304 vorbis_info_clear(vf->vi+i);
307 if(ogg_page_frameno(&og)!=-1){
308 vf->serialnos[i]=ogg_page_serialno(&og);
309 vf->pcmlengths[i]=ogg_page_frameno(&og);
317 static int _open_seekable(OggVorbis_File *vf){
324 /* is this even vorbis...? */
325 memset(&initial,0,sizeof(vorbis_info));
326 ret=_fetch_headers(vf,&initial,&serialno);
327 dataoffset=vf->offset;
328 ogg_stream_clear(&vf->os);
329 if(ret==-1)return(-1);
331 /* we can seek, so set out learning all about this file */
333 fseek(vf->f,0,SEEK_END);
334 vf->offset=vf->end=ftell(vf->f);
336 /* We get the offset for the last page of the physical bitstream.
337 Most OggVorbis files will contain a single logical bitstream */
338 end=_get_prev_page(vf,&og);
340 /* moer than one logical bitstream? */
341 if(ogg_page_serialno(&og)!=serialno){
343 /* Chained bitstream. Bisect-search each logical bitstream
344 section. Do so based on serial number only */
345 _bisect_forward_serialno(vf,0,0,end+1,serialno,0);
349 /* Only one logical bitstream */
350 _bisect_forward_serialno(vf,0,end,end+1,serialno,0);
354 _prefetch_all_headers(vf,&initial,dataoffset);
360 static int _open_nonseekable(OggVorbis_File *vf){
361 /* we cannot seek. Set up a 'single' (current) logical bitstream entry */
363 vf->vi=malloc(sizeof(vorbis_info));
365 /* Try to fetch the headers, maintaining all the storage */
366 if(_fetch_headers(vf,vf->vi,&vf->current_serialno)==-1)return(-1);
371 /* clear out the current logical bitstream decoder */
372 static void _decode_clear(OggVorbis_File *vf){
373 ogg_stream_clear(&vf->os);
374 vorbis_dsp_clear(&vf->vd);
375 vorbis_block_clear(&vf->vb);
380 /* fetch and process a packet. Handles the case where we're at a
381 bitstream boundary and dumps the decoding machine. If the decoding
382 machine is unloaded, it loads it. It also keeps pcm_offset up to
383 date (seek and read both use this. seek uses a special hack with
386 return: -1) hole in the data (lost packet)
387 0) need more date (only if readp==0)/eof
391 static int _process_packet(OggVorbis_File *vf,int readp){
394 /* handle one packet. Try to fetch it from current stream state */
395 /* extract packets from page */
398 /* process a packet if we can. If the machine isn't loaded,
400 if(vf->decode_ready){
402 int result=ogg_stream_packetout(&vf->os,&op);
405 if(result==-1)return(-1); /* hole in the data. alert the toplevel */
407 /* got a packet. process it */
409 if(!vorbis_synthesis(&vf->vb,&op)){ /* lazy check for lazy
411 header packets aren't
414 vorbis_synthesis will
416 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
418 /* update the pcm offset. */
420 int link=(vf->seekable?vf->current_link:0);
424 /* this packet has a pcm_offset on it (the last packet
425 completed on a page carries the offset) After processing
426 (above), we know the pcm position of the *last* sample
427 ready to be returned. Find the offset of the *first* */
429 samples=vorbis_synthesis_pcmout(&vf->vd,&dummy);
433 frameno+=vf->pcmlengths[i];
434 vf->pcm_offset=frameno;
442 if(_get_next_page(vf,&og,-1)<0)return(0); /* eof. leave unitialized */
444 /* has our decoding just traversed a bitstream boundary? */
445 if(vf->decode_ready){
446 if(vf->current_serialno!=ogg_page_serialno(&og)){
451 /* Do we need to load a new machine before submitting the page? */
452 /* This is different in the seekable and non-seekable cases.
454 In the seekable case, we already have all the header
455 information loaded and cached; we just initialize the machine
456 with it and continue on our merry way.
458 In the non-seekable (streaming) case, we'll only be at a
459 boundary if we just left the previous logical bitstream and
460 we're now nominally at the header of the next bitstream
463 if(!vf->decode_ready){
466 vf->current_serialno=ogg_page_serialno(&og);
468 /* match the serialno to bitstream section. We use this rather than
469 offset positions to avoid problems near logical bitstream
471 for(link=0;link<vf->links;link++)
472 if(vf->serialnos[link]==vf->current_serialno)break;
473 if(link==vf->links)return(-1); /* sign of a bogus stream. error out,
474 leave machine uninitialized */
476 vf->current_link=link;
478 /* we're streaming */
479 /* fetch the three header packets, build the info struct */
481 _fetch_headers(vf,vf->vi,&vf->current_serialno);
487 ogg_stream_init(&vf->os,vf->current_serialno);
488 ogg_stream_reset(&vf->os,ogg_page_pageno(&og));
489 vorbis_synthesis_init(&vf->vd,vf->vi+link);
490 vorbis_block_init(&vf->vd,&vf->vb);
493 ogg_stream_pagein(&vf->os,&og);
497 /**********************************************************************
498 * The helpers are over; it's all toplevel interface from here on out */
500 /* clear out the OggVorbis_File struct */
501 int ov_clear(OggVorbis_File *vf){
503 vorbis_block_clear(&vf->vb);
504 vorbis_dsp_clear(&vf->vd);
505 ogg_stream_clear(&vf->os);
507 if(vf->vi && vf->links){
509 for(i=0;i<vf->links;i++)
510 vorbis_info_clear(vf->vi+i);
513 if(vf->dataoffsets)free(vf->dataoffsets);
514 if(vf->pcmlengths)free(vf->pcmlengths);
515 if(vf->serialnos)free(vf->serialnos);
516 if(vf->offsets)free(vf->offsets);
517 ogg_sync_clear(&vf->oy);
518 if(vf->f)fclose(vf->f);
519 memset(vf,0,sizeof(OggVorbis_File));
524 /* inspects the OggVorbis file and finds/documents all the logical
525 bitstreams contained in it. Tries to be tolerant of logical
526 bitstream sections that are truncated/woogie.
532 int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
533 long offset=fseek(f,0,SEEK_CUR);
536 memset(vf,0,sizeof(OggVorbis_File));
539 /* init the framing state */
540 ogg_sync_init(&vf->oy);
542 /* perhaps some data was previously read into a buffer for testing
543 against other stream types. Allow initialization from this
544 previously read data (as we may be reading from a non-seekable
547 char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
548 memcpy(buffer,initial,ibytes);
549 ogg_sync_wrote(&vf->oy,ibytes);
552 /* can we seek? Stevens suggests the seek test was portable */
554 ret=_open_seekable(vf);
556 ret=_open_nonseekable(vf);
562 ogg_stream_init(&vf->os,vf->current_serialno);
563 vorbis_synthesis_init(&vf->vd,vf->vi);
564 vorbis_block_init(&vf->vd,&vf->vb);
570 /* How many logical bitstreams in this physical bitstream? */
571 long ov_streams(OggVorbis_File *vf){
575 /* Is the FILE * associated with vf seekable? */
576 long ov_seekable(OggVorbis_File *vf){
580 /* returns the bitrate for a given logical bitstream or the entire
581 physical bitstream. If the file is open for random access, it will
582 find the *actual* average bitrate. If the file is streaming, it
583 returns the nominal bitrate (if set) else the average of the
584 upper/lower bounds (if set) else -1 (unset).
586 If you want the actual bitrate field settings, get them from the
587 vorbis_info structs */
589 long ov_bitrate(OggVorbis_File *vf,int i){
590 if(i>=vf->links)return(-1);
591 if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
595 for(i=0;i<vf->links;i++)
596 bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
597 return(rint(bits/ov_time_total(vf,-1)));
600 /* return the actual bitrate */
601 return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
603 /* return nominal if set */
604 if(vf->vi[i].bitrate_nominal>0){
605 return vf->vi[i].bitrate_nominal;
607 if(vf->vi[i].bitrate_upper>0){
608 if(vf->vi[i].bitrate_lower>0){
609 return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
611 return vf->vi[i].bitrate_upper;
621 long ov_serialnumber(OggVorbis_File *vf,int i){
622 if(i>=vf->links)return(-1);
623 if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
625 return(vf->current_serialno);
627 return(vf->serialnos[i]);
631 /* returns: total raw (compressed) length of content if i==-1
632 raw (compressed) length of that logical bitstream for i==0 to n
633 -1 if the stream is not seekable (we can't know the length)
635 long ov_raw_total(OggVorbis_File *vf,int i){
636 if(!vf->seekable || i>=vf->links)return(-1);
640 for(i=0;i<vf->links;i++)
641 acc+=ov_raw_total(vf,i);
644 return(vf->offsets[i+1]-vf->offsets[i]);
648 /* returns: total PCM length (samples) of content if i==-1
649 PCM length (samples) of that logical bitstream for i==0 to n
650 -1 if the stream is not seekable (we can't know the length)
652 size64 ov_pcm_total(OggVorbis_File *vf,int i){
653 if(!vf->seekable || i>=vf->links)return(-1);
657 for(i=0;i<vf->links;i++)
658 acc+=ov_pcm_total(vf,i);
661 return(vf->pcmlengths[i]);
665 /* returns: total seconds of content if i==-1
666 seconds in that logical bitstream for i==0 to n
667 -1 if the stream is not seekable (we can't know the length)
669 double ov_time_total(OggVorbis_File *vf,int i){
670 if(!vf->seekable || i>=vf->links)return(-1);
674 for(i=0;i<vf->links;i++)
675 acc+=ov_time_total(vf,i);
678 return((float)(vf->pcmlengths[i])/vf->vi[i].rate);
682 /* seek to an offset relative to the *compressed* data. This also
683 immediately sucks in and decodes pages to update the PCM cursor. It
684 will cross a logical bitstream boundary, but only if it can't get
685 any packets out of the tail of the bitstream we seek to (so no
688 returns zero on success, nonzero on failure */
690 int ov_raw_seek(OggVorbis_File *vf,long pos){
692 if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
693 if(pos<0 || pos>vf->offsets[vf->links])goto seek_error;
695 /* clear out decoding machine state */
699 _seek_helper(vf,pos);
701 /* we need to make sure the pcm_offset is set. We use the
702 _fetch_packet helper to process one packet with readp set, then
703 call it until it returns '0' with readp not set (the last packet
704 from a page has the 'frameno' field set, and that's how the
705 helper updates the offset */
707 switch(_process_packet(vf,1)){
709 /* oh, eof. There are no packets remaining. Set the pcm offset to
711 vf->pcm_offset=ov_pcm_total(vf,-1);
714 /* error! missing data or invalid bitstream structure */
722 switch(_process_packet(vf,0)){
724 /* the offset is set. If it's a bogus bitstream with no offset
725 information, it's not but that's not our fault. We still run
726 gracefully, we're just missing the offset */
729 /* error! missing data or invalid bitstream structure */
732 /* continue processing packets */
738 /* dump the machine so we're in a known state */
743 /* seek to a sample offset relative to the decompressed pcm stream
745 returns zero on success, nonzero on failure */
747 int ov_pcm_seek(OggVorbis_File *vf,size64 pos){
749 size64 total=ov_pcm_total(vf,-1);
751 if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
752 if(pos<0 || pos>total)goto seek_error;
754 /* which bitstream section does this pcm offset occur in? */
755 for(link=vf->links-1;link>=0;link--){
756 total-=vf->pcmlengths[link];
760 /* search within the logical bitstream for the page with the highest
761 pcm_pos preceeding (or equal to) pos. There is a danger here;
762 missing pages or incorrect frame number information in the
763 bitstream could make our task impossible. Account for that (it
764 would be an error condition) */
766 size64 target=pos-total;
767 long end=vf->offsets[link+1];
768 long begin=vf->offsets[link];
776 if(end-begin<CHUNKSIZE){
779 bisect=(end+begin)/2;
782 _seek_helper(vf,bisect);
783 ret=_get_next_page(vf,&og,end-bisect);
788 size64 frameno=ogg_page_frameno(&og);
790 best=ret; /* raw offset of packet with frameno */
791 begin=vf->offset; /* raw offset of next packet */
798 /* found our page. seek to it (call raw_seek). */
800 if(ov_raw_seek(vf,best))goto seek_error;
804 if(vf->pcm_offset>=pos)goto seek_error;
805 if(pos>ov_pcm_total(vf,-1))goto seek_error;
807 /* discard samples until we reach the desired position. Crossing a
808 logical bitstream boundary with abandon is OK. */
809 while(vf->pcm_offset<pos){
811 long target=pos-vf->pcm_offset;
812 long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
814 if(samples>target)samples=target;
815 vorbis_synthesis_read(&vf->vd,samples);
816 vf->pcm_offset+=samples;
819 if(_process_packet(vf,1)==0)
820 vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
825 /* dump machine so we're in a known state */
830 /* seek to a playback time relative to the decompressed pcm stream
831 returns zero on success, nonzero on failure */
832 int ov_time_seek(OggVorbis_File *vf,double seconds){
833 /* translate time to PCM position and call ov_pcm_seek */
836 size64 pcm_total=ov_pcm_total(vf,-1);
837 double time_total=ov_time_total(vf,-1);
839 if(!vf->seekable)return(-1); /* don't dump machine if we can't seek */
840 if(seconds<0 || seconds>time_total)goto seek_error;
842 /* which bitstream section does this time offset occur in? */
843 for(link=vf->links-1;link>=0;link--){
844 pcm_total-=vf->pcmlengths[link];
845 time_total-=ov_time_total(vf,link);
846 if(seconds>=time_total)break;
849 /* enough information to convert time offset to pcm offset */
851 size64 target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
852 return(ov_pcm_seek(vf,target));
856 /* dump machine so we're in a known state */
861 /* tell the current stream offset cursor. Note that seek followed by
862 tell will likely not give the set offset due to caching */
863 long ov_raw_tell(OggVorbis_File *vf){
867 /* return PCM offset (sample) of next PCM sample to be read */
868 size64 ov_pcm_tell(OggVorbis_File *vf){
869 return(vf->pcm_offset);
872 /* return time offset (seconds) of next PCM sample to be read */
873 double ov_time_tell(OggVorbis_File *vf){
874 /* translate time to PCM position and call ov_pcm_seek */
878 double time_total=0.;
881 pcm_total=ov_pcm_total(vf,-1);
882 time_total=ov_time_total(vf,-1);
884 /* which bitstream section does this time offset occur in? */
885 for(link=vf->links-1;link>=0;link--){
886 pcm_total-=vf->pcmlengths[link];
887 time_total-=ov_time_total(vf,link);
888 if(vf->pcm_offset>pcm_total)break;
892 return(time_total+(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
895 /* link: -1) return the vorbis_info struct for the bitstream section
896 currently being decoded
897 0-n) to request information for a specific bitstream section
899 In the case of a non-seekable bitstream, any call returns the
900 current bitstream. NULL in the case that the machine is not
903 vorbis_info *ov_info(OggVorbis_File *vf,int link){
907 return vf->vi+vf->current_link;
923 /* up to this point, everything could more or less hide the multiple
924 logical bitstream nature of chaining from the toplevel application
925 if the toplevel application didn't particularly care. However, at
926 the point that we actually read audio back, the multiple-section
927 nature must surface: Multiple bitstream sections do not necessarily
928 have to have the same number of channels or sampling rate.
930 ov_read returns the sequential logical bitstream number currently
931 being decoded along with the PCM data in order that the toplevel
932 application can take action on channel/sample rate changes. This
933 number will be incremented even for streamed (non-seekable) streams
934 (for seekable streams, it represents the actual logical bitstream
935 index within the physical bitstream. Note that the accessor
936 functions above are aware of this dichotomy).
938 input values: buffer) a buffer to hold packed PCM data for return
939 length) the byte length requested to be placed into buffer
940 bigendianp) should the data be packed LSB first (0) or
942 word) word size for output. currently 1 (byte) or
945 return values: -1) error/hole in data
947 n) number of bytes of PCM actually returned. The
948 below works on a packet-by-packet basis, so the
949 return length is not related to the 'length' passed
950 in, just guaranteed to fit.
952 *section) set to the logical bitstream number */
954 long ov_read(OggVorbis_File *vf,char *buffer,int length,
955 int bigendianp,int word,int sgned,int *bitstream){
959 if(vf->decode_ready){
961 long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
963 /* yay! proceed to pack data into the byte buffer */
965 long channels=ov_info(vf,-1)->channels;
966 long bytespersample=word * channels;
967 if(samples>length/bytespersample)samples=length/bytespersample;
969 /* a tight loop to pack each size */
972 int off=(sgned?0:128);
973 for(j=0;j<samples;j++)
974 for(i=0;i<channels;i++){
975 int val=rint(pcm[i][j]*128.);
977 if(val<-128)val=-128;
981 int off=(sgned?0:32768);
984 for(j=0;j<samples;j++)
985 for(i=0;i<channels;i++){
986 int val=rint(pcm[i][j]*32768.);
987 if(val>32767)val=32767;
988 if(val<-32768)val=-32768;
991 *buffer++=(val&0xff);
994 for(j=0;j<samples;j++)
995 for(i=0;i<channels;i++){
996 int val=rint(pcm[i][j]*32768.);
997 if(val>32767)val=32767;
998 if(val<-32768)val=-32768;
1000 *buffer++=(val&0xff);
1008 vorbis_synthesis_read(&vf->vd,samples);
1009 vf->pcm_offset+=samples;
1010 if(bitstream)*bitstream=vf->current_link;
1011 return(samples*bytespersample);
1015 /* suck in another packet */
1016 switch(_process_packet(vf,1)){