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-2014 *
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"
26 /* we don't need or want the static callback symbols here */
27 #define OV_EXCLUDE_STATIC_CALLBACKS
28 #include "vorbis/vorbisfile.h"
33 /* A 'chained bitstream' is a Vorbis bitstream that contains more than
34 one logical bitstream arranged end to end (the only form of Ogg
35 multiplexing allowed in a Vorbis bitstream; grouping [parallel
36 multiplexing] is not allowed in Vorbis) */
38 /* A Vorbis file can be played beginning to end (streamed) without
39 worrying ahead of time about chaining (see decoder_example.c). If
40 we have the whole file, however, and want random access
41 (seeking/scrubbing) or desire to know the total length/time of a
42 file, we need to account for the possibility of chaining. */
44 /* We can handle things a number of ways; we can determine the entire
45 bitstream structure right off the bat, or find pieces on demand.
46 This example determines and caches structure for the entire
47 bitstream, but builds a virtual decoder on the fly when moving
48 between links in the chain. */
50 /* There are also different ways to implement seeking. Enough
51 information exists in an Ogg bitstream to seek to
52 sample-granularity positions in the output. Or, one can seek by
53 picking some portion of the stream roughly in the desired area if
54 we only want coarse navigation through the stream. */
56 /*************************************************************************
57 * Many, many internal helpers. The intention is not to be confusing;
58 * rampant duplication and monolithic function implementation would be
59 * harder to understand anyway. The high level functions are last. Begin
60 * grokking near the end of the file */
62 /* read a little more data from the file/pipe into the ogg_sync framer
64 #define CHUNKSIZE 65536 /* greater-than-page-size granularity seeking */
65 #define READSIZE 2048 /* a smaller read size is needed for low-rate streaming. */
67 static long _get_data(OggVorbis_File *vf){
69 if(!(vf->callbacks.read_func))return(-1);
71 char *buffer=ogg_sync_buffer(&vf->oy,READSIZE);
72 long bytes=(vf->callbacks.read_func)(buffer,1,READSIZE,vf->datasource);
73 if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
74 if(bytes==0 && errno)return(-1);
80 /* save a tiny smidge of verbosity to make the code more readable */
81 static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){
83 /* only seek if the file position isn't already there */
84 if(vf->offset != offset){
85 if(!(vf->callbacks.seek_func)||
86 (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)
89 ogg_sync_reset(&vf->oy);
92 /* shouldn't happen unless someone writes a broken callback */
98 /* The read/seek functions track absolute position within the stream */
100 /* from the head of the stream, get the next page. boundary specifies
101 if the function is allowed to fetch more data from the stream (and
102 how much) or only use internally buffered data.
104 boundary: -1) unbounded search
105 0) read no additional data; use cached only
106 n) search for a new page beginning for n bytes
108 return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
109 n) found a page at absolute offset n */
111 static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
112 ogg_int64_t boundary){
113 if(boundary>0)boundary+=vf->offset;
117 if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
118 more=ogg_sync_pageseek(&vf->oy,og);
121 /* skipped n bytes */
125 /* send more paramedics */
126 if(!boundary)return(OV_FALSE);
128 long ret=_get_data(vf);
129 if(ret==0)return(OV_EOF);
130 if(ret<0)return(OV_EREAD);
133 /* got a page. Return the offset at the page beginning,
134 advance the internal offset past the page end */
135 ogg_int64_t ret=vf->offset;
144 /* find the latest page beginning before the passed in position. Much
145 dirtier than the above as Ogg doesn't have any backward search
146 linkage. no 'readp' as it will certainly have to read. */
147 /* returns offset or OV_EREAD, OV_FAULT */
148 static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_int64_t begin,ogg_page *og){
149 ogg_int64_t end = begin;
151 ogg_int64_t offset=-1;
158 ret=_seek_helper(vf,begin);
161 while(vf->offset<end){
162 memset(og,0,sizeof(*og));
163 ret=_get_next_page(vf,og,end-vf->offset);
164 if(ret==OV_EREAD)return(OV_EREAD);
173 /* In a fully compliant, non-multiplexed stream, we'll still be
174 holding the last page. In multiplexed (or noncompliant streams),
175 we will probably have to re-read the last page we saw */
176 if(og->header_len==0){
177 ret=_seek_helper(vf,offset);
180 ret=_get_next_page(vf,og,CHUNKSIZE);
182 /* this shouldn't be possible */
189 static void _add_serialno(ogg_page *og,long **serialno_list, int *n){
190 long s = ogg_page_serialno(og);
194 *serialno_list = _ogg_realloc(*serialno_list, sizeof(**serialno_list)*(*n));
196 *serialno_list = _ogg_malloc(sizeof(**serialno_list));
199 (*serialno_list)[(*n)-1] = s;
202 /* returns nonzero if found */
203 static int _lookup_serialno(long s, long *serialno_list, int n){
206 if(*serialno_list == s) return 1;
213 static int _lookup_page_serialno(ogg_page *og, long *serialno_list, int n){
214 long s = ogg_page_serialno(og);
215 return _lookup_serialno(s,serialno_list,n);
218 /* performs the same search as _get_prev_page, but prefers pages of
219 the specified serial number. If a page of the specified serialno is
220 spotted during the seek-back-and-read-forward, it will return the
221 info of last page of the matching serial number instead of the very
222 last page. If no page of the specified serialno is seen, it will
223 return the info of last page and alter *serialno. */
224 static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf, ogg_int64_t begin,
225 long *serial_list, int serial_n,
226 int *serialno, ogg_int64_t *granpos){
228 ogg_int64_t end=begin;
231 ogg_int64_t prefoffset=-1;
232 ogg_int64_t offset=-1;
233 ogg_int64_t ret_serialno=-1;
234 ogg_int64_t ret_gran=-1;
241 ret=_seek_helper(vf,begin);
244 while(vf->offset<end){
245 ret=_get_next_page(vf,&og,end-vf->offset);
246 if(ret==OV_EREAD)return(OV_EREAD);
250 ret_serialno=ogg_page_serialno(&og);
251 ret_gran=ogg_page_granulepos(&og);
254 if(ret_serialno == *serialno){
259 if(!_lookup_serialno(ret_serialno,serial_list,serial_n)){
260 /* we fell off the end of the link, which means we seeked
261 back too far and shouldn't have been looking in that link
262 to begin with. If we found the preferred serial number,
263 forget that we saw it. */
270 /* we're not interested in the page... just the serialno and granpos. */
271 if(prefoffset>=0)return(prefoffset);
273 *serialno = ret_serialno;
279 /* uses the local ogg_stream storage in vf; this is important for
280 non-streaming input sources */
281 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
282 long **serialno_list, int *serialno_n,
290 ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
291 if(llret==OV_EREAD)return(OV_EREAD);
292 if(llret<0)return(OV_ENOTVORBIS);
296 vorbis_info_init(vi);
297 vorbis_comment_init(vc);
298 vf->ready_state=OPENED;
300 /* extract the serialnos of all BOS pages + the first set of vorbis
301 headers we see in the link */
303 while(ogg_page_bos(og_ptr)){
305 if(_lookup_page_serialno(og_ptr,*serialno_list,*serialno_n)){
306 /* a dupe serialnumber in an initial header packet set == invalid stream */
307 if(*serialno_list)_ogg_free(*serialno_list);
314 _add_serialno(og_ptr,serialno_list,serialno_n);
317 if(vf->ready_state<STREAMSET){
318 /* we don't have a vorbis stream in this link yet, so begin
319 prospective stream setup. We need a stream to get packets */
320 ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
321 ogg_stream_pagein(&vf->os,og_ptr);
323 if(ogg_stream_packetout(&vf->os,&op) > 0 &&
324 vorbis_synthesis_idheader(&op)){
325 /* vorbis header; continue setup */
326 vf->ready_state=STREAMSET;
327 if((ret=vorbis_synthesis_headerin(vi,vc,&op))){
336 ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE);
346 /* if this page also belongs to our vorbis stream, submit it and break */
347 if(vf->ready_state==STREAMSET &&
348 vf->os.serialno == ogg_page_serialno(og_ptr)){
349 ogg_stream_pagein(&vf->os,og_ptr);
355 if(vf->ready_state!=STREAMSET){
363 while(i<2){ /* get a page loop */
365 while(i<2){ /* get a packet loop */
367 int result=ogg_stream_packetout(&vf->os,&op);
374 if((ret=vorbis_synthesis_headerin(vi,vc,&op)))
381 if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){
386 /* if this page belongs to the correct stream, go parse it */
387 if(vf->os.serialno == ogg_page_serialno(og_ptr)){
388 ogg_stream_pagein(&vf->os,og_ptr);
392 /* if we never see the final vorbis headers before the link
394 if(ogg_page_bos(og_ptr)){
402 /* otherwise, keep looking */
410 vorbis_info_clear(vi);
411 vorbis_comment_clear(vc);
412 vf->ready_state=OPENED;
417 /* Starting from current cursor position, get initial PCM offset of
418 next page. Consumes the page in the process without decoding
419 audio, however this is only called during stream parsing upon
421 static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){
423 ogg_int64_t accumulated=0;
426 int serialno = vf->os.serialno;
430 if(_get_next_page(vf,&og,-1)<0)
431 break; /* should not be possible unless the file is truncated/mangled */
433 if(ogg_page_bos(&og)) break;
434 if(ogg_page_serialno(&og)!=serialno) continue;
436 /* count blocksizes of all frames in the page */
437 ogg_stream_pagein(&vf->os,&og);
438 while((result=ogg_stream_packetout(&vf->os,&op))){
439 if(result>0){ /* ignore holes */
440 long thisblock=vorbis_packet_blocksize(vi,&op);
442 accumulated+=(lastblock+thisblock)>>2;
447 if(ogg_page_granulepos(&og)!=-1){
448 /* pcm offset of last packet on the first audio page */
449 accumulated= ogg_page_granulepos(&og)-accumulated;
454 /* less than zero? Either a corrupt file or a stream with samples
455 trimmed off the beginning, a normal occurrence; in both cases set
456 the offset to zero */
457 if(accumulated<0)accumulated=0;
462 /* finds each bitstream link one at a time using a bisection search
463 (has to begin by knowing the offset of the lb's initial page).
464 Recurses for each link so it can alloc the link storage after
465 finding them all, then unroll and fill the cache at the same time */
466 static int _bisect_forward_serialno(OggVorbis_File *vf,
468 ogg_int64_t searched,
472 long *currentno_list,
475 ogg_int64_t pcmoffset;
476 ogg_int64_t dataoffset=searched;
477 ogg_int64_t endsearched=end;
478 ogg_int64_t next=end;
479 ogg_int64_t searchgran=-1;
481 ogg_int64_t ret,last;
482 int serialno = vf->os.serialno;
485 we have the headers and serialnos for the link beginning at 'begin'
486 we have the offset and granpos of the last page in the file (potentially
487 not a page we care about)
490 /* Is the last page in our list of current serialnumbers? */
491 if(_lookup_serialno(endserial,currentno_list,currentnos)){
493 /* last page is in the starting serialno list, so we've bisected
494 down to (or just started with) a single link. Now we need to
495 find the last vorbis page belonging to the first vorbis stream
498 while(endserial != serialno){
499 endserial = serialno;
500 searched=_get_prev_page_serial(vf,searched,currentno_list,currentnos,&endserial,&endgran);
504 if(vf->offsets)_ogg_free(vf->offsets);
505 if(vf->serialnos)_ogg_free(vf->serialnos);
506 if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
508 vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));
509 vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));
510 vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));
511 vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));
512 vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));
513 vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));
515 vf->offsets[m+1]=end;
516 vf->offsets[m]=begin;
517 vf->pcmlengths[m*2+1]=(endgran<0?0:endgran);
521 /* last page is not in the starting stream's serial number list,
522 so we have multiple links. Find where the stream that begins
523 our bisection ends. */
525 long *next_serialno_list=NULL;
526 int next_serialnos=0;
529 int testserial = serialno+1;
531 /* the below guards against garbage seperating the last and
532 first pages of two links. */
533 while(searched<endsearched){
536 if(endsearched-searched<CHUNKSIZE){
539 bisect=(searched+endsearched)/2;
542 ret=_seek_helper(vf,bisect);
545 last=_get_next_page(vf,&og,-1);
546 if(last==OV_EREAD)return(OV_EREAD);
547 if(last<0 || !_lookup_page_serialno(&og,currentno_list,currentnos)){
549 if(last>=0)next=last;
555 /* Bisection point found */
556 /* for the time being, fetch end PCM offset the simple way */
558 while(testserial != serialno){
559 testserial = serialno;
560 searched = _get_prev_page_serial(vf,searched,currentno_list,currentnos,&testserial,&searchgran);
563 ret=_seek_helper(vf,next);
566 ret=_fetch_headers(vf,&vi,&vc,&next_serialno_list,&next_serialnos,NULL);
568 serialno = vf->os.serialno;
569 dataoffset = vf->offset;
571 /* this will consume a page, however the next bisection always
572 starts with a raw seek */
573 pcmoffset = _initial_pcmoffset(vf,&vi);
575 ret=_bisect_forward_serialno(vf,next,vf->offset,end,endgran,endserial,
576 next_serialno_list,next_serialnos,m+1);
579 if(next_serialno_list)_ogg_free(next_serialno_list);
581 vf->offsets[m+1]=next;
582 vf->serialnos[m+1]=serialno;
583 vf->dataoffsets[m+1]=dataoffset;
588 vf->pcmlengths[m*2+1]=searchgran;
589 vf->pcmlengths[m*2+2]=pcmoffset;
590 vf->pcmlengths[m*2+3]-=pcmoffset;
591 if(vf->pcmlengths[m*2+3]<0)vf->pcmlengths[m*2+3]=0;
596 static int _make_decode_ready(OggVorbis_File *vf){
597 if(vf->ready_state>STREAMSET)return 0;
598 if(vf->ready_state<STREAMSET)return OV_EFAULT;
600 if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))
603 if(vorbis_synthesis_init(&vf->vd,vf->vi))
606 vorbis_block_init(&vf->vd,&vf->vb);
607 vf->ready_state=INITSET;
613 static int _open_seekable2(OggVorbis_File *vf){
614 ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1;
615 int endserial=vf->os.serialno;
616 int serialno=vf->os.serialno;
618 /* we're partially open and have a first link header state in
621 /* fetch initial PCM offset */
622 ogg_int64_t pcmoffset = _initial_pcmoffset(vf,vf->vi);
624 /* we can seek, so set out learning all about this file */
625 if(vf->callbacks.seek_func && vf->callbacks.tell_func){
626 (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
627 vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
629 vf->offset=vf->end=-1;
632 /* If seek_func is implemented, tell_func must also be implemented */
633 if(vf->end==-1) return(OV_EINVAL);
635 /* Get the offset of the last page of the physical bitstream, or, if
636 we're lucky the last vorbis page of this link as most OggVorbis
637 files will contain a single logical bitstream */
638 end=_get_prev_page_serial(vf,vf->end,vf->serialnos+2,vf->serialnos[1],&endserial,&endgran);
639 if(end<0)return(end);
641 /* now determine bitstream structure recursively */
642 if(_bisect_forward_serialno(vf,0,dataoffset,end,endgran,endserial,
643 vf->serialnos+2,vf->serialnos[1],0)<0)return(OV_EREAD);
646 vf->serialnos[0]=serialno;
647 vf->dataoffsets[0]=dataoffset;
648 vf->pcmlengths[0]=pcmoffset;
649 vf->pcmlengths[1]-=pcmoffset;
650 if(vf->pcmlengths[1]<0)vf->pcmlengths[1]=0;
652 return(ov_raw_seek(vf,dataoffset));
655 /* clear out the current logical bitstream decoder */
656 static void _decode_clear(OggVorbis_File *vf){
657 vorbis_dsp_clear(&vf->vd);
658 vorbis_block_clear(&vf->vb);
659 vf->ready_state=OPENED;
662 /* fetch and process a packet. Handles the case where we're at a
663 bitstream boundary and dumps the decoding machine. If the decoding
664 machine is unloaded, it loads it. It also keeps pcm_offset up to
665 date (seek and read both use this. seek uses a special hack with
668 return: <0) error, OV_HOLE (lost packet) or OV_EOF
669 0) need more data (only if readp==0)
673 static int _fetch_and_process_packet(OggVorbis_File *vf,
679 /* handle one packet. Try to fetch it from current stream state */
680 /* extract packets from page */
683 if(vf->ready_state==STREAMSET){
684 int ret=_make_decode_ready(vf);
688 /* process a packet if we can. */
690 if(vf->ready_state==INITSET){
691 int hs=vorbis_synthesis_halfrate_p(vf->vi);
695 ogg_packet *op_ptr=(op_in?op_in:&op);
696 int result=ogg_stream_packetout(&vf->os,op_ptr);
697 ogg_int64_t granulepos;
700 if(result==-1)return(OV_HOLE); /* hole in the data. */
702 /* got a packet. process it */
703 granulepos=op_ptr->granulepos;
704 if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
706 header packets aren't
709 vorbis_synthesis will
712 /* suck in the synthesis data and track bitrate */
714 int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
715 /* for proper use of libvorbis within libvorbisfile,
716 oldsamples will always be zero. */
717 if(oldsamples)return(OV_EFAULT);
719 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
720 vf->samptrack+=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
721 vf->bittrack+=op_ptr->bytes*8;
724 /* update the pcm offset. */
725 if(granulepos!=-1 && !op_ptr->e_o_s){
726 int link=(vf->seekable?vf->current_link:0);
729 /* this packet has a pcm_offset on it (the last packet
730 completed on a page carries the offset) After processing
731 (above), we know the pcm position of the *last* sample
732 ready to be returned. Find the offset of the *first*
734 As an aside, this trick is inaccurate if we begin
735 reading anew right at the last page; the end-of-stream
736 granulepos declares the last frame in the stream, and the
737 last packet of the last page may be a partial frame.
738 So, we need a previous granulepos from an in-sequence page
739 to have a reference point. Thus the !op_ptr->e_o_s clause
742 if(vf->seekable && link>0)
743 granulepos-=vf->pcmlengths[link*2];
744 if(granulepos<0)granulepos=0; /* actually, this
745 shouldn't be possible
746 here unless the stream
749 samples=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
753 granulepos+=vf->pcmlengths[i*2+1];
754 vf->pcm_offset=granulepos;
764 if(vf->ready_state>=OPENED){
768 /* the loop is not strictly necessary, but there's no sense in
769 doing the extra checks of the larger loop for the common
770 case in a multiplexed bistream where the page is simply
771 part of a different logical bitstream; keep reading until
772 we get one with the correct serialno */
775 if((ret=_get_next_page(vf,&og,-1))<0){
776 return(OV_EOF); /* eof. leave unitialized */
779 /* bitrate tracking; add the header's bytes here, the body bytes
780 are done by packet above */
781 vf->bittrack+=og.header_len*8;
783 if(vf->ready_state==INITSET){
784 if(vf->current_serialno!=ogg_page_serialno(&og)){
786 /* two possibilities:
787 1) our decoding just traversed a bitstream boundary
788 2) another stream is multiplexed into this logical section */
790 if(ogg_page_bos(&og)){
798 vorbis_info_clear(vf->vi);
799 vorbis_comment_clear(vf->vc);
804 continue; /* possibility #2 */
812 /* Do we need to load a new machine before submitting the page? */
813 /* This is different in the seekable and non-seekable cases.
815 In the seekable case, we already have all the header
816 information loaded and cached; we just initialize the machine
817 with it and continue on our merry way.
819 In the non-seekable (streaming) case, we'll only be at a
820 boundary if we just left the previous logical bitstream and
821 we're now nominally at the header of the next bitstream
824 if(vf->ready_state!=INITSET){
827 if(vf->ready_state<STREAMSET){
829 long serialno = ogg_page_serialno(&og);
831 /* match the serialno to bitstream section. We use this rather than
832 offset positions to avoid problems near logical bitstream
835 for(link=0;link<vf->links;link++)
836 if(vf->serialnos[link]==serialno)break;
838 if(link==vf->links) continue; /* not the desired Vorbis
839 bitstream section; keep
842 vf->current_serialno=serialno;
843 vf->current_link=link;
845 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
846 vf->ready_state=STREAMSET;
849 /* we're streaming */
850 /* fetch the three header packets, build the info struct */
852 int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);
854 vf->current_serialno=vf->os.serialno;
861 /* the buffered page is the data we want, and we're ready for it;
862 add it to the stream state */
863 ogg_stream_pagein(&vf->os,&og);
868 /* if, eg, 64 bit stdio is configured by default, this will build with
870 static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
871 if(f==NULL)return(-1);
872 return fseek(f,off,whence);
875 static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial,
876 long ibytes, ov_callbacks callbacks){
877 int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);
878 long *serialno_list=NULL;
879 int serialno_list_size=0;
882 memset(vf,0,sizeof(*vf));
884 vf->callbacks = callbacks;
886 /* init the framing state */
887 ogg_sync_init(&vf->oy);
889 /* perhaps some data was previously read into a buffer for testing
890 against other stream types. Allow initialization from this
891 previously read data (especially as we may be reading from a
892 non-seekable stream) */
894 char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
895 memcpy(buffer,initial,ibytes);
896 ogg_sync_wrote(&vf->oy,ibytes);
899 /* can we seek? Stevens suggests the seek test was portable */
900 if(offsettest!=-1)vf->seekable=1;
902 /* No seeking yet; Set up a 'single' (current) logical bitstream
903 entry for partial open */
905 vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
906 vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
907 ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
909 /* Fetch all BOS pages, store the vorbis header and all seen serial
910 numbers, load subsequent vorbis setup headers */
911 if((ret=_fetch_headers(vf,vf->vi,vf->vc,&serialno_list,&serialno_list_size,NULL))<0){
915 /* serial number list for first link needs to be held somewhere
916 for second stage of seekable stream open; this saves having to
917 seek/reread first link's serialnumber data then. */
918 vf->serialnos=_ogg_calloc(serialno_list_size+2,sizeof(*vf->serialnos));
919 vf->serialnos[0]=vf->current_serialno=vf->os.serialno;
920 vf->serialnos[1]=serialno_list_size;
921 memcpy(vf->serialnos+2,serialno_list,serialno_list_size*sizeof(*vf->serialnos));
923 vf->offsets=_ogg_calloc(1,sizeof(*vf->offsets));
924 vf->dataoffsets=_ogg_calloc(1,sizeof(*vf->dataoffsets));
926 vf->dataoffsets[0]=vf->offset;
928 vf->ready_state=PARTOPEN;
930 if(serialno_list)_ogg_free(serialno_list);
934 static int _ov_open2(OggVorbis_File *vf){
935 if(vf->ready_state != PARTOPEN) return OV_EINVAL;
936 vf->ready_state=OPENED;
938 int ret=_open_seekable2(vf);
945 vf->ready_state=STREAMSET;
951 /* clear out the OggVorbis_File struct */
952 int ov_clear(OggVorbis_File *vf){
954 vorbis_block_clear(&vf->vb);
955 vorbis_dsp_clear(&vf->vd);
956 ogg_stream_clear(&vf->os);
958 if(vf->vi && vf->links){
960 for(i=0;i<vf->links;i++){
961 vorbis_info_clear(vf->vi+i);
962 vorbis_comment_clear(vf->vc+i);
967 if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
968 if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
969 if(vf->serialnos)_ogg_free(vf->serialnos);
970 if(vf->offsets)_ogg_free(vf->offsets);
971 ogg_sync_clear(&vf->oy);
972 if(vf->datasource && vf->callbacks.close_func)
973 (vf->callbacks.close_func)(vf->datasource);
974 memset(vf,0,sizeof(*vf));
982 /* inspects the OggVorbis file and finds/documents all the logical
983 bitstreams contained in it. Tries to be tolerant of logical
984 bitstream sections that are truncated/woogie.
990 int ov_open_callbacks(void *f,OggVorbis_File *vf,
991 const char *initial,long ibytes,ov_callbacks callbacks){
992 int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
994 return _ov_open2(vf);
997 int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
998 ov_callbacks callbacks = {
999 (size_t (*)(void *, size_t, size_t, void *)) fread,
1000 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
1001 (int (*)(void *)) fclose,
1002 (long (*)(void *)) ftell
1005 return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
1008 int ov_fopen(const char *path,OggVorbis_File *vf){
1010 FILE *f = fopen(path,"rb");
1013 ret = ov_open(f,vf,NULL,0);
1019 /* cheap hack for game usage where downsampling is desirable; there's
1020 no need for SRC as we can just do it cheaply in libvorbis. */
1022 int ov_halfrate(OggVorbis_File *vf,int flag){
1024 if(vf->vi==NULL)return OV_EINVAL;
1025 if(vf->ready_state>STREAMSET){
1026 /* clear out stream state; dumping the decode machine is needed to
1027 reinit the MDCT lookups. */
1028 vorbis_dsp_clear(&vf->vd);
1029 vorbis_block_clear(&vf->vb);
1030 vf->ready_state=STREAMSET;
1031 if(vf->pcm_offset>=0){
1032 ogg_int64_t pos=vf->pcm_offset;
1033 vf->pcm_offset=-1; /* make sure the pos is dumped if unseekable */
1034 ov_pcm_seek(vf,pos);
1038 for(i=0;i<vf->links;i++){
1039 if(vorbis_synthesis_halfrate(vf->vi+i,flag)){
1040 if(flag) ov_halfrate(vf,0);
1047 int ov_halfrate_p(OggVorbis_File *vf){
1048 if(vf->vi==NULL)return OV_EINVAL;
1049 return vorbis_synthesis_halfrate_p(vf->vi);
1052 /* Only partially open the vorbis file; test for Vorbisness, and load
1053 the headers for the first chain. Do not seek (although test for
1054 seekability). Use ov_test_open to finish opening the file, else
1055 ov_clear to close/free it. Same return codes as open.
1057 Note that vorbisfile does _not_ take ownership of the file if the
1058 call fails; the calling applicaiton is responsible for closing the file
1059 if this call returns an error. */
1061 int ov_test_callbacks(void *f,OggVorbis_File *vf,
1062 const char *initial,long ibytes,ov_callbacks callbacks)
1064 return _ov_open1(f,vf,initial,ibytes,callbacks);
1067 int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
1068 ov_callbacks callbacks = {
1069 (size_t (*)(void *, size_t, size_t, void *)) fread,
1070 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
1071 (int (*)(void *)) fclose,
1072 (long (*)(void *)) ftell
1075 return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
1078 int ov_test_open(OggVorbis_File *vf){
1079 if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
1080 return _ov_open2(vf);
1083 /* How many logical bitstreams in this physical bitstream? */
1084 long ov_streams(OggVorbis_File *vf){
1088 /* Is the FILE * associated with vf seekable? */
1089 long ov_seekable(OggVorbis_File *vf){
1090 return vf->seekable;
1093 /* returns the bitrate for a given logical bitstream or the entire
1094 physical bitstream. If the file is open for random access, it will
1095 find the *actual* average bitrate. If the file is streaming, it
1096 returns the nominal bitrate (if set) else the average of the
1097 upper/lower bounds (if set) else -1 (unset).
1099 If you want the actual bitrate field settings, get them from the
1100 vorbis_info structs */
1102 long ov_bitrate(OggVorbis_File *vf,int i){
1103 if(vf->ready_state<OPENED)return(OV_EINVAL);
1104 if(i>=vf->links)return(OV_EINVAL);
1105 if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
1110 for(i=0;i<vf->links;i++)
1111 bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
1112 /* This once read: return(rint(bits/ov_time_total(vf,-1)));
1113 * gcc 3.x on x86 miscompiled this at optimisation level 2 and above,
1114 * so this is slightly transformed to make it work.
1116 br = bits/ov_time_total(vf,-1);
1120 /* return the actual bitrate */
1121 return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
1123 /* return nominal if set */
1124 if(vf->vi[i].bitrate_nominal>0){
1125 return vf->vi[i].bitrate_nominal;
1127 if(vf->vi[i].bitrate_upper>0){
1128 if(vf->vi[i].bitrate_lower>0){
1129 return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
1131 return vf->vi[i].bitrate_upper;
1140 /* returns the actual bitrate since last call. returns -1 if no
1141 additional data to offer since last call (or at beginning of stream),
1142 EINVAL if stream is only partially open
1144 long ov_bitrate_instant(OggVorbis_File *vf){
1145 int link=(vf->seekable?vf->current_link:0);
1147 if(vf->ready_state<OPENED)return(OV_EINVAL);
1148 if(vf->samptrack==0)return(OV_FALSE);
1149 ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
1156 long ov_serialnumber(OggVorbis_File *vf,int i){
1157 if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
1158 if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
1160 return(vf->current_serialno);
1162 return(vf->serialnos[i]);
1166 /* returns: total raw (compressed) length of content if i==-1
1167 raw (compressed) length of that logical bitstream for i==0 to n
1168 OV_EINVAL if the stream is not seekable (we can't know the length)
1169 or if stream is only partially open
1171 ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
1172 if(vf->ready_state<OPENED)return(OV_EINVAL);
1173 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1177 for(i=0;i<vf->links;i++)
1178 acc+=ov_raw_total(vf,i);
1181 return(vf->offsets[i+1]-vf->offsets[i]);
1185 /* returns: total PCM length (samples) of content if i==-1 PCM length
1186 (samples) of that logical bitstream for i==0 to n
1187 OV_EINVAL if the stream is not seekable (we can't know the
1188 length) or only partially open
1190 ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
1191 if(vf->ready_state<OPENED)return(OV_EINVAL);
1192 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1196 for(i=0;i<vf->links;i++)
1197 acc+=ov_pcm_total(vf,i);
1200 return(vf->pcmlengths[i*2+1]);
1204 /* returns: total seconds of content if i==-1
1205 seconds in that logical bitstream for i==0 to n
1206 OV_EINVAL if the stream is not seekable (we can't know the
1207 length) or only partially open
1209 double ov_time_total(OggVorbis_File *vf,int i){
1210 if(vf->ready_state<OPENED)return(OV_EINVAL);
1211 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1215 for(i=0;i<vf->links;i++)
1216 acc+=ov_time_total(vf,i);
1219 return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
1223 /* seek to an offset relative to the *compressed* data. This also
1224 scans packets to update the PCM cursor. It will cross a logical
1225 bitstream boundary, but only if it can't get any packets out of the
1226 tail of the bitstream we seek to (so no surprises).
1228 returns zero on success, nonzero on failure */
1230 int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
1231 ogg_stream_state work_os;
1234 if(vf->ready_state<OPENED)return(OV_EINVAL);
1236 return(OV_ENOSEEK); /* don't dump machine if we can't seek */
1238 if(pos<0 || pos>vf->end)return(OV_EINVAL);
1240 /* is the seek position outside our current link [if any]? */
1241 if(vf->ready_state>=STREAMSET){
1242 if(pos<vf->offsets[vf->current_link] || pos>=vf->offsets[vf->current_link+1])
1243 _decode_clear(vf); /* clear out stream state */
1246 /* don't yet clear out decoding machine (if it's initialized), in
1247 the case we're in the same link. Restart the decode lapping, and
1248 let _fetch_and_process_packet deal with a potential bitstream
1251 ogg_stream_reset_serialno(&vf->os,
1252 vf->current_serialno); /* must set serialno */
1253 vorbis_synthesis_restart(&vf->vd);
1255 ret=_seek_helper(vf,pos);
1256 if(ret)goto seek_error;
1258 /* we need to make sure the pcm_offset is set, but we don't want to
1259 advance the raw cursor past good packets just to get to the first
1260 with a granulepos. That's not equivalent behavior to beginning
1261 decoding as immediately after the seek position as possible.
1263 So, a hack. We use two stream states; a local scratch state and
1264 the shared vf->os stream state. We use the local state to
1265 scan, and the shared state as a buffer for later decode.
1267 Unfortuantely, on the last page we still advance to last packet
1268 because the granulepos on the last page is not necessarily on a
1269 packet boundary, and we need to make sure the granpos is
1281 ogg_int64_t pagepos=-1;
1283 ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
1284 ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
1285 return from not necessarily
1286 starting from the beginning */
1289 if(vf->ready_state>=STREAMSET){
1290 /* snarf/scan a packet if we can */
1291 int result=ogg_stream_packetout(&work_os,&op);
1295 if(vf->vi[vf->current_link].codec_setup){
1296 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1298 ogg_stream_packetout(&vf->os,NULL);
1302 /* We can't get a guaranteed correct pcm position out of the
1303 last page in a stream because it might have a 'short'
1304 granpos, which can only be detected in the presence of a
1305 preceding page. However, if the last page is also the first
1306 page, the granpos rules of a first page take precedence. Not
1307 only that, but for first==last, the EOS page must be treated
1308 as if its a normal first page for the stream to open/play. */
1309 if(lastflag && !firstflag)
1310 ogg_stream_packetout(&vf->os,NULL);
1312 if(lastblock)accblock+=(lastblock+thisblock)>>2;
1315 if(op.granulepos!=-1){
1316 int i,link=vf->current_link;
1317 ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
1318 if(granulepos<0)granulepos=0;
1321 granulepos+=vf->pcmlengths[i*2+1];
1322 vf->pcm_offset=granulepos-accblock;
1323 if(vf->pcm_offset<0)vf->pcm_offset=0;
1326 lastblock=thisblock;
1329 ogg_stream_packetout(&vf->os,NULL);
1334 pagepos=_get_next_page(vf,&og,-1);
1336 vf->pcm_offset=ov_pcm_total(vf,-1);
1340 /* huh? Bogus stream with packets but no granulepos */
1345 /* has our decoding just traversed a bitstream boundary? */
1346 if(vf->ready_state>=STREAMSET){
1347 if(vf->current_serialno!=ogg_page_serialno(&og)){
1349 /* two possibilities:
1350 1) our decoding just traversed a bitstream boundary
1351 2) another stream is multiplexed into this logical section? */
1353 if(ogg_page_bos(&og)){
1355 _decode_clear(vf); /* clear out stream state */
1356 ogg_stream_clear(&work_os);
1357 } /* else, do nothing; next loop will scoop another page */
1361 if(vf->ready_state<STREAMSET){
1363 long serialno = ogg_page_serialno(&og);
1365 for(link=0;link<vf->links;link++)
1366 if(vf->serialnos[link]==serialno)break;
1368 if(link==vf->links) continue; /* not the desired Vorbis
1369 bitstream section; keep
1371 vf->current_link=link;
1372 vf->current_serialno=serialno;
1373 ogg_stream_reset_serialno(&vf->os,serialno);
1374 ogg_stream_reset_serialno(&work_os,serialno);
1375 vf->ready_state=STREAMSET;
1376 firstflag=(pagepos<=vf->dataoffsets[link]);
1379 ogg_stream_pagein(&vf->os,&og);
1380 ogg_stream_pagein(&work_os,&og);
1381 lastflag=ogg_page_eos(&og);
1386 ogg_stream_clear(&work_os);
1392 /* dump the machine so we're in a known state */
1394 ogg_stream_clear(&work_os);
1399 /* Page granularity seek (faster than sample granularity because we
1400 don't do the last bit of decode to find a specific sample).
1402 Seek to the last [granule marked] page preceding the specified pos
1403 location, such that decoding past the returned point will quickly
1404 arrive at the requested position. */
1405 int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
1407 ogg_int64_t result=0;
1408 ogg_int64_t total=ov_pcm_total(vf,-1);
1410 if(vf->ready_state<OPENED)return(OV_EINVAL);
1411 if(!vf->seekable)return(OV_ENOSEEK);
1413 if(pos<0 || pos>total)return(OV_EINVAL);
1415 /* which bitstream section does this pcm offset occur in? */
1416 for(link=vf->links-1;link>=0;link--){
1417 total-=vf->pcmlengths[link*2+1];
1418 if(pos>=total)break;
1421 /* Search within the logical bitstream for the page with the highest
1422 pcm_pos preceding pos. If we're looking for a position on the
1423 first page, bisection will halt without finding our position as
1424 it's before the first explicit granulepos fencepost. That case is
1425 handled separately below.
1427 There is a danger here; missing pages or incorrect frame number
1428 information in the bitstream could make our task impossible.
1429 Account for that (it would be an error condition) */
1431 /* new search algorithm originally by HB (Nicholas Vinen) */
1434 ogg_int64_t end=vf->offsets[link+1];
1435 ogg_int64_t begin=vf->dataoffsets[link];
1436 ogg_int64_t begintime = vf->pcmlengths[link*2];
1437 ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
1438 ogg_int64_t target=pos-total+begintime;
1439 ogg_int64_t best=-1;
1442 /* bisection loop */
1446 if(end-begin<CHUNKSIZE){
1449 /* take a (pretty decent) guess. */
1451 (ogg_int64_t)((double)(target-begintime)*(end-begin)/(endtime-begintime))
1453 if(bisect<begin+CHUNKSIZE)
1457 result=_seek_helper(vf,bisect);
1458 if(result) goto seek_error;
1460 /* read loop within the bisection loop */
1462 result=_get_next_page(vf,&og,end-vf->offset);
1463 if(result==OV_EREAD) goto seek_error;
1465 /* there is no next page! */
1467 /* No bisection left to perform. We've either found the
1468 best candidate already or failed. Exit loop. */
1471 /* We tried to load a fraction of the last page; back up a
1472 bit and try to get the whole last page */
1473 if(bisect==0) goto seek_error;
1476 /* don't repeat/loop on a read we've already performed */
1477 if(bisect<=begin)bisect=begin+1;
1479 /* seek and cntinue bisection */
1480 result=_seek_helper(vf,bisect);
1481 if(result) goto seek_error;
1484 ogg_int64_t granulepos;
1486 /* got a page. analyze it */
1487 /* only consider pages from primary vorbis stream */
1488 if(ogg_page_serialno(&og)!=vf->serialnos[link])
1491 /* only consider pages with the granulepos set */
1492 granulepos=ogg_page_granulepos(&og);
1493 if(granulepos==-1)continue;
1495 if(granulepos<target){
1496 /* this page is a successful candidate! Set state */
1498 best=result; /* raw offset of packet with granulepos */
1499 begin=vf->offset; /* raw offset of next page */
1500 begintime=granulepos;
1502 /* if we're before our target but within a short distance,
1503 don't bisect; read forward */
1504 if(target-begintime>44100)break;
1506 bisect=begin; /* *not* begin + 1 as above */
1509 /* This is one of our pages, but the granpos is
1510 post-target; it is not a bisection return
1511 candidate. (The only way we'd use it is if it's the
1512 first page in the stream; we handle that case later
1513 outside the bisection) */
1514 if(bisect<=begin+1){
1515 /* No bisection left to perform. We've either found the
1516 best candidate already or failed. Exit loop. */
1519 if(end==vf->offset){
1520 /* bisection read to the end; use the known page
1521 boundary (result) to update bisection, back up a
1522 little bit, and try again */
1525 if(bisect<=begin)bisect=begin+1;
1526 result=_seek_helper(vf,bisect);
1527 if(result) goto seek_error;
1529 /* Normal bisection */
1540 /* Out of bisection: did it 'fail?' */
1543 /* Check the 'looking for data in first page' special case;
1544 bisection would 'fail' because our search target was before the
1545 first PCM granule position fencepost. */
1547 if(begin == vf->dataoffsets[link] &&
1548 ogg_page_serialno(&og)==vf->serialnos[link]){
1550 /* Yes, this is the beginning-of-stream case. We already have
1551 our page, right at the beginning of PCM data. Set state
1554 vf->pcm_offset=total;
1556 if(link!=vf->current_link){
1557 /* Different link; dump entire decode machine */
1560 vf->current_link=link;
1561 vf->current_serialno=vf->serialnos[link];
1562 vf->ready_state=STREAMSET;
1565 vorbis_synthesis_restart(&vf->vd);
1568 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1569 ogg_stream_pagein(&vf->os,&og);
1576 /* Bisection found our page. seek to it, update pcm offset. Easier case than
1577 raw_seek, don't keep packets preceding granulepos. */
1583 result=_seek_helper(vf,best);
1585 if(result) goto seek_error;
1586 result=_get_next_page(vf,&og,-1);
1587 if(result<0) goto seek_error;
1589 if(link!=vf->current_link){
1590 /* Different link; dump entire decode machine */
1593 vf->current_link=link;
1594 vf->current_serialno=vf->serialnos[link];
1595 vf->ready_state=STREAMSET;
1598 vorbis_synthesis_restart(&vf->vd);
1601 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1602 ogg_stream_pagein(&vf->os,&og);
1604 /* pull out all but last packet; the one with granulepos */
1606 result=ogg_stream_packetpeek(&vf->os,&op);
1608 /* No packet returned; we exited the bisection with 'best'
1609 pointing to a page with a granule position, so the packet
1610 finishing this page ('best') originated on a preceding
1611 page. Keep fetching previous pages until we get one with
1612 a granulepos or without the 'continued' flag set. Then
1613 just use raw_seek for simplicity. */
1614 /* Do not rewind past the beginning of link data; if we do,
1615 it's either a bug or a broken stream */
1617 while(result>vf->dataoffsets[link]){
1618 result=_get_prev_page(vf,result,&og);
1619 if(result<0) goto seek_error;
1620 if(ogg_page_serialno(&og)==vf->current_serialno &&
1621 (ogg_page_granulepos(&og)>-1 ||
1622 !ogg_page_continued(&og))){
1623 return ov_raw_seek(vf,result);
1628 result = OV_EBADPACKET;
1631 if(op.granulepos!=-1){
1632 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1633 if(vf->pcm_offset<0)vf->pcm_offset=0;
1634 vf->pcm_offset+=total;
1637 result=ogg_stream_packetout(&vf->os,NULL);
1643 if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
1652 /* dump machine so we're in a known state */
1658 /* seek to a sample offset relative to the decompressed pcm stream
1659 returns zero on success, nonzero on failure */
1661 int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
1662 int thisblock,lastblock=0;
1663 int ret=ov_pcm_seek_page(vf,pos);
1664 if(ret<0)return(ret);
1665 if((ret=_make_decode_ready(vf)))return ret;
1667 /* discard leading packets we don't need for the lapping of the
1668 position we want; don't decode them */
1674 int ret=ogg_stream_packetpeek(&vf->os,&op);
1676 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1678 ogg_stream_packetout(&vf->os,NULL);
1679 continue; /* non audio packet */
1681 if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
1683 if(vf->pcm_offset+((thisblock+
1684 vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
1686 /* remove the packet from packet queue and track its granulepos */
1687 ogg_stream_packetout(&vf->os,NULL);
1688 vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with
1691 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
1693 /* end of logical stream case is hard, especially with exact
1694 length positioning. */
1696 if(op.granulepos>-1){
1698 /* always believe the stream markers */
1699 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1700 if(vf->pcm_offset<0)vf->pcm_offset=0;
1701 for(i=0;i<vf->current_link;i++)
1702 vf->pcm_offset+=vf->pcmlengths[i*2+1];
1705 lastblock=thisblock;
1708 if(ret<0 && ret!=OV_HOLE)break;
1710 /* suck in a new page */
1711 if(_get_next_page(vf,&og,-1)<0)break;
1712 if(ogg_page_bos(&og))_decode_clear(vf);
1714 if(vf->ready_state<STREAMSET){
1715 long serialno=ogg_page_serialno(&og);
1718 for(link=0;link<vf->links;link++)
1719 if(vf->serialnos[link]==serialno)break;
1720 if(link==vf->links) continue;
1721 vf->current_link=link;
1723 vf->ready_state=STREAMSET;
1724 vf->current_serialno=ogg_page_serialno(&og);
1725 ogg_stream_reset_serialno(&vf->os,serialno);
1726 ret=_make_decode_ready(vf);
1731 ogg_stream_pagein(&vf->os,&og);
1737 /* discard samples until we reach the desired position. Crossing a
1738 logical bitstream boundary with abandon is OK. */
1740 /* note that halfrate could be set differently in each link, but
1741 vorbisfile encoforces all links are set or unset */
1742 int hs=vorbis_synthesis_halfrate_p(vf->vi);
1743 while(vf->pcm_offset<((pos>>hs)<<hs)){
1744 ogg_int64_t target=(pos-vf->pcm_offset)>>hs;
1745 long samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
1747 if(samples>target)samples=target;
1748 vorbis_synthesis_read(&vf->vd,samples);
1749 vf->pcm_offset+=samples<<hs;
1752 if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
1753 vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
1759 /* seek to a playback time relative to the decompressed pcm stream
1760 returns zero on success, nonzero on failure */
1761 int ov_time_seek(OggVorbis_File *vf,double seconds){
1762 /* translate time to PCM position and call ov_pcm_seek */
1765 ogg_int64_t pcm_total=0;
1766 double time_total=0.;
1768 if(vf->ready_state<OPENED)return(OV_EINVAL);
1769 if(!vf->seekable)return(OV_ENOSEEK);
1770 if(seconds<0)return(OV_EINVAL);
1772 /* which bitstream section does this time offset occur in? */
1773 for(link=0;link<vf->links;link++){
1774 double addsec = ov_time_total(vf,link);
1775 if(seconds<time_total+addsec)break;
1777 pcm_total+=vf->pcmlengths[link*2+1];
1780 if(link==vf->links)return(OV_EINVAL);
1782 /* enough information to convert time offset to pcm offset */
1784 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1785 return(ov_pcm_seek(vf,target));
1789 /* page-granularity version of ov_time_seek
1790 returns zero on success, nonzero on failure */
1791 int ov_time_seek_page(OggVorbis_File *vf,double seconds){
1792 /* translate time to PCM position and call ov_pcm_seek */
1795 ogg_int64_t pcm_total=0;
1796 double time_total=0.;
1798 if(vf->ready_state<OPENED)return(OV_EINVAL);
1799 if(!vf->seekable)return(OV_ENOSEEK);
1800 if(seconds<0)return(OV_EINVAL);
1802 /* which bitstream section does this time offset occur in? */
1803 for(link=0;link<vf->links;link++){
1804 double addsec = ov_time_total(vf,link);
1805 if(seconds<time_total+addsec)break;
1807 pcm_total+=vf->pcmlengths[link*2+1];
1810 if(link==vf->links)return(OV_EINVAL);
1812 /* enough information to convert time offset to pcm offset */
1814 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1815 return(ov_pcm_seek_page(vf,target));
1819 /* tell the current stream offset cursor. Note that seek followed by
1820 tell will likely not give the set offset due to caching */
1821 ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
1822 if(vf->ready_state<OPENED)return(OV_EINVAL);
1826 /* return PCM offset (sample) of next PCM sample to be read */
1827 ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
1828 if(vf->ready_state<OPENED)return(OV_EINVAL);
1829 return(vf->pcm_offset);
1832 /* return time offset (seconds) of next PCM sample to be read */
1833 double ov_time_tell(OggVorbis_File *vf){
1835 ogg_int64_t pcm_total=0;
1836 double time_total=0.f;
1838 if(vf->ready_state<OPENED)return(OV_EINVAL);
1840 pcm_total=ov_pcm_total(vf,-1);
1841 time_total=ov_time_total(vf,-1);
1843 /* which bitstream section does this time offset occur in? */
1844 for(link=vf->links-1;link>=0;link--){
1845 pcm_total-=vf->pcmlengths[link*2+1];
1846 time_total-=ov_time_total(vf,link);
1847 if(vf->pcm_offset>=pcm_total)break;
1851 return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
1854 /* link: -1) return the vorbis_info struct for the bitstream section
1855 currently being decoded
1856 0-n) to request information for a specific bitstream section
1858 In the case of a non-seekable bitstream, any call returns the
1859 current bitstream. NULL in the case that the machine is not
1862 vorbis_info *ov_info(OggVorbis_File *vf,int link){
1865 if(vf->ready_state>=STREAMSET)
1866 return vf->vi+vf->current_link;
1879 /* grr, strong typing, grr, no templates/inheritence, grr */
1880 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
1883 if(vf->ready_state>=STREAMSET)
1884 return vf->vc+vf->current_link;
1897 static int host_is_big_endian() {
1898 ogg_int32_t pattern = 0xfeedface; /* deadbeef */
1899 unsigned char *bytewise = (unsigned char *)&pattern;
1900 if (bytewise[0] == 0xfe) return 1;
1904 /* up to this point, everything could more or less hide the multiple
1905 logical bitstream nature of chaining from the toplevel application
1906 if the toplevel application didn't particularly care. However, at
1907 the point that we actually read audio back, the multiple-section
1908 nature must surface: Multiple bitstream sections do not necessarily
1909 have to have the same number of channels or sampling rate.
1911 ov_read returns the sequential logical bitstream number currently
1912 being decoded along with the PCM data in order that the toplevel
1913 application can take action on channel/sample rate changes. This
1914 number will be incremented even for streamed (non-seekable) streams
1915 (for seekable streams, it represents the actual logical bitstream
1916 index within the physical bitstream. Note that the accessor
1917 functions above are aware of this dichotomy).
1919 ov_read_filter is exactly the same as ov_read except that it processes
1920 the decoded audio data through a filter before packing it into the
1921 requested format. This gives greater accuracy than applying a filter
1922 after the audio has been converted into integral PCM.
1924 input values: buffer) a buffer to hold packed PCM data for return
1925 length) the byte length requested to be placed into buffer
1926 bigendianp) should the data be packed LSB first (0) or
1928 word) word size for output. currently 1 (byte) or
1931 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1933 n) number of bytes of PCM actually returned. The
1934 below works on a packet-by-packet basis, so the
1935 return length is not related to the 'length' passed
1936 in, just guaranteed to fit.
1938 *section) set to the logical bitstream number */
1940 long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
1941 int bigendianp,int word,int sgned,int *bitstream,
1942 void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param){
1944 int host_endian = host_is_big_endian();
1950 if(vf->ready_state<OPENED)return(OV_EINVAL);
1953 if(vf->ready_state==INITSET){
1954 samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1958 /* suck in another packet */
1960 int ret=_fetch_and_process_packet(vf,NULL,1,1);
1971 /* yay! proceed to pack data into the byte buffer */
1973 long channels=ov_info(vf,-1)->channels;
1974 long bytespersample=word * channels;
1975 vorbis_fpu_control fpu;
1976 if(samples>length/bytespersample)samples=length/bytespersample;
1983 filter(pcm,channels,samples,filter_param);
1985 /* a tight loop to pack each size */
1989 int off=(sgned?0:128);
1990 vorbis_fpu_setround(&fpu);
1991 for(j=0;j<samples;j++)
1992 for(i=0;i<channels;i++){
1993 val=vorbis_ftoi(pcm[i][j]*128.f);
1995 else if(val<-128)val=-128;
1998 vorbis_fpu_restore(fpu);
2000 int off=(sgned?0:32768);
2002 if(host_endian==bigendianp){
2005 vorbis_fpu_setround(&fpu);
2006 for(i=0;i<channels;i++) { /* It's faster in this order */
2008 short *dest=((short *)buffer)+i;
2009 for(j=0;j<samples;j++) {
2010 val=vorbis_ftoi(src[j]*32768.f);
2011 if(val>32767)val=32767;
2012 else if(val<-32768)val=-32768;
2017 vorbis_fpu_restore(fpu);
2021 vorbis_fpu_setround(&fpu);
2022 for(i=0;i<channels;i++) {
2024 short *dest=((short *)buffer)+i;
2025 for(j=0;j<samples;j++) {
2026 val=vorbis_ftoi(src[j]*32768.f);
2027 if(val>32767)val=32767;
2028 else if(val<-32768)val=-32768;
2033 vorbis_fpu_restore(fpu);
2036 }else if(bigendianp){
2038 vorbis_fpu_setround(&fpu);
2039 for(j=0;j<samples;j++)
2040 for(i=0;i<channels;i++){
2041 val=vorbis_ftoi(pcm[i][j]*32768.f);
2042 if(val>32767)val=32767;
2043 else if(val<-32768)val=-32768;
2046 *buffer++=(val&0xff);
2048 vorbis_fpu_restore(fpu);
2052 vorbis_fpu_setround(&fpu);
2053 for(j=0;j<samples;j++)
2054 for(i=0;i<channels;i++){
2055 val=vorbis_ftoi(pcm[i][j]*32768.f);
2056 if(val>32767)val=32767;
2057 else if(val<-32768)val=-32768;
2059 *buffer++=(val&0xff);
2062 vorbis_fpu_restore(fpu);
2068 vorbis_synthesis_read(&vf->vd,samples);
2069 hs=vorbis_synthesis_halfrate_p(vf->vi);
2070 vf->pcm_offset+=(samples<<hs);
2071 if(bitstream)*bitstream=vf->current_link;
2072 return(samples*bytespersample);
2078 long ov_read(OggVorbis_File *vf,char *buffer,int length,
2079 int bigendianp,int word,int sgned,int *bitstream){
2080 return ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, NULL, NULL);
2083 /* input values: pcm_channels) a float vector per channel of output
2084 length) the sample length being read by the app
2086 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
2088 n) number of samples of PCM actually returned. The
2089 below works on a packet-by-packet basis, so the
2090 return length is not related to the 'length' passed
2091 in, just guaranteed to fit.
2093 *section) set to the logical bitstream number */
2097 long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
2100 if(vf->ready_state<OPENED)return(OV_EINVAL);
2103 if(vf->ready_state==INITSET){
2105 long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
2107 int hs=vorbis_synthesis_halfrate_p(vf->vi);
2108 if(pcm_channels)*pcm_channels=pcm;
2109 if(samples>length)samples=length;
2110 vorbis_synthesis_read(&vf->vd,samples);
2111 vf->pcm_offset+=samples<<hs;
2112 if(bitstream)*bitstream=vf->current_link;
2118 /* suck in another packet */
2120 int ret=_fetch_and_process_packet(vf,NULL,1,1);
2121 if(ret==OV_EOF)return(0);
2122 if(ret<=0)return(ret);
2128 extern const float *vorbis_window(vorbis_dsp_state *v,int W);
2130 static void _ov_splice(float **pcm,float **lappcm,
2133 const float *w1, const float *w2){
2144 for(j=0;j<ch1 && j<ch2;j++){
2151 d[i]=d[i]*wd + s[i]*ws;
2154 /* window from zero */
2165 /* make sure vf is INITSET */
2166 static int _ov_initset(OggVorbis_File *vf){
2168 if(vf->ready_state==INITSET)break;
2169 /* suck in another packet */
2171 int ret=_fetch_and_process_packet(vf,NULL,1,0);
2172 if(ret<0 && ret!=OV_HOLE)return(ret);
2178 /* make sure vf is INITSET and that we have a primed buffer; if
2179 we're crosslapping at a stream section boundary, this also makes
2180 sure we're sanity checking against the right stream information */
2181 static int _ov_initprime(OggVorbis_File *vf){
2182 vorbis_dsp_state *vd=&vf->vd;
2184 if(vf->ready_state==INITSET)
2185 if(vorbis_synthesis_pcmout(vd,NULL))break;
2187 /* suck in another packet */
2189 int ret=_fetch_and_process_packet(vf,NULL,1,0);
2190 if(ret<0 && ret!=OV_HOLE)return(ret);
2196 /* grab enough data for lapping from vf; this may be in the form of
2197 unreturned, already-decoded pcm, remaining PCM we will need to
2198 decode, or synthetic postextrapolation from last packets. */
2199 static void _ov_getlap(OggVorbis_File *vf,vorbis_info *vi,vorbis_dsp_state *vd,
2200 float **lappcm,int lapsize){
2204 /* try first to decode the lapping data */
2205 while(lapcount<lapsize){
2206 int samples=vorbis_synthesis_pcmout(vd,&pcm);
2208 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2209 for(i=0;i<vi->channels;i++)
2210 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2212 vorbis_synthesis_read(vd,samples);
2214 /* suck in another packet */
2215 int ret=_fetch_and_process_packet(vf,NULL,1,0); /* do *not* span */
2216 if(ret==OV_EOF)break;
2219 if(lapcount<lapsize){
2220 /* failed to get lapping data from normal decode; pry it from the
2221 postextrapolation buffering, or the second half of the MDCT
2222 from the last packet */
2223 int samples=vorbis_synthesis_lapout(&vf->vd,&pcm);
2225 for(i=0;i<vi->channels;i++)
2226 memset(lappcm[i]+lapcount,0,sizeof(**pcm)*lapsize-lapcount);
2229 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2230 for(i=0;i<vi->channels;i++)
2231 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2237 /* this sets up crosslapping of a sample by using trailing data from
2238 sample 1 and lapping it into the windowing buffer of sample 2 */
2239 int ov_crosslap(OggVorbis_File *vf1, OggVorbis_File *vf2){
2240 vorbis_info *vi1,*vi2;
2243 const float *w1,*w2;
2244 int n1,n2,i,ret,hs1,hs2;
2246 if(vf1==vf2)return(0); /* degenerate case */
2247 if(vf1->ready_state<OPENED)return(OV_EINVAL);
2248 if(vf2->ready_state<OPENED)return(OV_EINVAL);
2250 /* the relevant overlap buffers must be pre-checked and pre-primed
2251 before looking at settings in the event that priming would cross
2252 a bitstream boundary. So, do it now */
2254 ret=_ov_initset(vf1);
2256 ret=_ov_initprime(vf2);
2259 vi1=ov_info(vf1,-1);
2260 vi2=ov_info(vf2,-1);
2261 hs1=ov_halfrate_p(vf1);
2262 hs2=ov_halfrate_p(vf2);
2264 lappcm=alloca(sizeof(*lappcm)*vi1->channels);
2265 n1=vorbis_info_blocksize(vi1,0)>>(1+hs1);
2266 n2=vorbis_info_blocksize(vi2,0)>>(1+hs2);
2267 w1=vorbis_window(&vf1->vd,0);
2268 w2=vorbis_window(&vf2->vd,0);
2270 for(i=0;i<vi1->channels;i++)
2271 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2273 _ov_getlap(vf1,vi1,&vf1->vd,lappcm,n1);
2275 /* have a lapping buffer from vf1; now to splice it into the lapping
2277 /* consolidate and expose the buffer. */
2278 vorbis_synthesis_lapout(&vf2->vd,&pcm);
2281 _analysis_output_always("pcmL",0,pcm[0],n1*2,0,0,0);
2282 _analysis_output_always("pcmR",0,pcm[1],n1*2,0,0,0);
2286 _ov_splice(pcm,lappcm,n1,n2,vi1->channels,vi2->channels,w1,w2);
2292 static int _ov_64_seek_lap(OggVorbis_File *vf,ogg_int64_t pos,
2293 int (*localseek)(OggVorbis_File *,ogg_int64_t)){
2297 const float *w1,*w2;
2298 int n1,n2,ch1,ch2,hs;
2301 if(vf->ready_state<OPENED)return(OV_EINVAL);
2302 ret=_ov_initset(vf);
2305 hs=ov_halfrate_p(vf);
2308 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2309 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
2310 persistent; even if the decode state
2311 from this link gets dumped, this
2312 window array continues to exist */
2314 lappcm=alloca(sizeof(*lappcm)*ch1);
2316 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2317 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2319 /* have lapping data; seek and prime the buffer */
2320 ret=localseek(vf,pos);
2322 ret=_ov_initprime(vf);
2325 /* Guard against cross-link changes; they're perfectly legal */
2328 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2329 w2=vorbis_window(&vf->vd,0);
2331 /* consolidate and expose the buffer. */
2332 vorbis_synthesis_lapout(&vf->vd,&pcm);
2335 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2341 int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2342 return _ov_64_seek_lap(vf,pos,ov_raw_seek);
2345 int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2346 return _ov_64_seek_lap(vf,pos,ov_pcm_seek);
2349 int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos){
2350 return _ov_64_seek_lap(vf,pos,ov_pcm_seek_page);
2353 static int _ov_d_seek_lap(OggVorbis_File *vf,double pos,
2354 int (*localseek)(OggVorbis_File *,double)){
2358 const float *w1,*w2;
2359 int n1,n2,ch1,ch2,hs;
2362 if(vf->ready_state<OPENED)return(OV_EINVAL);
2363 ret=_ov_initset(vf);
2366 hs=ov_halfrate_p(vf);
2369 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2370 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
2371 persistent; even if the decode state
2372 from this link gets dumped, this
2373 window array continues to exist */
2375 lappcm=alloca(sizeof(*lappcm)*ch1);
2377 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2378 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2380 /* have lapping data; seek and prime the buffer */
2381 ret=localseek(vf,pos);
2383 ret=_ov_initprime(vf);
2386 /* Guard against cross-link changes; they're perfectly legal */
2389 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2390 w2=vorbis_window(&vf->vd,0);
2392 /* consolidate and expose the buffer. */
2393 vorbis_synthesis_lapout(&vf->vd,&pcm);
2396 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2402 int ov_time_seek_lap(OggVorbis_File *vf,double pos){
2403 return _ov_d_seek_lap(vf,pos,ov_time_seek);
2406 int ov_time_seek_page_lap(OggVorbis_File *vf,double pos){
2407 return _ov_d_seek_lap(vf,pos,ov_time_seek_page);