1 /********************************************************************
3 * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE. *
4 * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
5 * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
6 * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
11 ********************************************************************
13 function: stdio-based convenience library for opening/seeking/decoding
16 ********************************************************************/
24 #include "vorbis/codec.h"
25 #include "vorbis/vorbisfile.h"
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) */
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. */
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. */
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 coarse navigation through the stream. */
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 */
59 /* read a little more data from the file/pipe into the ogg_sync framer
61 #define CHUNKSIZE 65536
63 static long _get_data(OggVorbis_File *vf){
65 if(!(vf->callbacks.read_func))return(-1);
67 char *buffer=ogg_sync_buffer(&vf->oy,CHUNKSIZE);
68 long bytes=(vf->callbacks.read_func)(buffer,1,CHUNKSIZE,vf->datasource);
69 if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
70 if(bytes==0 && errno)return(-1);
76 /* save a tiny smidge of verbosity to make the code more readable */
77 static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){
79 if(!(vf->callbacks.seek_func)||
80 (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)
83 ogg_sync_reset(&vf->oy);
85 /* shouldn't happen unless someone writes a broken callback */
91 /* The read/seek functions track absolute position within the stream */
93 /* from the head of the stream, get the next page. boundary specifies
94 if the function is allowed to fetch more data from the stream (and
95 how much) or only use internally buffered data.
97 boundary: -1) unbounded search
98 0) read no additional data; use cached only
99 n) search for a new page beginning for n bytes
101 return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
102 n) found a page at absolute offset n */
104 static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
105 ogg_int64_t boundary){
106 if(boundary>0)boundary+=vf->offset;
110 if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
111 more=ogg_sync_pageseek(&vf->oy,og);
114 /* skipped n bytes */
118 /* send more paramedics */
119 if(!boundary)return(OV_FALSE);
121 long ret=_get_data(vf);
122 if(ret==0)return(OV_EOF);
123 if(ret<0)return(OV_EREAD);
126 /* got a page. Return the offset at the page beginning,
127 advance the internal offset past the page end */
128 ogg_int64_t ret=vf->offset;
137 /* find the latest page beginning before the current stream cursor
138 position. Much dirtier than the above as Ogg doesn't have any
139 backward search linkage. no 'readp' as it will certainly have to
141 /* returns offset or OV_EREAD, OV_FAULT */
142 static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){
143 ogg_int64_t begin=vf->offset;
144 ogg_int64_t end=begin;
146 ogg_int64_t offset=-1;
153 ret=_seek_helper(vf,begin);
156 while(vf->offset<end){
157 memset(og,0,sizeof(*og));
158 ret=_get_next_page(vf,og,end-vf->offset);
159 if(ret==OV_EREAD)return(OV_EREAD);
168 /* In a fully compliant, non-multiplexed stream, we'll still be
169 holding the last page. In multiplexed (or noncompliant streams),
170 we may need to re-read the last page we saw */
171 if(og->header_len==0){
172 ret=_seek_helper(vf,offset);
175 ret=_get_next_page(vf,og,CHUNKSIZE);
177 /* this shouldn't be possible */
184 static void _add_serialno(ogg_page *og,long **serialno_list, int *n){
185 long s = ogg_page_serialno(og);
189 *serialno_list = _ogg_realloc(*serialno_list, sizeof(*serialno_list)*(*n));
191 *serialno_list = _ogg_malloc(sizeof(**serialno_list));
194 (*serialno_list)[(*n)-1] = s;
197 /* returns nonzero if found */
198 static int _lookup_serialno(ogg_page *og, long *serialno_list, int n){
199 long s = ogg_page_serialno(og);
203 if(*serialno_list == s) return 1;
210 /* start parsing pages at current offset, remembering all serial
211 numbers. Stop logging at first non-bos page */
212 static int _get_serialnos(OggVorbis_File *vf, long **s, int *n){
219 ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
220 if(llret==OV_EOF)return(0);
221 if(llret<0)return(llret);
222 if(!ogg_page_bos(&og)) return 0;
224 /* look for duplicate serialnos; add this one if unique */
225 if(_lookup_serialno(&og,*s,*n)){
229 return(OV_EBADHEADER);
232 _add_serialno(&og,s,n);
236 /* finds each bitstream link one at a time using a bisection search
237 (has to begin by knowing the offset of the lb's initial page).
238 Recurses for each link so it can alloc the link storage after
239 finding them all, then unroll and fill the cache at the same time */
240 static int _bisect_forward_serialno(OggVorbis_File *vf,
242 ogg_int64_t searched,
244 long *currentno_list,
247 ogg_int64_t endsearched=end;
248 ogg_int64_t next=end;
252 /* the below guards against garbage seperating the last and
253 first pages of two links. */
254 while(searched<endsearched){
257 if(endsearched-searched<CHUNKSIZE){
260 bisect=(searched+endsearched)/2;
263 ret=_seek_helper(vf,bisect);
266 ret=_get_next_page(vf,&og,-1);
267 if(ret==OV_EREAD)return(OV_EREAD);
268 if(ret<0 || !_lookup_serialno(&og,currentno_list,currentnos)){
272 searched=ret+og.header_len+og.body_len;
277 long *next_serialno_list=NULL;
278 int next_serialnos=0;
280 ret=_seek_helper(vf,next);
282 ret=_get_serialnos(vf,&next_serialno_list,&next_serialnos);
285 if(searched>=end || next_serialnos==0){
287 vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));
288 vf->offsets[m+1]=searched;
290 ret=_bisect_forward_serialno(vf,next,vf->offset,
291 end,next_serialno_list,next_serialnos,m+1);
295 if(next_serialno_list)_ogg_free(next_serialno_list);
297 vf->offsets[m]=begin;
301 /* uses the local ogg_stream storage in vf; this is important for
302 non-streaming input sources */
303 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
304 long *serialno,ogg_page *og_ptr){
311 ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
312 if(llret==OV_EREAD)return(OV_EREAD);
313 if(llret<0)return(OV_ENOTVORBIS);
317 vorbis_info_init(vi);
318 vorbis_comment_init(vc);
320 /* extract the first set of vorbis headers we see in the headerset */
324 /* if we're past the ID headers, we won't be finding a Vorbis
325 stream in this link */
326 if(!ogg_page_bos(og_ptr)){
331 /* prospective stream setup; we need a stream to get packets */
332 ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
333 ogg_stream_pagein(&vf->os,og_ptr);
335 if(ogg_stream_packetout(&vf->os,&op) > 0 &&
336 vorbis_synthesis_idheader(&op)){
338 /* continue Vorbis header load; past this point, any error will
339 render this link useless (we won't continue looking for more
341 if(serialno)*serialno=vf->os.serialno;
342 vf->ready_state=STREAMSET;
343 if((ret=vorbis_synthesis_headerin(vi,vc,&op)))
347 while(i<2){ /* get a page loop */
349 while(i<2){ /* get a packet loop */
351 int result=ogg_stream_packetout(&vf->os,&op);
358 if((ret=vorbis_synthesis_headerin(vi,vc,&op)))
365 if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){
370 /* if this page belongs to the correct stream, go parse it */
371 if(vf->os.serialno == ogg_page_serialno(og_ptr)){
372 ogg_stream_pagein(&vf->os,og_ptr);
376 /* if we never see the final vorbis headers before the link
378 if(ogg_page_bos(og_ptr)){
386 /* otherwise, keep looking */
393 /* this wasn't vorbis, get next page, try again */
395 ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE);
396 if(llret==OV_EREAD)return(OV_EREAD);
397 if(llret<0)return(OV_ENOTVORBIS);
402 vorbis_info_clear(vi);
403 vorbis_comment_clear(vc);
404 vf->ready_state=OPENED;
409 /* last step of the OggVorbis_File initialization; get all the
410 vorbis_info structs and PCM positions. Only called by the seekable
411 initialization (local stream storage is hacked slightly; pay
412 attention to how that's done) */
414 /* this is void and does not propogate errors up because we want to be
415 able to open and use damaged bitstreams as well as we can. Just
416 watch out for missing information for links in the OggVorbis_File
418 static void _prefetch_all_headers(OggVorbis_File *vf, ogg_int64_t dataoffset){
423 vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));
424 vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));
425 vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));
426 vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));
427 vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));
429 for(i=0;i<vf->links;i++){
431 /* we already grabbed the initial header earlier. Just set the offset */
432 vf->serialnos[i]=vf->current_serialno;
433 vf->dataoffsets[i]=dataoffset;
434 ret=_seek_helper(vf,dataoffset);
436 vf->dataoffsets[i]=-1;
440 /* seek to the location of the initial header */
442 ret=_seek_helper(vf,vf->offsets[i]);
444 vf->dataoffsets[i]=-1;
446 if(_fetch_headers(vf,vf->vi+i,vf->vc+i,vf->serialnos+i,NULL)<0){
447 vf->dataoffsets[i]=-1;
449 vf->dataoffsets[i]=vf->offset;
454 /* fetch beginning PCM offset */
456 if(vf->dataoffsets[i]!=-1){
457 ogg_int64_t accumulated=0;
461 ogg_stream_reset_serialno(&vf->os,vf->serialnos[i]);
466 ret=_get_next_page(vf,&og,-1);
468 /* this should not be possible unless the file is
472 if(ogg_page_bos(&og)) break;
474 if(ogg_page_serialno(&og)!=vf->serialnos[i])
477 /* count blocksizes of all frames in the page */
478 ogg_stream_pagein(&vf->os,&og);
479 while((result=ogg_stream_packetout(&vf->os,&op))){
480 if(result>0){ /* ignore holes */
481 long thisblock=vorbis_packet_blocksize(vf->vi+i,&op);
483 accumulated+=(lastblock+thisblock)>>2;
488 if(ogg_page_granulepos(&og)!=-1){
489 /* pcm offset of last packet on the first audio page */
490 accumulated= ogg_page_granulepos(&og)-accumulated;
495 /* less than zero? This is a stream with samples trimmed off
496 the beginning, a normal occurrence; set the offset to zero */
497 if(accumulated<0)accumulated=0;
499 vf->pcmlengths[i*2]=accumulated;
502 /* get the PCM length of this link. To do this,
503 get the last page of the stream */
505 ogg_int64_t end=vf->offsets[i+1];
506 ret=_seek_helper(vf,end);
508 /* this should not be possible */
509 vorbis_info_clear(vf->vi+i);
510 vorbis_comment_clear(vf->vc+i);
514 ret=_get_prev_page(vf,&og);
516 /* this should not be possible */
517 vorbis_info_clear(vf->vi+i);
518 vorbis_comment_clear(vf->vc+i);
521 if(ogg_page_serialno(&og)==vf->serialnos[i]){
522 if(ogg_page_granulepos(&og)!=-1){
523 vf->pcmlengths[i*2+1]=ogg_page_granulepos(&og)-vf->pcmlengths[i*2];
534 static int _make_decode_ready(OggVorbis_File *vf){
535 if(vf->ready_state>STREAMSET)return 0;
536 if(vf->ready_state<STREAMSET)return OV_EFAULT;
538 if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))
541 if(vorbis_synthesis_init(&vf->vd,vf->vi))
544 vorbis_block_init(&vf->vd,&vf->vb);
545 vf->ready_state=INITSET;
551 static int _open_seekable2(OggVorbis_File *vf){
552 ogg_int64_t dataoffset=vf->offset,end;
553 long *serialno_list=NULL;
558 /* we're partially open and have a first link header state in
560 /* we can seek, so set out learning all about this file */
561 if(vf->callbacks.seek_func && vf->callbacks.tell_func){
562 (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
563 vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
565 vf->offset=vf->end=-1;
568 /* If seek_func is implemented, tell_func must also be implemented */
569 if(vf->end==-1) return(OV_EINVAL);
571 /* We get the offset for the last page of the physical bitstream.
572 Most OggVorbis files will contain a single logical bitstream */
573 end=_get_prev_page(vf,&og);
574 if(end<0)return(end);
576 /* back to beginning, learn all serialnos of first link */
577 ret=_seek_helper(vf,0);
579 ret=_get_serialnos(vf,&serialno_list,&serialnos);
582 /* now determine bitstream structure recursively */
583 if(_bisect_forward_serialno(vf,0,0,end+1,serialno_list,serialnos,0)<0)return(OV_EREAD);
584 if(serialno_list)_ogg_free(serialno_list);
586 /* the initial header memory is referenced by vf after; don't free it */
587 _prefetch_all_headers(vf,dataoffset);
588 return(ov_raw_seek(vf,0));
591 /* clear out the current logical bitstream decoder */
592 static void _decode_clear(OggVorbis_File *vf){
593 vorbis_dsp_clear(&vf->vd);
594 vorbis_block_clear(&vf->vb);
595 vf->ready_state=OPENED;
598 /* fetch and process a packet. Handles the case where we're at a
599 bitstream boundary and dumps the decoding machine. If the decoding
600 machine is unloaded, it loads it. It also keeps pcm_offset up to
601 date (seek and read both use this. seek uses a special hack with
604 return: <0) error, OV_HOLE (lost packet) or OV_EOF
605 0) need more data (only if readp==0)
609 static int _fetch_and_process_packet(OggVorbis_File *vf,
615 /* handle one packet. Try to fetch it from current stream state */
616 /* extract packets from page */
619 /* process a packet if we can. If the machine isn't loaded,
621 if(vf->ready_state==INITSET){
624 ogg_packet *op_ptr=(op_in?op_in:&op);
625 int result=ogg_stream_packetout(&vf->os,op_ptr);
626 ogg_int64_t granulepos;
629 if(result==-1)return(OV_HOLE); /* hole in the data. */
631 /* got a packet. process it */
632 granulepos=op_ptr->granulepos;
633 if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
635 header packets aren't
638 vorbis_synthesis will
641 /* suck in the synthesis data and track bitrate */
643 int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
644 /* for proper use of libvorbis within libvorbisfile,
645 oldsamples will always be zero. */
646 if(oldsamples)return(OV_EFAULT);
648 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
649 vf->samptrack+=vorbis_synthesis_pcmout(&vf->vd,NULL)-oldsamples;
650 vf->bittrack+=op_ptr->bytes*8;
653 /* update the pcm offset. */
654 if(granulepos!=-1 && !op_ptr->e_o_s){
655 int link=(vf->seekable?vf->current_link:0);
658 /* this packet has a pcm_offset on it (the last packet
659 completed on a page carries the offset) After processing
660 (above), we know the pcm position of the *last* sample
661 ready to be returned. Find the offset of the *first*
663 As an aside, this trick is inaccurate if we begin
664 reading anew right at the last page; the end-of-stream
665 granulepos declares the last frame in the stream, and the
666 last packet of the last page may be a partial frame.
667 So, we need a previous granulepos from an in-sequence page
668 to have a reference point. Thus the !op_ptr->e_o_s clause
671 if(vf->seekable && link>0)
672 granulepos-=vf->pcmlengths[link*2];
673 if(granulepos<0)granulepos=0; /* actually, this
674 shouldn't be possible
675 here unless the stream
678 samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
682 granulepos+=vf->pcmlengths[i*2+1];
683 vf->pcm_offset=granulepos;
693 if(vf->ready_state>=OPENED){
697 /* the loop is not strictly necessary, but there's no sense in
698 doing the extra checks of the larger loop for the common
699 case in a multiplexed bistream where the page is simply
700 part of a different logical bitstream; keep reading until
701 we get one with the correct serialno */
704 if((ret=_get_next_page(vf,&og,-1))<0){
705 return(OV_EOF); /* eof. leave unitialized */
708 /* bitrate tracking; add the header's bytes here, the body bytes
709 are done by packet above */
710 vf->bittrack+=og.header_len*8;
712 if(vf->ready_state==INITSET){
713 if(vf->current_serialno!=ogg_page_serialno(&og)){
715 /* two possibilities:
716 1) our decoding just traversed a bitstream boundary
717 2) another stream is multiplexed into this logical section? */
719 if(ogg_page_bos(&og)){
727 vorbis_info_clear(vf->vi);
728 vorbis_comment_clear(vf->vc);
733 continue; /* possibility #2 */
741 /* Do we need to load a new machine before submitting the page? */
742 /* This is different in the seekable and non-seekable cases.
744 In the seekable case, we already have all the header
745 information loaded and cached; we just initialize the machine
746 with it and continue on our merry way.
748 In the non-seekable (streaming) case, we'll only be at a
749 boundary if we just left the previous logical bitstream and
750 we're now nominally at the header of the next bitstream
753 if(vf->ready_state!=INITSET){
756 if(vf->ready_state<STREAMSET){
758 long serialno = ogg_page_serialno(&og);
760 /* match the serialno to bitstream section. We use this rather than
761 offset positions to avoid problems near logical bitstream
764 for(link=0;link<vf->links;link++)
765 if(vf->serialnos[link]==serialno)break;
767 if(link==vf->links) continue; /* not the desired Vorbis
768 bitstream section; keep
771 vf->current_serialno=serialno;
772 vf->current_link=link;
774 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
775 vf->ready_state=STREAMSET;
778 /* we're streaming */
779 /* fetch the three header packets, build the info struct */
781 int ret=_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno,&og);
789 int ret=_make_decode_ready(vf);
794 /* the buffered page is the data we want, and we're ready for it;
795 add it to the stream state */
796 ogg_stream_pagein(&vf->os,&og);
801 /* if, eg, 64 bit stdio is configured by default, this will build with
803 static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
804 if(f==NULL)return(-1);
805 return fseek(f,off,whence);
808 static int _ov_open1(void *f,OggVorbis_File *vf,char *initial,
809 long ibytes, ov_callbacks callbacks){
810 int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);
813 memset(vf,0,sizeof(*vf));
815 vf->callbacks = callbacks;
817 /* init the framing state */
818 ogg_sync_init(&vf->oy);
820 /* perhaps some data was previously read into a buffer for testing
821 against other stream types. Allow initialization from this
822 previously read data (as we may be reading from a non-seekable
825 char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
826 memcpy(buffer,initial,ibytes);
827 ogg_sync_wrote(&vf->oy,ibytes);
830 /* can we seek? Stevens suggests the seek test was portable */
831 if(offsettest!=-1)vf->seekable=1;
833 /* No seeking yet; Set up a 'single' (current) logical bitstream
834 entry for partial open */
836 vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
837 vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
838 ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
840 /* Try to fetch the headers, maintaining all the storage */
841 if((ret=_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno,NULL))<0){
845 vf->ready_state=PARTOPEN;
849 static int _ov_open2(OggVorbis_File *vf){
850 if(vf->ready_state != PARTOPEN) return OV_EINVAL;
851 vf->ready_state=OPENED;
853 int ret=_open_seekable2(vf);
860 vf->ready_state=STREAMSET;
866 /* clear out the OggVorbis_File struct */
867 int ov_clear(OggVorbis_File *vf){
869 vorbis_block_clear(&vf->vb);
870 vorbis_dsp_clear(&vf->vd);
871 ogg_stream_clear(&vf->os);
873 if(vf->vi && vf->links){
875 for(i=0;i<vf->links;i++){
876 vorbis_info_clear(vf->vi+i);
877 vorbis_comment_clear(vf->vc+i);
882 if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
883 if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
884 if(vf->serialnos)_ogg_free(vf->serialnos);
885 if(vf->offsets)_ogg_free(vf->offsets);
886 ogg_sync_clear(&vf->oy);
887 if(vf->datasource && vf->callbacks.close_func)
888 (vf->callbacks.close_func)(vf->datasource);
889 memset(vf,0,sizeof(*vf));
897 /* inspects the OggVorbis file and finds/documents all the logical
898 bitstreams contained in it. Tries to be tolerant of logical
899 bitstream sections that are truncated/woogie.
905 int ov_open_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
906 ov_callbacks callbacks){
907 int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
909 return _ov_open2(vf);
912 int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
913 ov_callbacks callbacks = {
914 (size_t (*)(void *, size_t, size_t, void *)) fread,
915 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
916 (int (*)(void *)) fclose,
917 (long (*)(void *)) ftell
920 return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
923 int ov_fopen(char *path,OggVorbis_File *vf){
925 FILE *f = fopen(path,"rb");
928 ret = ov_open(f,vf,NULL,0);
934 /* cheap hack for game usage where downsampling is desirable; there's
935 no need for SRC as we can just do it cheaply in libvorbis. */
937 int ov_halfrate(OggVorbis_File *vf,int flag){
939 if(vf->vi==NULL)return OV_EINVAL;
940 if(!vf->seekable)return OV_EINVAL;
941 if(vf->ready_state>=STREAMSET)
942 _decode_clear(vf); /* clear out stream state; later on libvorbis
943 will be able to swap this on the fly, but
944 for now dumping the decode machine is needed
945 to reinit the MDCT lookups. 1.1 libvorbis
946 is planned to be able to switch on the fly */
948 for(i=0;i<vf->links;i++){
949 if(vorbis_synthesis_halfrate(vf->vi+i,flag)){
957 int ov_halfrate_p(OggVorbis_File *vf){
958 if(vf->vi==NULL)return OV_EINVAL;
959 return vorbis_synthesis_halfrate_p(vf->vi);
962 /* Only partially open the vorbis file; test for Vorbisness, and load
963 the headers for the first chain. Do not seek (although test for
964 seekability). Use ov_test_open to finish opening the file, else
965 ov_clear to close/free it. Same return codes as open. */
967 int ov_test_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
968 ov_callbacks callbacks)
970 return _ov_open1(f,vf,initial,ibytes,callbacks);
973 int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
974 ov_callbacks callbacks = {
975 (size_t (*)(void *, size_t, size_t, void *)) fread,
976 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
977 (int (*)(void *)) fclose,
978 (long (*)(void *)) ftell
981 return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
984 int ov_test_open(OggVorbis_File *vf){
985 if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
986 return _ov_open2(vf);
989 /* How many logical bitstreams in this physical bitstream? */
990 long ov_streams(OggVorbis_File *vf){
994 /* Is the FILE * associated with vf seekable? */
995 long ov_seekable(OggVorbis_File *vf){
999 /* returns the bitrate for a given logical bitstream or the entire
1000 physical bitstream. If the file is open for random access, it will
1001 find the *actual* average bitrate. If the file is streaming, it
1002 returns the nominal bitrate (if set) else the average of the
1003 upper/lower bounds (if set) else -1 (unset).
1005 If you want the actual bitrate field settings, get them from the
1006 vorbis_info structs */
1008 long ov_bitrate(OggVorbis_File *vf,int i){
1009 if(vf->ready_state<OPENED)return(OV_EINVAL);
1010 if(i>=vf->links)return(OV_EINVAL);
1011 if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
1016 for(i=0;i<vf->links;i++)
1017 bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
1018 /* This once read: return(rint(bits/ov_time_total(vf,-1)));
1019 * gcc 3.x on x86 miscompiled this at optimisation level 2 and above,
1020 * so this is slightly transformed to make it work.
1022 br = bits/ov_time_total(vf,-1);
1026 /* return the actual bitrate */
1027 return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
1029 /* return nominal if set */
1030 if(vf->vi[i].bitrate_nominal>0){
1031 return vf->vi[i].bitrate_nominal;
1033 if(vf->vi[i].bitrate_upper>0){
1034 if(vf->vi[i].bitrate_lower>0){
1035 return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
1037 return vf->vi[i].bitrate_upper;
1046 /* returns the actual bitrate since last call. returns -1 if no
1047 additional data to offer since last call (or at beginning of stream),
1048 EINVAL if stream is only partially open
1050 long ov_bitrate_instant(OggVorbis_File *vf){
1051 int link=(vf->seekable?vf->current_link:0);
1053 if(vf->ready_state<OPENED)return(OV_EINVAL);
1054 if(vf->samptrack==0)return(OV_FALSE);
1055 ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
1062 long ov_serialnumber(OggVorbis_File *vf,int i){
1063 if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
1064 if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
1066 return(vf->current_serialno);
1068 return(vf->serialnos[i]);
1072 /* returns: total raw (compressed) length of content if i==-1
1073 raw (compressed) length of that logical bitstream for i==0 to n
1074 OV_EINVAL if the stream is not seekable (we can't know the length)
1075 or if stream is only partially open
1077 ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
1078 if(vf->ready_state<OPENED)return(OV_EINVAL);
1079 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1083 for(i=0;i<vf->links;i++)
1084 acc+=ov_raw_total(vf,i);
1087 return(vf->offsets[i+1]-vf->offsets[i]);
1091 /* returns: total PCM length (samples) of content if i==-1 PCM length
1092 (samples) of that logical bitstream for i==0 to n
1093 OV_EINVAL if the stream is not seekable (we can't know the
1094 length) or only partially open
1096 ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
1097 if(vf->ready_state<OPENED)return(OV_EINVAL);
1098 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1102 for(i=0;i<vf->links;i++)
1103 acc+=ov_pcm_total(vf,i);
1106 return(vf->pcmlengths[i*2+1]);
1110 /* returns: total seconds of content if i==-1
1111 seconds in that logical bitstream for i==0 to n
1112 OV_EINVAL if the stream is not seekable (we can't know the
1113 length) or only partially open
1115 double ov_time_total(OggVorbis_File *vf,int i){
1116 if(vf->ready_state<OPENED)return(OV_EINVAL);
1117 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1121 for(i=0;i<vf->links;i++)
1122 acc+=ov_time_total(vf,i);
1125 return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
1129 /* seek to an offset relative to the *compressed* data. This also
1130 scans packets to update the PCM cursor. It will cross a logical
1131 bitstream boundary, but only if it can't get any packets out of the
1132 tail of the bitstream we seek to (so no surprises).
1134 returns zero on success, nonzero on failure */
1136 int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
1137 ogg_stream_state work_os;
1140 if(vf->ready_state<OPENED)return(OV_EINVAL);
1142 return(OV_ENOSEEK); /* don't dump machine if we can't seek */
1144 if(pos<0 || pos>vf->end)return(OV_EINVAL);
1146 /* don't yet clear out decoding machine (if it's initialized), in
1147 the case we're in the same link. Restart the decode lapping, and
1148 let _fetch_and_process_packet deal with a potential bitstream
1151 ogg_stream_reset_serialno(&vf->os,
1152 vf->current_serialno); /* must set serialno */
1153 vorbis_synthesis_restart(&vf->vd);
1155 ret=_seek_helper(vf,pos);
1156 if(ret)goto seek_error;
1158 /* we need to make sure the pcm_offset is set, but we don't want to
1159 advance the raw cursor past good packets just to get to the first
1160 with a granulepos. That's not equivalent behavior to beginning
1161 decoding as immediately after the seek position as possible.
1163 So, a hack. We use two stream states; a local scratch state and
1164 the shared vf->os stream state. We use the local state to
1165 scan, and the shared state as a buffer for later decode.
1167 Unfortuantely, on the last page we still advance to last packet
1168 because the granulepos on the last page is not necessarily on a
1169 packet boundary, and we need to make sure the granpos is
1181 ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
1182 ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
1183 return from not necessarily
1184 starting from the beginning */
1187 if(vf->ready_state>=STREAMSET){
1188 /* snarf/scan a packet if we can */
1189 int result=ogg_stream_packetout(&work_os,&op);
1193 if(vf->vi[vf->current_link].codec_setup){
1194 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1196 ogg_stream_packetout(&vf->os,NULL);
1201 ogg_stream_packetout(&vf->os,NULL);
1203 if(lastblock)accblock+=(lastblock+thisblock)>>2;
1206 if(op.granulepos!=-1){
1207 int i,link=vf->current_link;
1208 ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
1209 if(granulepos<0)granulepos=0;
1212 granulepos+=vf->pcmlengths[i*2+1];
1213 vf->pcm_offset=granulepos-accblock;
1216 lastblock=thisblock;
1219 ogg_stream_packetout(&vf->os,NULL);
1224 if(_get_next_page(vf,&og,-1)<0){
1225 vf->pcm_offset=ov_pcm_total(vf,-1);
1229 /* huh? Bogus stream with packets but no granulepos */
1234 /* has our decoding just traversed a bitstream boundary? */
1235 if(vf->ready_state>=STREAMSET){
1236 if(vf->current_serialno!=ogg_page_serialno(&og)){
1238 /* two possibilities:
1239 1) our decoding just traversed a bitstream boundary
1240 2) another stream is multiplexed into this logical section? */
1242 if(ogg_page_bos(&og)){
1244 _decode_clear(vf); /* clear out stream state */
1245 ogg_stream_clear(&work_os);
1246 } /* else, do nothing; next loop will scoop another page */
1250 if(vf->ready_state<STREAMSET){
1252 long serialno = ogg_page_serialno(&og);
1254 for(link=0;link<vf->links;link++)
1255 if(vf->serialnos[link]==serialno)break;
1257 if(link==vf->links) continue; /* not the desired Vorbis
1258 bitstream section; keep
1260 vf->current_link=link;
1261 vf->current_serialno=serialno;
1262 ogg_stream_reset_serialno(&vf->os,serialno);
1263 ogg_stream_reset_serialno(&work_os,serialno);
1264 vf->ready_state=STREAMSET;
1268 ogg_stream_pagein(&vf->os,&og);
1269 ogg_stream_pagein(&work_os,&og);
1270 eosflag=ogg_page_eos(&og);
1274 ogg_stream_clear(&work_os);
1280 /* dump the machine so we're in a known state */
1282 ogg_stream_clear(&work_os);
1287 /* Page granularity seek (faster than sample granularity because we
1288 don't do the last bit of decode to find a specific sample).
1290 Seek to the last [granule marked] page preceeding the specified pos
1291 location, such that decoding past the returned point will quickly
1292 arrive at the requested position. */
1293 int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
1295 ogg_int64_t result=0;
1296 ogg_int64_t total=ov_pcm_total(vf,-1);
1298 if(vf->ready_state<OPENED)return(OV_EINVAL);
1299 if(!vf->seekable)return(OV_ENOSEEK);
1301 if(pos<0 || pos>total)return(OV_EINVAL);
1303 /* which bitstream section does this pcm offset occur in? */
1304 for(link=vf->links-1;link>=0;link--){
1305 total-=vf->pcmlengths[link*2+1];
1306 if(pos>=total)break;
1309 /* search within the logical bitstream for the page with the highest
1310 pcm_pos preceeding (or equal to) pos. There is a danger here;
1311 missing pages or incorrect frame number information in the
1312 bitstream could make our task impossible. Account for that (it
1313 would be an error condition) */
1315 /* new search algorithm by HB (Nicholas Vinen) */
1317 ogg_int64_t end=vf->offsets[link+1];
1318 ogg_int64_t begin=vf->offsets[link];
1319 ogg_int64_t begintime = vf->pcmlengths[link*2];
1320 ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
1321 ogg_int64_t target=pos-total+begintime;
1322 ogg_int64_t best=begin;
1328 if(end-begin<CHUNKSIZE){
1331 /* take a (pretty decent) guess. */
1333 (ogg_int64_t)((double)(target-begintime)*(end-begin)/(endtime-begintime))
1339 result=_seek_helper(vf,bisect);
1340 if(result) goto seek_error;
1343 result=_get_next_page(vf,&og,end-vf->offset);
1344 if(result==OV_EREAD) goto seek_error;
1347 end=begin; /* found it */
1349 if(bisect==0) goto seek_error;
1351 if(bisect<=begin)bisect=begin+1;
1352 result=_seek_helper(vf,bisect);
1353 if(result) goto seek_error;
1356 ogg_int64_t granulepos;
1358 if(ogg_page_serialno(&og)!=vf->serialnos[link])
1361 granulepos=ogg_page_granulepos(&og);
1362 if(granulepos==-1)continue;
1364 if(granulepos<target){
1365 best=result; /* raw offset of packet with granulepos */
1366 begin=vf->offset; /* raw offset of next page */
1367 begintime=granulepos;
1369 if(target-begintime>44100)break;
1370 bisect=begin; /* *not* begin + 1 */
1373 end=begin; /* found it */
1375 if(end==vf->offset){ /* we're pretty close - we'd be stuck in */
1377 bisect-=CHUNKSIZE; /* an endless loop otherwise. */
1378 if(bisect<=begin)bisect=begin+1;
1379 result=_seek_helper(vf,bisect);
1380 if(result) goto seek_error;
1392 /* found our page. seek to it, update pcm offset. Easier case than
1393 raw_seek, don't keep packets preceeding granulepos. */
1399 result=_seek_helper(vf,best);
1401 if(result) goto seek_error;
1402 result=_get_next_page(vf,&og,-1);
1403 if(result<0) goto seek_error;
1405 if(link!=vf->current_link){
1406 /* Different link; dump entire decode machine */
1409 vf->current_link=link;
1410 vf->current_serialno=vf->serialnos[link];
1411 vf->ready_state=STREAMSET;
1414 vorbis_synthesis_restart(&vf->vd);
1417 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1418 ogg_stream_pagein(&vf->os,&og);
1420 /* pull out all but last packet; the one with granulepos */
1422 result=ogg_stream_packetpeek(&vf->os,&op);
1424 /* !!! the packet finishing this page originated on a
1425 preceeding page. Keep fetching previous pages until we
1426 get one with a granulepos or without the 'continued' flag
1427 set. Then just use raw_seek for simplicity. */
1429 result=_seek_helper(vf,best);
1430 if(result<0) goto seek_error;
1433 result=_get_prev_page(vf,&og);
1434 if(result<0) goto seek_error;
1435 if(ogg_page_serialno(&og)==vf->current_serialno &&
1436 (ogg_page_granulepos(&og)>-1 ||
1437 !ogg_page_continued(&og))){
1438 return ov_raw_seek(vf,result);
1444 result = OV_EBADPACKET;
1447 if(op.granulepos!=-1){
1448 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1449 if(vf->pcm_offset<0)vf->pcm_offset=0;
1450 vf->pcm_offset+=total;
1453 result=ogg_stream_packetout(&vf->os,NULL);
1459 if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
1468 /* dump machine so we're in a known state */
1474 /* seek to a sample offset relative to the decompressed pcm stream
1475 returns zero on success, nonzero on failure */
1477 int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
1478 int thisblock,lastblock=0;
1479 int ret=ov_pcm_seek_page(vf,pos);
1480 if(ret<0)return(ret);
1481 if((ret=_make_decode_ready(vf)))return ret;
1483 /* discard leading packets we don't need for the lapping of the
1484 position we want; don't decode them */
1490 int ret=ogg_stream_packetpeek(&vf->os,&op);
1492 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1494 ogg_stream_packetout(&vf->os,NULL);
1495 continue; /* non audio packet */
1497 if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
1499 if(vf->pcm_offset+((thisblock+
1500 vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
1502 /* remove the packet from packet queue and track its granulepos */
1503 ogg_stream_packetout(&vf->os,NULL);
1504 vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with
1507 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
1509 /* end of logical stream case is hard, especially with exact
1510 length positioning. */
1512 if(op.granulepos>-1){
1514 /* always believe the stream markers */
1515 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1516 if(vf->pcm_offset<0)vf->pcm_offset=0;
1517 for(i=0;i<vf->current_link;i++)
1518 vf->pcm_offset+=vf->pcmlengths[i*2+1];
1521 lastblock=thisblock;
1524 if(ret<0 && ret!=OV_HOLE)break;
1526 /* suck in a new page */
1527 if(_get_next_page(vf,&og,-1)<0)break;
1528 if(ogg_page_bos(&og))_decode_clear(vf);
1530 if(vf->ready_state<STREAMSET){
1531 long serialno=ogg_page_serialno(&og);
1534 for(link=0;link<vf->links;link++)
1535 if(vf->serialnos[link]==serialno)break;
1536 if(link==vf->links) continue;
1537 vf->current_link=link;
1539 vf->ready_state=STREAMSET;
1540 vf->current_serialno=ogg_page_serialno(&og);
1541 ogg_stream_reset_serialno(&vf->os,serialno);
1542 ret=_make_decode_ready(vf);
1547 ogg_stream_pagein(&vf->os,&og);
1553 /* discard samples until we reach the desired position. Crossing a
1554 logical bitstream boundary with abandon is OK. */
1555 while(vf->pcm_offset<pos){
1556 ogg_int64_t target=pos-vf->pcm_offset;
1557 long samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
1559 if(samples>target)samples=target;
1560 vorbis_synthesis_read(&vf->vd,samples);
1561 vf->pcm_offset+=samples;
1564 if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
1565 vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
1570 /* seek to a playback time relative to the decompressed pcm stream
1571 returns zero on success, nonzero on failure */
1572 int ov_time_seek(OggVorbis_File *vf,double seconds){
1573 /* translate time to PCM position and call ov_pcm_seek */
1576 ogg_int64_t pcm_total=0;
1577 double time_total=0.;
1579 if(vf->ready_state<OPENED)return(OV_EINVAL);
1580 if(!vf->seekable)return(OV_ENOSEEK);
1581 if(seconds<0)return(OV_EINVAL);
1583 /* which bitstream section does this time offset occur in? */
1584 for(link=0;link<vf->links;link++){
1585 double addsec = ov_time_total(vf,link);
1586 if(seconds<time_total+addsec)break;
1588 pcm_total+=vf->pcmlengths[link*2+1];
1591 if(link==vf->links)return(OV_EINVAL);
1593 /* enough information to convert time offset to pcm offset */
1595 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1596 return(ov_pcm_seek(vf,target));
1600 /* page-granularity version of ov_time_seek
1601 returns zero on success, nonzero on failure */
1602 int ov_time_seek_page(OggVorbis_File *vf,double seconds){
1603 /* translate time to PCM position and call ov_pcm_seek */
1606 ogg_int64_t pcm_total=0;
1607 double time_total=0.;
1609 if(vf->ready_state<OPENED)return(OV_EINVAL);
1610 if(!vf->seekable)return(OV_ENOSEEK);
1611 if(seconds<0)return(OV_EINVAL);
1613 /* which bitstream section does this time offset occur in? */
1614 for(link=0;link<vf->links;link++){
1615 double addsec = ov_time_total(vf,link);
1616 if(seconds<time_total+addsec)break;
1618 pcm_total+=vf->pcmlengths[link*2+1];
1621 if(link==vf->links)return(OV_EINVAL);
1623 /* enough information to convert time offset to pcm offset */
1625 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1626 return(ov_pcm_seek_page(vf,target));
1630 /* tell the current stream offset cursor. Note that seek followed by
1631 tell will likely not give the set offset due to caching */
1632 ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
1633 if(vf->ready_state<OPENED)return(OV_EINVAL);
1637 /* return PCM offset (sample) of next PCM sample to be read */
1638 ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
1639 if(vf->ready_state<OPENED)return(OV_EINVAL);
1640 return(vf->pcm_offset);
1643 /* return time offset (seconds) of next PCM sample to be read */
1644 double ov_time_tell(OggVorbis_File *vf){
1646 ogg_int64_t pcm_total=0;
1647 double time_total=0.f;
1649 if(vf->ready_state<OPENED)return(OV_EINVAL);
1651 pcm_total=ov_pcm_total(vf,-1);
1652 time_total=ov_time_total(vf,-1);
1654 /* which bitstream section does this time offset occur in? */
1655 for(link=vf->links-1;link>=0;link--){
1656 pcm_total-=vf->pcmlengths[link*2+1];
1657 time_total-=ov_time_total(vf,link);
1658 if(vf->pcm_offset>=pcm_total)break;
1662 return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
1665 /* link: -1) return the vorbis_info struct for the bitstream section
1666 currently being decoded
1667 0-n) to request information for a specific bitstream section
1669 In the case of a non-seekable bitstream, any call returns the
1670 current bitstream. NULL in the case that the machine is not
1673 vorbis_info *ov_info(OggVorbis_File *vf,int link){
1676 if(vf->ready_state>=STREAMSET)
1677 return vf->vi+vf->current_link;
1690 /* grr, strong typing, grr, no templates/inheritence, grr */
1691 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
1694 if(vf->ready_state>=STREAMSET)
1695 return vf->vc+vf->current_link;
1708 static int host_is_big_endian() {
1709 ogg_int32_t pattern = 0xfeedface; /* deadbeef */
1710 unsigned char *bytewise = (unsigned char *)&pattern;
1711 if (bytewise[0] == 0xfe) return 1;
1715 /* up to this point, everything could more or less hide the multiple
1716 logical bitstream nature of chaining from the toplevel application
1717 if the toplevel application didn't particularly care. However, at
1718 the point that we actually read audio back, the multiple-section
1719 nature must surface: Multiple bitstream sections do not necessarily
1720 have to have the same number of channels or sampling rate.
1722 ov_read returns the sequential logical bitstream number currently
1723 being decoded along with the PCM data in order that the toplevel
1724 application can take action on channel/sample rate changes. This
1725 number will be incremented even for streamed (non-seekable) streams
1726 (for seekable streams, it represents the actual logical bitstream
1727 index within the physical bitstream. Note that the accessor
1728 functions above are aware of this dichotomy).
1730 ov_read_filter is exactly the same as ov_read except that it processes
1731 the decoded audio data through a filter before packing it into the
1732 requested format. This gives greater accuracy than applying a filter
1733 after the audio has been converted into integral PCM.
1735 input values: buffer) a buffer to hold packed PCM data for return
1736 length) the byte length requested to be placed into buffer
1737 bigendianp) should the data be packed LSB first (0) or
1739 word) word size for output. currently 1 (byte) or
1742 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1744 n) number of bytes of PCM actually returned. The
1745 below works on a packet-by-packet basis, so the
1746 return length is not related to the 'length' passed
1747 in, just guaranteed to fit.
1749 *section) set to the logical bitstream number */
1751 long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
1752 int bigendianp,int word,int sgned,int *bitstream,
1753 void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param){
1755 int host_endian = host_is_big_endian();
1760 if(vf->ready_state<OPENED)return(OV_EINVAL);
1763 if(vf->ready_state==INITSET){
1764 samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1768 /* suck in another packet */
1770 int ret=_fetch_and_process_packet(vf,NULL,1,1);
1781 /* yay! proceed to pack data into the byte buffer */
1783 long channels=ov_info(vf,-1)->channels;
1784 long bytespersample=word * channels;
1785 vorbis_fpu_control fpu;
1786 if(samples>length/bytespersample)samples=length/bytespersample;
1793 filter(pcm,channels,samples,filter_param);
1795 /* a tight loop to pack each size */
1799 int off=(sgned?0:128);
1800 vorbis_fpu_setround(&fpu);
1801 for(j=0;j<samples;j++)
1802 for(i=0;i<channels;i++){
1803 val=vorbis_ftoi(pcm[i][j]*128.f);
1805 else if(val<-128)val=-128;
1808 vorbis_fpu_restore(fpu);
1810 int off=(sgned?0:32768);
1812 if(host_endian==bigendianp){
1815 vorbis_fpu_setround(&fpu);
1816 for(i=0;i<channels;i++) { /* It's faster in this order */
1818 short *dest=((short *)buffer)+i;
1819 for(j=0;j<samples;j++) {
1820 val=vorbis_ftoi(src[j]*32768.f);
1821 if(val>32767)val=32767;
1822 else if(val<-32768)val=-32768;
1827 vorbis_fpu_restore(fpu);
1831 vorbis_fpu_setround(&fpu);
1832 for(i=0;i<channels;i++) {
1834 short *dest=((short *)buffer)+i;
1835 for(j=0;j<samples;j++) {
1836 val=vorbis_ftoi(src[j]*32768.f);
1837 if(val>32767)val=32767;
1838 else if(val<-32768)val=-32768;
1843 vorbis_fpu_restore(fpu);
1846 }else if(bigendianp){
1848 vorbis_fpu_setround(&fpu);
1849 for(j=0;j<samples;j++)
1850 for(i=0;i<channels;i++){
1851 val=vorbis_ftoi(pcm[i][j]*32768.f);
1852 if(val>32767)val=32767;
1853 else if(val<-32768)val=-32768;
1856 *buffer++=(val&0xff);
1858 vorbis_fpu_restore(fpu);
1862 vorbis_fpu_setround(&fpu);
1863 for(j=0;j<samples;j++)
1864 for(i=0;i<channels;i++){
1865 val=vorbis_ftoi(pcm[i][j]*32768.f);
1866 if(val>32767)val=32767;
1867 else if(val<-32768)val=-32768;
1869 *buffer++=(val&0xff);
1872 vorbis_fpu_restore(fpu);
1878 vorbis_synthesis_read(&vf->vd,samples);
1879 vf->pcm_offset+=samples;
1880 if(bitstream)*bitstream=vf->current_link;
1881 return(samples*bytespersample);
1887 long ov_read(OggVorbis_File *vf,char *buffer,int length,
1888 int bigendianp,int word,int sgned,int *bitstream){
1889 return ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, NULL, NULL);
1892 /* input values: pcm_channels) a float vector per channel of output
1893 length) the sample length being read by the app
1895 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1897 n) number of samples of PCM actually returned. The
1898 below works on a packet-by-packet basis, so the
1899 return length is not related to the 'length' passed
1900 in, just guaranteed to fit.
1902 *section) set to the logical bitstream number */
1906 long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
1909 if(vf->ready_state<OPENED)return(OV_EINVAL);
1912 if(vf->ready_state==INITSET){
1914 long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1916 if(pcm_channels)*pcm_channels=pcm;
1917 if(samples>length)samples=length;
1918 vorbis_synthesis_read(&vf->vd,samples);
1919 vf->pcm_offset+=samples;
1920 if(bitstream)*bitstream=vf->current_link;
1926 /* suck in another packet */
1928 int ret=_fetch_and_process_packet(vf,NULL,1,1);
1929 if(ret==OV_EOF)return(0);
1930 if(ret<=0)return(ret);
1936 extern float *vorbis_window(vorbis_dsp_state *v,int W);
1937 extern void _analysis_output_always(char *base,int i,float *v,int n,int bark,int dB,
1940 static void _ov_splice(float **pcm,float **lappcm,
1943 float *w1, float *w2){
1954 for(j=0;j<ch1 && j<ch2;j++){
1961 d[i]=d[i]*wd + s[i]*ws;
1964 /* window from zero */
1975 /* make sure vf is INITSET */
1976 static int _ov_initset(OggVorbis_File *vf){
1978 if(vf->ready_state==INITSET)break;
1979 /* suck in another packet */
1981 int ret=_fetch_and_process_packet(vf,NULL,1,0);
1982 if(ret<0 && ret!=OV_HOLE)return(ret);
1988 /* make sure vf is INITSET and that we have a primed buffer; if
1989 we're crosslapping at a stream section boundary, this also makes
1990 sure we're sanity checking against the right stream information */
1991 static int _ov_initprime(OggVorbis_File *vf){
1992 vorbis_dsp_state *vd=&vf->vd;
1994 if(vf->ready_state==INITSET)
1995 if(vorbis_synthesis_pcmout(vd,NULL))break;
1997 /* suck in another packet */
1999 int ret=_fetch_and_process_packet(vf,NULL,1,0);
2000 if(ret<0 && ret!=OV_HOLE)return(ret);
2006 /* grab enough data for lapping from vf; this may be in the form of
2007 unreturned, already-decoded pcm, remaining PCM we will need to
2008 decode, or synthetic postextrapolation from last packets. */
2009 static void _ov_getlap(OggVorbis_File *vf,vorbis_info *vi,vorbis_dsp_state *vd,
2010 float **lappcm,int lapsize){
2014 /* try first to decode the lapping data */
2015 while(lapcount<lapsize){
2016 int samples=vorbis_synthesis_pcmout(vd,&pcm);
2018 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2019 for(i=0;i<vi->channels;i++)
2020 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2022 vorbis_synthesis_read(vd,samples);
2024 /* suck in another packet */
2025 int ret=_fetch_and_process_packet(vf,NULL,1,0); /* do *not* span */
2026 if(ret==OV_EOF)break;
2029 if(lapcount<lapsize){
2030 /* failed to get lapping data from normal decode; pry it from the
2031 postextrapolation buffering, or the second half of the MDCT
2032 from the last packet */
2033 int samples=vorbis_synthesis_lapout(&vf->vd,&pcm);
2035 for(i=0;i<vi->channels;i++)
2036 memset(lappcm[i]+lapcount,0,sizeof(**pcm)*lapsize-lapcount);
2039 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2040 for(i=0;i<vi->channels;i++)
2041 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2047 /* this sets up crosslapping of a sample by using trailing data from
2048 sample 1 and lapping it into the windowing buffer of sample 2 */
2049 int ov_crosslap(OggVorbis_File *vf1, OggVorbis_File *vf2){
2050 vorbis_info *vi1,*vi2;
2054 int n1,n2,i,ret,hs1,hs2;
2056 if(vf1==vf2)return(0); /* degenerate case */
2057 if(vf1->ready_state<OPENED)return(OV_EINVAL);
2058 if(vf2->ready_state<OPENED)return(OV_EINVAL);
2060 /* the relevant overlap buffers must be pre-checked and pre-primed
2061 before looking at settings in the event that priming would cross
2062 a bitstream boundary. So, do it now */
2064 ret=_ov_initset(vf1);
2066 ret=_ov_initprime(vf2);
2069 vi1=ov_info(vf1,-1);
2070 vi2=ov_info(vf2,-1);
2071 hs1=ov_halfrate_p(vf1);
2072 hs2=ov_halfrate_p(vf2);
2074 lappcm=alloca(sizeof(*lappcm)*vi1->channels);
2075 n1=vorbis_info_blocksize(vi1,0)>>(1+hs1);
2076 n2=vorbis_info_blocksize(vi2,0)>>(1+hs2);
2077 w1=vorbis_window(&vf1->vd,0);
2078 w2=vorbis_window(&vf2->vd,0);
2080 for(i=0;i<vi1->channels;i++)
2081 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2083 _ov_getlap(vf1,vi1,&vf1->vd,lappcm,n1);
2085 /* have a lapping buffer from vf1; now to splice it into the lapping
2087 /* consolidate and expose the buffer. */
2088 vorbis_synthesis_lapout(&vf2->vd,&pcm);
2089 _analysis_output_always("pcmL",0,pcm[0],n1*2,0,0,0);
2090 _analysis_output_always("pcmR",0,pcm[1],n1*2,0,0,0);
2093 _ov_splice(pcm,lappcm,n1,n2,vi1->channels,vi2->channels,w1,w2);
2099 static int _ov_64_seek_lap(OggVorbis_File *vf,ogg_int64_t pos,
2100 int (*localseek)(OggVorbis_File *,ogg_int64_t)){
2105 int n1,n2,ch1,ch2,hs;
2108 if(vf->ready_state<OPENED)return(OV_EINVAL);
2109 ret=_ov_initset(vf);
2112 hs=ov_halfrate_p(vf);
2115 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2116 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
2117 persistent; even if the decode state
2118 from this link gets dumped, this
2119 window array continues to exist */
2121 lappcm=alloca(sizeof(*lappcm)*ch1);
2123 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2124 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2126 /* have lapping data; seek and prime the buffer */
2127 ret=localseek(vf,pos);
2129 ret=_ov_initprime(vf);
2132 /* Guard against cross-link changes; they're perfectly legal */
2135 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2136 w2=vorbis_window(&vf->vd,0);
2138 /* consolidate and expose the buffer. */
2139 vorbis_synthesis_lapout(&vf->vd,&pcm);
2142 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2148 int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2149 return _ov_64_seek_lap(vf,pos,ov_raw_seek);
2152 int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2153 return _ov_64_seek_lap(vf,pos,ov_pcm_seek);
2156 int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos){
2157 return _ov_64_seek_lap(vf,pos,ov_pcm_seek_page);
2160 static int _ov_d_seek_lap(OggVorbis_File *vf,double pos,
2161 int (*localseek)(OggVorbis_File *,double)){
2166 int n1,n2,ch1,ch2,hs;
2169 if(vf->ready_state<OPENED)return(OV_EINVAL);
2170 ret=_ov_initset(vf);
2173 hs=ov_halfrate_p(vf);
2176 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2177 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
2178 persistent; even if the decode state
2179 from this link gets dumped, this
2180 window array continues to exist */
2182 lappcm=alloca(sizeof(*lappcm)*ch1);
2184 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2185 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2187 /* have lapping data; seek and prime the buffer */
2188 ret=localseek(vf,pos);
2190 ret=_ov_initprime(vf);
2193 /* Guard against cross-link changes; they're perfectly legal */
2196 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2197 w2=vorbis_window(&vf->vd,0);
2199 /* consolidate and expose the buffer. */
2200 vorbis_synthesis_lapout(&vf->vd,&pcm);
2203 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2209 int ov_time_seek_lap(OggVorbis_File *vf,double pos){
2210 return _ov_d_seek_lap(vf,pos,ov_time_seek);
2213 int ov_time_seek_page_lap(OggVorbis_File *vf,double pos){
2214 return _ov_d_seek_lap(vf,pos,ov_time_seek_page);