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-2002 *
9 * by the XIPHOPHORUS Company http://www.xiph.org/ *
11 ********************************************************************
13 function: stdio-based convenience library for opening/seeking/decoding
16 ********************************************************************/
24 #include "vorbis/codec.h"
25 #include "vorbis/vorbisfile.h"
30 /* A 'chained bitstream' is a Vorbis bitstream that contains more than
31 one logical bitstream arranged end to end (the only form of Ogg
32 multiplexing allowed in a Vorbis bitstream; grouping [parallel
33 multiplexing] is not allowed in Vorbis) */
35 /* A Vorbis file can be played beginning to end (streamed) without
36 worrying ahead of time about chaining (see decoder_example.c). If
37 we have the whole file, however, and want random access
38 (seeking/scrubbing) or desire to know the total length/time of a
39 file, we need to account for the possibility of chaining. */
41 /* We can handle things a number of ways; we can determine the entire
42 bitstream structure right off the bat, or find pieces on demand.
43 This example determines and caches structure for the entire
44 bitstream, but builds a virtual decoder on the fly when moving
45 between links in the chain. */
47 /* There are also different ways to implement seeking. Enough
48 information exists in an Ogg bitstream to seek to
49 sample-granularity positions in the output. Or, one can seek by
50 picking some portion of the stream roughly in the desired area if
51 we only want coarse navigation through the stream. */
53 /*************************************************************************
54 * Many, many internal helpers. The intention is not to be confusing;
55 * rampant duplication and monolithic function implementation would be
56 * harder to understand anyway. The high level functions are last. Begin
57 * grokking near the end of the file */
59 /* read a little more data from the file/pipe into the ogg_sync framer
61 #define CHUNKSIZE 8500 /* a shade over 8k; anyone using pages well
62 over 8k gets what they deserve */
63 static long _get_data(OggVorbis_File *vf){
66 char *buffer=ogg_sync_buffer(&vf->oy,CHUNKSIZE);
67 long bytes=(vf->callbacks.read_func)(buffer,1,CHUNKSIZE,vf->datasource);
68 if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
69 if(bytes==0 && errno)return(-1);
75 /* save a tiny smidge of verbosity to make the code more readable */
76 static void _seek_helper(OggVorbis_File *vf,ogg_int64_t offset){
78 (vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET);
80 ogg_sync_reset(&vf->oy);
82 /* shouldn't happen unless someone writes a broken callback */
87 /* The read/seek functions track absolute position within the stream */
89 /* from the head of the stream, get the next page. boundary specifies
90 if the function is allowed to fetch more data from the stream (and
91 how much) or only use internally buffered data.
93 boundary: -1) unbounded search
94 0) read no additional data; use cached only
95 n) search for a new page beginning for n bytes
97 return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
98 n) found a page at absolute offset n */
100 static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
101 ogg_int64_t boundary){
102 if(boundary>0)boundary+=vf->offset;
106 if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
107 more=ogg_sync_pageseek(&vf->oy,og);
110 /* skipped n bytes */
114 /* send more paramedics */
115 if(!boundary)return(OV_FALSE);
117 long ret=_get_data(vf);
118 if(ret==0)return(OV_EOF);
119 if(ret<0)return(OV_EREAD);
122 /* got a page. Return the offset at the page beginning,
123 advance the internal offset past the page end */
124 ogg_int64_t ret=vf->offset;
133 /* find the latest page beginning before the current stream cursor
134 position. Much dirtier than the above as Ogg doesn't have any
135 backward search linkage. no 'readp' as it will certainly have to
137 /* returns offset or OV_EREAD, OV_FAULT */
138 static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){
139 ogg_int64_t begin=vf->offset;
140 ogg_int64_t end=begin;
142 ogg_int64_t offset=-1;
148 _seek_helper(vf,begin);
149 while(vf->offset<end){
150 ret=_get_next_page(vf,og,end-vf->offset);
151 if(ret==OV_EREAD)return(OV_EREAD);
160 /* we have the offset. Actually snork and hold the page now */
161 _seek_helper(vf,offset);
162 ret=_get_next_page(vf,og,CHUNKSIZE);
164 /* this shouldn't be possible */
170 /* finds each bitstream link one at a time using a bisection search
171 (has to begin by knowing the offset of the lb's initial page).
172 Recurses for each link so it can alloc the link storage after
173 finding them all, then unroll and fill the cache at the same time */
174 static int _bisect_forward_serialno(OggVorbis_File *vf,
176 ogg_int64_t searched,
180 ogg_int64_t endsearched=end;
181 ogg_int64_t next=end;
185 /* the below guards against garbage seperating the last and
186 first pages of two links. */
187 while(searched<endsearched){
190 if(endsearched-searched<CHUNKSIZE){
193 bisect=(searched+endsearched)/2;
196 _seek_helper(vf,bisect);
197 ret=_get_next_page(vf,&og,-1);
198 if(ret==OV_EREAD)return(OV_EREAD);
199 if(ret<0 || ogg_page_serialno(&og)!=currentno){
203 searched=ret+og.header_len+og.body_len;
207 _seek_helper(vf,next);
208 ret=_get_next_page(vf,&og,-1);
209 if(ret==OV_EREAD)return(OV_EREAD);
211 if(searched>=end || ret<0){
213 vf->offsets=_ogg_malloc((vf->links+1)*sizeof(*vf->offsets));
214 vf->serialnos=_ogg_malloc(vf->links*sizeof(*vf->serialnos));
215 vf->offsets[m+1]=searched;
217 ret=_bisect_forward_serialno(vf,next,vf->offset,
218 end,ogg_page_serialno(&og),m+1);
219 if(ret==OV_EREAD)return(OV_EREAD);
222 vf->offsets[m]=begin;
223 vf->serialnos[m]=currentno;
227 /* uses the local ogg_stream storage in vf; this is important for
228 non-streaming input sources */
229 static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
230 long *serialno,ogg_page *og_ptr){
236 ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
237 if(llret==OV_EREAD)return(OV_EREAD);
238 if(llret<0)return OV_ENOTVORBIS;
242 ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
243 if(serialno)*serialno=vf->os.serialno;
244 vf->ready_state=STREAMSET;
246 /* extract the initial header from the first page and verify that the
247 Ogg bitstream is in fact Vorbis data */
249 vorbis_info_init(vi);
250 vorbis_comment_init(vc);
254 ogg_stream_pagein(&vf->os,og_ptr);
256 int result=ogg_stream_packetout(&vf->os,&op);
262 if((ret=vorbis_synthesis_headerin(vi,vc,&op))){
268 if(_get_next_page(vf,og_ptr,CHUNKSIZE)<0){
276 vorbis_info_clear(vi);
277 vorbis_comment_clear(vc);
278 vf->ready_state=OPENED;
283 /* last step of the OggVorbis_File initialization; get all the
284 vorbis_info structs and PCM positions. Only called by the seekable
285 initialization (local stream storage is hacked slightly; pay
286 attention to how that's done) */
288 /* this is void and does not propogate errors up because we want to be
289 able to open and use damaged bitstreams as well as we can. Just
290 watch out for missing information for links in the OggVorbis_File
292 static void _prefetch_all_headers(OggVorbis_File *vf, ogg_int64_t dataoffset){
297 vf->vi=_ogg_realloc(vf->vi,vf->links*sizeof(*vf->vi));
298 vf->vc=_ogg_realloc(vf->vc,vf->links*sizeof(*vf->vc));
299 vf->dataoffsets=_ogg_malloc(vf->links*sizeof(*vf->dataoffsets));
300 vf->pcmlengths=_ogg_malloc(vf->links*2*sizeof(*vf->pcmlengths));
302 for(i=0;i<vf->links;i++){
304 /* we already grabbed the initial header earlier. Just set the offset */
305 vf->dataoffsets[i]=dataoffset;
306 _seek_helper(vf,dataoffset);
310 /* seek to the location of the initial header */
312 _seek_helper(vf,vf->offsets[i]);
313 if(_fetch_headers(vf,vf->vi+i,vf->vc+i,NULL,NULL)<0){
314 vf->dataoffsets[i]=-1;
316 vf->dataoffsets[i]=vf->offset;
320 /* fetch beginning PCM offset */
322 if(vf->dataoffsets[i]!=-1){
323 ogg_int64_t accumulated=0;
327 ogg_stream_reset_serialno(&vf->os,vf->serialnos[i]);
332 ret=_get_next_page(vf,&og,-1);
334 /* this should not be possible unless the file is
338 if(ogg_page_serialno(&og)!=vf->serialnos[i])
341 /* count blocksizes of all frames in the page */
342 ogg_stream_pagein(&vf->os,&og);
343 while((result=ogg_stream_packetout(&vf->os,&op))){
344 if(result>0){ /* ignore holes */
345 long thisblock=vorbis_packet_blocksize(vf->vi+i,&op);
347 accumulated+=(lastblock+thisblock)>>2;
352 if(ogg_page_granulepos(&og)!=-1){
353 /* pcm offset of last packet on the first audio page */
354 accumulated= ogg_page_granulepos(&og)-accumulated;
359 /* less than zero? This is a stream with samples trimmed off
360 the beginning, a normal occurrence; set the offset to zero */
361 if(accumulated<0)accumulated=0;
363 vf->pcmlengths[i*2]=accumulated;
366 /* get the PCM length of this link. To do this,
367 get the last page of the stream */
369 ogg_int64_t end=vf->offsets[i+1];
370 _seek_helper(vf,end);
373 ret=_get_prev_page(vf,&og);
375 /* this should not be possible */
376 vorbis_info_clear(vf->vi+i);
377 vorbis_comment_clear(vf->vc+i);
380 if(ogg_page_granulepos(&og)!=-1){
381 vf->pcmlengths[i*2+1]=ogg_page_granulepos(&og)-vf->pcmlengths[i*2];
390 static int _make_decode_ready(OggVorbis_File *vf){
391 if(vf->ready_state>STREAMSET)return 0;
392 if(vf->ready_state<STREAMSET)return OV_EFAULT;
394 if(vorbis_synthesis_init(&vf->vd,vf->vi+vf->current_link))
397 if(vorbis_synthesis_init(&vf->vd,vf->vi))
400 vorbis_block_init(&vf->vd,&vf->vb);
401 vf->ready_state=INITSET;
407 static int _open_seekable2(OggVorbis_File *vf){
408 long serialno=vf->current_serialno;
409 ogg_int64_t dataoffset=vf->offset, end;
412 /* we're partially open and have a first link header state in
414 /* we can seek, so set out learning all about this file */
415 (vf->callbacks.seek_func)(vf->datasource,0,SEEK_END);
416 vf->offset=vf->end=(vf->callbacks.tell_func)(vf->datasource);
418 /* If seek_func is implemented, tell_func must also be implemented */
419 if(vf->end==-1) return(OV_EINVAL);
421 /* We get the offset for the last page of the physical bitstream.
422 Most OggVorbis files will contain a single logical bitstream */
423 end=_get_prev_page(vf,&og);
424 if(end<0)return(end);
426 /* more than one logical bitstream? */
427 if(ogg_page_serialno(&og)!=serialno){
429 /* Chained bitstream. Bisect-search each logical bitstream
430 section. Do so based on serial number only */
431 if(_bisect_forward_serialno(vf,0,0,end+1,serialno,0)<0)return(OV_EREAD);
435 /* Only one logical bitstream */
436 if(_bisect_forward_serialno(vf,0,end,end+1,serialno,0))return(OV_EREAD);
440 /* the initial header memory is referenced by vf after; don't free it */
441 _prefetch_all_headers(vf,dataoffset);
442 return(ov_raw_seek(vf,0));
445 /* clear out the current logical bitstream decoder */
446 static void _decode_clear(OggVorbis_File *vf){
447 vorbis_dsp_clear(&vf->vd);
448 vorbis_block_clear(&vf->vb);
449 vf->ready_state=OPENED;
452 /* fetch and process a packet. Handles the case where we're at a
453 bitstream boundary and dumps the decoding machine. If the decoding
454 machine is unloaded, it loads it. It also keeps pcm_offset up to
455 date (seek and read both use this. seek uses a special hack with
458 return: <0) error, OV_HOLE (lost packet) or OV_EOF
459 0) need more data (only if readp==0)
463 static int _fetch_and_process_packet(OggVorbis_File *vf,
469 /* handle one packet. Try to fetch it from current stream state */
470 /* extract packets from page */
473 /* process a packet if we can. If the machine isn't loaded,
475 if(vf->ready_state==INITSET){
478 ogg_packet *op_ptr=(op_in?op_in:&op);
479 int result=ogg_stream_packetout(&vf->os,op_ptr);
480 ogg_int64_t granulepos;
483 if(result==-1)return(OV_HOLE); /* hole in the data. */
485 /* got a packet. process it */
486 granulepos=op_ptr->granulepos;
487 if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
489 header packets aren't
492 vorbis_synthesis will
495 /* suck in the synthesis data and track bitrate */
497 int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
498 /* for proper use of libvorbis within libvorbisfile,
499 oldsamples will always be zero. */
500 if(oldsamples)return(OV_EFAULT);
502 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
503 vf->samptrack+=vorbis_synthesis_pcmout(&vf->vd,NULL)-oldsamples;
504 vf->bittrack+=op_ptr->bytes*8;
507 /* update the pcm offset. */
508 if(granulepos!=-1 && !op_ptr->e_o_s){
509 int link=(vf->seekable?vf->current_link:0);
512 /* this packet has a pcm_offset on it (the last packet
513 completed on a page carries the offset) After processing
514 (above), we know the pcm position of the *last* sample
515 ready to be returned. Find the offset of the *first*
517 As an aside, this trick is inaccurate if we begin
518 reading anew right at the last page; the end-of-stream
519 granulepos declares the last frame in the stream, and the
520 last packet of the last page may be a partial frame.
521 So, we need a previous granulepos from an in-sequence page
522 to have a reference point. Thus the !op_ptr->e_o_s clause
525 if(vf->seekable && link>0)
526 granulepos-=vf->pcmlengths[link*2];
527 if(granulepos<0)granulepos=0; /* actually, this
528 shouldn't be possible
529 here unless the stream
532 samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
536 granulepos+=vf->pcmlengths[i*2+1];
537 vf->pcm_offset=granulepos;
547 if(vf->ready_state>=OPENED){
550 if((ret=_get_next_page(vf,&og,-1))<0){
551 return(OV_EOF); /* eof.
555 /* bitrate tracking; add the header's bytes here, the body bytes
556 are done by packet above */
557 vf->bittrack+=og.header_len*8;
559 /* has our decoding just traversed a bitstream boundary? */
560 if(vf->ready_state==INITSET){
561 if(vf->current_serialno!=ogg_page_serialno(&og)){
568 vorbis_info_clear(vf->vi);
569 vorbis_comment_clear(vf->vc);
575 /* Do we need to load a new machine before submitting the page? */
576 /* This is different in the seekable and non-seekable cases.
578 In the seekable case, we already have all the header
579 information loaded and cached; we just initialize the machine
580 with it and continue on our merry way.
582 In the non-seekable (streaming) case, we'll only be at a
583 boundary if we just left the previous logical bitstream and
584 we're now nominally at the header of the next bitstream
587 if(vf->ready_state!=INITSET){
590 if(vf->ready_state<STREAMSET){
592 vf->current_serialno=ogg_page_serialno(&og);
594 /* match the serialno to bitstream section. We use this rather than
595 offset positions to avoid problems near logical bitstream
597 for(link=0;link<vf->links;link++)
598 if(vf->serialnos[link]==vf->current_serialno)break;
599 if(link==vf->links)return(OV_EBADLINK); /* sign of a bogus
604 vf->current_link=link;
606 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
607 vf->ready_state=STREAMSET;
610 /* we're streaming */
611 /* fetch the three header packets, build the info struct */
613 int ret=_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno,&og);
621 int ret=_make_decode_ready(vf);
625 ogg_stream_pagein(&vf->os,&og);
629 /* if, eg, 64 bit stdio is configured by default, this will build with
631 static int _fseek64_wrap(FILE *f,ogg_int64_t off,int whence){
632 if(f==NULL)return(-1);
633 return fseek(f,off,whence);
636 static int _ov_open1(void *f,OggVorbis_File *vf,char *initial,
637 long ibytes, ov_callbacks callbacks){
638 int offsettest=(f?callbacks.seek_func(f,0,SEEK_CUR):-1);
641 memset(vf,0,sizeof(*vf));
643 vf->callbacks = callbacks;
645 /* init the framing state */
646 ogg_sync_init(&vf->oy);
648 /* perhaps some data was previously read into a buffer for testing
649 against other stream types. Allow initialization from this
650 previously read data (as we may be reading from a non-seekable
653 char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
654 memcpy(buffer,initial,ibytes);
655 ogg_sync_wrote(&vf->oy,ibytes);
658 /* can we seek? Stevens suggests the seek test was portable */
659 if(offsettest!=-1)vf->seekable=1;
661 /* No seeking yet; Set up a 'single' (current) logical bitstream
662 entry for partial open */
664 vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
665 vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
666 ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
668 /* Try to fetch the headers, maintaining all the storage */
669 if((ret=_fetch_headers(vf,vf->vi,vf->vc,&vf->current_serialno,NULL))<0){
673 vf->ready_state=PARTOPEN;
677 static int _ov_open2(OggVorbis_File *vf){
678 if(vf->ready_state != PARTOPEN) return OV_EINVAL;
679 vf->ready_state=OPENED;
681 int ret=_open_seekable2(vf);
688 vf->ready_state=STREAMSET;
694 /* clear out the OggVorbis_File struct */
695 int ov_clear(OggVorbis_File *vf){
697 vorbis_block_clear(&vf->vb);
698 vorbis_dsp_clear(&vf->vd);
699 ogg_stream_clear(&vf->os);
701 if(vf->vi && vf->links){
703 for(i=0;i<vf->links;i++){
704 vorbis_info_clear(vf->vi+i);
705 vorbis_comment_clear(vf->vc+i);
710 if(vf->dataoffsets)_ogg_free(vf->dataoffsets);
711 if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
712 if(vf->serialnos)_ogg_free(vf->serialnos);
713 if(vf->offsets)_ogg_free(vf->offsets);
714 ogg_sync_clear(&vf->oy);
715 if(vf->datasource)(vf->callbacks.close_func)(vf->datasource);
716 memset(vf,0,sizeof(*vf));
724 /* inspects the OggVorbis file and finds/documents all the logical
725 bitstreams contained in it. Tries to be tolerant of logical
726 bitstream sections that are truncated/woogie.
732 int ov_open_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
733 ov_callbacks callbacks){
734 int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
736 return _ov_open2(vf);
739 int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
740 ov_callbacks callbacks = {
741 (size_t (*)(void *, size_t, size_t, void *)) fread,
742 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
743 (int (*)(void *)) fclose,
744 (long (*)(void *)) ftell
747 return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
750 /* cheap hack for game usage where downsampling is desirable; there's
751 no need for SRC as we can just do it cheaply in libvorbis. */
753 int ov_halfrate(OggVorbis_File *vf,int flag){
755 if(vf->vi==NULL)return OV_EINVAL;
756 if(!vf->seekable)return OV_EINVAL;
757 if(vf->ready_state>=STREAMSET)
758 _decode_clear(vf); /* clear out stream state; later on libvorbis
759 will be able to swap this on the fly, but
760 for now dumping the decode machine is needed
761 to reinit the MDCT lookups. 1.1 libvorbis
762 is planned to be able to switch on the fly */
764 for(i=0;i<vf->links;i++){
765 if(vorbis_synthesis_halfrate(vf->vi+i,flag)){
773 int ov_halfrate_p(OggVorbis_File *vf){
774 if(vf->vi==NULL)return OV_EINVAL;
775 return vorbis_synthesis_halfrate_p(vf->vi);
778 /* Only partially open the vorbis file; test for Vorbisness, and load
779 the headers for the first chain. Do not seek (although test for
780 seekability). Use ov_test_open to finish opening the file, else
781 ov_clear to close/free it. Same return codes as open. */
783 int ov_test_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
784 ov_callbacks callbacks)
786 return _ov_open1(f,vf,initial,ibytes,callbacks);
789 int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
790 ov_callbacks callbacks = {
791 (size_t (*)(void *, size_t, size_t, void *)) fread,
792 (int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
793 (int (*)(void *)) fclose,
794 (long (*)(void *)) ftell
797 return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
800 int ov_test_open(OggVorbis_File *vf){
801 if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
802 return _ov_open2(vf);
805 /* How many logical bitstreams in this physical bitstream? */
806 long ov_streams(OggVorbis_File *vf){
810 /* Is the FILE * associated with vf seekable? */
811 long ov_seekable(OggVorbis_File *vf){
815 /* returns the bitrate for a given logical bitstream or the entire
816 physical bitstream. If the file is open for random access, it will
817 find the *actual* average bitrate. If the file is streaming, it
818 returns the nominal bitrate (if set) else the average of the
819 upper/lower bounds (if set) else -1 (unset).
821 If you want the actual bitrate field settings, get them from the
822 vorbis_info structs */
824 long ov_bitrate(OggVorbis_File *vf,int i){
825 if(vf->ready_state<OPENED)return(OV_EINVAL);
826 if(i>=vf->links)return(OV_EINVAL);
827 if(!vf->seekable && i!=0)return(ov_bitrate(vf,0));
832 for(i=0;i<vf->links;i++)
833 bits+=(vf->offsets[i+1]-vf->dataoffsets[i])*8;
834 /* This once read: return(rint(bits/ov_time_total(vf,-1)));
835 * gcc 3.x on x86 miscompiled this at optimisation level 2 and above,
836 * so this is slightly transformed to make it work.
838 br = bits/ov_time_total(vf,-1);
842 /* return the actual bitrate */
843 return(rint((vf->offsets[i+1]-vf->dataoffsets[i])*8/ov_time_total(vf,i)));
845 /* return nominal if set */
846 if(vf->vi[i].bitrate_nominal>0){
847 return vf->vi[i].bitrate_nominal;
849 if(vf->vi[i].bitrate_upper>0){
850 if(vf->vi[i].bitrate_lower>0){
851 return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
853 return vf->vi[i].bitrate_upper;
862 /* returns the actual bitrate since last call. returns -1 if no
863 additional data to offer since last call (or at beginning of stream),
864 EINVAL if stream is only partially open
866 long ov_bitrate_instant(OggVorbis_File *vf){
867 int link=(vf->seekable?vf->current_link:0);
869 if(vf->ready_state<OPENED)return(OV_EINVAL);
870 if(vf->samptrack==0)return(OV_FALSE);
871 ret=vf->bittrack/vf->samptrack*vf->vi[link].rate+.5;
878 long ov_serialnumber(OggVorbis_File *vf,int i){
879 if(i>=vf->links)return(ov_serialnumber(vf,vf->links-1));
880 if(!vf->seekable && i>=0)return(ov_serialnumber(vf,-1));
882 return(vf->current_serialno);
884 return(vf->serialnos[i]);
888 /* returns: total raw (compressed) length of content if i==-1
889 raw (compressed) length of that logical bitstream for i==0 to n
890 OV_EINVAL if the stream is not seekable (we can't know the length)
891 or if stream is only partially open
893 ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
894 if(vf->ready_state<OPENED)return(OV_EINVAL);
895 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
899 for(i=0;i<vf->links;i++)
900 acc+=ov_raw_total(vf,i);
903 return(vf->offsets[i+1]-vf->offsets[i]);
907 /* returns: total PCM length (samples) of content if i==-1 PCM length
908 (samples) of that logical bitstream for i==0 to n
909 OV_EINVAL if the stream is not seekable (we can't know the
910 length) or only partially open
912 ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
913 if(vf->ready_state<OPENED)return(OV_EINVAL);
914 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
918 for(i=0;i<vf->links;i++)
919 acc+=ov_pcm_total(vf,i);
922 return(vf->pcmlengths[i*2+1]);
926 /* returns: total seconds of content if i==-1
927 seconds in that logical bitstream for i==0 to n
928 OV_EINVAL if the stream is not seekable (we can't know the
929 length) or only partially open
931 double ov_time_total(OggVorbis_File *vf,int i){
932 if(vf->ready_state<OPENED)return(OV_EINVAL);
933 if(!vf->seekable || i>=vf->links)return(OV_EINVAL);
937 for(i=0;i<vf->links;i++)
938 acc+=ov_time_total(vf,i);
941 return((double)(vf->pcmlengths[i*2+1])/vf->vi[i].rate);
945 /* seek to an offset relative to the *compressed* data. This also
946 scans packets to update the PCM cursor. It will cross a logical
947 bitstream boundary, but only if it can't get any packets out of the
948 tail of the bitstream we seek to (so no surprises).
950 returns zero on success, nonzero on failure */
952 int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
953 ogg_stream_state work_os;
955 if(vf->ready_state<OPENED)return(OV_EINVAL);
957 return(OV_ENOSEEK); /* don't dump machine if we can't seek */
959 if(pos<0 || pos>vf->end)return(OV_EINVAL);
961 /* don't yet clear out decoding machine (if it's initialized), in
962 the case we're in the same link. Restart the decode lapping, and
963 let _fetch_and_process_packet deal with a potential bitstream
966 ogg_stream_reset_serialno(&vf->os,
967 vf->current_serialno); /* must set serialno */
968 vorbis_synthesis_restart(&vf->vd);
970 _seek_helper(vf,pos);
972 /* we need to make sure the pcm_offset is set, but we don't want to
973 advance the raw cursor past good packets just to get to the first
974 with a granulepos. That's not equivalent behavior to beginning
975 decoding as immediately after the seek position as possible.
977 So, a hack. We use two stream states; a local scratch state and
978 the shared vf->os stream state. We use the local state to
979 scan, and the shared state as a buffer for later decode.
981 Unfortuantely, on the last page we still advance to last packet
982 because the granulepos on the last page is not necessarily on a
983 packet boundary, and we need to make sure the granpos is
995 ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
996 ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
997 return from not necessarily
998 starting from the beginning */
1001 if(vf->ready_state>=STREAMSET){
1002 /* snarf/scan a packet if we can */
1003 int result=ogg_stream_packetout(&work_os,&op);
1007 if(vf->vi[vf->current_link].codec_setup){
1008 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1010 ogg_stream_packetout(&vf->os,NULL);
1015 ogg_stream_packetout(&vf->os,NULL);
1017 if(lastblock)accblock+=(lastblock+thisblock)>>2;
1020 if(op.granulepos!=-1){
1021 int i,link=vf->current_link;
1022 ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
1023 if(granulepos<0)granulepos=0;
1026 granulepos+=vf->pcmlengths[i*2+1];
1027 vf->pcm_offset=granulepos-accblock;
1030 lastblock=thisblock;
1033 ogg_stream_packetout(&vf->os,NULL);
1038 if(_get_next_page(vf,&og,-1)<0){
1039 vf->pcm_offset=ov_pcm_total(vf,-1);
1043 /* huh? Bogus stream with packets but no granulepos */
1048 /* has our decoding just traversed a bitstream boundary? */
1049 if(vf->ready_state>=STREAMSET)
1050 if(vf->current_serialno!=ogg_page_serialno(&og)){
1051 _decode_clear(vf); /* clear out stream state */
1052 ogg_stream_clear(&work_os);
1055 if(vf->ready_state<STREAMSET){
1058 vf->current_serialno=ogg_page_serialno(&og);
1059 for(link=0;link<vf->links;link++)
1060 if(vf->serialnos[link]==vf->current_serialno)break;
1061 if(link==vf->links)goto seek_error; /* sign of a bogus stream.
1063 machine uninitialized */
1064 vf->current_link=link;
1066 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1067 ogg_stream_reset_serialno(&work_os,vf->current_serialno);
1068 vf->ready_state=STREAMSET;
1072 ogg_stream_pagein(&vf->os,&og);
1073 ogg_stream_pagein(&work_os,&og);
1074 eosflag=ogg_page_eos(&og);
1078 ogg_stream_clear(&work_os);
1084 /* dump the machine so we're in a known state */
1086 ogg_stream_clear(&work_os);
1091 /* Page granularity seek (faster than sample granularity because we
1092 don't do the last bit of decode to find a specific sample).
1094 Seek to the last [granule marked] page preceeding the specified pos
1095 location, such that decoding past the returned point will quickly
1096 arrive at the requested position. */
1097 int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
1099 ogg_int64_t result=0;
1100 ogg_int64_t total=ov_pcm_total(vf,-1);
1102 if(vf->ready_state<OPENED)return(OV_EINVAL);
1103 if(!vf->seekable)return(OV_ENOSEEK);
1105 if(pos<0 || pos>total)return(OV_EINVAL);
1107 /* which bitstream section does this pcm offset occur in? */
1108 for(link=vf->links-1;link>=0;link--){
1109 total-=vf->pcmlengths[link*2+1];
1110 if(pos>=total)break;
1113 /* search within the logical bitstream for the page with the highest
1114 pcm_pos preceeding (or equal to) pos. There is a danger here;
1115 missing pages or incorrect frame number information in the
1116 bitstream could make our task impossible. Account for that (it
1117 would be an error condition) */
1119 /* new search algorithm by HB (Nicholas Vinen) */
1121 ogg_int64_t end=vf->offsets[link+1];
1122 ogg_int64_t begin=vf->offsets[link];
1123 ogg_int64_t begintime = vf->pcmlengths[link*2];
1124 ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
1125 ogg_int64_t target=pos-total+begintime;
1126 ogg_int64_t best=begin;
1132 if(end-begin<CHUNKSIZE){
1135 /* take a (pretty decent) guess. */
1137 (target-begintime)*(end-begin)/(endtime-begintime) - CHUNKSIZE;
1142 _seek_helper(vf,bisect);
1145 result=_get_next_page(vf,&og,end-vf->offset);
1146 if(result==OV_EREAD) goto seek_error;
1149 end=begin; /* found it */
1151 if(bisect==0) goto seek_error;
1153 if(bisect<=begin)bisect=begin+1;
1154 _seek_helper(vf,bisect);
1157 ogg_int64_t granulepos=ogg_page_granulepos(&og);
1158 if(granulepos==-1)continue;
1159 if(granulepos<target){
1160 best=result; /* raw offset of packet with granulepos */
1161 begin=vf->offset; /* raw offset of next page */
1162 begintime=granulepos;
1164 if(target-begintime>44100)break;
1165 bisect=begin; /* *not* begin + 1 */
1168 end=begin; /* found it */
1170 if(end==vf->offset){ /* we're pretty close - we'd be stuck in */
1172 bisect-=CHUNKSIZE; /* an endless loop otherwise. */
1173 if(bisect<=begin)bisect=begin+1;
1174 _seek_helper(vf,bisect);
1186 /* found our page. seek to it, update pcm offset. Easier case than
1187 raw_seek, don't keep packets preceeding granulepos. */
1193 _seek_helper(vf,best);
1196 if(_get_next_page(vf,&og,-1)<0)return(OV_EOF); /* shouldn't happen */
1198 if(link!=vf->current_link){
1199 /* Different link; dump entire decode machine */
1202 vf->current_link=link;
1203 vf->current_serialno=ogg_page_serialno(&og);
1204 vf->ready_state=STREAMSET;
1207 vorbis_synthesis_restart(&vf->vd);
1210 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1211 ogg_stream_pagein(&vf->os,&og);
1213 /* pull out all but last packet; the one with granulepos */
1215 result=ogg_stream_packetpeek(&vf->os,&op);
1217 /* !!! the packet finishing this page originated on a
1218 preceeding page. Keep fetching previous pages until we
1219 get one with a granulepos or without the 'continued' flag
1220 set. Then just use raw_seek for simplicity. */
1222 _seek_helper(vf,best);
1225 result=_get_prev_page(vf,&og);
1226 if(result<0) goto seek_error;
1227 if(ogg_page_granulepos(&og)>-1 ||
1228 !ogg_page_continued(&og)){
1229 return ov_raw_seek(vf,result);
1235 result = OV_EBADPACKET;
1238 if(op.granulepos!=-1){
1239 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1240 if(vf->pcm_offset<0)vf->pcm_offset=0;
1241 vf->pcm_offset+=total;
1244 result=ogg_stream_packetout(&vf->os,NULL);
1250 if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
1259 /* dump machine so we're in a known state */
1265 /* seek to a sample offset relative to the decompressed pcm stream
1266 returns zero on success, nonzero on failure */
1268 int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
1269 int thisblock,lastblock=0;
1270 int ret=ov_pcm_seek_page(vf,pos);
1271 if(ret<0)return(ret);
1272 if((ret=_make_decode_ready(vf)))return ret;
1274 /* discard leading packets we don't need for the lapping of the
1275 position we want; don't decode them */
1281 int ret=ogg_stream_packetpeek(&vf->os,&op);
1283 thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
1285 ogg_stream_packetout(&vf->os,NULL);
1286 continue; /* non audio packet */
1288 if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
1290 if(vf->pcm_offset+((thisblock+
1291 vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
1293 /* remove the packet from packet queue and track its granulepos */
1294 ogg_stream_packetout(&vf->os,NULL);
1295 vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with
1298 vorbis_synthesis_blockin(&vf->vd,&vf->vb);
1300 /* end of logical stream case is hard, especially with exact
1301 length positioning. */
1303 if(op.granulepos>-1){
1305 /* always believe the stream markers */
1306 vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
1307 if(vf->pcm_offset<0)vf->pcm_offset=0;
1308 for(i=0;i<vf->current_link;i++)
1309 vf->pcm_offset+=vf->pcmlengths[i*2+1];
1312 lastblock=thisblock;
1315 if(ret<0 && ret!=OV_HOLE)break;
1317 /* suck in a new page */
1318 if(_get_next_page(vf,&og,-1)<0)break;
1319 if(vf->current_serialno!=ogg_page_serialno(&og))_decode_clear(vf);
1321 if(vf->ready_state<STREAMSET){
1324 vf->current_serialno=ogg_page_serialno(&og);
1325 for(link=0;link<vf->links;link++)
1326 if(vf->serialnos[link]==vf->current_serialno)break;
1327 if(link==vf->links)return(OV_EBADLINK);
1328 vf->current_link=link;
1330 ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
1331 vf->ready_state=STREAMSET;
1332 ret=_make_decode_ready(vf);
1337 ogg_stream_pagein(&vf->os,&og);
1343 /* discard samples until we reach the desired position. Crossing a
1344 logical bitstream boundary with abandon is OK. */
1345 while(vf->pcm_offset<pos){
1346 ogg_int64_t target=pos-vf->pcm_offset;
1347 long samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
1349 if(samples>target)samples=target;
1350 vorbis_synthesis_read(&vf->vd,samples);
1351 vf->pcm_offset+=samples;
1354 if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
1355 vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
1360 /* seek to a playback time relative to the decompressed pcm stream
1361 returns zero on success, nonzero on failure */
1362 int ov_time_seek(OggVorbis_File *vf,double seconds){
1363 /* translate time to PCM position and call ov_pcm_seek */
1366 ogg_int64_t pcm_total=0;
1367 double time_total=0.;
1369 if(vf->ready_state<OPENED)return(OV_EINVAL);
1370 if(!vf->seekable)return(OV_ENOSEEK);
1371 if(seconds<0)return(OV_EINVAL);
1373 /* which bitstream section does this time offset occur in? */
1374 for(link=0;link<vf->links;link++){
1375 double addsec = ov_time_total(vf,link);
1376 if(seconds<time_total+addsec)break;
1378 pcm_total+=vf->pcmlengths[link*2+1];
1381 if(link==vf->links)return(OV_EINVAL);
1383 /* enough information to convert time offset to pcm offset */
1385 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1386 return(ov_pcm_seek(vf,target));
1390 /* page-granularity version of ov_time_seek
1391 returns zero on success, nonzero on failure */
1392 int ov_time_seek_page(OggVorbis_File *vf,double seconds){
1393 /* translate time to PCM position and call ov_pcm_seek */
1396 ogg_int64_t pcm_total=0;
1397 double time_total=0.;
1399 if(vf->ready_state<OPENED)return(OV_EINVAL);
1400 if(!vf->seekable)return(OV_ENOSEEK);
1401 if(seconds<0)return(OV_EINVAL);
1403 /* which bitstream section does this time offset occur in? */
1404 for(link=0;link<vf->links;link++){
1405 double addsec = ov_time_total(vf,link);
1406 if(seconds<time_total+addsec)break;
1408 pcm_total+=vf->pcmlengths[link*2+1];
1411 if(link==vf->links)return(OV_EINVAL);
1413 /* enough information to convert time offset to pcm offset */
1415 ogg_int64_t target=pcm_total+(seconds-time_total)*vf->vi[link].rate;
1416 return(ov_pcm_seek_page(vf,target));
1420 /* tell the current stream offset cursor. Note that seek followed by
1421 tell will likely not give the set offset due to caching */
1422 ogg_int64_t ov_raw_tell(OggVorbis_File *vf){
1423 if(vf->ready_state<OPENED)return(OV_EINVAL);
1427 /* return PCM offset (sample) of next PCM sample to be read */
1428 ogg_int64_t ov_pcm_tell(OggVorbis_File *vf){
1429 if(vf->ready_state<OPENED)return(OV_EINVAL);
1430 return(vf->pcm_offset);
1433 /* return time offset (seconds) of next PCM sample to be read */
1434 double ov_time_tell(OggVorbis_File *vf){
1436 ogg_int64_t pcm_total=0;
1437 double time_total=0.f;
1439 if(vf->ready_state<OPENED)return(OV_EINVAL);
1441 pcm_total=ov_pcm_total(vf,-1);
1442 time_total=ov_time_total(vf,-1);
1444 /* which bitstream section does this time offset occur in? */
1445 for(link=vf->links-1;link>=0;link--){
1446 pcm_total-=vf->pcmlengths[link*2+1];
1447 time_total-=ov_time_total(vf,link);
1448 if(vf->pcm_offset>=pcm_total)break;
1452 return((double)time_total+(double)(vf->pcm_offset-pcm_total)/vf->vi[link].rate);
1455 /* link: -1) return the vorbis_info struct for the bitstream section
1456 currently being decoded
1457 0-n) to request information for a specific bitstream section
1459 In the case of a non-seekable bitstream, any call returns the
1460 current bitstream. NULL in the case that the machine is not
1463 vorbis_info *ov_info(OggVorbis_File *vf,int link){
1466 if(vf->ready_state>=STREAMSET)
1467 return vf->vi+vf->current_link;
1480 /* grr, strong typing, grr, no templates/inheritence, grr */
1481 vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
1484 if(vf->ready_state>=STREAMSET)
1485 return vf->vc+vf->current_link;
1498 static int host_is_big_endian() {
1499 ogg_int32_t pattern = 0xfeedface; /* deadbeef */
1500 unsigned char *bytewise = (unsigned char *)&pattern;
1501 if (bytewise[0] == 0xfe) return 1;
1505 /* up to this point, everything could more or less hide the multiple
1506 logical bitstream nature of chaining from the toplevel application
1507 if the toplevel application didn't particularly care. However, at
1508 the point that we actually read audio back, the multiple-section
1509 nature must surface: Multiple bitstream sections do not necessarily
1510 have to have the same number of channels or sampling rate.
1512 ov_read returns the sequential logical bitstream number currently
1513 being decoded along with the PCM data in order that the toplevel
1514 application can take action on channel/sample rate changes. This
1515 number will be incremented even for streamed (non-seekable) streams
1516 (for seekable streams, it represents the actual logical bitstream
1517 index within the physical bitstream. Note that the accessor
1518 functions above are aware of this dichotomy).
1520 input values: buffer) a buffer to hold packed PCM data for return
1521 length) the byte length requested to be placed into buffer
1522 bigendianp) should the data be packed LSB first (0) or
1524 word) word size for output. currently 1 (byte) or
1527 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1529 n) number of bytes of PCM actually returned. The
1530 below works on a packet-by-packet basis, so the
1531 return length is not related to the 'length' passed
1532 in, just guaranteed to fit.
1534 *section) set to the logical bitstream number */
1536 long ov_read(OggVorbis_File *vf,char *buffer,int length,
1537 int bigendianp,int word,int sgned,int *bitstream){
1539 int host_endian = host_is_big_endian();
1544 if(vf->ready_state<OPENED)return(OV_EINVAL);
1547 if(vf->ready_state==INITSET){
1548 samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1552 /* suck in another packet */
1554 int ret=_fetch_and_process_packet(vf,NULL,1,1);
1565 /* yay! proceed to pack data into the byte buffer */
1567 long channels=ov_info(vf,-1)->channels;
1568 long bytespersample=word * channels;
1569 vorbis_fpu_control fpu;
1570 if(samples>length/bytespersample)samples=length/bytespersample;
1575 /* a tight loop to pack each size */
1579 int off=(sgned?0:128);
1580 vorbis_fpu_setround(&fpu);
1581 for(j=0;j<samples;j++)
1582 for(i=0;i<channels;i++){
1583 val=vorbis_ftoi(pcm[i][j]*128.f);
1585 else if(val<-128)val=-128;
1588 vorbis_fpu_restore(fpu);
1590 int off=(sgned?0:32768);
1592 if(host_endian==bigendianp){
1595 vorbis_fpu_setround(&fpu);
1596 for(i=0;i<channels;i++) { /* It's faster in this order */
1598 short *dest=((short *)buffer)+i;
1599 for(j=0;j<samples;j++) {
1600 val=vorbis_ftoi(src[j]*32768.f);
1601 if(val>32767)val=32767;
1602 else if(val<-32768)val=-32768;
1607 vorbis_fpu_restore(fpu);
1611 vorbis_fpu_setround(&fpu);
1612 for(i=0;i<channels;i++) {
1614 short *dest=((short *)buffer)+i;
1615 for(j=0;j<samples;j++) {
1616 val=vorbis_ftoi(src[j]*32768.f);
1617 if(val>32767)val=32767;
1618 else if(val<-32768)val=-32768;
1623 vorbis_fpu_restore(fpu);
1626 }else if(bigendianp){
1628 vorbis_fpu_setround(&fpu);
1629 for(j=0;j<samples;j++)
1630 for(i=0;i<channels;i++){
1631 val=vorbis_ftoi(pcm[i][j]*32768.f);
1632 if(val>32767)val=32767;
1633 else if(val<-32768)val=-32768;
1636 *buffer++=(val&0xff);
1638 vorbis_fpu_restore(fpu);
1642 vorbis_fpu_setround(&fpu);
1643 for(j=0;j<samples;j++)
1644 for(i=0;i<channels;i++){
1645 val=vorbis_ftoi(pcm[i][j]*32768.f);
1646 if(val>32767)val=32767;
1647 else if(val<-32768)val=-32768;
1649 *buffer++=(val&0xff);
1652 vorbis_fpu_restore(fpu);
1658 vorbis_synthesis_read(&vf->vd,samples);
1659 vf->pcm_offset+=samples;
1660 if(bitstream)*bitstream=vf->current_link;
1661 return(samples*bytespersample);
1667 /* input values: pcm_channels) a float vector per channel of output
1668 length) the sample length being read by the app
1670 return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
1672 n) number of samples of PCM actually returned. The
1673 below works on a packet-by-packet basis, so the
1674 return length is not related to the 'length' passed
1675 in, just guaranteed to fit.
1677 *section) set to the logical bitstream number */
1681 long ov_read_float(OggVorbis_File *vf,float ***pcm_channels,int length,
1684 if(vf->ready_state<OPENED)return(OV_EINVAL);
1687 if(vf->ready_state==INITSET){
1689 long samples=vorbis_synthesis_pcmout(&vf->vd,&pcm);
1691 if(pcm_channels)*pcm_channels=pcm;
1692 if(samples>length)samples=length;
1693 vorbis_synthesis_read(&vf->vd,samples);
1694 vf->pcm_offset+=samples;
1695 if(bitstream)*bitstream=vf->current_link;
1701 /* suck in another packet */
1703 int ret=_fetch_and_process_packet(vf,NULL,1,1);
1704 if(ret==OV_EOF)return(0);
1705 if(ret<=0)return(ret);
1711 extern float *vorbis_window(vorbis_dsp_state *v,int W);
1712 extern void _analysis_output_always(char *base,int i,float *v,int n,int bark,int dB,
1715 static void _ov_splice(float **pcm,float **lappcm,
1718 float *w1, float *w2){
1729 for(j=0;j<ch1 && j<ch2;j++){
1736 d[i]=d[i]*wd + s[i]*ws;
1739 /* window from zero */
1750 /* make sure vf is INITSET */
1751 static int _ov_initset(OggVorbis_File *vf){
1753 if(vf->ready_state==INITSET)break;
1754 /* suck in another packet */
1756 int ret=_fetch_and_process_packet(vf,NULL,1,0);
1757 if(ret<0 && ret!=OV_HOLE)return(ret);
1763 /* make sure vf is INITSET and that we have a primed buffer; if
1764 we're crosslapping at a stream section boundary, this also makes
1765 sure we're sanity checking against the right stream information */
1766 static int _ov_initprime(OggVorbis_File *vf){
1767 vorbis_dsp_state *vd=&vf->vd;
1769 if(vf->ready_state==INITSET)
1770 if(vorbis_synthesis_pcmout(vd,NULL))break;
1772 /* suck in another packet */
1774 int ret=_fetch_and_process_packet(vf,NULL,1,0);
1775 if(ret<0 && ret!=OV_HOLE)return(ret);
1781 /* grab enough data for lapping from vf; this may be in the form of
1782 unreturned, already-decoded pcm, remaining PCM we will need to
1783 decode, or synthetic postextrapolation from last packets. */
1784 static void _ov_getlap(OggVorbis_File *vf,vorbis_info *vi,vorbis_dsp_state *vd,
1785 float **lappcm,int lapsize){
1789 /* try first to decode the lapping data */
1790 while(lapcount<lapsize){
1791 int samples=vorbis_synthesis_pcmout(vd,&pcm);
1793 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
1794 for(i=0;i<vi->channels;i++)
1795 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
1797 vorbis_synthesis_read(vd,samples);
1799 /* suck in another packet */
1800 int ret=_fetch_and_process_packet(vf,NULL,1,0); /* do *not* span */
1801 if(ret==OV_EOF)break;
1804 if(lapcount<lapsize){
1805 /* failed to get lapping data from normal decode; pry it from the
1806 postextrapolation buffering, or the second half of the MDCT
1807 from the last packet */
1808 int samples=vorbis_synthesis_lapout(&vf->vd,&pcm);
1810 for(i=0;i<vi->channels;i++)
1811 memset(lappcm[i]+lapcount,0,sizeof(**pcm)*lapsize-lapcount);
1814 if(samples>lapsize-lapcount)samples=lapsize-lapcount;
1815 for(i=0;i<vi->channels;i++)
1816 memcpy(lappcm[i]+lapcount,pcm[i],sizeof(**pcm)*samples);
1822 /* this sets up crosslapping of a sample by using trailing data from
1823 sample 1 and lapping it into the windowing buffer of sample 2 */
1824 int ov_crosslap(OggVorbis_File *vf1, OggVorbis_File *vf2){
1825 vorbis_info *vi1,*vi2;
1829 int n1,n2,i,ret,hs1,hs2;
1831 if(vf1==vf2)return(0); /* degenerate case */
1832 if(vf1->ready_state<OPENED)return(OV_EINVAL);
1833 if(vf2->ready_state<OPENED)return(OV_EINVAL);
1835 /* the relevant overlap buffers must be pre-checked and pre-primed
1836 before looking at settings in the event that priming would cross
1837 a bitstream boundary. So, do it now */
1839 ret=_ov_initset(vf1);
1841 ret=_ov_initprime(vf2);
1844 vi1=ov_info(vf1,-1);
1845 vi2=ov_info(vf2,-1);
1846 hs1=ov_halfrate_p(vf1);
1847 hs2=ov_halfrate_p(vf2);
1849 lappcm=alloca(sizeof(*lappcm)*vi1->channels);
1850 n1=vorbis_info_blocksize(vi1,0)>>(1+hs1);
1851 n2=vorbis_info_blocksize(vi2,0)>>(1+hs2);
1852 w1=vorbis_window(&vf1->vd,0);
1853 w2=vorbis_window(&vf2->vd,0);
1855 for(i=0;i<vi1->channels;i++)
1856 lappcm[i]=alloca(sizeof(**lappcm)*n1);
1858 _ov_getlap(vf1,vi1,&vf1->vd,lappcm,n1);
1860 /* have a lapping buffer from vf1; now to splice it into the lapping
1862 /* consolidate and expose the buffer. */
1863 vorbis_synthesis_lapout(&vf2->vd,&pcm);
1864 _analysis_output_always("pcmL",0,pcm[0],n1*2,0,0,0);
1865 _analysis_output_always("pcmR",0,pcm[1],n1*2,0,0,0);
1868 _ov_splice(pcm,lappcm,n1,n2,vi1->channels,vi2->channels,w1,w2);
1874 static int _ov_64_seek_lap(OggVorbis_File *vf,ogg_int64_t pos,
1875 int (*localseek)(OggVorbis_File *,ogg_int64_t)){
1880 int n1,n2,ch1,ch2,hs;
1883 if(vf->ready_state<OPENED)return(OV_EINVAL);
1884 ret=_ov_initset(vf);
1887 hs=ov_halfrate_p(vf);
1890 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
1891 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
1892 persistent; even if the decode state
1893 from this link gets dumped, this
1894 window array continues to exist */
1896 lappcm=alloca(sizeof(*lappcm)*ch1);
1898 lappcm[i]=alloca(sizeof(**lappcm)*n1);
1899 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
1901 /* have lapping data; seek and prime the buffer */
1902 ret=localseek(vf,pos);
1904 ret=_ov_initprime(vf);
1907 /* Guard against cross-link changes; they're perfectly legal */
1910 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
1911 w2=vorbis_window(&vf->vd,0);
1913 /* consolidate and expose the buffer. */
1914 vorbis_synthesis_lapout(&vf->vd,&pcm);
1917 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
1923 int ov_raw_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
1924 return _ov_64_seek_lap(vf,pos,ov_raw_seek);
1927 int ov_pcm_seek_lap(OggVorbis_File *vf,ogg_int64_t pos){
1928 return _ov_64_seek_lap(vf,pos,ov_pcm_seek);
1931 int ov_pcm_seek_page_lap(OggVorbis_File *vf,ogg_int64_t pos){
1932 return _ov_64_seek_lap(vf,pos,ov_pcm_seek_page);
1935 static int _ov_d_seek_lap(OggVorbis_File *vf,double pos,
1936 int (*localseek)(OggVorbis_File *,double)){
1941 int n1,n2,ch1,ch2,hs;
1944 if(vf->ready_state<OPENED)return(OV_EINVAL);
1945 ret=_ov_initset(vf);
1948 hs=ov_halfrate_p(vf);
1951 n1=vorbis_info_blocksize(vi,0)>>(1+hs);
1952 w1=vorbis_window(&vf->vd,0); /* window arrays from libvorbis are
1953 persistent; even if the decode state
1954 from this link gets dumped, this
1955 window array continues to exist */
1957 lappcm=alloca(sizeof(*lappcm)*ch1);
1959 lappcm[i]=alloca(sizeof(**lappcm)*n1);
1960 _ov_getlap(vf,vi,&vf->vd,lappcm,n1);
1962 /* have lapping data; seek and prime the buffer */
1963 ret=localseek(vf,pos);
1965 ret=_ov_initprime(vf);
1968 /* Guard against cross-link changes; they're perfectly legal */
1971 n2=vorbis_info_blocksize(vi,0)>>(1+hs);
1972 w2=vorbis_window(&vf->vd,0);
1974 /* consolidate and expose the buffer. */
1975 vorbis_synthesis_lapout(&vf->vd,&pcm);
1978 _ov_splice(pcm,lappcm,n1,n2,ch1,ch2,w1,w2);
1984 int ov_time_seek_lap(OggVorbis_File *vf,double pos){
1985 return _ov_d_seek_lap(vf,pos,ov_time_seek);
1988 int ov_time_seek_page_lap(OggVorbis_File *vf,double pos){
1989 return _ov_d_seek_lap(vf,pos,ov_time_seek_page);