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-2015 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
11 ********************************************************************
13 function: stdio-based convenience library for opening/seeking/decoding
15 ********************************************************************/
23 #include "vorbis/codec.h"
25 /* we don't need or want the static callback symbols here */
26 #define OV_EXCLUDE_STATIC_CALLBACKS
27 #include "vorbis/vorbisfile.h"
32 /* A 'chained bitstream' is a Vorbis bitstream that contains more than
33 one logical bitstream arranged end to end (the only form of Ogg
34 multiplexing allowed in a Vorbis bitstream; grouping [parallel
35 multiplexing] is not allowed in Vorbis) */
37 /* A Vorbis file can be played beginning to end (streamed) without
38 worrying ahead of time about chaining (see decoder_example.c). If
39 we have the whole file, however, and want random access
40 (seeking/scrubbing) or desire to know the total length/time of a
41 file, we need to account for the possibility of chaining. */
43 /* We can handle things a number of ways; we can determine the entire
44 bitstream structure right off the bat, or find pieces on demand.
45 This example determines and caches structure for the entire
46 bitstream, but builds a virtual decoder on the fly when moving
47 between links in the chain. */
49 /* There are also different ways to implement seeking. Enough
50 information exists in an Ogg bitstream to seek to
51 sample-granularity positions in the output. Or, one can seek by
52 picking some portion of the stream roughly in the desired area if
53 we only want coarse navigation through the stream. */
55 /*************************************************************************
56 * Many, many internal helpers. The intention is not to be confusing;
57 * rampant duplication and monolithic function implementation would be
58 * harder to understand anyway. The high level functions are last. Begin
59 * grokking near the end of the file */
61 /* read a little more data from the file/pipe into the ogg_sync framer
63 #define CHUNKSIZE 65536 /* greater-than-page-size granularity seeking */
64 #define READSIZE 2048 /* a smaller read size is needed for low-rate streaming. */
66 static long _get_data(OggVorbis_File *vf){
68 if(!(vf->callbacks.read_func))return(-1);
70 char *buffer=ogg_sync_buffer(&vf->oy,READSIZE);
71 long bytes=(vf->callbacks.read_func)(buffer,1,READSIZE,vf->datasource);
72 if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
73 if(bytes==0 && errno)return(-1);
79 /* save a tiny smidge of verbosity to make the code more readable */
80 static int _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){
82 /* only seek if the file position isn't already there */
83 if(vf->offset != offset){
84 if(!(vf->callbacks.seek_func)||
85 (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)
88 ogg_sync_reset(&vf->oy);
91 /* shouldn't happen unless someone writes a broken callback */
97 /* The read/seek functions track absolute position within the stream */
99 /* from the head of the stream, get the next page. boundary specifies
100 if the function is allowed to fetch more data from the stream (and
101 how much) or only use internally buffered data.
103 boundary: -1) unbounded search
104 0) read no additional data; use cached only
105 n) search for a new page beginning for n bytes
107 return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
108 n) found a page at absolute offset n */
110 static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
111 ogg_int64_t boundary){
112 if(boundary>0)boundary+=vf->offset;
116 if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
117 more=ogg_sync_pageseek(&vf->oy,og);
120 /* skipped n bytes */
124 /* send more paramedics */
125 if(!boundary)return(OV_FALSE);
127 long ret=_get_data(vf);
128 if(ret==0)return(OV_EOF);
129 if(ret<0)return(OV_EREAD);
132 /* got a page. Return the offset at the page beginning,
133 advance the internal offset past the page end */
134 ogg_int64_t ret=vf->offset;
143 /* find the latest page beginning before the passed in position. Much
144 dirtier than the above as Ogg doesn't have any backward search
145 linkage. no 'readp' as it will certainly have to read. */
146 /* returns offset or OV_EREAD, OV_FAULT */
147 static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_int64_t begin,ogg_page *og){
148 ogg_int64_t end = begin;
150 ogg_int64_t offset=-1;
157 ret=_seek_helper(vf,begin);
160 while(vf->offset<end){
161 memset(og,0,sizeof(*og));
162 ret=_get_next_page(vf,og,end-vf->offset);
163 if(ret==OV_EREAD)return(OV_EREAD);
172 /* In a fully compliant, non-multiplexed stream, we'll still be
173 holding the last page. In multiplexed (or noncompliant streams),
174 we will probably have to re-read the last page we saw */
175 if(og->header_len==0){
176 ret=_seek_helper(vf,offset);
179 ret=_get_next_page(vf,og,CHUNKSIZE);
181 /* this shouldn't be possible */
188 static void _add_serialno(ogg_page *og,long **serialno_list, int *n){
189 long s = ogg_page_serialno(og);
193 *serialno_list = _ogg_realloc(*serialno_list, sizeof(**serialno_list)*(*n));
195 *serialno_list = _ogg_malloc(sizeof(**serialno_list));
198 (*serialno_list)[(*n)-1] = s;
201 /* returns nonzero if found */
202 static int _lookup_serialno(long s, long *serialno_list, int n){
205 if(*serialno_list == s) return 1;
212 static int _lookup_page_serialno(ogg_page *og, long *serialno_list, int n){
213 long s = ogg_page_serialno(og);
214 return _lookup_serialno(s,serialno_list,n);
217 /* performs the same search as _get_prev_page, but prefers pages of
218 the specified serial number. If a page of the specified serialno is
219 spotted during the seek-back-and-read-forward, it will return the
220 info of last page of the matching serial number instead of the very
221 last page. If no page of the specified serialno is seen, it will
222 return the info of last page and alter *serialno. */
223 static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf, ogg_int64_t begin,
224 long *serial_list, int serial_n,
225 int *serialno, ogg_int64_t *granpos){
227 ogg_int64_t end=begin;
230 ogg_int64_t prefoffset=-1;
231 ogg_int64_t offset=-1;
232 ogg_int64_t ret_serialno=-1;
233 ogg_int64_t ret_gran=-1;
240 ret=_seek_helper(vf,begin);
243 while(vf->offset<end){
244 ret=_get_next_page(vf,&og,end-vf->offset);
245 if(ret==OV_EREAD)return(OV_EREAD);
249 ret_serialno=ogg_page_serialno(&og);
250 ret_gran=ogg_page_granulepos(&og);
253 if(ret_serialno == *serialno){
258 if(!_lookup_serialno(ret_serialno,serial_list,serial_n)){
259 /* we fell off the end of the link, which means we seeked
260 back too far and shouldn't have been looking in that link
261 to begin with. If we found the preferred serial number,
262 forget that we saw it. */
269 /* we're not interested in the page... just the serialno and granpos. */
270 if(prefoffset>=0)return(prefoffset);
272 *serialno = ret_serialno;
278 /* uses the local ogg_stream storage in vf; this is important for
279 non-streaming input sources */
280 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
281 long **serialno_list, int *serialno_n,
289 ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
290 if(llret==OV_EREAD)return(OV_EREAD);
291 if(llret<0)return(OV_ENOTVORBIS);
295 vorbis_info_init(vi);
296 vorbis_comment_init(vc);
297 vf->ready_state=OPENED;
299 /* extract the serialnos of all BOS pages + the first set of vorbis
300 headers we see in the link */
302 while(ogg_page_bos(og_ptr)){
304 if(_lookup_page_serialno(og_ptr,*serialno_list,*serialno_n)){
305 /* a dupe serialnumber in an initial header packet set == invalid stream */
306 if(*serialno_list)_ogg_free(*serialno_list);
313 _add_serialno(og_ptr,serialno_list,serialno_n);
316 if(vf->ready_state<STREAMSET){
317 /* we don't have a vorbis stream in this link yet, so begin
318 prospective stream setup. We need a stream to get packets */
319 ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
320 ogg_stream_pagein(&vf->os,og_ptr);
322 if(ogg_stream_packetout(&vf->os,&op) > 0 &&
323 vorbis_synthesis_idheader(&op)){
324 /* vorbis header; continue setup */
325 vf->ready_state=STREAMSET;
326 if((ret=vorbis_synthesis_headerin(vi,vc,&op))){
335 ogg_int64_t llret=_get_next_page(vf,og_ptr,CHUNKSIZE);
345 /* if this page also belongs to our vorbis stream, submit it and break */
346 if(vf->ready_state==STREAMSET &&
347 vf->os.serialno == ogg_page_serialno(og_ptr)){
348 ogg_stream_pagein(&vf->os,og_ptr);
354 if(vf->ready_state!=STREAMSET){
362 while(i<2){ /* get a page loop */
364 while(i<2){ /* get a packet loop */
366 int result=ogg_stream_packetout(&vf->os,&op);
373 if((ret=vorbis_synthesis_headerin(vi,vc,&op)))
380 if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){
385 /* if this page belongs to the correct stream, go parse it */
386 if(vf->os.serialno == ogg_page_serialno(og_ptr)){
387 ogg_stream_pagein(&vf->os,og_ptr);
391 /* if we never see the final vorbis headers before the link
393 if(ogg_page_bos(og_ptr)){
401 /* otherwise, keep looking */
409 vorbis_info_clear(vi);
410 vorbis_comment_clear(vc);
411 vf->ready_state=OPENED;
416 /* Starting from current cursor position, get initial PCM offset of
417 next page. Consumes the page in the process without decoding
418 audio, however this is only called during stream parsing upon
420 static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){
422 ogg_int64_t accumulated=0;
425 int serialno = vf->os.serialno;
429 if(_get_next_page(vf,&og,-1)<0)
430 break; /* should not be possible unless the file is truncated/mangled */
432 if(ogg_page_bos(&og)) break;
433 if(ogg_page_serialno(&og)!=serialno) continue;
435 /* count blocksizes of all frames in the page */
436 ogg_stream_pagein(&vf->os,&og);
437 while((result=ogg_stream_packetout(&vf->os,&op))){
438 if(result>0){ /* ignore holes */
439 long thisblock=vorbis_packet_blocksize(vi,&op);
442 accumulated+=(lastblock+thisblock)>>2;
448 if(ogg_page_granulepos(&og)!=-1){
449 /* pcm offset of last packet on the first audio page */
450 accumulated= ogg_page_granulepos(&og)-accumulated;
455 /* less than zero? Either a corrupt file or a stream with samples
456 trimmed off the beginning, a normal occurrence; in both cases set
457 the offset to zero */
458 if(accumulated<0)accumulated=0;
463 /* finds each bitstream link one at a time using a bisection search
464 (has to begin by knowing the offset of the lb's initial page).
465 Recurses for each link so it can alloc the link storage after
466 finding them all, then unroll and fill the cache at the same time */
467 static int _bisect_forward_serialno(OggVorbis_File *vf,
469 ogg_int64_t searched,
473 long *currentno_list,
476 ogg_int64_t pcmoffset;
477 ogg_int64_t dataoffset=searched;
478 ogg_int64_t endsearched=end;
479 ogg_int64_t next=end;
480 ogg_int64_t searchgran=-1;
482 ogg_int64_t ret,last;
483 int serialno = vf->os.serialno;
486 we have the headers and serialnos for the link beginning at 'begin'
487 we have the offset and granpos of the last page in the file (potentially
488 not a page we care about)
491 /* Is the last page in our list of current serialnumbers? */
492 if(_lookup_serialno(endserial,currentno_list,currentnos)){
494 /* last page is in the starting serialno list, so we've bisected
495 down to (or just started with) a single link. Now we need to
496 find the last vorbis page belonging to the first vorbis stream
499 while(endserial != serialno){
500 endserial = serialno;
501 searched=_get_prev_page_serial(vf,searched,currentno_list,currentnos,&endserial,&endgran);
505 if(vf->offsets)_ogg_free(vf->offsets);
506 if(vf->serialnos)_ogg_free(vf->serialnos);
507 if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
509 vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));
510 vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));
511 vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));
512 vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));
513 vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));
514 vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));
516 vf->offsets[m+1]=end;
517 vf->offsets[m]=begin;
518 vf->pcmlengths[m*2+1]=(endgran<0?0:endgran);
522 /* last page is not in the starting stream's serial number list,
523 so we have multiple links. Find where the stream that begins
524 our bisection ends. */
526 long *next_serialno_list=NULL;
527 int next_serialnos=0;
530 int testserial = serialno+1;
532 /* the below guards against garbage seperating the last and
533 first pages of two links. */
534 while(searched<endsearched){
537 if(endsearched-searched<CHUNKSIZE){
540 bisect=(searched+endsearched)/2;
543 ret=_seek_helper(vf,bisect);
546 last=_get_next_page(vf,&og,-1);
547 if(last==OV_EREAD)return(OV_EREAD);
548 if(last<0 || !_lookup_page_serialno(&og,currentno_list,currentnos)){
550 if(last>=0)next=last;
556 /* Bisection point found */
557 /* for the time being, fetch end PCM offset the simple way */
559 while(testserial != serialno){
560 testserial = serialno;
561 searched = _get_prev_page_serial(vf,searched,currentno_list,currentnos,&testserial,&searchgran);
564 ret=_seek_helper(vf,next);
567 ret=_fetch_headers(vf,&vi,&vc,&next_serialno_list,&next_serialnos,NULL);
569 serialno = vf->os.serialno;
570 dataoffset = vf->offset;
572 /* this will consume a page, however the next bisection always
573 starts with a raw seek */
574 pcmoffset = _initial_pcmoffset(vf,&vi);
576 ret=_bisect_forward_serialno(vf,next,vf->offset,end,endgran,endserial,
577 next_serialno_list,next_serialnos,m+1);
580 if(next_serialno_list)_ogg_free(next_serialno_list);
582 vf->offsets[m+1]=next;
583 vf->serialnos[m+1]=serialno;
584 vf->dataoffsets[m+1]=dataoffset;
589 vf->pcmlengths[m*2+1]=searchgran;
590 vf->pcmlengths[m*2+2]=pcmoffset;
591 vf->pcmlengths[m*2+3]-=pcmoffset;
592 if(vf->pcmlengths[m*2+3]<0)vf->pcmlengths[m*2+3]=0;
597 static int _make_decode_ready(OggVorbis_File *vf){
598 if(vf->ready_state>STREAMSET)return 0;
599 if(vf->ready_state<STREAMSET)return OV_EFAULT;
601 if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))
604 if(vorbis_synthesis_init(&vf->vd,vf->vi))
607 vorbis_block_init(&vf->vd,&vf->vb);
608 vf->ready_state=INITSET;
614 static int _open_seekable2(OggVorbis_File *vf){
615 ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1;
616 int endserial=vf->os.serialno;
617 int serialno=vf->os.serialno;
619 /* we're partially open and have a first link header state in
622 /* fetch initial PCM offset */
623 ogg_int64_t pcmoffset = _initial_pcmoffset(vf,vf->vi);
625 /* we can seek, so set out learning all about this file */
626 if(vf->callbacks.seek_func && vf->callbacks.tell_func){
627 (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
628 vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
630 vf->offset=vf->end=-1;
633 /* If seek_func is implemented, tell_func must also be implemented */
634 if(vf->end==-1) return(OV_EINVAL);
636 /* Get the offset of the last page of the physical bitstream, or, if
637 we're lucky the last vorbis page of this link as most OggVorbis
638 files will contain a single logical bitstream */
639 end=_get_prev_page_serial(vf,vf->end,vf->serialnos+2,vf->serialnos[1],&endserial,&endgran);
640 if(end<0)return(end);
642 /* now determine bitstream structure recursively */
643 if(_bisect_forward_serialno(vf,0,dataoffset,end,endgran,endserial,
644 vf->serialnos+2,vf->serialnos[1],0)<0)return(OV_EREAD);
647 vf->serialnos[0]=serialno;
648 vf->dataoffsets[0]=dataoffset;
649 vf->pcmlengths[0]=pcmoffset;
650 vf->pcmlengths[1]-=pcmoffset;
651 if(vf->pcmlengths[1]<0)vf->pcmlengths[1]=0;
653 return(ov_raw_seek(vf,dataoffset));
656 /* clear out the current logical bitstream decoder */
657 static void _decode_clear(OggVorbis_File *vf){
658 vorbis_dsp_clear(&vf->vd);
659 vorbis_block_clear(&vf->vb);
660 vf->ready_state=OPENED;
663 /* fetch and process a packet. Handles the case where we're at a
664 bitstream boundary and dumps the decoding machine. If the decoding
665 machine is unloaded, it loads it. It also keeps pcm_offset up to
666 date (seek and read both use this. seek uses a special hack with
669 return: <0) error, OV_HOLE (lost packet) or OV_EOF
670 0) need more data (only if readp==0)
674 static int _fetch_and_process_packet(OggVorbis_File *vf,
680 /* handle one packet. Try to fetch it from current stream state */
681 /* extract packets from page */
684 if(vf->ready_state==STREAMSET){
685 int ret=_make_decode_ready(vf);
689 /* process a packet if we can. */
691 if(vf->ready_state==INITSET){
692 int hs=vorbis_synthesis_halfrate_p(vf->vi);
696 ogg_packet *op_ptr=(op_in?op_in:&op);
697 int result=ogg_stream_packetout(&vf->os,op_ptr);
698 ogg_int64_t granulepos;
701 if(result==-1)return(OV_HOLE); /* hole in the data. */
703 /* got a packet. process it */
704 granulepos=op_ptr->granulepos;
705 if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
707 header packets aren't
710 vorbis_synthesis will
713 /* suck in the synthesis data and track bitrate */
715 int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
716 /* for proper use of libvorbis within libvorbisfile,
717 oldsamples will always be zero. */
718 if(oldsamples)return(OV_EFAULT);
720 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
721 vf->samptrack+=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
722 vf->bittrack+=op_ptr->bytes*8;
725 /* update the pcm offset. */
726 if(granulepos!=-1 && !op_ptr->e_o_s){
727 int link=(vf->seekable?vf->current_link:0);
730 /* this packet has a pcm_offset on it (the last packet
731 completed on a page carries the offset) After processing
732 (above), we know the pcm position of the *last* sample
733 ready to be returned. Find the offset of the *first*
735 As an aside, this trick is inaccurate if we begin
736 reading anew right at the last page; the end-of-stream
737 granulepos declares the last frame in the stream, and the
738 last packet of the last page may be a partial frame.
739 So, we need a previous granulepos from an in-sequence page
740 to have a reference point. Thus the !op_ptr->e_o_s clause
743 if(vf->seekable && link>0)
744 granulepos-=vf->pcmlengths[link*2];
745 if(granulepos<0)granulepos=0; /* actually, this
746 shouldn't be possible
747 here unless the stream
750 samples=(vorbis_synthesis_pcmout(&vf->vd,NULL)<<hs);
754 granulepos+=vf->pcmlengths[i*2+1];
755 vf->pcm_offset=granulepos;
765 if(vf->ready_state>=OPENED){
769 /* the loop is not strictly necessary, but there's no sense in
770 doing the extra checks of the larger loop for the common
771 case in a multiplexed bistream where the page is simply
772 part of a different logical bitstream; keep reading until
773 we get one with the correct serialno */
776 if((ret=_get_next_page(vf,&og,-1))<0){
777 return(OV_EOF); /* eof. leave unitialized */
780 /* bitrate tracking; add the header's bytes here, the body bytes
781 are done by packet above */
782 vf->bittrack+=og.header_len*8;
784 if(vf->ready_state==INITSET){
785 if(vf->current_serialno!=ogg_page_serialno(&og)){
787 /* two possibilities:
788 1) our decoding just traversed a bitstream boundary
789 2) another stream is multiplexed into this logical section */
791 if(ogg_page_bos(&og)){
799 vorbis_info_clear(vf->vi);
800 vorbis_comment_clear(vf->vc);
805 continue; /* possibility #2 */
813 /* Do we need to load a new machine before submitting the page? */
814 /* This is different in the seekable and non-seekable cases.
816 In the seekable case, we already have all the header
817 information loaded and cached; we just initialize the machine
818 with it and continue on our merry way.
820 In the non-seekable (streaming) case, we'll only be at a
821 boundary if we just left the previous logical bitstream and
822 we're now nominally at the header of the next bitstream
825 if(vf->ready_state!=INITSET){
828 if(vf->ready_state<STREAMSET){
830 long serialno = ogg_page_serialno(&og);
832 /* match the serialno to bitstream section. We use this rather than
833 offset positions to avoid problems near logical bitstream
836 for(link=0;link<vf->links;link++)
837 if(vf->serialnos[link]==serialno)break;
839 if(link==vf->links) continue; /* not the desired Vorbis
840 bitstream section; keep
843 vf->current_serialno=serialno;
844 vf->current_link=link;
846 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
847 vf->ready_state=STREAMSET;
850 /* we're streaming */
851 /* fetch the three header packets, build the info struct */
853 int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);
855 vf->current_serialno=vf->os.serialno;
862 /* the buffered page is the data we want, and we're ready for it;
863 add it to the stream state */
864 ogg_stream_pagein(&vf->os,&og);
869 /* if, eg, 64 bit stdio is configured by default, this will build with
871 static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
872 if(f==NULL)return(-1);
873 return fseek(f,off,whence);
876 static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial,
877 long ibytes, ov_callbacks callbacks){
878 int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);
879 long *serialno_list=NULL;
880 int serialno_list_size=0;
883 memset(vf,0,sizeof(*vf));
885 vf->callbacks = callbacks;
887 /* init the framing state */
888 ogg_sync_init(&vf->oy);
890 /* perhaps some data was previously read into a buffer for testing
891 against other stream types. Allow initialization from this
892 previously read data (especially as we may be reading from a
893 non-seekable stream) */
895 char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
896 memcpy(buffer,initial,ibytes);
897 ogg_sync_wrote(&vf->oy,ibytes);
900 /* can we seek? Stevens suggests the seek test was portable */
901 if(offsettest!=-1)vf->seekable=1;
903 /* No seeking yet; Set up a 'single' (current) logical bitstream
904 entry for partial open */
906 vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
907 vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
908 ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
910 /* Fetch all BOS pages, store the vorbis header and all seen serial
911 numbers, load subsequent vorbis setup headers */
912 if((ret=_fetch_headers(vf,vf->vi,vf->vc,&serialno_list,&serialno_list_size,NULL))<0){
916 /* serial number list for first link needs to be held somewhere
917 for second stage of seekable stream open; this saves having to
918 seek/reread first link's serialnumber data then. */
919 vf->serialnos=_ogg_calloc(serialno_list_size+2,sizeof(*vf->serialnos));
920 vf->serialnos[0]=vf->current_serialno=vf->os.serialno;
921 vf->serialnos[1]=serialno_list_size;
922 memcpy(vf->serialnos+2,serialno_list,serialno_list_size*sizeof(*vf->serialnos));
924 vf->offsets=_ogg_calloc(1,sizeof(*vf->offsets));
925 vf->dataoffsets=_ogg_calloc(1,sizeof(*vf->dataoffsets));
927 vf->dataoffsets[0]=vf->offset;
929 vf->ready_state=PARTOPEN;
931 if(serialno_list)_ogg_free(serialno_list);
935 static int _ov_open2(OggVorbis_File *vf){
936 if(vf->ready_state != PARTOPEN) return OV_EINVAL;
937 vf->ready_state=OPENED;
939 int ret=_open_seekable2(vf);
946 vf->ready_state=STREAMSET;
952 /* clear out the OggVorbis_File struct */
953 int ov_clear(OggVorbis_File *vf){
955 vorbis_block_clear(&vf->vb);
956 vorbis_dsp_clear(&vf->vd);
957 ogg_stream_clear(&vf->os);
959 if(vf->vi && vf->links){
961 for(i=0;i<vf->links;i++){
962 vorbis_info_clear(vf->vi+i);
963 vorbis_comment_clear(vf->vc+i);
968 if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
969 if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
970 if(vf->serialnos)_ogg_free(vf->serialnos);
971 if(vf->offsets)_ogg_free(vf->offsets);
972 ogg_sync_clear(&vf->oy);
973 if(vf->datasource && vf->callbacks.close_func)
974 (vf->callbacks.close_func)(vf->datasource);
975 memset(vf,0,sizeof(*vf));
983 /* inspects the OggVorbis file and finds/documents all the logical
984 bitstreams contained in it. Tries to be tolerant of logical
985 bitstream sections that are truncated/woogie.
991 int ov_open_callbacks(void *f,OggVorbis_File *vf,
992 const char *initial,long ibytes,ov_callbacks callbacks){
993 int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
995 return _ov_open2(vf);
998 int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
999 ov_callbacks callbacks = {
1000 (size_t (*)(void *, size_t, size_t, void *)) fread,
1001 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
1002 (int (*)(void *)) fclose,
1003 (long (*)(void *)) ftell
1006 return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
1009 int ov_fopen(const char *path,OggVorbis_File *vf){
1011 FILE *f = fopen(path,"rb");
1014 ret = ov_open(f,vf,NULL,0);
1020 /* cheap hack for game usage where downsampling is desirable; there's
1021 no need for SRC as we can just do it cheaply in libvorbis. */
1023 int ov_halfrate(OggVorbis_File *vf,int flag){
1025 if(vf->vi==NULL)return OV_EINVAL;
1026 if(vf->ready_state>STREAMSET){
1027 /* clear out stream state; dumping the decode machine is needed to
1028 reinit the MDCT lookups. */
1029 vorbis_dsp_clear(&vf->vd);
1030 vorbis_block_clear(&vf->vb);
1031 vf->ready_state=STREAMSET;
1032 if(vf->pcm_offset>=0){
1033 ogg_int64_t pos=vf->pcm_offset;
1034 vf->pcm_offset=-1; /* make sure the pos is dumped if unseekable */
1035 ov_pcm_seek(vf,pos);
1039 for(i=0;i<vf->links;i++){
1040 if(vorbis_synthesis_halfrate(vf->vi+i,flag)){
1041 if(flag) ov_halfrate(vf,0);
1048 int ov_halfrate_p(OggVorbis_File *vf){
1049 if(vf->vi==NULL)return OV_EINVAL;
1050 return vorbis_synthesis_halfrate_p(vf->vi);
1053 /* Only partially open the vorbis file; test for Vorbisness, and load
1054 the headers for the first chain. Do not seek (although test for
1055 seekability). Use ov_test_open to finish opening the file, else
1056 ov_clear to close/free it. Same return codes as open.
1058 Note that vorbisfile does _not_ take ownership of the file if the
1059 call fails; the calling applicaiton is responsible for closing the file
1060 if this call returns an error. */
1062 int ov_test_callbacks(void *f,OggVorbis_File *vf,
1063 const char *initial,long ibytes,ov_callbacks callbacks)
1065 return _ov_open1(f,vf,initial,ibytes,callbacks);
1068 int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
1069 ov_callbacks callbacks = {
1070 (size_t (*)(void *, size_t, size_t, void *)) fread,
1071 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
1072 (int (*)(void *)) fclose,
1073 (long (*)(void *)) ftell
1076 return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
1079 int ov_test_open(OggVorbis_File *vf){
1080 if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
1081 return _ov_open2(vf);
1084 /* How many logical bitstreams in this physical bitstream? */
1085 long ov_streams(OggVorbis_File *vf){
1089 /* Is the FILE * associated with vf seekable? */
1090 long ov_seekable(OggVorbis_File *vf){
1091 return vf->seekable;
1094 /* returns the bitrate for a given logical bitstream or the entire
1095 physical bitstream. If the file is open for random access, it will
1096 find the *actual* average bitrate. If the file is streaming, it
1097 returns the nominal bitrate (if set) else the average of the
1098 upper/lower bounds (if set) else -1 (unset).
1100 If you want the actual bitrate field settings, get them from the
1101 vorbis_info structs */
1103 long ov_bitrate(OggVorbis_File *vf,int i){
1104 if(vf->ready_state<OPENED)return(OV_EINVAL);
1105 if(i>=vf->links)return(OV_EINVAL);
1106 if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
1111 for(i=0;i<vf->links;i++)
1112 bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
1113 /* This once read: return(rint(bits/ov_time_total(vf,-1)));
1114 * gcc 3.x on x86 miscompiled this at optimisation level 2 and above,
1115 * so this is slightly transformed to make it work.
1117 br = bits/ov_time_total(vf,-1);
1121 /* return the actual bitrate */
1122 return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
1124 /* return nominal if set */
1125 if(vf->vi[i].bitrate_nominal>0){
1126 return vf->vi[i].bitrate_nominal;
1128 if(vf->vi[i].bitrate_upper>0){
1129 if(vf->vi[i].bitrate_lower>0){
1130 return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
1132 return vf->vi[i].bitrate_upper;
1141 /* returns the actual bitrate since last call. returns -1 if no
1142 additional data to offer since last call (or at beginning of stream),
1143 EINVAL if stream is only partially open
1145 long ov_bitrate_instant(OggVorbis_File *vf){
1146 int link=(vf->seekable?vf->current_link:0);
1148 if(vf->ready_state<OPENED)return(OV_EINVAL);
1149 if(vf->samptrack==0)return(OV_FALSE);
1150 ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
1157 long ov_serialnumber(OggVorbis_File *vf,int i){
1158 if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
1159 if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
1161 return(vf->current_serialno);
1163 return(vf->serialnos[i]);
1167 /* returns: total raw (compressed) length of content if i==-1
1168 raw (compressed) length of that logical bitstream for i==0 to n
1169 OV_EINVAL if the stream is not seekable (we can't know the length)
1170 or if stream is only partially open
1172 ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
1173 if(vf->ready_state<OPENED)return(OV_EINVAL);
1174 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1178 for(i=0;i<vf->links;i++)
1179 acc+=ov_raw_total(vf,i);
1182 return(vf->offsets[i+1]-vf->offsets[i]);
1186 /* returns: total PCM length (samples) of content if i==-1 PCM length
1187 (samples) of that logical bitstream for i==0 to n
1188 OV_EINVAL if the stream is not seekable (we can't know the
1189 length) or only partially open
1191 ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
1192 if(vf->ready_state<OPENED)return(OV_EINVAL);
1193 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1197 for(i=0;i<vf->links;i++)
1198 acc+=ov_pcm_total(vf,i);
1201 return(vf->pcmlengths[i*2+1]);
1205 /* returns: total seconds of content if i==-1
1206 seconds in that logical bitstream for i==0 to n
1207 OV_EINVAL if the stream is not seekable (we can't know the
1208 length) or only partially open
1210 double ov_time_total(OggVorbis_File *vf,int i){
1211 if(vf->ready_state<OPENED)return(OV_EINVAL);
1212 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
1216 for(i=0;i<vf->links;i++)
1217 acc+=ov_time_total(vf,i);
1220 return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
1224 /* seek to an offset relative to the *compressed* data. This also
1225 scans packets to update the PCM cursor. It will cross a logical
1226 bitstream boundary, but only if it can't get any packets out of the
1227 tail of the bitstream we seek to (so no surprises).
1229 returns zero on success, nonzero on failure */
1231 int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
1232 ogg_stream_state work_os;
1235 if(vf->ready_state<OPENED)return(OV_EINVAL);
1237 return(OV_ENOSEEK); /* don't dump machine if we can't seek */
1239 if(pos<0 || pos>vf->end)return(OV_EINVAL);
1241 /* is the seek position outside our current link [if any]? */
1242 if(vf->ready_state>=STREAMSET){
1243 if(pos<vf->offsets[vf->current_link] || pos>=vf->offsets[vf->current_link+1])
1244 _decode_clear(vf); /* clear out stream state */
1247 /* don't yet clear out decoding machine (if it's initialized), in
1248 the case we're in the same link. Restart the decode lapping, and
1249 let _fetch_and_process_packet deal with a potential bitstream
1252 ogg_stream_reset_serialno(&vf->os,
1253 vf->current_serialno); /* must set serialno */
1254 vorbis_synthesis_restart(&vf->vd);
1256 ret=_seek_helper(vf,pos);
1257 if(ret)goto seek_error;
1259 /* we need to make sure the pcm_offset is set, but we don't want to
1260 advance the raw cursor past good packets just to get to the first
1261 with a granulepos. That's not equivalent behavior to beginning
1262 decoding as immediately after the seek position as possible.
1264 So, a hack. We use two stream states; a local scratch state and
1265 the shared vf->os stream state. We use the local state to
1266 scan, and the shared state as a buffer for later decode.
1268 Unfortuantely, on the last page we still advance to last packet
1269 because the granulepos on the last page is not necessarily on a
1270 packet boundary, and we need to make sure the granpos is
1282 ogg_int64_t pagepos=-1;
1284 ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
1285 ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
1286 return from not necessarily
1287 starting from the beginning */
1290 if(vf->ready_state>=STREAMSET){
1291 /* snarf/scan a packet if we can */
1292 int result=ogg_stream_packetout(&work_os,&op);
1296 if(vf->vi[vf->current_link].codec_setup){
1297 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1299 ogg_stream_packetout(&vf->os,NULL);
1303 /* We can't get a guaranteed correct pcm position out of the
1304 last page in a stream because it might have a 'short'
1305 granpos, which can only be detected in the presence of a
1306 preceding page. However, if the last page is also the first
1307 page, the granpos rules of a first page take precedence. Not
1308 only that, but for first==last, the EOS page must be treated
1309 as if its a normal first page for the stream to open/play. */
1310 if(lastflag && !firstflag)
1311 ogg_stream_packetout(&vf->os,NULL);
1313 if(lastblock)accblock+=(lastblock+thisblock)>>2;
1316 if(op.granulepos!=-1){
1317 int i,link=vf->current_link;
1318 ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
1319 if(granulepos<0)granulepos=0;
1322 granulepos+=vf->pcmlengths[i*2+1];
1323 vf->pcm_offset=granulepos-accblock;
1324 if(vf->pcm_offset<0)vf->pcm_offset=0;
1327 lastblock=thisblock;
1330 ogg_stream_packetout(&vf->os,NULL);
1335 pagepos=_get_next_page(vf,&og,-1);
1337 vf->pcm_offset=ov_pcm_total(vf,-1);
1341 /* huh? Bogus stream with packets but no granulepos */
1346 /* has our decoding just traversed a bitstream boundary? */
1347 if(vf->ready_state>=STREAMSET){
1348 if(vf->current_serialno!=ogg_page_serialno(&og)){
1350 /* two possibilities:
1351 1) our decoding just traversed a bitstream boundary
1352 2) another stream is multiplexed into this logical section? */
1354 if(ogg_page_bos(&og)){
1356 _decode_clear(vf); /* clear out stream state */
1357 ogg_stream_clear(&work_os);
1358 } /* else, do nothing; next loop will scoop another page */
1362 if(vf->ready_state<STREAMSET){
1364 long serialno = ogg_page_serialno(&og);
1366 for(link=0;link<vf->links;link++)
1367 if(vf->serialnos[link]==serialno)break;
1369 if(link==vf->links) continue; /* not the desired Vorbis
1370 bitstream section; keep
1372 vf->current_link=link;
1373 vf->current_serialno=serialno;
1374 ogg_stream_reset_serialno(&vf->os,serialno);
1375 ogg_stream_reset_serialno(&work_os,serialno);
1376 vf->ready_state=STREAMSET;
1377 firstflag=(pagepos<=vf->dataoffsets[link]);
1380 ogg_stream_pagein(&vf->os,&og);
1381 ogg_stream_pagein(&work_os,&og);
1382 lastflag=ogg_page_eos(&og);
1387 ogg_stream_clear(&work_os);
1393 /* dump the machine so we're in a known state */
1395 ogg_stream_clear(&work_os);
1400 /* Page granularity seek (faster than sample granularity because we
1401 don't do the last bit of decode to find a specific sample).
1403 Seek to the last [granule marked] page preceding the specified pos
1404 location, such that decoding past the returned point will quickly
1405 arrive at the requested position. */
1406 int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
1408 ogg_int64_t result=0;
1409 ogg_int64_t total=ov_pcm_total(vf,-1);
1411 if(vf->ready_state<OPENED)return(OV_EINVAL);
1412 if(!vf->seekable)return(OV_ENOSEEK);
1414 if(pos<0 || pos>total)return(OV_EINVAL);
1416 /* which bitstream section does this pcm offset occur in? */
1417 for(link=vf->links-1;link>=0;link--){
1418 total-=vf->pcmlengths[link*2+1];
1419 if(pos>=total)break;
1422 /* Search within the logical bitstream for the page with the highest
1423 pcm_pos preceding pos. If we're looking for a position on the
1424 first page, bisection will halt without finding our position as
1425 it's before the first explicit granulepos fencepost. That case is
1426 handled separately below.
1428 There is a danger here; missing pages or incorrect frame number
1429 information in the bitstream could make our task impossible.
1430 Account for that (it would be an error condition) */
1432 /* new search algorithm originally by HB (Nicholas Vinen) */
1435 ogg_int64_t end=vf->offsets[link+1];
1436 ogg_int64_t begin=vf->dataoffsets[link];
1437 ogg_int64_t begintime = vf->pcmlengths[link*2];
1438 ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
1439 ogg_int64_t target=pos-total+begintime;
1440 ogg_int64_t best=-1;
1445 /* if we have only one page, there will be no bisection. Grab the page here */
1447 result=_seek_helper(vf,begin);
1448 if(result) goto seek_error;
1450 result=_get_next_page(vf,&og,1);
1451 if(result<0) goto seek_error;
1456 /* bisection loop */
1460 if(end-begin<CHUNKSIZE){
1463 /* take a (pretty decent) guess. */
1465 (ogg_int64_t)((double)(target-begintime)*(end-begin)/(endtime-begintime))
1467 if(bisect<begin+CHUNKSIZE)
1471 result=_seek_helper(vf,bisect);
1472 if(result) goto seek_error;
1474 /* read loop within the bisection loop */
1476 result=_get_next_page(vf,&og,end-vf->offset);
1477 if(result==OV_EREAD) goto seek_error;
1479 /* there is no next page! */
1481 /* No bisection left to perform. We've either found the
1482 best candidate already or failed. Exit loop. */
1485 /* We tried to load a fraction of the last page; back up a
1486 bit and try to get the whole last page */
1487 if(bisect==0) goto seek_error;
1490 /* don't repeat/loop on a read we've already performed */
1491 if(bisect<=begin)bisect=begin+1;
1493 /* seek and cntinue bisection */
1494 result=_seek_helper(vf,bisect);
1495 if(result) goto seek_error;
1498 ogg_int64_t granulepos;
1501 /* got a page. analyze it */
1502 /* only consider pages from primary vorbis stream */
1503 if(ogg_page_serialno(&og)!=vf->serialnos[link])
1506 /* only consider pages with the granulepos set */
1507 granulepos=ogg_page_granulepos(&og);
1508 if(granulepos==-1)continue;
1510 if(granulepos<target){
1511 /* this page is a successful candidate! Set state */
1513 best=result; /* raw offset of packet with granulepos */
1514 begin=vf->offset; /* raw offset of next page */
1515 begintime=granulepos;
1517 /* if we're before our target but within a short distance,
1518 don't bisect; read forward */
1519 if(target-begintime>44100)break;
1521 bisect=begin; /* *not* begin + 1 as above */
1524 /* This is one of our pages, but the granpos is
1525 post-target; it is not a bisection return
1526 candidate. (The only way we'd use it is if it's the
1527 first page in the stream; we handle that case later
1528 outside the bisection) */
1529 if(bisect<=begin+1){
1530 /* No bisection left to perform. We've either found the
1531 best candidate already or failed. Exit loop. */
1534 if(end==vf->offset){
1535 /* bisection read to the end; use the known page
1536 boundary (result) to update bisection, back up a
1537 little bit, and try again */
1540 if(bisect<=begin)bisect=begin+1;
1541 result=_seek_helper(vf,bisect);
1542 if(result) goto seek_error;
1544 /* Normal bisection */
1555 /* Out of bisection: did it 'fail?' */
1558 /* Check the 'looking for data in first page' special case;
1559 bisection would 'fail' because our search target was before the
1560 first PCM granule position fencepost. */
1563 begin == vf->dataoffsets[link] &&
1564 ogg_page_serialno(&og)==vf->serialnos[link]){
1566 /* Yes, this is the beginning-of-stream case. We already have
1567 our page, right at the beginning of PCM data. Set state
1570 vf->pcm_offset=total;
1572 if(link!=vf->current_link){
1573 /* Different link; dump entire decode machine */
1576 vf->current_link=link;
1577 vf->current_serialno=vf->serialnos[link];
1578 vf->ready_state=STREAMSET;
1581 vorbis_synthesis_restart(&vf->vd);
1584 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1585 ogg_stream_pagein(&vf->os,&og);
1592 /* Bisection found our page. seek to it, update pcm offset. Easier case than
1593 raw_seek, don't keep packets preceding granulepos. */
1599 result=_seek_helper(vf,best);
1601 if(result) goto seek_error;
1602 result=_get_next_page(vf,&og,-1);
1603 if(result<0) goto seek_error;
1605 if(link!=vf->current_link){
1606 /* Different link; dump entire decode machine */
1609 vf->current_link=link;
1610 vf->current_serialno=vf->serialnos[link];
1611 vf->ready_state=STREAMSET;
1614 vorbis_synthesis_restart(&vf->vd);
1617 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1618 ogg_stream_pagein(&vf->os,&og);
1620 /* pull out all but last packet; the one with granulepos */
1622 result=ogg_stream_packetpeek(&vf->os,&op);
1624 /* No packet returned; we exited the bisection with 'best'
1625 pointing to a page with a granule position, so the packet
1626 finishing this page ('best') originated on a preceding
1627 page. Keep fetching previous pages until we get one with
1628 a granulepos or without the 'continued' flag set. Then
1629 just use raw_seek for simplicity. */
1630 /* Do not rewind past the beginning of link data; if we do,
1631 it's either a bug or a broken stream */
1633 while(result>vf->dataoffsets[link]){
1634 result=_get_prev_page(vf,result,&og);
1635 if(result<0) goto seek_error;
1636 if(ogg_page_serialno(&og)==vf->current_serialno &&
1637 (ogg_page_granulepos(&og)>-1 ||
1638 !ogg_page_continued(&og))){
1639 return ov_raw_seek(vf,result);
1644 result = OV_EBADPACKET;
1647 if(op.granulepos!=-1){
1648 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1649 if(vf->pcm_offset<0)vf->pcm_offset=0;
1650 vf->pcm_offset+=total;
1653 result=ogg_stream_packetout(&vf->os,NULL);
1659 if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
1668 /* dump machine so we're in a known state */
1674 /* seek to a sample offset relative to the decompressed pcm stream
1675 returns zero on success, nonzero on failure */
1677 int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
1678 int thisblock,lastblock=0;
1679 int ret=ov_pcm_seek_page(vf,pos);
1680 if(ret<0)return(ret);
1681 if((ret=_make_decode_ready(vf)))return ret;
1683 /* discard leading packets we don't need for the lapping of the
1684 position we want; don't decode them */
1690 int ret=ogg_stream_packetpeek(&vf->os,&op);
1692 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1694 ogg_stream_packetout(&vf->os,NULL);
1695 continue; /* non audio packet */
1697 if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
1699 if(vf->pcm_offset+((thisblock+
1700 vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
1702 /* remove the packet from packet queue and track its granulepos */
1703 ogg_stream_packetout(&vf->os,NULL);
1704 vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with
1707 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
1709 /* end of logical stream case is hard, especially with exact
1710 length positioning. */
1712 if(op.granulepos>-1){
1714 /* always believe the stream markers */
1715 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1716 if(vf->pcm_offset<0)vf->pcm_offset=0;
1717 for(i=0;i<vf->current_link;i++)
1718 vf->pcm_offset+=vf->pcmlengths[i*2+1];
1721 lastblock=thisblock;
1724 if(ret<0 && ret!=OV_HOLE)break;
1726 /* suck in a new page */
1727 if(_get_next_page(vf,&og,-1)<0)break;
1728 if(ogg_page_bos(&og))_decode_clear(vf);
1730 if(vf->ready_state<STREAMSET){
1731 long serialno=ogg_page_serialno(&og);
1734 for(link=0;link<vf->links;link++)
1735 if(vf->serialnos[link]==serialno)break;
1736 if(link==vf->links) continue;
1737 vf->current_link=link;
1739 vf->ready_state=STREAMSET;
1740 vf->current_serialno=ogg_page_serialno(&og);
1741 ogg_stream_reset_serialno(&vf->os,serialno);
1742 ret=_make_decode_ready(vf);
1747 ogg_stream_pagein(&vf->os,&og);
1753 /* discard samples until we reach the desired position. Crossing a
1754 logical bitstream boundary with abandon is OK. */
1756 /* note that halfrate could be set differently in each link, but
1757 vorbisfile encoforces all links are set or unset */
1758 int hs=vorbis_synthesis_halfrate_p(vf->vi);
1759 while(vf->pcm_offset<((pos>>hs)<<hs)){
1760 ogg_int64_t target=(pos-vf->pcm_offset)>>hs;
1761 long samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
1763 if(samples>target)samples=target;
1764 vorbis_synthesis_read(&vf->vd,samples);
1765 vf->pcm_offset+=samples<<hs;
1768 if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
1769 vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
1775 /* seek to a playback time relative to the decompressed pcm stream
1776 returns zero on success, nonzero on failure */
1777 int ov_time_seek(OggVorbis_File *vf,double seconds){
1778 /* translate time to PCM position and call ov_pcm_seek */
1781 ogg_int64_t pcm_total=0;
1782 double time_total=0.;
1784 if(vf->ready_state<OPENED)return(OV_EINVAL);
1785 if(!vf->seekable)return(OV_ENOSEEK);
1786 if(seconds<0)return(OV_EINVAL);
1788 /* which bitstream section does this time offset occur in? */
1789 for(link=0;link<vf->links;link++){
1790 double addsec = ov_time_total(vf,link);
1791 if(seconds<time_total+addsec)break;
1793 pcm_total+=vf->pcmlengths[link*2+1];
1796 if(link==vf->links)return(OV_EINVAL);
1798 /* enough information to convert time offset to pcm offset */
1800 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1801 return(ov_pcm_seek(vf,target));
1805 /* page-granularity version of ov_time_seek
1806 returns zero on success, nonzero on failure */
1807 int ov_time_seek_page(OggVorbis_File *vf,double seconds){
1808 /* translate time to PCM position and call ov_pcm_seek */
1811 ogg_int64_t pcm_total=0;
1812 double time_total=0.;
1814 if(vf->ready_state<OPENED)return(OV_EINVAL);
1815 if(!vf->seekable)return(OV_ENOSEEK);
1816 if(seconds<0)return(OV_EINVAL);
1818 /* which bitstream section does this time offset occur in? */
1819 for(link=0;link<vf->links;link++){
1820 double addsec = ov_time_total(vf,link);
1821 if(seconds<time_total+addsec)break;
1823 pcm_total+=vf->pcmlengths[link*2+1];
1826 if(link==vf->links)return(OV_EINVAL);
1828 /* enough information to convert time offset to pcm offset */
1830 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1831 return(ov_pcm_seek_page(vf,target));
1835 /* tell the current stream offset cursor. Note that seek followed by
1836 tell will likely not give the set offset due to caching */
1837 ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
1838 if(vf->ready_state<OPENED)return(OV_EINVAL);
1842 /* return PCM offset (sample) of next PCM sample to be read */
1843 ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
1844 if(vf->ready_state<OPENED)return(OV_EINVAL);
1845 return(vf->pcm_offset);
1848 /* return time offset (seconds) of next PCM sample to be read */
1849 double ov_time_tell(OggVorbis_File *vf){
1851 ogg_int64_t pcm_total=0;
1852 double time_total=0.f;
1854 if(vf->ready_state<OPENED)return(OV_EINVAL);
1856 pcm_total=ov_pcm_total(vf,-1);
1857 time_total=ov_time_total(vf,-1);
1859 /* which bitstream section does this time offset occur in? */
1860 for(link=vf->links-1;link>=0;link--){
1861 pcm_total-=vf->pcmlengths[link*2+1];
1862 time_total-=ov_time_total(vf,link);
1863 if(vf->pcm_offset>=pcm_total)break;
1867 return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
1870 /* link: -1) return the vorbis_info struct for the bitstream section
1871 currently being decoded
1872 0-n) to request information for a specific bitstream section
1874 In the case of a non-seekable bitstream, any call returns the
1875 current bitstream. NULL in the case that the machine is not
1878 vorbis_info *ov_info(OggVorbis_File *vf,int link){
1881 if(vf->ready_state>=STREAMSET)
1882 return vf->vi+vf->current_link;
1895 /* grr, strong typing, grr, no templates/inheritence, grr */
1896 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
1899 if(vf->ready_state>=STREAMSET)
1900 return vf->vc+vf->current_link;
1913 static int host_is_big_endian() {
1914 ogg_int32_t pattern = 0xfeedface; /* deadbeef */
1915 unsigned char *bytewise = (unsigned char *)&pattern;
1916 if (bytewise[0] == 0xfe) return 1;
1920 /* up to this point, everything could more or less hide the multiple
1921 logical bitstream nature of chaining from the toplevel application
1922 if the toplevel application didn't particularly care. However, at
1923 the point that we actually read audio back, the multiple-section
1924 nature must surface: Multiple bitstream sections do not necessarily
1925 have to have the same number of channels or sampling rate.
1927 ov_read returns the sequential logical bitstream number currently
1928 being decoded along with the PCM data in order that the toplevel
1929 application can take action on channel/sample rate changes. This
1930 number will be incremented even for streamed (non-seekable) streams
1931 (for seekable streams, it represents the actual logical bitstream
1932 index within the physical bitstream. Note that the accessor
1933 functions above are aware of this dichotomy).
1935 ov_read_filter is exactly the same as ov_read except that it processes
1936 the decoded audio data through a filter before packing it into the
1937 requested format. This gives greater accuracy than applying a filter
1938 after the audio has been converted into integral PCM.
1940 input values: buffer) a buffer to hold packed PCM data for return
1941 length) the byte length requested to be placed into buffer
1942 bigendianp) should the data be packed LSB first (0) or
1944 word) word size for output. currently 1 (byte) or
1947 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1949 n) number of bytes of PCM actually returned. The
1950 below works on a packet-by-packet basis, so the
1951 return length is not related to the 'length' passed
1952 in, just guaranteed to fit.
1954 *section) set to the logical bitstream number */
1956 long ov_read_filter(OggVorbis_File *vf,char *buffer,int length,
1957 int bigendianp,int word,int sgned,int *bitstream,
1958 void (*filter)(float **pcm,long channels,long samples,void *filter_param),void *filter_param){
1960 int host_endian = host_is_big_endian();
1966 if(vf->ready_state<OPENED)return(OV_EINVAL);
1969 if(vf->ready_state==INITSET){
1970 samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1974 /* suck in another packet */
1976 int ret=_fetch_and_process_packet(vf,NULL,1,1);
1987 /* yay! proceed to pack data into the byte buffer */
1989 long channels=ov_info(vf,-1)->channels;
1990 long bytespersample=word * channels;
1991 vorbis_fpu_control fpu;
1992 if(samples>length/bytespersample)samples=length/bytespersample;
1999 filter(pcm,channels,samples,filter_param);
2001 /* a tight loop to pack each size */
2005 int off=(sgned?0:128);
2006 vorbis_fpu_setround(&fpu);
2007 for(j=0;j<samples;j++)
2008 for(i=0;i<channels;i++){
2009 val=vorbis_ftoi(pcm[i][j]*128.f);
2011 else if(val<-128)val=-128;
2014 vorbis_fpu_restore(fpu);
2016 int off=(sgned?0:32768);
2018 if(host_endian==bigendianp){
2021 vorbis_fpu_setround(&fpu);
2022 for(i=0;i<channels;i++) { /* It's faster in this order */
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);
2037 vorbis_fpu_setround(&fpu);
2038 for(i=0;i<channels;i++) {
2040 short *dest=((short *)buffer)+i;
2041 for(j=0;j<samples;j++) {
2042 val=vorbis_ftoi(src[j]*32768.f);
2043 if(val>32767)val=32767;
2044 else if(val<-32768)val=-32768;
2049 vorbis_fpu_restore(fpu);
2052 }else if(bigendianp){
2054 vorbis_fpu_setround(&fpu);
2055 for(j=0;j<samples;j++)
2056 for(i=0;i<channels;i++){
2057 val=vorbis_ftoi(pcm[i][j]*32768.f);
2058 if(val>32767)val=32767;
2059 else if(val<-32768)val=-32768;
2062 *buffer++=(val&0xff);
2064 vorbis_fpu_restore(fpu);
2068 vorbis_fpu_setround(&fpu);
2069 for(j=0;j<samples;j++)
2070 for(i=0;i<channels;i++){
2071 val=vorbis_ftoi(pcm[i][j]*32768.f);
2072 if(val>32767)val=32767;
2073 else if(val<-32768)val=-32768;
2075 *buffer++=(val&0xff);
2078 vorbis_fpu_restore(fpu);
2084 vorbis_synthesis_read(&vf->vd,samples);
2085 hs=vorbis_synthesis_halfrate_p(vf->vi);
2086 vf->pcm_offset+=(samples<<hs);
2087 if(bitstream)*bitstream=vf->current_link;
2088 return(samples*bytespersample);
2094 long ov_read(OggVorbis_File *vf,char *buffer,int length,
2095 int bigendianp,int word,int sgned,int *bitstream){
2096 return ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, NULL, NULL);
2099 /* input values: pcm_channels) a float vector per channel of output
2100 length) the sample length being read by the app
2102 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
2104 n) number of samples of PCM actually returned. The
2105 below works on a packet-by-packet basis, so the
2106 return length is not related to the 'length' passed
2107 in, just guaranteed to fit.
2109 *section) set to the logical bitstream number */
2113 long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
2116 if(vf->ready_state<OPENED)return(OV_EINVAL);
2119 if(vf->ready_state==INITSET){
2121 long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
2123 int hs=vorbis_synthesis_halfrate_p(vf->vi);
2124 if(pcm_channels)*pcm_channels=pcm;
2125 if(samples>length)samples=length;
2126 vorbis_synthesis_read(&vf->vd,samples);
2127 vf->pcm_offset+=samples<<hs;
2128 if(bitstream)*bitstream=vf->current_link;
2134 /* suck in another packet */
2136 int ret=_fetch_and_process_packet(vf,NULL,1,1);
2137 if(ret==OV_EOF)return(0);
2138 if(ret<=0)return(ret);
2144 extern const float *vorbis_window(vorbis_dsp_state *v,int W);
2146 static void _ov_splice(float **pcm,float **lappcm,
2149 const float *w1, const float *w2){
2160 for(j=0;j<ch1 && j<ch2;j++){
2167 d[i]=d[i]*wd + s[i]*ws;
2170 /* window from zero */
2181 /* make sure vf is INITSET */
2182 static int _ov_initset(OggVorbis_File *vf){
2184 if(vf->ready_state==INITSET)break;
2185 /* suck in another packet */
2187 int ret=_fetch_and_process_packet(vf,NULL,1,0);
2188 if(ret<0 && ret!=OV_HOLE)return(ret);
2194 /* make sure vf is INITSET and that we have a primed buffer; if
2195 we're crosslapping at a stream section boundary, this also makes
2196 sure we're sanity checking against the right stream information */
2197 static int _ov_initprime(OggVorbis_File *vf){
2198 vorbis_dsp_state *vd=&vf->vd;
2200 if(vf->ready_state==INITSET)
2201 if(vorbis_synthesis_pcmout(vd,NULL))break;
2203 /* suck in another packet */
2205 int ret=_fetch_and_process_packet(vf,NULL,1,0);
2206 if(ret<0 && ret!=OV_HOLE)return(ret);
2212 /* grab enough data for lapping from vf; this may be in the form of
2213 unreturned, already-decoded pcm, remaining PCM we will need to
2214 decode, or synthetic postextrapolation from last packets. */
2215 static void _ov_getlap(OggVorbis_File *vf,vorbis_info *vi,vorbis_dsp_state *vd,
2216 float **lappcm,int lapsize){
2220 /* try first to decode the lapping data */
2221 while(lapcount<lapsize){
2222 int samples=vorbis_synthesis_pcmout(vd,&pcm);
2224 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2225 for(i=0;i<vi->channels;i++)
2226 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2228 vorbis_synthesis_read(vd,samples);
2230 /* suck in another packet */
2231 int ret=_fetch_and_process_packet(vf,NULL,1,0); /* do *not* span */
2232 if(ret==OV_EOF)break;
2235 if(lapcount<lapsize){
2236 /* failed to get lapping data from normal decode; pry it from the
2237 postextrapolation buffering, or the second half of the MDCT
2238 from the last packet */
2239 int samples=vorbis_synthesis_lapout(&vf->vd,&pcm);
2241 for(i=0;i<vi->channels;i++)
2242 memset(lappcm[i]+lapcount,0,sizeof(**pcm)*lapsize-lapcount);
2245 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
2246 for(i=0;i<vi->channels;i++)
2247 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
2253 /* this sets up crosslapping of a sample by using trailing data from
2254 sample 1 and lapping it into the windowing buffer of sample 2 */
2255 int ov_crosslap(OggVorbis_File *vf1, OggVorbis_File *vf2){
2256 vorbis_info *vi1,*vi2;
2259 const float *w1,*w2;
2260 int n1,n2,i,ret,hs1,hs2;
2262 if(vf1==vf2)return(0); /* degenerate case */
2263 if(vf1->ready_state<OPENED)return(OV_EINVAL);
2264 if(vf2->ready_state<OPENED)return(OV_EINVAL);
2266 /* the relevant overlap buffers must be pre-checked and pre-primed
2267 before looking at settings in the event that priming would cross
2268 a bitstream boundary. So, do it now */
2270 ret=_ov_initset(vf1);
2272 ret=_ov_initprime(vf2);
2275 vi1=ov_info(vf1,-1);
2276 vi2=ov_info(vf2,-1);
2277 hs1=ov_halfrate_p(vf1);
2278 hs2=ov_halfrate_p(vf2);
2280 lappcm=alloca(sizeof(*lappcm)*vi1->channels);
2281 n1=vorbis_info_blocksize(vi1,0)>>(1+hs1);
2282 n2=vorbis_info_blocksize(vi2,0)>>(1+hs2);
2283 w1=vorbis_window(&vf1->vd,0);
2284 w2=vorbis_window(&vf2->vd,0);
2286 for(i=0;i<vi1->channels;i++)
2287 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2289 _ov_getlap(vf1,vi1,&vf1->vd,lappcm,n1);
2291 /* have a lapping buffer from vf1; now to splice it into the lapping
2293 /* consolidate and expose the buffer. */
2294 vorbis_synthesis_lapout(&vf2->vd,&pcm);
2297 _analysis_output_always("pcmL",0,pcm[0],n1*2,0,0,0);
2298 _analysis_output_always("pcmR",0,pcm[1],n1*2,0,0,0);
2302 _ov_splice(pcm,lappcm,n1,n2,vi1->channels,vi2->channels,w1,w2);
2308 static int _ov_64_seek_lap(OggVorbis_File *vf,ogg_int64_t pos,
2309 int (*localseek)(OggVorbis_File *,ogg_int64_t)){
2313 const float *w1,*w2;
2314 int n1,n2,ch1,ch2,hs;
2317 if(vf->ready_state<OPENED)return(OV_EINVAL);
2318 ret=_ov_initset(vf);
2321 hs=ov_halfrate_p(vf);
2324 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2325 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
2326 persistent; even if the decode state
2327 from this link gets dumped, this
2328 window array continues to exist */
2330 lappcm=alloca(sizeof(*lappcm)*ch1);
2332 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2333 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2335 /* have lapping data; seek and prime the buffer */
2336 ret=localseek(vf,pos);
2338 ret=_ov_initprime(vf);
2341 /* Guard against cross-link changes; they're perfectly legal */
2344 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2345 w2=vorbis_window(&vf->vd,0);
2347 /* consolidate and expose the buffer. */
2348 vorbis_synthesis_lapout(&vf->vd,&pcm);
2351 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2357 int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2358 return _ov_64_seek_lap(vf,pos,ov_raw_seek);
2361 int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
2362 return _ov_64_seek_lap(vf,pos,ov_pcm_seek);
2365 int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos){
2366 return _ov_64_seek_lap(vf,pos,ov_pcm_seek_page);
2369 static int _ov_d_seek_lap(OggVorbis_File *vf,double pos,
2370 int (*localseek)(OggVorbis_File *,double)){
2374 const float *w1,*w2;
2375 int n1,n2,ch1,ch2,hs;
2378 if(vf->ready_state<OPENED)return(OV_EINVAL);
2379 ret=_ov_initset(vf);
2382 hs=ov_halfrate_p(vf);
2385 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
2386 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
2387 persistent; even if the decode state
2388 from this link gets dumped, this
2389 window array continues to exist */
2391 lappcm=alloca(sizeof(*lappcm)*ch1);
2393 lappcm[i]=alloca(sizeof(**lappcm)*n1);
2394 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
2396 /* have lapping data; seek and prime the buffer */
2397 ret=localseek(vf,pos);
2399 ret=_ov_initprime(vf);
2402 /* Guard against cross-link changes; they're perfectly legal */
2405 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
2406 w2=vorbis_window(&vf->vd,0);
2408 /* consolidate and expose the buffer. */
2409 vorbis_synthesis_lapout(&vf->vd,&pcm);
2412 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
2418 int ov_time_seek_lap(OggVorbis_File *vf,double pos){
2419 return _ov_d_seek_lap(vf,pos,ov_time_seek);
2422 int ov_time_seek_page_lap(OggVorbis_File *vf,double pos){
2423 return _ov_d_seek_lap(vf,pos,ov_time_seek_page);