[xiph-commits] r17375 - trunk/Tremor
tterribe at svn.xiph.org
tterribe at svn.xiph.org
Tue Aug 31 12:10:31 PDT 2010
Author: tterribe
Date: 2010-08-31 12:10:31 -0700 (Tue, 31 Aug 2010)
New Revision: 17375
Removed:
trunk/Tremor/bitwise.c
trunk/Tremor/framing.c
trunk/Tremor/ogg.h
trunk/Tremor/os_types.h
Modified:
trunk/Tremor/Makefile.am
trunk/Tremor/block.c
trunk/Tremor/codebook.c
trunk/Tremor/codebook.h
trunk/Tremor/configure.in
trunk/Tremor/floor0.c
trunk/Tremor/floor1.c
trunk/Tremor/info.c
trunk/Tremor/ivorbiscodec.h
trunk/Tremor/ivorbisfile.h
trunk/Tremor/lsp_lookup.h
trunk/Tremor/mapping0.c
trunk/Tremor/mdct_lookup.h
trunk/Tremor/misc.h
trunk/Tremor/os.h
trunk/Tremor/res012.c
trunk/Tremor/sharedbook.c
trunk/Tremor/synthesis.c
trunk/Tremor/vorbisfile.c
trunk/Tremor/window_lookup.h
Log:
Convert Tremor to use libogg instead of its own internal libogg2.
This makes it easier to use Tremor as a drop-in replacement for libvorbis and
reduces code size and overhead for those who don't want to use its built-in
Ogg demuxer.
This commit also backports all of the changes that have accumulated in
libvorbis's vorbisfile implementation, with the exception of halfrate decoding
and cross-lapped seeking.
Those should not be too hard to add if someone really wants them.
Modified: trunk/Tremor/Makefile.am
===================================================================
--- trunk/Tremor/Makefile.am 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/Makefile.am 2010-08-31 19:10:31 UTC (rev 17375)
@@ -1,6 +1,6 @@
AUTOMAKE_OPTIONS = foreign
-INCLUDES = -I./
+INCLUDES = -I./ @OGG_CFLAGS@
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = vorbisidec.pc
@@ -11,28 +11,29 @@
synthesis.c info.c \
floor1.c floor0.c vorbisfile.c \
res012.c mapping0.c registry.c codebook.c \
- sharedbook.c framing.c bitwise.c \
+ sharedbook.c \
codebook.h misc.h mdct_lookup.h\
os.h mdct.h block.h ivorbisfile.h lsp_lookup.h\
registry.h window.h window_lookup.h\
- codec_internal.h backends.h ogg.h \
+ codec_internal.h backends.h \
asm_arm.h ivorbiscodec.h
libvorbisidec_la_LDFLAGS = -version-info @V_LIB_CURRENT@:@V_LIB_REVISION@:@V_LIB_AGE@
+libvorbisidec_la_LIBADD = @OGG_LIBS@
EXTRA_PROGRAMS = ivorbisfile_example iseeking_example
CLEANFILES = $(EXTRA_PROGRAMS) $(lib_LTLIBRARIES)
ivorbisfile_example_SOURCES = ivorbisfile_example.c
ivorbisfile_example_LDFLAGS = -static
-ivorbisfile_example_LDADD = libvorbisidec.la
+ivorbisfile_example_LDADD = libvorbisidec.la @OGG_LIBS@
iseeking_example_SOURCES = iseeking_example.c
iseeking_example_LDFLAGS = -static
-iseeking_example_LDADD = libvorbisidec.la
+iseeking_example_LDADD = libvorbisidec.la @OGG_LIBS@
includedir = $(prefix)/include/tremor
-include_HEADERS = ivorbiscodec.h ivorbisfile.h ogg.h os_types.h config_types.h
+include_HEADERS = ivorbiscodec.h ivorbisfile.h config_types.h
EXTRA_DIST = vorbisidec.pc.in \
$(srcdir)/doc/*.html $(srcdir)/win32/VS*/libtremor/*.vcproj
Deleted: trunk/Tremor/bitwise.c
===================================================================
--- trunk/Tremor/bitwise.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/bitwise.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -1,265 +0,0 @@
-/********************************************************************
- * *
- * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
- * *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
- * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
- * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
- * *
- * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
- * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
- * *
- ********************************************************************
-
- function: packing variable sized words into an octet stream
-
- ********************************************************************/
-
-/* We're 'LSb' endian; if we write a word but read individual bits,
- then we'll read the lsb first */
-
-#include <string.h>
-#include <stdlib.h>
-#include "ogg.h"
-
-static unsigned long mask[]=
-{0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
- 0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
- 0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
- 0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff,
- 0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff,
- 0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
- 0x3fffffff,0x7fffffff,0xffffffff };
-
-/* mark read process as having run off the end */
-static void _adv_halt(oggpack_buffer *b){
- b->headptr=b->head->buffer->data+b->head->begin+b->head->length;
- b->headend=-1;
- b->headbit=0;
-}
-
-/* spans forward, skipping as many bytes as headend is negative; if
- headend is zero, simply finds next byte. If we're up to the end
- of the buffer, leaves headend at zero. If we've read past the end,
- halt the decode process. */
-static void _span(oggpack_buffer *b){
- while(b->headend<1){
- if(b->head->next){
- b->count+=b->head->length;
- b->head=b->head->next;
- b->headptr=b->head->buffer->data+b->head->begin-b->headend;
- b->headend+=b->head->length;
- }else{
- /* we've either met the end of decode, or gone past it. halt
- only if we're past */
- if(b->headend<0 || b->headbit)
- /* read has fallen off the end */
- _adv_halt(b);
-
- break;
- }
- }
-}
-
-void oggpack_readinit(oggpack_buffer *b,ogg_reference *r){
- memset(b,0,sizeof(*b));
-
- b->tail=b->head=r;
- b->count=0;
- b->headptr=b->head->buffer->data+b->head->begin;
- b->headend=b->head->length;
- _span(b);
-}
-
-#define _lookspan() while(!end){\
- head=head->next;\
- if(!head) return -1;\
- ptr=head->buffer->data + head->begin;\
- end=head->length;\
- }
-
-/* Read in bits without advancing the bitptr; bits <= 32 */
-long oggpack_look(oggpack_buffer *b,int bits){
- unsigned long m=mask[bits];
- unsigned long ret=-1;
-
- bits+=b->headbit;
-
- if(bits >= b->headend<<3){
- int end=b->headend;
- unsigned char *ptr=b->headptr;
- ogg_reference *head=b->head;
-
- if(end<0)return -1;
-
- if(bits){
- _lookspan();
- ret=*ptr++>>b->headbit;
- if(bits>8){
- --end;
- _lookspan();
- ret|=*ptr++<<(8-b->headbit);
- if(bits>16){
- --end;
- _lookspan();
- ret|=*ptr++<<(16-b->headbit);
- if(bits>24){
- --end;
- _lookspan();
- ret|=*ptr++<<(24-b->headbit);
- if(bits>32 && b->headbit){
- --end;
- _lookspan();
- ret|=*ptr<<(32-b->headbit);
- }
- }
- }
- }
- }
-
- }else{
-
- /* make this a switch jump-table */
- ret=b->headptr[0]>>b->headbit;
- if(bits>8){
- ret|=b->headptr[1]<<(8-b->headbit);
- if(bits>16){
- ret|=b->headptr[2]<<(16-b->headbit);
- if(bits>24){
- ret|=b->headptr[3]<<(24-b->headbit);
- if(bits>32 && b->headbit)
- ret|=b->headptr[4]<<(32-b->headbit);
- }
- }
- }
- }
-
- ret&=m;
- return ret;
-}
-
-/* limited to 32 at a time */
-void oggpack_adv(oggpack_buffer *b,int bits){
- bits+=b->headbit;
- b->headbit=bits&7;
- b->headptr+=bits/8;
- if((b->headend-=bits/8)<1)_span(b);
-}
-
-/* spans forward and finds next byte. Never halts */
-static void _span_one(oggpack_buffer *b){
- while(b->headend<1){
- if(b->head->next){
- b->count+=b->head->length;
- b->head=b->head->next;
- b->headptr=b->head->buffer->data+b->head->begin;
- b->headend=b->head->length;
- }else
- break;
- }
-}
-
-static int _halt_one(oggpack_buffer *b){
- if(b->headend<1){
- _adv_halt(b);
- return -1;
- }
- return 0;
-}
-
-int oggpack_eop(oggpack_buffer *b){
- if(b->headend<0)return -1;
- return 0;
-}
-
-/* bits <= 32 */
-long oggpack_read(oggpack_buffer *b,int bits){
- unsigned long m=mask[bits];
- ogg_uint32_t ret=-1;
-
- bits+=b->headbit;
-
- if(bits >= b->headend<<3){
-
- if(b->headend<0)return -1;
-
- if(bits){
- if (_halt_one(b)) return -1;
- ret=*b->headptr>>b->headbit;
-
- if(bits>=8){
- ++b->headptr;
- --b->headend;
- _span_one(b);
- if(bits>8){
- if (_halt_one(b)) return -1;
- ret|=*b->headptr<<(8-b->headbit);
-
- if(bits>=16){
- ++b->headptr;
- --b->headend;
- _span_one(b);
- if(bits>16){
- if (_halt_one(b)) return -1;
- ret|=*b->headptr<<(16-b->headbit);
-
- if(bits>=24){
- ++b->headptr;
- --b->headend;
- _span_one(b);
- if(bits>24){
- if (_halt_one(b)) return -1;
- ret|=*b->headptr<<(24-b->headbit);
-
- if(bits>=32){
- ++b->headptr;
- --b->headend;
- _span_one(b);
- if(bits>32){
- if (_halt_one(b)) return -1;
- if(b->headbit)ret|=*b->headptr<<(32-b->headbit);
-
- }
- }
- }
- }
- }
- }
- }
- }
- }
- }else{
-
- ret=b->headptr[0]>>b->headbit;
- if(bits>8){
- ret|=b->headptr[1]<<(8-b->headbit);
- if(bits>16){
- ret|=b->headptr[2]<<(16-b->headbit);
- if(bits>24){
- ret|=b->headptr[3]<<(24-b->headbit);
- if(bits>32 && b->headbit){
- ret|=b->headptr[4]<<(32-b->headbit);
- }
- }
- }
- }
-
- b->headptr+=bits/8;
- b->headend-=bits/8;
- }
-
- ret&=m;
- b->headbit=bits&7;
- return ret;
-}
-
-long oggpack_bytes(oggpack_buffer *b){
- return(b->count+b->headptr-b->head->buffer->data-b->head->begin+
- (b->headbit+7)/8);
-}
-
-long oggpack_bits(oggpack_buffer *b){
- return((b->count+b->headptr-b->head->buffer->data-b->head->begin)*8+
- b->headbit);
-}
-
Modified: trunk/Tremor/block.c
===================================================================
--- trunk/Tremor/block.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/block.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codec_internal.h"
Modified: trunk/Tremor/codebook.c
===================================================================
--- trunk/Tremor/codebook.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/codebook.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <string.h>
#include <math.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codebook.h"
#include "misc.h"
Modified: trunk/Tremor/codebook.h
===================================================================
--- trunk/Tremor/codebook.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/codebook.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#ifndef _V_CODEBOOK_H_
#define _V_CODEBOOK_H_
-#include "ogg.h"
+#include <ogg/ogg.h>
/* This structure encapsulates huffman and VQ style encoding books; it
doesn't do anything specific to either.
Modified: trunk/Tremor/configure.in
===================================================================
--- trunk/Tremor/configure.in 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/configure.in 2010-08-31 19:10:31 UTC (rev 17375)
@@ -115,6 +115,27 @@
dnl none
dnl --------------------------------------------------
+dnl Check for libraries
+dnl --------------------------------------------------
+
+PKG_PROG_PKG_CONFIG
+
+HAVE_OGG=no
+if test "x$PKG_CONFIG" != "x"
+then
+ PKG_CHECK_MODULES(OGG, ogg >= 1.0, HAVE_OGG=yes, HAVE_OGG=no)
+fi
+if test "x$HAVE_OGG" = "xno"
+then
+ dnl fall back to the old school test
+ XIPH_PATH_OGG(, AC_MSG_ERROR(must have Ogg installed!))
+ libs_save=$LIBS
+ LIBS="$OGG_LIBS"
+ AC_CHECK_FUNC(oggpack_writealign, , AC_MSG_ERROR(Ogg >= 1.0 required !))
+ LIBS=$libs_save
+fi
+
+dnl --------------------------------------------------
dnl Check for library functions
dnl --------------------------------------------------
Modified: trunk/Tremor/floor0.c
===================================================================
--- trunk/Tremor/floor0.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/floor0.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <string.h>
#include <math.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codec_internal.h"
#include "registry.h"
Modified: trunk/Tremor/floor1.c
===================================================================
--- trunk/Tremor/floor1.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/floor1.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <string.h>
#include <math.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codec_internal.h"
#include "registry.h"
Deleted: trunk/Tremor/framing.c
===================================================================
--- trunk/Tremor/framing.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/framing.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -1,1126 +0,0 @@
-/********************************************************************
- * *
- * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
- * *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
- * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
- * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
- * *
- * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 *
- * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
- * *
- ********************************************************************
-
- function: decode Ogg streams back into raw packets
-
- note: The CRC code is directly derived from public domain code by
- Ross Williams (ross at guest.adelaide.edu.au). See docs/framing.html
- for details.
-
- ********************************************************************/
-
-#include <stdlib.h>
-#include <string.h>
-#include "ogg.h"
-#include "misc.h"
-
-
-/* A complete description of Ogg framing exists in docs/framing.html */
-
-/* basic, centralized Ogg memory management based on linked lists of
- references to refcounted memory buffers. References and buffers
- are both recycled. Buffers are passed around and consumed in
- reference form. */
-
-static ogg_buffer_state *ogg_buffer_create(void){
- ogg_buffer_state *bs=_ogg_calloc(1,sizeof(*bs));
- return bs;
-}
-
-/* destruction is 'lazy'; there may be memory references outstanding,
- and yanking the buffer state out from underneath would be
- antisocial. Dealloc what is currently unused and have
- _release_one watch for the stragglers to come in. When they do,
- finish destruction. */
-
-/* call the helper while holding lock */
-static void _ogg_buffer_destroy(ogg_buffer_state *bs){
- ogg_buffer *bt;
- ogg_reference *rt;
-
- if(bs->shutdown){
-
- bt=bs->unused_buffers;
- rt=bs->unused_references;
-
- while(bt){
- ogg_buffer *b=bt;
- bt=b->ptr.next;
- if(b->data)_ogg_free(b->data);
- _ogg_free(b);
- }
- bs->unused_buffers=0;
- while(rt){
- ogg_reference *r=rt;
- rt=r->next;
- _ogg_free(r);
- }
- bs->unused_references=0;
-
- if(!bs->outstanding)
- _ogg_free(bs);
-
- }
-}
-
-static void ogg_buffer_destroy(ogg_buffer_state *bs){
- bs->shutdown=1;
- _ogg_buffer_destroy(bs);
-}
-
-static ogg_buffer *_fetch_buffer(ogg_buffer_state *bs,long bytes){
- ogg_buffer *ob;
- bs->outstanding++;
-
- /* do we have an unused buffer sitting in the pool? */
- if(bs->unused_buffers){
- ob=bs->unused_buffers;
- bs->unused_buffers=ob->ptr.next;
-
- /* if the unused buffer is too small, grow it */
- if(ob->size<bytes){
- ob->data=_ogg_realloc(ob->data,bytes);
- ob->size=bytes;
- }
- }else{
- /* allocate a new buffer */
- ob=_ogg_malloc(sizeof(*ob));
- ob->data=_ogg_malloc(bytes<16?16:bytes);
- ob->size=bytes;
- }
-
- ob->refcount=1;
- ob->ptr.owner=bs;
- return ob;
-}
-
-static ogg_reference *_fetch_ref(ogg_buffer_state *bs){
- ogg_reference *or;
- bs->outstanding++;
-
- /* do we have an unused reference sitting in the pool? */
- if(bs->unused_references){
- or=bs->unused_references;
- bs->unused_references=or->next;
- }else{
- /* allocate a new reference */
- or=_ogg_malloc(sizeof(*or));
- }
-
- or->begin=0;
- or->length=0;
- or->next=0;
- return or;
-}
-
-/* fetch a reference pointing to a fresh, initially continguous buffer
- of at least [bytes] length */
-static ogg_reference *ogg_buffer_alloc(ogg_buffer_state *bs,long bytes){
- ogg_buffer *ob=_fetch_buffer(bs,bytes);
- ogg_reference *or=_fetch_ref(bs);
- or->buffer=ob;
- return or;
-}
-
-/* enlarge the data buffer in the current link */
-static void ogg_buffer_realloc(ogg_reference *or,long bytes){
- ogg_buffer *ob=or->buffer;
-
- /* if the unused buffer is too small, grow it */
- if(ob->size<bytes){
- ob->data=_ogg_realloc(ob->data,bytes);
- ob->size=bytes;
- }
-}
-
-static void _ogg_buffer_mark_one(ogg_reference *or){
- or->buffer->refcount++;
-}
-
-/* increase the refcount of the buffers to which the reference points */
-static void ogg_buffer_mark(ogg_reference *or){
- while(or){
- _ogg_buffer_mark_one(or);
- or=or->next;
- }
-}
-
-/* duplicate a reference (pointing to the same actual buffer memory)
- and increment buffer refcount. If the desired segment begins out
- of range, NULL is returned; if the desired segment is simply zero
- length, a zero length ref is returned. Partial range overlap
- returns the overlap of the ranges */
-static ogg_reference *ogg_buffer_sub(ogg_reference *or,long begin,long length){
- ogg_reference *ret=0,*head=0;
-
- /* walk past any preceeding fragments we don't want */
- while(or && begin>=or->length){
- begin-=or->length;
- or=or->next;
- }
-
- /* duplicate the reference chain; increment refcounts */
- while(or && length){
- ogg_reference *temp=_fetch_ref(or->buffer->ptr.owner);
- if(head)
- head->next=temp;
- else
- ret=temp;
- head=temp;
- head->buffer=or->buffer;
- head->begin=or->begin+begin;
- head->length=length;
- if(head->length>or->length-begin)
- head->length=or->length-begin;
-
- begin=0;
- length-=head->length;
- or=or->next;
- }
-
- ogg_buffer_mark(ret);
- return ret;
-}
-
-ogg_reference *ogg_buffer_dup(ogg_reference *or){
- ogg_reference *ret=0,*head=0;
- /* duplicate the reference chain; increment refcounts */
- while(or){
- ogg_reference *temp=_fetch_ref(or->buffer->ptr.owner);
- if(head)
- head->next=temp;
- else
- ret=temp;
- head=temp;
- head->buffer=or->buffer;
- head->begin=or->begin;
- head->length=or->length;
- or=or->next;
- }
-
- ogg_buffer_mark(ret);
- return ret;
-}
-
-/* split a reference into two references; 'return' is a reference to
- the buffer preceeding pos and 'head'/'tail' are the buffer past the
- split. If pos is at or past the end of the passed in segment,
- 'head/tail' are NULL */
-static ogg_reference *ogg_buffer_split(ogg_reference **tail,
- ogg_reference **head,long pos){
-
- /* walk past any preceeding fragments to one of:
- a) the exact boundary that seps two fragments
- b) the fragment that needs split somewhere in the middle */
- ogg_reference *ret=*tail;
- ogg_reference *or=*tail;
-
- while(or && pos>or->length){
- pos-=or->length;
- or=or->next;
- }
-
- if(!or || pos==0){
-
- return 0;
-
- }else{
-
- if(pos>=or->length){
- /* exact split, or off the end? */
- if(or->next){
-
- /* a split */
- *tail=or->next;
- or->next=0;
-
- }else{
-
- /* off or at the end */
- *tail=*head=0;
-
- }
- }else{
-
- /* split within a fragment */
- long lengthA=pos;
- long beginB=or->begin+pos;
- long lengthB=or->length-pos;
-
- /* make a new reference to tail the second piece */
- *tail=_fetch_ref(or->buffer->ptr.owner);
-
- (*tail)->buffer=or->buffer;
- (*tail)->begin=beginB;
- (*tail)->length=lengthB;
- (*tail)->next=or->next;
- _ogg_buffer_mark_one(*tail);
- if(head && or==*head)*head=*tail;
-
- /* update the first piece */
- or->next=0;
- or->length=lengthA;
-
- }
- }
- return ret;
-}
-
-static void ogg_buffer_release_one(ogg_reference *or){
- ogg_buffer *ob=or->buffer;
- ogg_buffer_state *bs=ob->ptr.owner;
-
- ob->refcount--;
- if(ob->refcount==0){
- bs->outstanding--; /* for the returned buffer */
- ob->ptr.next=bs->unused_buffers;
- bs->unused_buffers=ob;
- }
-
- bs->outstanding--; /* for the returned reference */
- or->next=bs->unused_references;
- bs->unused_references=or;
-
- _ogg_buffer_destroy(bs); /* lazy cleanup (if needed) */
-
-}
-
-/* release the references, decrease the refcounts of buffers to which
- they point, release any buffers with a refcount that drops to zero */
-static void ogg_buffer_release(ogg_reference *or){
- while(or){
- ogg_reference *next=or->next;
- ogg_buffer_release_one(or);
- or=next;
- }
-}
-
-static ogg_reference *ogg_buffer_pretruncate(ogg_reference *or,long pos){
- /* release preceeding fragments we don't want */
- while(or && pos>=or->length){
- ogg_reference *next=or->next;
- pos-=or->length;
- ogg_buffer_release_one(or);
- or=next;
- }
- if (or) {
- or->begin+=pos;
- or->length-=pos;
- }
- return or;
-}
-
-static ogg_reference *ogg_buffer_walk(ogg_reference *or){
- if(!or)return NULL;
- while(or->next){
- or=or->next;
- }
- return(or);
-}
-
-/* *head is appended to the front end (head) of *tail; both continue to
- be valid pointers, with *tail at the tail and *head at the head */
-static ogg_reference *ogg_buffer_cat(ogg_reference *tail, ogg_reference *head){
- if(!tail)return head;
-
- while(tail->next){
- tail=tail->next;
- }
- tail->next=head;
- return ogg_buffer_walk(head);
-}
-
-static void _positionB(oggbyte_buffer *b,int pos){
- if(pos<b->pos){
- /* start at beginning, scan forward */
- b->ref=b->baseref;
- b->pos=0;
- b->end=b->pos+b->ref->length;
- b->ptr=b->ref->buffer->data+b->ref->begin;
- }
-}
-
-static void _positionF(oggbyte_buffer *b,int pos){
- /* scan forward for position */
- while(pos>=b->end){
- /* just seek forward */
- b->pos+=b->ref->length;
- b->ref=b->ref->next;
- b->end=b->ref->length+b->pos;
- b->ptr=b->ref->buffer->data+b->ref->begin;
- }
-}
-
-static int oggbyte_init(oggbyte_buffer *b,ogg_reference *or){
- memset(b,0,sizeof(*b));
- if(or){
- b->ref=b->baseref=or;
- b->pos=0;
- b->end=b->ref->length;
- b->ptr=b->ref->buffer->data+b->ref->begin;
- return 0;
- }else
- return -1;
-}
-
-static void oggbyte_set4(oggbyte_buffer *b,ogg_uint32_t val,int pos){
- int i;
- _positionB(b,pos);
- for(i=0;i<4;i++){
- _positionF(b,pos);
- b->ptr[pos-b->pos]=val;
- val>>=8;
- ++pos;
- }
-}
-
-static unsigned char oggbyte_read1(oggbyte_buffer *b,int pos){
- _positionB(b,pos);
- _positionF(b,pos);
- return b->ptr[pos-b->pos];
-}
-
-static ogg_uint32_t oggbyte_read4(oggbyte_buffer *b,int pos){
- ogg_uint32_t ret;
- _positionB(b,pos);
- _positionF(b,pos);
- ret=b->ptr[pos-b->pos];
- _positionF(b,++pos);
- ret|=b->ptr[pos-b->pos]<<8;
- _positionF(b,++pos);
- ret|=b->ptr[pos-b->pos]<<16;
- _positionF(b,++pos);
- ret|=b->ptr[pos-b->pos]<<24;
- return ret;
-}
-
-static ogg_int64_t oggbyte_read8(oggbyte_buffer *b,int pos){
- ogg_int64_t ret;
- unsigned char t[7];
- int i;
- _positionB(b,pos);
- for(i=0;i<7;i++){
- _positionF(b,pos);
- t[i]=b->ptr[pos++ -b->pos];
- }
-
- _positionF(b,pos);
- ret=b->ptr[pos-b->pos];
-
- for(i=6;i>=0;--i)
- ret= ret<<8 | t[i];
-
- return ret;
-}
-
-/* Now we get to the actual framing code */
-
-int ogg_page_version(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read1(&ob,4);
-}
-
-int ogg_page_continued(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read1(&ob,5)&0x01;
-}
-
-int ogg_page_bos(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read1(&ob,5)&0x02;
-}
-
-int ogg_page_eos(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read1(&ob,5)&0x04;
-}
-
-ogg_int64_t ogg_page_granulepos(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read8(&ob,6);
-}
-
-ogg_uint32_t ogg_page_serialno(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read4(&ob,14);
-}
-
-ogg_uint32_t ogg_page_pageno(ogg_page *og){
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
- return oggbyte_read4(&ob,18);
-}
-
-/* returns the number of packets that are completed on this page (if
- the leading packet is begun on a previous page, but ends on this
- page, it's counted */
-
-/* NOTE:
-If a page consists of a packet begun on a previous page, and a new
-packet begun (but not completed) on this page, the return will be:
- ogg_page_packets(page) ==1,
- ogg_page_continued(page) !=0
-
-If a page happens to be a single packet that was begun on a
-previous page, and spans to the next page (in the case of a three or
-more page packet), the return will be:
- ogg_page_packets(page) ==0,
- ogg_page_continued(page) !=0
-*/
-
-int ogg_page_packets(ogg_page *og){
- int i;
- int n;
- int count=0;
- oggbyte_buffer ob;
- oggbyte_init(&ob,og->header);
-
- n=oggbyte_read1(&ob,26);
- for(i=0;i<n;i++)
- if(oggbyte_read1(&ob,27+i)<255)count++;
- return(count);
-}
-
-/* Static CRC calculation table. See older code in CVS for dead
- run-time initialization code. */
-
-static ogg_uint32_t crc_lookup[256]={
- 0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
- 0x130476dc,0x17c56b6b,0x1a864db2,0x1e475005,
- 0x2608edb8,0x22c9f00f,0x2f8ad6d6,0x2b4bcb61,
- 0x350c9b64,0x31cd86d3,0x3c8ea00a,0x384fbdbd,
- 0x4c11db70,0x48d0c6c7,0x4593e01e,0x4152fda9,
- 0x5f15adac,0x5bd4b01b,0x569796c2,0x52568b75,
- 0x6a1936c8,0x6ed82b7f,0x639b0da6,0x675a1011,
- 0x791d4014,0x7ddc5da3,0x709f7b7a,0x745e66cd,
- 0x9823b6e0,0x9ce2ab57,0x91a18d8e,0x95609039,
- 0x8b27c03c,0x8fe6dd8b,0x82a5fb52,0x8664e6e5,
- 0xbe2b5b58,0xbaea46ef,0xb7a96036,0xb3687d81,
- 0xad2f2d84,0xa9ee3033,0xa4ad16ea,0xa06c0b5d,
- 0xd4326d90,0xd0f37027,0xddb056fe,0xd9714b49,
- 0xc7361b4c,0xc3f706fb,0xceb42022,0xca753d95,
- 0xf23a8028,0xf6fb9d9f,0xfbb8bb46,0xff79a6f1,
- 0xe13ef6f4,0xe5ffeb43,0xe8bccd9a,0xec7dd02d,
- 0x34867077,0x30476dc0,0x3d044b19,0x39c556ae,
- 0x278206ab,0x23431b1c,0x2e003dc5,0x2ac12072,
- 0x128e9dcf,0x164f8078,0x1b0ca6a1,0x1fcdbb16,
- 0x018aeb13,0x054bf6a4,0x0808d07d,0x0cc9cdca,
- 0x7897ab07,0x7c56b6b0,0x71159069,0x75d48dde,
- 0x6b93dddb,0x6f52c06c,0x6211e6b5,0x66d0fb02,
- 0x5e9f46bf,0x5a5e5b08,0x571d7dd1,0x53dc6066,
- 0x4d9b3063,0x495a2dd4,0x44190b0d,0x40d816ba,
- 0xaca5c697,0xa864db20,0xa527fdf9,0xa1e6e04e,
- 0xbfa1b04b,0xbb60adfc,0xb6238b25,0xb2e29692,
- 0x8aad2b2f,0x8e6c3698,0x832f1041,0x87ee0df6,
- 0x99a95df3,0x9d684044,0x902b669d,0x94ea7b2a,
- 0xe0b41de7,0xe4750050,0xe9362689,0xedf73b3e,
- 0xf3b06b3b,0xf771768c,0xfa325055,0xfef34de2,
- 0xc6bcf05f,0xc27dede8,0xcf3ecb31,0xcbffd686,
- 0xd5b88683,0xd1799b34,0xdc3abded,0xd8fba05a,
- 0x690ce0ee,0x6dcdfd59,0x608edb80,0x644fc637,
- 0x7a089632,0x7ec98b85,0x738aad5c,0x774bb0eb,
- 0x4f040d56,0x4bc510e1,0x46863638,0x42472b8f,
- 0x5c007b8a,0x58c1663d,0x558240e4,0x51435d53,
- 0x251d3b9e,0x21dc2629,0x2c9f00f0,0x285e1d47,
- 0x36194d42,0x32d850f5,0x3f9b762c,0x3b5a6b9b,
- 0x0315d626,0x07d4cb91,0x0a97ed48,0x0e56f0ff,
- 0x1011a0fa,0x14d0bd4d,0x19939b94,0x1d528623,
- 0xf12f560e,0xf5ee4bb9,0xf8ad6d60,0xfc6c70d7,
- 0xe22b20d2,0xe6ea3d65,0xeba91bbc,0xef68060b,
- 0xd727bbb6,0xd3e6a601,0xdea580d8,0xda649d6f,
- 0xc423cd6a,0xc0e2d0dd,0xcda1f604,0xc960ebb3,
- 0xbd3e8d7e,0xb9ff90c9,0xb4bcb610,0xb07daba7,
- 0xae3afba2,0xaafbe615,0xa7b8c0cc,0xa379dd7b,
- 0x9b3660c6,0x9ff77d71,0x92b45ba8,0x9675461f,
- 0x8832161a,0x8cf30bad,0x81b02d74,0x857130c3,
- 0x5d8a9099,0x594b8d2e,0x5408abf7,0x50c9b640,
- 0x4e8ee645,0x4a4ffbf2,0x470cdd2b,0x43cdc09c,
- 0x7b827d21,0x7f436096,0x7200464f,0x76c15bf8,
- 0x68860bfd,0x6c47164a,0x61043093,0x65c52d24,
- 0x119b4be9,0x155a565e,0x18197087,0x1cd86d30,
- 0x029f3d35,0x065e2082,0x0b1d065b,0x0fdc1bec,
- 0x3793a651,0x3352bbe6,0x3e119d3f,0x3ad08088,
- 0x2497d08d,0x2056cd3a,0x2d15ebe3,0x29d4f654,
- 0xc5a92679,0xc1683bce,0xcc2b1d17,0xc8ea00a0,
- 0xd6ad50a5,0xd26c4d12,0xdf2f6bcb,0xdbee767c,
- 0xe3a1cbc1,0xe760d676,0xea23f0af,0xeee2ed18,
- 0xf0a5bd1d,0xf464a0aa,0xf9278673,0xfde69bc4,
- 0x89b8fd09,0x8d79e0be,0x803ac667,0x84fbdbd0,
- 0x9abc8bd5,0x9e7d9662,0x933eb0bb,0x97ffad0c,
- 0xafb010b1,0xab710d06,0xa6322bdf,0xa2f33668,
- 0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
-
-ogg_sync_state *ogg_sync_create(void){
- ogg_sync_state *oy=_ogg_calloc(1,sizeof(*oy));
- memset(oy,0,sizeof(*oy));
- oy->bufferpool=ogg_buffer_create();
- return oy;
-}
-
-int ogg_sync_destroy(ogg_sync_state *oy){
- if(oy){
- ogg_sync_reset(oy);
- ogg_buffer_destroy(oy->bufferpool);
- memset(oy,0,sizeof(*oy));
- _ogg_free(oy);
- }
- return OGG_SUCCESS;
-}
-
-unsigned char *ogg_sync_bufferin(ogg_sync_state *oy, long bytes){
-
- /* [allocate and] expose a buffer for data submission.
-
- If there is no head fragment
- allocate one and expose it
- else
- if the current head fragment has sufficient unused space
- expose it
- else
- if the current head fragment is unused
- resize and expose it
- else
- allocate new fragment and expose it
- */
-
- /* base case; fifo uninitialized */
- if(!oy->fifo_head){
- oy->fifo_head=oy->fifo_tail=ogg_buffer_alloc(oy->bufferpool,bytes);
- return oy->fifo_head->buffer->data;
- }
-
- /* space left in current fragment case */
- if(oy->fifo_head->buffer->size-
- oy->fifo_head->length-
- oy->fifo_head->begin >= bytes)
- return oy->fifo_head->buffer->data+
- oy->fifo_head->length+oy->fifo_head->begin;
-
- /* current fragment is unused, but too small */
- if(!oy->fifo_head->length){
- ogg_buffer_realloc(oy->fifo_head,bytes);
- return oy->fifo_head->buffer->data+oy->fifo_head->begin;
- }
-
- /* current fragment used/full; get new fragment */
- {
- ogg_reference *new=ogg_buffer_alloc(oy->bufferpool,bytes);
- oy->fifo_head->next=new;
- oy->fifo_head=new;
- }
- return oy->fifo_head->buffer->data;
-}
-
-int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
- if(!oy->fifo_head)return OGG_EINVAL;
- if(oy->fifo_head->buffer->size-oy->fifo_head->length-oy->fifo_head->begin <
- bytes)return OGG_EINVAL;
- oy->fifo_head->length+=bytes;
- oy->fifo_fill+=bytes;
- return OGG_SUCCESS;
-}
-
-static ogg_uint32_t _checksum(ogg_reference *or, int bytes){
- ogg_uint32_t crc_reg=0;
- int j,post;
-
- while(or){
- unsigned char *data=or->buffer->data+or->begin;
- post=(bytes<or->length?bytes:or->length);
- for(j=0;j<post;++j)
- crc_reg=(crc_reg<<8)^crc_lookup[((crc_reg >> 24)&0xff)^data[j]];
- bytes-=j;
- or=or->next;
- }
-
- return crc_reg;
-}
-
-
-/* sync the stream. This is meant to be useful for finding page
- boundaries.
-
- return values for this:
- -n) skipped n bytes
- 0) page not ready; more data (no bytes skipped)
- n) page synced at current location; page length n bytes
-
-*/
-
-long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){
- oggbyte_buffer page;
- long bytes,ret=0;
-
- ogg_page_release(og);
-
- bytes=oy->fifo_fill;
- oggbyte_init(&page,oy->fifo_tail);
-
- if(oy->headerbytes==0){
- if(bytes<27)goto sync_out; /* not enough for even a minimal header */
-
- /* verify capture pattern */
- if(oggbyte_read1(&page,0)!=(int)'O' ||
- oggbyte_read1(&page,1)!=(int)'g' ||
- oggbyte_read1(&page,2)!=(int)'g' ||
- oggbyte_read1(&page,3)!=(int)'S' ) goto sync_fail;
-
- oy->headerbytes=oggbyte_read1(&page,26)+27;
- }
- if(bytes<oy->headerbytes)goto sync_out; /* not enough for header +
- seg table */
- if(oy->bodybytes==0){
- int i;
- /* count up body length in the segment table */
- for(i=0;i<oy->headerbytes-27;i++)
- oy->bodybytes+=oggbyte_read1(&page,27+i);
- }
-
- if(oy->bodybytes+oy->headerbytes>bytes)goto sync_out;
-
- /* we have what appears to be a complete page; last test: verify
- checksum */
- {
- ogg_uint32_t chksum=oggbyte_read4(&page,22);
- oggbyte_set4(&page,0,22);
-
- /* Compare checksums; memory continues to be common access */
- if(chksum!=_checksum(oy->fifo_tail,oy->bodybytes+oy->headerbytes)){
-
- /* D'oh. Mismatch! Corrupt page (or miscapture and not a page
- at all). replace the computed checksum with the one actually
- read in; remember all the memory is common access */
-
- oggbyte_set4(&page,chksum,22);
- goto sync_fail;
- }
- oggbyte_set4(&page,chksum,22);
- }
-
- /* We have a page. Set up page return. */
- if(og){
- /* set up page output */
- og->header=ogg_buffer_split(&oy->fifo_tail,&oy->fifo_head,oy->headerbytes);
- og->header_len=oy->headerbytes;
- og->body=ogg_buffer_split(&oy->fifo_tail,&oy->fifo_head,oy->bodybytes);
- og->body_len=oy->bodybytes;
- }else{
- /* simply advance */
- oy->fifo_tail=
- ogg_buffer_pretruncate(oy->fifo_tail,oy->headerbytes+oy->bodybytes);
- if(!oy->fifo_tail)oy->fifo_head=0;
- }
-
- ret=oy->headerbytes+oy->bodybytes;
- oy->unsynced=0;
- oy->headerbytes=0;
- oy->bodybytes=0;
- oy->fifo_fill-=ret;
-
- return ret;
-
- sync_fail:
-
- oy->headerbytes=0;
- oy->bodybytes=0;
- oy->fifo_tail=ogg_buffer_pretruncate(oy->fifo_tail,1);
- ret--;
-
- /* search forward through fragments for possible capture */
- while(oy->fifo_tail){
- /* invariant: fifo_cursor points to a position in fifo_tail */
- unsigned char *now=oy->fifo_tail->buffer->data+oy->fifo_tail->begin;
- unsigned char *next=memchr(now, 'O', oy->fifo_tail->length);
-
- if(next){
- /* possible capture in this segment */
- long bytes=next-now;
- oy->fifo_tail=ogg_buffer_pretruncate(oy->fifo_tail,bytes);
- ret-=bytes;
- break;
- }else{
- /* no capture. advance to next segment */
- long bytes=oy->fifo_tail->length;
- ret-=bytes;
- oy->fifo_tail=ogg_buffer_pretruncate(oy->fifo_tail,bytes);
- }
- }
- if(!oy->fifo_tail)oy->fifo_head=0;
- oy->fifo_fill+=ret;
-
- sync_out:
- return ret;
-}
-
-/* sync the stream and get a page. Keep trying until we find a page.
- Supress 'sync errors' after reporting the first.
-
- return values:
- OGG_HOLE) recapture (hole in data)
- 0) need more data
- 1) page returned
-
- Returns pointers into buffered data; invalidated by next call to
- _stream, _clear, _init, or _buffer */
-
-int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og){
-
- /* all we need to do is verify a page at the head of the stream
- buffer. If it doesn't verify, we look for the next potential
- frame */
-
- while(1){
- long ret=ogg_sync_pageseek(oy,og);
- if(ret>0){
- /* have a page */
- return 1;
- }
- if(ret==0){
- /* need more data */
- return 0;
- }
-
- /* head did not start a synced page... skipped some bytes */
- if(!oy->unsynced){
- oy->unsynced=1;
- return OGG_HOLE;
- }
-
- /* loop. keep looking */
-
- }
-}
-
-/* clear things to an initial state. Good to call, eg, before seeking */
-int ogg_sync_reset(ogg_sync_state *oy){
-
- ogg_buffer_release(oy->fifo_tail);
- oy->fifo_tail=0;
- oy->fifo_head=0;
- oy->fifo_fill=0;
-
- oy->unsynced=0;
- oy->headerbytes=0;
- oy->bodybytes=0;
- return OGG_SUCCESS;
-}
-
-ogg_stream_state *ogg_stream_create(int serialno){
- ogg_stream_state *os=_ogg_calloc(1,sizeof(*os));
- os->serialno=serialno;
- os->pageno=-1;
- return os;
-}
-
-int ogg_stream_destroy(ogg_stream_state *os){
- if(os){
- ogg_buffer_release(os->header_tail);
- ogg_buffer_release(os->body_tail);
- memset(os,0,sizeof(*os));
- _ogg_free(os);
- }
- return OGG_SUCCESS;
-}
-
-
-#define FINFLAG 0x80000000UL
-#define FINMASK 0x7fffffffUL
-
-static void _next_lace(oggbyte_buffer *ob,ogg_stream_state *os){
- /* search ahead one lace */
- os->body_fill_next=0;
- while(os->laceptr<os->lacing_fill){
- int val=oggbyte_read1(ob,27+os->laceptr++);
- os->body_fill_next+=val;
- if(val<255){
- os->body_fill_next|=FINFLAG;
- os->clearflag=1;
- break;
- }
- }
-}
-
-static void _span_queued_page(ogg_stream_state *os){
- while( !(os->body_fill&FINFLAG) ){
-
- if(!os->header_tail)break;
-
- /* first flush out preceeding page header (if any). Body is
- flushed as it's consumed, so that's not done here. */
-
- if(os->lacing_fill>=0)
- os->header_tail=ogg_buffer_pretruncate(os->header_tail,
- os->lacing_fill+27);
- os->lacing_fill=0;
- os->laceptr=0;
- os->clearflag=0;
-
- if(!os->header_tail){
- os->header_head=0;
- break;
- }else{
-
- /* process/prepare next page, if any */
-
- long pageno;
- oggbyte_buffer ob;
- ogg_page og; /* only for parsing header values */
- og.header=os->header_tail; /* only for parsing header values */
- pageno=ogg_page_pageno(&og);
-
- oggbyte_init(&ob,os->header_tail);
- os->lacing_fill=oggbyte_read1(&ob,26);
-
- /* are we in sequence? */
- if(pageno!=os->pageno){
- if(os->pageno==-1) /* indicates seek or reset */
- os->holeflag=1; /* set for internal use */
- else
- os->holeflag=2; /* set for external reporting */
-
- os->body_tail=ogg_buffer_pretruncate(os->body_tail,
- os->body_fill);
- if(os->body_tail==0)os->body_head=0;
- os->body_fill=0;
-
- }
-
- if(ogg_page_continued(&og)){
- if(os->body_fill==0){
- /* continued packet, but no preceeding data to continue */
- /* dump the first partial packet on the page */
- _next_lace(&ob,os);
- os->body_tail=
- ogg_buffer_pretruncate(os->body_tail,os->body_fill_next&FINMASK);
- if(os->body_tail==0)os->body_head=0;
- /* set span flag */
- if(!os->spanflag && !os->holeflag)os->spanflag=2;
- }
- }else{
- if(os->body_fill>0){
- /* preceeding data to continue, but not a continued page */
- /* dump body_fill */
- os->body_tail=ogg_buffer_pretruncate(os->body_tail,
- os->body_fill);
- if(os->body_tail==0)os->body_head=0;
- os->body_fill=0;
-
- /* set espan flag */
- if(!os->spanflag && !os->holeflag)os->spanflag=2;
- }
- }
-
- if(os->laceptr<os->lacing_fill){
- os->granulepos=ogg_page_granulepos(&og);
-
- /* get current packet size & flag */
- _next_lace(&ob,os);
- os->body_fill+=os->body_fill_next; /* addition handles the flag fine;
- unsigned on purpose */
- /* ...and next packet size & flag */
- _next_lace(&ob,os);
-
- }
-
- os->pageno=pageno+1;
- os->e_o_s=ogg_page_eos(&og);
- os->b_o_s=ogg_page_bos(&og);
-
- }
- }
-}
-
-/* add the incoming page to the stream state; we decompose the page
- into packet segments here as well. */
-
-int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og){
-
- int serialno=ogg_page_serialno(og);
- int version=ogg_page_version(og);
-
- /* check the serial number */
- if(serialno!=os->serialno){
- ogg_page_release(og);
- return OGG_ESERIAL;
- }
- if(version>0){
- ogg_page_release(og);
- return OGG_EVERSION;
- }
-
- /* add to fifos */
- if(!os->body_tail){
- os->body_tail=og->body;
- os->body_head=ogg_buffer_walk(og->body);
- }else{
- os->body_head=ogg_buffer_cat(os->body_head,og->body);
- }
- if(!os->header_tail){
- os->header_tail=og->header;
- os->header_head=ogg_buffer_walk(og->header);
- os->lacing_fill=-27;
- }else{
- os->header_head=ogg_buffer_cat(os->header_head,og->header);
- }
-
- memset(og,0,sizeof(*og));
- return OGG_SUCCESS;
-}
-
-int ogg_stream_reset(ogg_stream_state *os){
-
- ogg_buffer_release(os->header_tail);
- ogg_buffer_release(os->body_tail);
- os->header_tail=os->header_head=0;
- os->body_tail=os->body_head=0;
-
- os->e_o_s=0;
- os->b_o_s=0;
- os->pageno=-1;
- os->packetno=0;
- os->granulepos=0;
-
- os->body_fill=0;
- os->lacing_fill=0;
-
- os->holeflag=0;
- os->spanflag=0;
- os->clearflag=0;
- os->laceptr=0;
- os->body_fill_next=0;
-
- return OGG_SUCCESS;
-}
-
-int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
- ogg_stream_reset(os);
- os->serialno=serialno;
- return OGG_SUCCESS;
-}
-
-static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){
-
- ogg_packet_release(op);
- _span_queued_page(os);
-
- if(os->holeflag){
- int temp=os->holeflag;
- if(os->clearflag)
- os->holeflag=0;
- else
- os->holeflag=1;
- if(temp==2){
- os->packetno++;
- return OGG_HOLE;
- }
- }
- if(os->spanflag){
- int temp=os->spanflag;
- if(os->clearflag)
- os->spanflag=0;
- else
- os->spanflag=1;
- if(temp==2){
- os->packetno++;
- return OGG_SPAN;
- }
- }
-
- if(!(os->body_fill&FINFLAG)) return 0;
- if(!op && !adv)return 1; /* just using peek as an inexpensive way
- to ask if there's a whole packet
- waiting */
- if(op){
- op->b_o_s=os->b_o_s;
- if(os->e_o_s && os->body_fill_next==0)
- op->e_o_s=os->e_o_s;
- else
- op->e_o_s=0;
- if( (os->body_fill&FINFLAG) && !(os->body_fill_next&FINFLAG) )
- op->granulepos=os->granulepos;
- else
- op->granulepos=-1;
- op->packetno=os->packetno;
- }
-
- if(adv){
- oggbyte_buffer ob;
- oggbyte_init(&ob,os->header_tail);
-
- /* split the body contents off */
- if(op){
- op->packet=ogg_buffer_split(&os->body_tail,&os->body_head,
- os->body_fill&FINMASK);
- op->bytes=os->body_fill&FINMASK;
- }else{
- os->body_tail=ogg_buffer_pretruncate(os->body_tail,
- os->body_fill&FINMASK);
- if(os->body_tail==0)os->body_head=0;
- }
-
- /* update lacing pointers */
- os->body_fill=os->body_fill_next;
- _next_lace(&ob,os);
- }else{
- if(op){
- op->packet=ogg_buffer_sub(os->body_tail,0,os->body_fill&FINMASK);
- op->bytes=os->body_fill&FINMASK;
- }
- }
-
- if(adv){
- os->packetno++;
- os->b_o_s=0;
- }
-
- return 1;
-}
-
-int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
- return _packetout(os,op,1);
-}
-
-int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
- return _packetout(os,op,0);
-}
-
-int ogg_packet_release(ogg_packet *op) {
- if(op){
- ogg_buffer_release(op->packet);
- memset(op, 0, sizeof(*op));
- }
- return OGG_SUCCESS;
-}
-
-int ogg_page_release(ogg_page *og) {
- if(og){
- ogg_buffer_release(og->header);
- ogg_buffer_release(og->body);
- memset(og, 0, sizeof(*og));
- }
- return OGG_SUCCESS;
-}
-
-void ogg_page_dup(ogg_page *dup,ogg_page *orig){
- dup->header_len=orig->header_len;
- dup->body_len=orig->body_len;
- dup->header=ogg_buffer_dup(orig->header);
- dup->body=ogg_buffer_dup(orig->body);
-}
-
Modified: trunk/Tremor/info.c
===================================================================
--- trunk/Tremor/info.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/info.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -21,7 +21,7 @@
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codec_internal.h"
#include "codebook.h"
@@ -299,7 +299,7 @@
char buffer[6];
if(op){
- oggpack_readinit(&opb,op->packet);
+ oggpack_readinit(&opb,op->packet,op->bytes);
if(!op->b_o_s)
return(0); /* Not the initial packet */
@@ -327,7 +327,7 @@
oggpack_buffer opb;
if(op){
- oggpack_readinit(&opb,op->packet);
+ oggpack_readinit(&opb,op->packet,op->bytes);
/* Which of the three types of header is this? */
/* Also verify header-ness, vorbis */
Modified: trunk/Tremor/ivorbiscodec.h
===================================================================
--- trunk/Tremor/ivorbiscodec.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/ivorbiscodec.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -23,7 +23,7 @@
{
#endif /* __cplusplus */
-#include "ogg.h"
+#include <ogg/ogg.h>
typedef struct vorbis_info{
int version;
Modified: trunk/Tremor/ivorbisfile.h
===================================================================
--- trunk/Tremor/ivorbisfile.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/ivorbisfile.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -55,7 +55,7 @@
int seekable;
ogg_int64_t offset;
ogg_int64_t end;
- ogg_sync_state *oy;
+ ogg_sync_state oy;
/* If the FILE handle isn't seekable (eg, a pipe), only the current
stream appears */
@@ -76,7 +76,7 @@
ogg_int64_t bittrack;
ogg_int64_t samptrack;
- ogg_stream_state *os; /* take physical pages, weld into a logical
+ ogg_stream_state os; /* take physical pages, weld into a logical
stream of packets */
vorbis_dsp_state vd; /* central working state for the packet->PCM decoder */
vorbis_block vb; /* local working space for packet->PCM decode */
@@ -86,13 +86,13 @@
} OggVorbis_File;
extern int ov_clear(OggVorbis_File *vf);
-extern int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes);
+extern int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes);
extern int ov_open_callbacks(void *datasource, OggVorbis_File *vf,
- char *initial, long ibytes, ov_callbacks callbacks);
+ const char *initial, long ibytes, ov_callbacks callbacks);
-extern int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes);
+extern int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes);
extern int ov_test_callbacks(void *datasource, OggVorbis_File *vf,
- char *initial, long ibytes, ov_callbacks callbacks);
+ const char *initial, long ibytes, ov_callbacks callbacks);
extern int ov_test_open(OggVorbis_File *vf);
extern long ov_bitrate(OggVorbis_File *vf,int i);
Modified: trunk/Tremor/lsp_lookup.h
===================================================================
--- trunk/Tremor/lsp_lookup.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/lsp_lookup.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#ifndef _V_LOOKUP_DATA_H_
#define _V_LOOKUP_DATA_H_
-#include "os_types.h"
+#include <ogg/os_types.h>
#define FROMdB_LOOKUP_SZ 35
#define FROMdB2_LOOKUP_SZ 32
Modified: trunk/Tremor/mapping0.c
===================================================================
--- trunk/Tremor/mapping0.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/mapping0.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -19,7 +19,7 @@
#include <stdio.h>
#include <string.h>
#include <math.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "mdct.h"
#include "codec_internal.h"
Modified: trunk/Tremor/mdct_lookup.h
===================================================================
--- trunk/Tremor/mdct_lookup.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/mdct_lookup.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -15,7 +15,7 @@
********************************************************************/
-#include "os_types.h"
+#include "misc.h"
/* {sin(2*i*PI/4096), cos(2*i*PI/4096)}, with i = 0 to 512 */
static LOOKUP_T sincos_lookup0[1026] = {
Modified: trunk/Tremor/misc.h
===================================================================
--- trunk/Tremor/misc.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/misc.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -20,6 +20,14 @@
#include "ivorbiscodec.h"
#include "os.h"
+#ifdef _LOW_ACCURACY_
+# define X(n) (((((n)>>22)+1)>>1) - ((((n)>>22)+1)>>9))
+# define LOOKUP_T const unsigned char
+#else
+# define X(n) (n)
+# define LOOKUP_T const ogg_int32_t
+#endif
+
#include "asm_arm.h"
#include <stdlib.h> /* for abs() */
Deleted: trunk/Tremor/ogg.h
===================================================================
--- trunk/Tremor/ogg.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/ogg.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -1,206 +0,0 @@
-/********************************************************************
- * *
- * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
- * *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
- * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
- * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
- * *
- * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2003 *
- * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
- * *
- ********************************************************************
-
- function: subsumed libogg includes
-
- ********************************************************************/
-#ifndef _OGG_H
-#define _OGG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "os_types.h"
-
-typedef struct ogg_buffer_state{
- struct ogg_buffer *unused_buffers;
- struct ogg_reference *unused_references;
- int outstanding;
- int shutdown;
-} ogg_buffer_state;
-
-typedef struct ogg_buffer {
- unsigned char *data;
- long size;
- int refcount;
-
- union {
- ogg_buffer_state *owner;
- struct ogg_buffer *next;
- } ptr;
-} ogg_buffer;
-
-typedef struct ogg_reference {
- ogg_buffer *buffer;
- long begin;
- long length;
-
- struct ogg_reference *next;
-} ogg_reference;
-
-typedef struct oggpack_buffer {
- int headbit;
- unsigned char *headptr;
- long headend;
-
- /* memory management */
- ogg_reference *head;
- ogg_reference *tail;
-
- /* render the byte/bit counter API constant time */
- long count; /* doesn't count the tail */
-} oggpack_buffer;
-
-typedef struct oggbyte_buffer {
- ogg_reference *baseref;
-
- ogg_reference *ref;
- unsigned char *ptr;
- long pos;
- long end;
-} oggbyte_buffer;
-
-typedef struct ogg_sync_state {
- /* decode memory management pool */
- ogg_buffer_state *bufferpool;
-
- /* stream buffers */
- ogg_reference *fifo_head;
- ogg_reference *fifo_tail;
- long fifo_fill;
-
- /* stream sync management */
- int unsynced;
- int headerbytes;
- int bodybytes;
-
-} ogg_sync_state;
-
-typedef struct ogg_stream_state {
- ogg_reference *header_head;
- ogg_reference *header_tail;
- ogg_reference *body_head;
- ogg_reference *body_tail;
-
- int e_o_s; /* set when we have buffered the last
- packet in the logical bitstream */
- int b_o_s; /* set after we've written the initial page
- of a logical bitstream */
- long serialno;
- long pageno;
- ogg_int64_t packetno; /* sequence number for decode; the framing
- knows where there's a hole in the data,
- but we need coupling so that the codec
- (which is in a seperate abstraction
- layer) also knows about the gap */
- ogg_int64_t granulepos;
-
- int lacing_fill;
- ogg_uint32_t body_fill;
-
- /* decode-side state data */
- int holeflag;
- int spanflag;
- int clearflag;
- int laceptr;
- ogg_uint32_t body_fill_next;
-
-} ogg_stream_state;
-
-typedef struct {
- ogg_reference *packet;
- long bytes;
- long b_o_s;
- long e_o_s;
- ogg_int64_t granulepos;
- ogg_int64_t packetno; /* sequence number for decode; the framing
- knows where there's a hole in the data,
- but we need coupling so that the codec
- (which is in a seperate abstraction
- layer) also knows about the gap */
-} ogg_packet;
-
-typedef struct {
- ogg_reference *header;
- int header_len;
- ogg_reference *body;
- long body_len;
-} ogg_page;
-
-/* Ogg BITSTREAM PRIMITIVES: bitstream ************************/
-
-extern void oggpack_readinit(oggpack_buffer *b,ogg_reference *r);
-extern long oggpack_look(oggpack_buffer *b,int bits);
-extern void oggpack_adv(oggpack_buffer *b,int bits);
-extern long oggpack_read(oggpack_buffer *b,int bits);
-extern long oggpack_bytes(oggpack_buffer *b);
-extern long oggpack_bits(oggpack_buffer *b);
-extern int oggpack_eop(oggpack_buffer *b);
-
-/* Ogg BITSTREAM PRIMITIVES: decoding **************************/
-
-extern ogg_sync_state *ogg_sync_create(void);
-extern int ogg_sync_destroy(ogg_sync_state *oy);
-extern int ogg_sync_reset(ogg_sync_state *oy);
-
-extern unsigned char *ogg_sync_bufferin(ogg_sync_state *oy, long size);
-extern int ogg_sync_wrote(ogg_sync_state *oy, long bytes);
-extern long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og);
-extern int ogg_sync_pageout(ogg_sync_state *oy, ogg_page *og);
-extern int ogg_stream_pagein(ogg_stream_state *os, ogg_page *og);
-extern int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op);
-extern int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op);
-
-/* Ogg BITSTREAM PRIMITIVES: general ***************************/
-
-extern ogg_stream_state *ogg_stream_create(int serialno);
-extern int ogg_stream_destroy(ogg_stream_state *os);
-extern int ogg_stream_reset(ogg_stream_state *os);
-extern int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno);
-extern int ogg_stream_eos(ogg_stream_state *os);
-
-extern int ogg_page_checksum_set(ogg_page *og);
-
-extern int ogg_page_version(ogg_page *og);
-extern int ogg_page_continued(ogg_page *og);
-extern int ogg_page_bos(ogg_page *og);
-extern int ogg_page_eos(ogg_page *og);
-extern ogg_int64_t ogg_page_granulepos(ogg_page *og);
-extern ogg_uint32_t ogg_page_serialno(ogg_page *og);
-extern ogg_uint32_t ogg_page_pageno(ogg_page *og);
-extern int ogg_page_packets(ogg_page *og);
-extern int ogg_page_getbuffer(ogg_page *og, unsigned char **buffer);
-
-extern int ogg_packet_release(ogg_packet *op);
-extern int ogg_page_release(ogg_page *og);
-
-extern void ogg_page_dup(ogg_page *d, ogg_page *s);
-
-/* Ogg BITSTREAM PRIMITIVES: return codes ***************************/
-
-#define OGG_SUCCESS 0
-
-#define OGG_HOLE -10
-#define OGG_SPAN -11
-#define OGG_EVERSION -12
-#define OGG_ESERIAL -13
-#define OGG_EINVAL -14
-#define OGG_EEOS -15
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _OGG_H */
Modified: trunk/Tremor/os.h
===================================================================
--- trunk/Tremor/os.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/os.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
********************************************************************/
#include <math.h>
-#include "os_types.h"
+#include <ogg/os_types.h>
#ifndef _V_IFDEFJAIL_H_
# define _V_IFDEFJAIL_H_
Deleted: trunk/Tremor/os_types.h
===================================================================
--- trunk/Tremor/os_types.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/os_types.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -1,88 +0,0 @@
-/********************************************************************
- * *
- * THIS FILE IS PART OF THE OggVorbis 'TREMOR' CODEC SOURCE CODE. *
- * *
- * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS *
- * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
- * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING. *
- * *
- * THE OggVorbis 'TREMOR' SOURCE CODE IS (C) COPYRIGHT 1994-2002 *
- * BY THE Xiph.Org FOUNDATION http://www.xiph.org/ *
- * *
- ********************************************************************
-
- function: #ifdef jail to whip a few platforms into the UNIX ideal.
-
- ********************************************************************/
-#ifndef _OS_TYPES_H
-#define _OS_TYPES_H
-
-#ifdef _LOW_ACCURACY_
-# define X(n) (((((n)>>22)+1)>>1) - ((((n)>>22)+1)>>9))
-# define LOOKUP_T const unsigned char
-#else
-# define X(n) (n)
-# define LOOKUP_T const ogg_int32_t
-#endif
-
-/* make it easy on the folks that want to compile the libs with a
- different malloc than stdlib */
-#define _ogg_malloc malloc
-#define _ogg_calloc calloc
-#define _ogg_realloc realloc
-#define _ogg_free free
-
-#ifdef _WIN32
-
-# ifndef __GNUC__
- /* MSVC/Borland */
- typedef __int64 ogg_int64_t;
- typedef __int32 ogg_int32_t;
- typedef unsigned __int32 ogg_uint32_t;
- typedef __int16 ogg_int16_t;
-# else
- /* Cygwin */
- #include <_G_config.h>
- typedef _G_int64_t ogg_int64_t;
- typedef _G_int32_t ogg_int32_t;
- typedef _G_uint32_t ogg_uint32_t;
- typedef _G_int16_t ogg_int16_t;
-# endif
-
-#elif defined(__MACOS__)
-
-# include <sys/types.h>
- typedef SInt16 ogg_int16_t;
- typedef SInt32 ogg_int32_t;
- typedef UInt32 ogg_uint32_t;
- typedef SInt64 ogg_int64_t;
-
-#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
-
-# include <sys/types.h>
- typedef int16_t ogg_int16_t;
- typedef int32_t ogg_int32_t;
- typedef u_int32_t ogg_uint32_t;
- typedef int64_t ogg_int64_t;
-
-#elif defined(__BEOS__)
-
- /* Be */
-# include <inttypes.h>
-
-#elif defined (__EMX__)
-
- /* OS/2 GCC */
- typedef short ogg_int16_t;
- typedef int ogg_int32_t;
- typedef unsigned int ogg_uint32_t;
- typedef long long ogg_int64_t;
-
-#else
-
-# include <sys/types.h>
-# include "config_types.h"
-
-#endif
-
-#endif /* _OS_TYPES_H */
Modified: trunk/Tremor/res012.c
===================================================================
--- trunk/Tremor/res012.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/res012.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <string.h>
#include <math.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codec_internal.h"
#include "registry.h"
Modified: trunk/Tremor/sharedbook.c
===================================================================
--- trunk/Tremor/sharedbook.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/sharedbook.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -18,7 +18,7 @@
#include <stdlib.h>
#include <math.h>
#include <string.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "misc.h"
#include "ivorbiscodec.h"
#include "codebook.h"
Modified: trunk/Tremor/synthesis.c
===================================================================
--- trunk/Tremor/synthesis.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/synthesis.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -17,7 +17,7 @@
********************************************************************/
#include <stdio.h>
-#include "ogg.h"
+#include <ogg/ogg.h>
#include "ivorbiscodec.h"
#include "codec_internal.h"
#include "registry.h"
@@ -34,7 +34,7 @@
/* first things first. Make sure decode is ready */
_vorbis_block_ripcord(vb);
- oggpack_readinit(opb,op->packet);
+ oggpack_readinit(opb,op->packet,op->bytes);
/* Check the packet type */
if(oggpack_read(opb,1)!=0){
@@ -86,6 +86,8 @@
return _vorbis_synthesis1(vb,op,1);
}
+/* used to track pcm position without actually performing decode.
+ Useful for sequential 'fast forward' */
int vorbis_synthesis_trackonly(vorbis_block *vb,ogg_packet *op){
return _vorbis_synthesis1(vb,op,0);
}
@@ -95,7 +97,7 @@
oggpack_buffer opb;
int mode;
- oggpack_readinit(&opb,op->packet);
+ oggpack_readinit(&opb,op->packet,op->bytes);
/* Check the packet type */
if(oggpack_read(&opb,1)!=0){
Modified: trunk/Tremor/vorbisfile.c
===================================================================
--- trunk/Tremor/vorbisfile.c 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/vorbisfile.c 2010-08-31 19:10:31 UTC (rev 17375)
@@ -25,6 +25,7 @@
#include "ivorbiscodec.h"
#include "ivorbisfile.h"
+#include "os.h"
#include "misc.h"
/* A 'chained bitstream' is a Vorbis bitstream that contains more than
@@ -51,8 +52,8 @@
we only want coarse navigation through the stream. */
/*************************************************************************
- * Many, many internal helpers. The intention is not to be confusing;
- * rampant duplication and monolithic function implementation would be
+ * Many, many internal helpers. The intention is not to be confusing;
+ * rampant duplication and monolithic function implementation would be
* harder to understand anyway. The high level functions are last. Begin
* grokking near the end of the file */
@@ -60,10 +61,11 @@
/* read a little more data from the file/pipe into the ogg_sync framer */
static long _get_data(OggVorbis_File *vf){
errno=0;
+ if(!(vf->callbacks.read_func))return(-1);
if(vf->datasource){
- unsigned char *buffer=ogg_sync_bufferin(vf->oy,CHUNKSIZE);
+ char *buffer=ogg_sync_buffer(&vf->oy,CHUNKSIZE);
long bytes=(vf->callbacks.read_func)(buffer,1,CHUNKSIZE,vf->datasource);
- if(bytes>0)ogg_sync_wrote(vf->oy,bytes);
+ if(bytes>0)ogg_sync_wrote(&vf->oy,bytes);
if(bytes==0 && errno)return(-1);
return(bytes);
}else
@@ -77,7 +79,7 @@
(vf->callbacks.seek_func)(vf->datasource, offset, SEEK_SET) == -1)
return OV_EREAD;
vf->offset=offset;
- ogg_sync_reset(vf->oy);
+ ogg_sync_reset(&vf->oy);
}else{
/* shouldn't happen unless someone writes a broken callback */
return OV_EFAULT;
@@ -93,41 +95,39 @@
boundary: -1) unbounded search
0) read no additional data; use cached only
- n) search for a new page beginning for n bytes
+ n) search for a new page beginning for n bytes
return: <0) did not find a page (OV_FALSE, OV_EOF, OV_EREAD)
- n) found a page at absolute offset n
+ n) found a page at absolute offset n */
- produces a refcounted page */
-
static ogg_int64_t _get_next_page(OggVorbis_File *vf,ogg_page *og,
- ogg_int64_t boundary){
+ ogg_int64_t boundary){
if(boundary>0)boundary+=vf->offset;
while(1){
long more;
if(boundary>0 && vf->offset>=boundary)return(OV_FALSE);
- more=ogg_sync_pageseek(vf->oy,og);
-
+ more=ogg_sync_pageseek(&vf->oy,og);
+
if(more<0){
/* skipped n bytes */
vf->offset-=more;
}else{
if(more==0){
- /* send more paramedics */
- if(!boundary)return(OV_FALSE);
- {
- long ret=_get_data(vf);
- if(ret==0)return(OV_EOF);
- if(ret<0)return(OV_EREAD);
- }
+ /* send more paramedics */
+ if(!boundary)return(OV_FALSE);
+ {
+ long ret=_get_data(vf);
+ if(ret==0)return(OV_EOF);
+ if(ret<0)return(OV_EREAD);
+ }
}else{
- /* got a page. Return the offset at the page beginning,
+ /* got a page. Return the offset at the page beginning,
advance the internal offset past the page end */
- ogg_int64_t ret=vf->offset;
- vf->offset+=more;
- return(ret);
-
+ ogg_int64_t ret=vf->offset;
+ vf->offset+=more;
+ return(ret);
+
}
}
}
@@ -137,8 +137,7 @@
position. Much dirtier than the above as Ogg doesn't have any
backward search linkage. no 'readp' as it will certainly have to
read. */
-/* returns offset or OV_EREAD, OV_FAULT and produces a refcounted page */
-
+/* returns offset or OV_EREAD, OV_FAULT */
static ogg_int64_t _get_prev_page(OggVorbis_File *vf,ogg_page *og){
ogg_int64_t begin=vf->offset;
ogg_int64_t end=begin;
@@ -151,15 +150,16 @@
begin=0;
ret=_seek_helper(vf,begin);
- if(ret)return(ret);
+ if(ret)return(ret);
while(vf->offset<end){
+ memset(og,0,sizeof(*og));
ret=_get_next_page(vf,og,end-vf->offset);
if(ret==OV_EREAD)return(OV_EREAD);
if(ret<0){
- break;
+ break;
}else{
- offset=ret;
+ offset=ret;
}
}
}
@@ -168,7 +168,6 @@
holding the last page. In multiplexed (or noncompliant streams),
we will probably have to re-read the last page we saw */
if(og->header_len==0){
- ogg_page_release(og);
ret=_seek_helper(vf,offset);
if(ret)return(ret);
@@ -219,14 +218,14 @@
static ogg_int64_t _get_prev_page_serial(OggVorbis_File *vf,
ogg_uint32_t *serial_list, int serial_n,
int *serialno, ogg_int64_t *granpos){
- ogg_page og={0,0,0,0};
+ ogg_page og;
ogg_int64_t begin=vf->offset;
ogg_int64_t end=begin;
ogg_int64_t ret;
ogg_int64_t prefoffset=-1;
ogg_int64_t offset=-1;
- ogg_uint32_t ret_serialno=-1;
+ ogg_int64_t ret_serialno=-1;
ogg_int64_t ret_gran=-1;
while(offset==-1){
@@ -241,13 +240,11 @@
ret=_get_next_page(vf,&og,end-vf->offset);
if(ret==OV_EREAD)return(OV_EREAD);
if(ret<0){
- ogg_page_release(&og);
break;
}else{
ret_serialno=ogg_page_serialno(&og);
ret_gran=ogg_page_granulepos(&og);
offset=ret;
- ogg_page_release(&og);
if(ret_serialno == *serialno){
prefoffset=ret;
@@ -276,23 +273,18 @@
/* uses the local ogg_stream storage in vf; this is important for
non-streaming input sources */
-/* consumes the page that's passed in (if any) */
-
-static int _fetch_headers(OggVorbis_File *vf,
- vorbis_info *vi,
- vorbis_comment *vc,
- ogg_uint32_t **serialno_list,
- int *serialno_n,
- ogg_page *og_ptr){
- ogg_page og={0,0,0,0};
- ogg_packet op={0,0,0,0,0,0};
+static int _fetch_headers(OggVorbis_File *vf,vorbis_info *vi,vorbis_comment *vc,
+ ogg_uint32_t **serialno_list, int *serialno_n,
+ ogg_page *og_ptr){
+ ogg_page og;
+ ogg_packet op;
int i,ret;
int allbos=0;
-
+
if(!og_ptr){
ogg_int64_t llret=_get_next_page(vf,&og,CHUNKSIZE);
if(llret==OV_EREAD)return(OV_EREAD);
- if(llret<0)return OV_ENOTVORBIS;
+ if(llret<0)return(OV_ENOTVORBIS);
og_ptr=&og;
}
@@ -320,10 +312,10 @@
if(vf->ready_state<STREAMSET){
/* we don't have a vorbis stream in this link yet, so begin
prospective stream setup. We need a stream to get packets */
- ogg_stream_reset_serialno(vf->os,ogg_page_serialno(og_ptr));
- ogg_stream_pagein(vf->os,og_ptr);
+ ogg_stream_reset_serialno(&vf->os,ogg_page_serialno(og_ptr));
+ ogg_stream_pagein(&vf->os,og_ptr);
- if(ogg_stream_packetout(vf->os,&op) > 0 &&
+ if(ogg_stream_packetout(&vf->os,&op) > 0 &&
vorbis_synthesis_idheader(&op)){
/* vorbis header; continue setup */
vf->ready_state=STREAMSET;
@@ -348,8 +340,8 @@
/* if this page also belongs to our vorbis stream, submit it and break */
if(vf->ready_state==STREAMSET &&
- vf->os->serialno == ogg_page_serialno(og_ptr)){
- ogg_stream_pagein(vf->os,og_ptr);
+ vf->os.serialno == ogg_page_serialno(og_ptr)){
+ ogg_stream_pagein(&vf->os,og_ptr);
break;
}
}
@@ -367,7 +359,7 @@
while(i<2){ /* get a packet loop */
- int result=ogg_stream_packetout(vf->os,&op);
+ int result=ogg_stream_packetout(&vf->os,&op);
if(result==0)break;
if(result==-1){
ret=OV_EBADHEADER;
@@ -387,8 +379,8 @@
}
/* if this page belongs to the correct stream, go parse it */
- if(vf->os->serialno == ogg_page_serialno(og_ptr)){
- ogg_stream_pagein(vf->os,og_ptr);
+ if(vf->os.serialno == ogg_page_serialno(og_ptr)){
+ ogg_stream_pagein(&vf->os,og_ptr);
break;
}
@@ -406,15 +398,10 @@
}
}
- ogg_packet_release(&op);
- ogg_page_release(&og);
-
return 0;
}
bail_header:
- ogg_packet_release(&op);
- ogg_page_release(&og);
vorbis_info_clear(vi);
vorbis_comment_clear(vc);
vf->ready_state=OPENED;
@@ -427,25 +414,23 @@
audio, however this is only called during stream parsing upon
seekable open. */
static ogg_int64_t _initial_pcmoffset(OggVorbis_File *vf, vorbis_info *vi){
- ogg_page og={0,0,0,0};
- ogg_int64_t accumulated=0,pos;
+ ogg_page og;
+ ogg_int64_t accumulated=0;
long lastblock=-1;
int result;
- int serialno = vf->os->serialno;
+ int serialno = vf->os.serialno;
while(1){
- ogg_packet op={0,0,0,0,0,0};
-
+ ogg_packet op;
if(_get_next_page(vf,&og,-1)<0)
break; /* should not be possible unless the file is truncated/mangled */
if(ogg_page_bos(&og)) break;
if(ogg_page_serialno(&og)!=serialno) continue;
- pos=ogg_page_granulepos(&og);
/* count blocksizes of all frames in the page */
- ogg_stream_pagein(vf->os,&og);
- while((result=ogg_stream_packetout(vf->os,&op))){
+ ogg_stream_pagein(&vf->os,&og);
+ while((result=ogg_stream_packetout(&vf->os,&op))){
if(result>0){ /* ignore holes */
long thisblock=vorbis_packet_blocksize(vi,&op);
if(lastblock!=-1)
@@ -453,11 +438,10 @@
lastblock=thisblock;
}
}
- ogg_packet_release(&op);
- if(pos!=-1){
+ if(ogg_page_granulepos(&og)!=-1){
/* pcm offset of last packet on the first audio page */
- accumulated= pos-accumulated;
+ accumulated= ogg_page_granulepos(&og)-accumulated;
break;
}
}
@@ -466,32 +450,30 @@
the beginning, a normal occurrence; set the offset to zero */
if(accumulated<0)accumulated=0;
- ogg_page_release(&og);
return accumulated;
}
-
/* finds each bitstream link one at a time using a bisection search
(has to begin by knowing the offset of the lb's initial page).
Recurses for each link so it can alloc the link storage after
finding them all, then unroll and fill the cache at the same time */
static int _bisect_forward_serialno(OggVorbis_File *vf,
- ogg_int64_t begin,
- ogg_int64_t searched,
- ogg_int64_t end,
+ ogg_int64_t begin,
+ ogg_int64_t searched,
+ ogg_int64_t end,
ogg_int64_t endgran,
int endserial,
ogg_uint32_t *currentno_list,
int currentnos,
long m){
-
ogg_int64_t pcmoffset;
ogg_int64_t dataoffset=searched;
ogg_int64_t endsearched=end;
ogg_int64_t next=end;
ogg_int64_t searchgran=-1;
+ ogg_page og;
ogg_int64_t ret,last;
- int serialno = vf->os->serialno;
+ int serialno = vf->os.serialno;
/* invariants:
we have the headers and serialnos for the link beginning at 'begin'
@@ -538,7 +520,6 @@
/* the below guards against garbage seperating the last and
first pages of two links. */
while(searched<endsearched){
- ogg_page og={0,0,0,0};
ogg_int64_t bisect;
if(endsearched-searched<CHUNKSIZE){
@@ -547,8 +528,10 @@
bisect=(searched+endsearched)/2;
}
- ret=_seek_helper(vf,bisect);
- if(ret)return(ret);
+ if(bisect != vf->offset){
+ ret=_seek_helper(vf,bisect);
+ if(ret)return(ret);
+ }
last=_get_next_page(vf,&og,-1);
if(last==OV_EREAD)return(OV_EREAD);
@@ -556,9 +539,8 @@
endsearched=bisect;
if(last>=0)next=last;
}else{
- searched=last+og.header_len+og.body_len;
+ searched=vf->offset;
}
- ogg_page_release(&og);
}
/* Bisection point found */
@@ -580,7 +562,7 @@
ret=_fetch_headers(vf,&vi,&vc,&next_serialno_list,&next_serialnos,NULL);
if(ret)return(ret);
- serialno = vf->os->serialno;
+ serialno = vf->os.serialno;
dataoffset = vf->offset;
/* this will consume a page, however the next bistection always
@@ -627,8 +609,8 @@
static int _open_seekable2(OggVorbis_File *vf){
ogg_int64_t dataoffset=vf->dataoffsets[0],end,endgran=-1;
- int endserial=vf->os->serialno;
- int serialno=vf->os->serialno;
+ int endserial=vf->os.serialno;
+ int serialno=vf->os.serialno;
/* we're partially open and have a first link header state in
storage in vf */
@@ -666,7 +648,7 @@
return(ov_raw_seek(vf,dataoffset));
}
-/* clear out the current logical bitstream decoder */
+/* clear out the current logical bitstream decoder */
static void _decode_clear(OggVorbis_File *vf){
vorbis_dsp_clear(&vf->vd);
vorbis_block_clear(&vf->vb);
@@ -677,109 +659,104 @@
bitstream boundary and dumps the decoding machine. If the decoding
machine is unloaded, it loads it. It also keeps pcm_offset up to
date (seek and read both use this. seek uses a special hack with
- readp).
+ readp).
return: <0) error, OV_HOLE (lost packet) or OV_EOF
0) need more data (only if readp==0)
- 1) got a packet
+ 1) got a packet
*/
static int _fetch_and_process_packet(OggVorbis_File *vf,
- int readp,
- int spanp){
- ogg_page og={0,0,0,0};
- ogg_packet op={0,0,0,0,0,0};
- int ret=0;
+ ogg_packet *op_in,
+ int readp,
+ int spanp){
+ ogg_page og;
/* handle one packet. Try to fetch it from current stream state */
/* extract packets from page */
while(1){
-
+
if(vf->ready_state==STREAMSET){
- ret=_make_decode_ready(vf);
- if(ret<0) goto cleanup;
+ int ret=_make_decode_ready(vf);
+ if(ret<0)return ret;
}
/* process a packet if we can. If the machine isn't loaded,
neither is a page */
if(vf->ready_state==INITSET){
while(1) {
- int result=ogg_stream_packetout(vf->os,&op);
- ogg_int64_t granulepos;
+ ogg_packet op;
+ ogg_packet *op_ptr=(op_in?op_in:&op);
+ int result=ogg_stream_packetout(&vf->os,op_ptr);
+ ogg_int64_t granulepos;
- if(result==-1){
- ret=OV_HOLE; /* hole in the data. */
- goto cleanup;
- }
- if(result>0){
- /* got a packet. process it */
- granulepos=op.granulepos;
- if(!vorbis_synthesis(&vf->vb,&op)){ /* lazy check for lazy
- header handling. The
- header packets aren't
- audio, so if/when we
- submit them,
- vorbis_synthesis will
- reject them */
+ op_in=NULL;
+ if(result==-1)return(OV_HOLE); /* hole in the data. */
+ if(result>0){
+ /* got a packet. process it */
+ granulepos=op_ptr->granulepos;
+ if(!vorbis_synthesis(&vf->vb,op_ptr)){ /* lazy check for lazy
+ header handling. The
+ header packets aren't
+ audio, so if/when we
+ submit them,
+ vorbis_synthesis will
+ reject them */
- /* suck in the synthesis data and track bitrate */
- {
- int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
- /* for proper use of libvorbis within libvorbisfile,
+ /* suck in the synthesis data and track bitrate */
+ {
+ int oldsamples=vorbis_synthesis_pcmout(&vf->vd,NULL);
+ /* for proper use of libvorbis within libvorbisfile,
oldsamples will always be zero. */
- if(oldsamples){
- ret=OV_EFAULT;
- goto cleanup;
- }
+ if(oldsamples)return(OV_EFAULT);
- vorbis_synthesis_blockin(&vf->vd,&vf->vb);
- vf->samptrack+=vorbis_synthesis_pcmout(&vf->vd,NULL)-oldsamples;
- vf->bittrack+=op.bytes*8;
- }
-
- /* update the pcm offset. */
- if(granulepos!=-1 && !op.e_o_s){
- int link=(vf->seekable?vf->current_link:0);
- int i,samples;
-
- /* this packet has a pcm_offset on it (the last packet
- completed on a page carries the offset) After processing
- (above), we know the pcm position of the *last* sample
- ready to be returned. Find the offset of the *first*
+ vorbis_synthesis_blockin(&vf->vd,&vf->vb);
+ vf->samptrack+=vorbis_synthesis_pcmout(&vf->vd,NULL)-oldsamples;
+ vf->bittrack+=op_ptr->bytes*8;
+ }
- As an aside, this trick is inaccurate if we begin
- reading anew right at the last page; the end-of-stream
- granulepos declares the last frame in the stream, and the
- last packet of the last page may be a partial frame.
- So, we need a previous granulepos from an in-sequence page
- to have a reference point. Thus the !op.e_o_s clause
- above */
+ /* update the pcm offset. */
+ if(granulepos!=-1 && !op_ptr->e_o_s){
+ int link=(vf->seekable?vf->current_link:0);
+ int i,samples;
- if(vf->seekable && link>0)
- granulepos-=vf->pcmlengths[link*2];
- if(granulepos<0)granulepos=0; /* actually, this
- shouldn't be possible
- here unless the stream
- is very broken */
+ /* this packet has a pcm_offset on it (the last packet
+ completed on a page carries the offset) After processing
+ (above), we know the pcm position of the *last* sample
+ ready to be returned. Find the offset of the *first*
- samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
-
- granulepos-=samples;
- for(i=0;i<link;i++)
- granulepos+=vf->pcmlengths[i*2+1];
- vf->pcm_offset=granulepos;
- }
- ret=1;
- goto cleanup;
- }
- }
- else
- break;
+ As an aside, this trick is inaccurate if we begin
+ reading anew right at the last page; the end-of-stream
+ granulepos declares the last frame in the stream, and the
+ last packet of the last page may be a partial frame.
+ So, we need a previous granulepos from an in-sequence page
+ to have a reference point. Thus the !op_ptr->e_o_s clause
+ above */
+
+ if(vf->seekable && link>0)
+ granulepos-=vf->pcmlengths[link*2];
+ if(granulepos<0)granulepos=0; /* actually, this
+ shouldn't be possible
+ here unless the stream
+ is very broken */
+
+ samples=vorbis_synthesis_pcmout(&vf->vd,NULL);
+
+ granulepos-=samples;
+ for(i=0;i<link;i++)
+ granulepos+=vf->pcmlengths[i*2+1];
+ vf->pcm_offset=granulepos;
+ }
+ return(1);
+ }
+ }
+ else
+ break;
}
}
if(vf->ready_state>=OPENED){
- ogg_int64_t lret;
+ ogg_int64_t ret;
while(1){
/* the loop is not strictly necessary, but there's no sense in
@@ -788,17 +765,13 @@
part of a different logical bitstream; keep reading until
we get one with the correct serialno */
- if(!readp){
- ret=0;
- goto cleanup;
+ if(!readp)return(0);
+ if((ret=_get_next_page(vf,&og,-1))<0){
+ return(OV_EOF); /* eof. leave unitialized */
}
- if((lret=_get_next_page(vf,&og,-1))<0){
- ret=OV_EOF; /* eof. leave unitialized */
- goto cleanup;
- }
- /* bitrate tracking; add the header's bytes here, the body bytes
- are done by packet above */
+ /* bitrate tracking; add the header's bytes here, the body bytes
+ are done by packet above */
vf->bittrack+=og.header_len*8;
if(vf->ready_state==INITSET){
@@ -810,10 +783,8 @@
if(ogg_page_bos(&og)){
/* boundary case */
- if(!spanp){
- ret=OV_EOF;
- goto cleanup;
- }
+ if(!spanp)
+ return(OV_EOF);
_decode_clear(vf);
@@ -827,12 +798,13 @@
continue; /* possibility #2 */
}
}
+
break;
}
}
/* Do we need to load a new machine before submitting the page? */
- /* This is different in the seekable and non-seekable cases.
+ /* This is different in the seekable and non-seekable cases.
In the seekable case, we already have all the header
information loaded and cached; we just initialize the machine
@@ -843,51 +815,48 @@
we're now nominally at the header of the next bitstream
*/
- if(vf->ready_state!=INITSET){
+ if(vf->ready_state!=INITSET){
int link;
if(vf->ready_state<STREAMSET){
- if(vf->seekable){
- long serialno=ogg_page_serialno(&og);
+ if(vf->seekable){
+ long serialno = ogg_page_serialno(&og);
- /* match the serialno to bitstream section. We use this rather than
- offset positions to avoid problems near logical bitstream
- boundaries */
+ /* match the serialno to bitstream section. We use this rather than
+ offset positions to avoid problems near logical bitstream
+ boundaries */
- for(link=0;link<vf->links;link++)
- if(vf->serialnos[link]==serialno)break;
+ for(link=0;link<vf->links;link++)
+ if(vf->serialnos[link]==serialno)break;
- if(link==vf->links) continue; /* not the desired Vorbis
- bitstream section; keep
- trying */
+ if(link==vf->links) continue; /* not the desired Vorbis
+ bitstream section; keep
+ trying */
vf->current_serialno=serialno;
- vf->current_link=link;
+ vf->current_link=link;
- ogg_stream_reset_serialno(vf->os,vf->current_serialno);
- vf->ready_state=STREAMSET;
+ ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
+ vf->ready_state=STREAMSET;
- }else{
- /* we're streaming */
- /* fetch the three header packets, build the info struct */
-
- int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);
- if(ret) goto cleanup;
- vf->current_serialno=vf->os->serialno;
- vf->current_link++;
- link=0;
- }
+ }else{
+ /* we're streaming */
+ /* fetch the three header packets, build the info struct */
+
+ int ret=_fetch_headers(vf,vf->vi,vf->vc,NULL,NULL,&og);
+ if(ret)return(ret);
+ vf->current_serialno=vf->os.serialno;
+ vf->current_link++;
+ link=0;
+ }
}
}
/* the buffered page is the data we want, and we're ready for it;
add it to the stream state */
- ogg_stream_pagein(vf->os,&og);
+ ogg_stream_pagein(&vf->os,&og);
+
}
- cleanup:
- ogg_packet_release(&op);
- ogg_page_release(&og);
- return ret;
}
/* if, eg, 64 bit stdio is configured by default, this will build with
@@ -897,9 +866,9 @@
return fseek(f,off,whence);
}
-static int _ov_open1(void *f,OggVorbis_File *vf,char *initial,
- long ibytes, ov_callbacks callbacks){
- int offsettest=(f?callbacks.seek_func(f,0,SEEK_CUR):-1);
+static int _ov_open1(void *f,OggVorbis_File *vf,const char *initial,
+ long ibytes, ov_callbacks callbacks){
+ int offsettest=((f && callbacks.seek_func)?callbacks.seek_func(f,0,SEEK_CUR):-1);
ogg_uint32_t *serialno_list=NULL;
int serialno_list_size=0;
int ret;
@@ -909,16 +878,16 @@
vf->callbacks = callbacks;
/* init the framing state */
- vf->oy=ogg_sync_create();
+ ogg_sync_init(&vf->oy);
/* perhaps some data was previously read into a buffer for testing
against other stream types. Allow initialization from this
previously read data (especially as we may be reading from a
non-seekable stream) */
if(initial){
- unsigned char *buffer=ogg_sync_bufferin(vf->oy,ibytes);
+ char *buffer=ogg_sync_buffer(&vf->oy,ibytes);
memcpy(buffer,initial,ibytes);
- ogg_sync_wrote(vf->oy,ibytes);
+ ogg_sync_wrote(&vf->oy,ibytes);
}
/* can we seek? Stevens suggests the seek test was portable */
@@ -929,7 +898,7 @@
vf->links=1;
vf->vi=_ogg_calloc(vf->links,sizeof(*vf->vi));
vf->vc=_ogg_calloc(vf->links,sizeof(*vf->vc));
- vf->os=ogg_stream_create(-1); /* fill in the serialno later */
+ ogg_stream_init(&vf->os,-1); /* fill in the serialno later */
/* Fetch all BOS pages, store the vorbis header and all seen serial
numbers, load subsequent vorbis setup headers */
@@ -949,7 +918,7 @@
vf->dataoffsets=_ogg_calloc(1,sizeof(*vf->dataoffsets));
vf->offsets[0]=0;
vf->dataoffsets[0]=vf->offset;
- vf->current_serialno=vf->os->serialno;
+ vf->current_serialno=vf->os.serialno;
vf->ready_state=PARTOPEN;
}
@@ -958,8 +927,8 @@
}
static int _ov_open2(OggVorbis_File *vf){
- if(vf->ready_state < OPENED)
- vf->ready_state=OPENED;
+ if(vf->ready_state != PARTOPEN) return OV_EINVAL;
+ vf->ready_state=OPENED;
if(vf->seekable){
int ret=_open_seekable2(vf);
if(ret){
@@ -967,7 +936,9 @@
ov_clear(vf);
}
return(ret);
- }
+ }else
+ vf->ready_state=STREAMSET;
+
return 0;
}
@@ -977,13 +948,13 @@
if(vf){
vorbis_block_clear(&vf->vb);
vorbis_dsp_clear(&vf->vd);
- ogg_stream_destroy(vf->os);
-
+ ogg_stream_clear(&vf->os);
+
if(vf->vi && vf->links){
int i;
for(i=0;i<vf->links;i++){
- vorbis_info_clear(vf->vi+i);
- vorbis_comment_clear(vf->vc+i);
+ vorbis_info_clear(vf->vi+i);
+ vorbis_comment_clear(vf->vc+i);
}
_ogg_free(vf->vi);
_ogg_free(vf->vc);
@@ -992,8 +963,7 @@
if(vf->pcmlengths)_ogg_free(vf->pcmlengths);
if(vf->serialnos)_ogg_free(vf->serialnos);
if(vf->offsets)_ogg_free(vf->offsets);
- ogg_sync_destroy(vf->oy);
-
+ ogg_sync_clear(&vf->oy);
if(vf->datasource && vf->callbacks.close_func)
(vf->callbacks.close_func)(vf->datasource);
memset(vf,0,sizeof(*vf));
@@ -1006,20 +976,20 @@
/* inspects the OggVorbis file and finds/documents all the logical
bitstreams contained in it. Tries to be tolerant of logical
- bitstream sections that are truncated/woogie.
+ bitstream sections that are truncated/woogie.
return: -1) error
0) OK
*/
-int ov_open_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
- ov_callbacks callbacks){
+int ov_open_callbacks(void *f,OggVorbis_File *vf,
+ const char *initial,long ibytes,ov_callbacks callbacks){
int ret=_ov_open1(f,vf,initial,ibytes,callbacks);
if(ret)return ret;
return _ov_open2(vf);
}
-int ov_open(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
+int ov_open(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
ov_callbacks callbacks = {
(size_t (*)(void *, size_t, size_t, void *)) fread,
(int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
@@ -1029,19 +999,30 @@
return ov_open_callbacks((void *)f, vf, initial, ibytes, callbacks);
}
-
+
+int ov_fopen(const char *path,OggVorbis_File *vf){
+ int ret;
+ FILE *f = fopen(path,"rb");
+ if(!f) return -1;
+
+ ret = ov_open(f,vf,NULL,0);
+ if(ret) fclose(f);
+ return ret;
+}
+
+
/* Only partially open the vorbis file; test for Vorbisness, and load
the headers for the first chain. Do not seek (although test for
seekability). Use ov_test_open to finish opening the file, else
ov_clear to close/free it. Same return codes as open. */
-int ov_test_callbacks(void *f,OggVorbis_File *vf,char *initial,long ibytes,
- ov_callbacks callbacks)
+int ov_test_callbacks(void *f,OggVorbis_File *vf,
+ const char *initial,long ibytes,ov_callbacks callbacks)
{
return _ov_open1(f,vf,initial,ibytes,callbacks);
}
-int ov_test(FILE *f,OggVorbis_File *vf,char *initial,long ibytes){
+int ov_test(FILE *f,OggVorbis_File *vf,const char *initial,long ibytes){
ov_callbacks callbacks = {
(size_t (*)(void *, size_t, size_t, void *)) fread,
(int (*)(void *, ogg_int64_t, int)) _fseek64_wrap,
@@ -1051,7 +1032,7 @@
return ov_test_callbacks((void *)f, vf, initial, ibytes, callbacks);
}
-
+
int ov_test_open(OggVorbis_File *vf){
if(vf->ready_state!=PARTOPEN)return(OV_EINVAL);
return _ov_open2(vf);
@@ -1097,16 +1078,16 @@
}else{
/* return nominal if set */
if(vf->vi[i].bitrate_nominal>0){
- return vf->vi[i].bitrate_nominal;
+ return vf->vi[i].bitrate_nominal;
}else{
- if(vf->vi[i].bitrate_upper>0){
- if(vf->vi[i].bitrate_lower>0){
- return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
- }else{
- return vf->vi[i].bitrate_upper;
- }
- }
- return(OV_FALSE);
+ if(vf->vi[i].bitrate_upper>0){
+ if(vf->vi[i].bitrate_lower>0){
+ return (vf->vi[i].bitrate_upper+vf->vi[i].bitrate_lower)/2;
+ }else{
+ return vf->vi[i].bitrate_upper;
+ }
+ }
+ return(OV_FALSE);
}
}
}
@@ -1114,7 +1095,7 @@
/* returns the actual bitrate since last call. returns -1 if no
additional data to offer since last call (or at beginning of stream),
- EINVAL if stream is only partially open
+ EINVAL if stream is only partially open
*/
long ov_bitrate_instant(OggVorbis_File *vf){
int link=(vf->seekable?vf->current_link:0);
@@ -1140,8 +1121,8 @@
/* returns: total raw (compressed) length of content if i==-1
raw (compressed) length of that logical bitstream for i==0 to n
- OV_EINVAL if the stream is not seekable (we can't know the length)
- or if stream is only partially open
+ OV_EINVAL if the stream is not seekable (we can't know the length)
+ or if stream is only partially open
*/
ogg_int64_t ov_raw_total(OggVorbis_File *vf,int i){
if(vf->ready_state<OPENED)return(OV_EINVAL);
@@ -1158,9 +1139,9 @@
}
/* returns: total PCM length (samples) of content if i==-1 PCM length
- (samples) of that logical bitstream for i==0 to n
- OV_EINVAL if the stream is not seekable (we can't know the
- length) or only partially open
+ (samples) of that logical bitstream for i==0 to n
+ OV_EINVAL if the stream is not seekable (we can't know the
+ length) or only partially open
*/
ogg_int64_t ov_pcm_total(OggVorbis_File *vf,int i){
if(vf->ready_state<OPENED)return(OV_EINVAL);
@@ -1178,8 +1159,8 @@
/* returns: total milliseconds of content if i==-1
milliseconds in that logical bitstream for i==0 to n
- OV_EINVAL if the stream is not seekable (we can't know the
- length) or only partially open
+ OV_EINVAL if the stream is not seekable (we can't know the
+ length) or only partially open
*/
ogg_int64_t ov_time_total(OggVorbis_File *vf,int i){
if(vf->ready_state<OPENED)return(OV_EINVAL);
@@ -1203,9 +1184,7 @@
returns zero on success, nonzero on failure */
int ov_raw_seek(OggVorbis_File *vf,ogg_int64_t pos){
- ogg_stream_state *work_os=NULL;
- ogg_page og={0,0,0,0};
- ogg_packet op={0,0,0,0,0,0};
+ ogg_stream_state work_os;
int ret;
if(vf->ready_state<OPENED)return(OV_EINVAL);
@@ -1214,15 +1193,21 @@
if(pos<0 || pos>vf->end)return(OV_EINVAL);
+ /* is the seek position outside our current link [if any]? */
+ if(vf->ready_state>=STREAMSET){
+ if(pos<vf->offsets[vf->current_link] || pos>=vf->offsets[vf->current_link+1])
+ _decode_clear(vf); /* clear out stream state */
+ }
+
/* don't yet clear out decoding machine (if it's initialized), in
the case we're in the same link. Restart the decode lapping, and
let _fetch_and_process_packet deal with a potential bitstream
boundary */
vf->pcm_offset=-1;
- ogg_stream_reset_serialno(vf->os,
- vf->current_serialno); /* must set serialno */
+ ogg_stream_reset_serialno(&vf->os,
+ vf->current_serialno); /* must set serialno */
vorbis_synthesis_restart(&vf->vd);
-
+
ret=_seek_helper(vf,pos);
if(ret)goto seek_error;
@@ -1233,83 +1218,90 @@
So, a hack. We use two stream states; a local scratch state and
the shared vf->os stream state. We use the local state to
- scan, and the shared state as a buffer for later decode.
+ scan, and the shared state as a buffer for later decode.
Unfortuantely, on the last page we still advance to last packet
because the granulepos on the last page is not necessarily on a
packet boundary, and we need to make sure the granpos is
- correct.
+ correct.
*/
{
+ ogg_page og;
+ ogg_packet op;
int lastblock=0;
int accblock=0;
- int thisblock;
+ int thisblock=0;
int lastflag=0;
int firstflag=0;
ogg_int64_t pagepos=-1;
- work_os=ogg_stream_create(vf->current_serialno); /* get the memory ready */
+ ogg_stream_init(&work_os,vf->current_serialno); /* get the memory ready */
+ ogg_stream_reset(&work_os); /* eliminate the spurious OV_HOLE
+ return from not necessarily
+ starting from the beginning */
+
while(1){
if(vf->ready_state>=STREAMSET){
- /* snarf/scan a packet if we can */
- int result=ogg_stream_packetout(work_os,&op);
-
- if(result>0){
+ /* snarf/scan a packet if we can */
+ int result=ogg_stream_packetout(&work_os,&op);
- if(vf->vi[vf->current_link].codec_setup){
- thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
- if(thisblock<0){
- ogg_stream_packetout(vf->os,NULL);
- thisblock=0;
- }else{
-
+ if(result>0){
+
+ if(vf->vi[vf->current_link].codec_setup){
+ thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
+ if(thisblock<0){
+ ogg_stream_packetout(&vf->os,NULL);
+ thisblock=0;
+ }else{
+
/* We can't get a guaranteed correct pcm position out of the
last page in a stream because it might have a 'short'
granpos, which can only be detected in the presence of a
- preceeding page. However, if the last page is also the first
+ preceding page. However, if the last page is also the first
page, the granpos rules of a first page take precedence. Not
only that, but for first==last, the EOS page must be treated
as if its a normal first page for the stream to open/play. */
if(lastflag && !firstflag)
- ogg_stream_packetout(vf->os,NULL);
- else
- if(lastblock)accblock+=(lastblock+thisblock)>>2;
- }
+ ogg_stream_packetout(&vf->os,NULL);
+ else
+ if(lastblock)accblock+=(lastblock+thisblock)>>2;
+ }
- if(op.granulepos!=-1){
- int i,link=vf->current_link;
- ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
- if(granulepos<0)granulepos=0;
-
- for(i=0;i<link;i++)
- granulepos+=vf->pcmlengths[i*2+1];
- vf->pcm_offset=granulepos-accblock;
+ if(op.granulepos!=-1){
+ int i,link=vf->current_link;
+ ogg_int64_t granulepos=op.granulepos-vf->pcmlengths[link*2];
+ if(granulepos<0)granulepos=0;
+
+ for(i=0;i<link;i++)
+ granulepos+=vf->pcmlengths[i*2+1];
+ vf->pcm_offset=granulepos-accblock;
if(vf->pcm_offset<0)vf->pcm_offset=0;
- break;
- }
- lastblock=thisblock;
- continue;
- }else
- ogg_stream_packetout(vf->os,NULL);
- }
+ break;
+ }
+ lastblock=thisblock;
+ continue;
+ }else
+ ogg_stream_packetout(&vf->os,NULL);
+ }
}
-
+
if(!lastblock){
pagepos=_get_next_page(vf,&og,-1);
if(pagepos<0){
- vf->pcm_offset=ov_pcm_total(vf,-1);
- break;
- }
+ vf->pcm_offset=ov_pcm_total(vf,-1);
+ break;
+ }
}else{
- /* huh? Bogus stream with packets but no granulepos */
- vf->pcm_offset=-1;
- break;
+ /* huh? Bogus stream with packets but no granulepos */
+ vf->pcm_offset=-1;
+ break;
}
-
+
/* has our decoding just traversed a bitstream boundary? */
if(vf->ready_state>=STREAMSET){
- if(vf->current_serialno!=ogg_page_serialno(&og)){
+ if(vf->current_serialno!=ogg_page_serialno(&og)){
+
/* two possibilities:
1) our decoding just traversed a bitstream boundary
2) another stream is multiplexed into this logical section? */
@@ -1317,53 +1309,45 @@
if(ogg_page_bos(&og)){
/* we traversed */
_decode_clear(vf); /* clear out stream state */
- ogg_stream_destroy(work_os);
+ ogg_stream_clear(&work_os);
} /* else, do nothing; next loop will scoop another page */
}
}
if(vf->ready_state<STREAMSET){
- int link;
+ int link;
long serialno = ogg_page_serialno(&og);
- for(link=0;link<vf->links;link++)
- if(vf->serialnos[link]==vf->current_serialno)break;
+ for(link=0;link<vf->links;link++)
+ if(vf->serialnos[link]==serialno)break;
if(link==vf->links) continue; /* not the desired Vorbis
bitstream section; keep
trying */
vf->current_link=link;
vf->current_serialno=serialno;
- ogg_stream_reset_serialno(vf->os,vf->current_serialno);
- ogg_stream_reset_serialno(work_os,vf->current_serialno);
- vf->ready_state=STREAMSET;
+ ogg_stream_reset_serialno(&vf->os,serialno);
+ ogg_stream_reset_serialno(&work_os,serialno);
+ vf->ready_state=STREAMSET;
firstflag=(pagepos<=vf->dataoffsets[link]);
}
-
- {
- ogg_page dup;
- ogg_page_dup(&dup,&og);
- lastflag=ogg_page_eos(&og);
- ogg_stream_pagein(vf->os,&og);
- ogg_stream_pagein(work_os,&dup);
- }
+
+ ogg_stream_pagein(&vf->os,&og);
+ ogg_stream_pagein(&work_os,&og);
+ lastflag=ogg_page_eos(&og);
+
}
}
- ogg_packet_release(&op);
- ogg_page_release(&og);
- ogg_stream_destroy(work_os);
+ ogg_stream_clear(&work_os);
vf->bittrack=0;
vf->samptrack=0;
return(0);
seek_error:
- ogg_packet_release(&op);
- ogg_page_release(&og);
-
/* dump the machine so we're in a known state */
vf->pcm_offset=-1;
- ogg_stream_destroy(work_os);
+ ogg_stream_clear(&work_os);
_decode_clear(vf);
return OV_EBADLINK;
}
@@ -1371,20 +1355,19 @@
/* Page granularity seek (faster than sample granularity because we
don't do the last bit of decode to find a specific sample).
- Seek to the last [granule marked] page preceeding the specified pos
+ Seek to the last [granule marked] page preceding the specified pos
location, such that decoding past the returned point will quickly
arrive at the requested position. */
int ov_pcm_seek_page(OggVorbis_File *vf,ogg_int64_t pos){
int link=-1;
ogg_int64_t result=0;
ogg_int64_t total=ov_pcm_total(vf,-1);
- ogg_page og={0,0,0,0};
- ogg_packet op={0,0,0,0,0,0};
if(vf->ready_state<OPENED)return(OV_EINVAL);
if(!vf->seekable)return(OV_ENOSEEK);
+
if(pos<0 || pos>total)return(OV_EINVAL);
-
+
/* which bitstream section does this pcm offset occur in? */
for(link=vf->links-1;link>=0;link--){
total-=vf->pcmlengths[link*2+1];
@@ -1392,7 +1375,7 @@
}
/* search within the logical bitstream for the page with the highest
- pcm_pos preceeding (or equal to) pos. There is a danger here;
+ pcm_pos preceding (or equal to) pos. There is a danger here;
missing pages or incorrect frame number information in the
bitstream could make our task impossible. Account for that (it
would be an error condition) */
@@ -1405,68 +1388,82 @@
ogg_int64_t endtime = vf->pcmlengths[link*2+1]+begintime;
ogg_int64_t target=pos-total+begintime;
ogg_int64_t best=begin;
-
+
+ ogg_page og;
while(begin<end){
ogg_int64_t bisect;
-
+
if(end-begin<CHUNKSIZE){
- bisect=begin;
+ bisect=begin;
}else{
- /* take a (pretty decent) guess. */
- bisect=begin +
- (target-begintime)*(end-begin)/(endtime-begintime) - CHUNKSIZE;
- if(bisect<=begin)
- bisect=begin+1;
+ /* take a (pretty decent) guess. */
+ bisect=begin +
+ (target-begintime)*(end-begin)/(endtime-begintime) - CHUNKSIZE;
+ if(bisect<begin+CHUNKSIZE)
+ bisect=begin;
}
-
- _seek_helper(vf,bisect);
-
+
+ if(bisect!=vf->offset){
+ result=_seek_helper(vf,bisect);
+ if(result) goto seek_error;
+ }
+
while(begin<end){
- result=_get_next_page(vf,&og,end-vf->offset);
- if(result==OV_EREAD) goto seek_error;
- if(result<0){
- if(bisect<=begin+1)
- end=begin; /* found it */
- else{
- if(bisect==0) goto seek_error;
- bisect-=CHUNKSIZE;
- if(bisect<=begin)bisect=begin+1;
- _seek_helper(vf,bisect);
- }
- }else{
- ogg_int64_t granulepos=ogg_page_granulepos(&og);
- if(granulepos==-1)continue;
- if(granulepos<target){
- best=result; /* raw offset of packet with granulepos */
- begin=vf->offset; /* raw offset of next page */
- begintime=granulepos;
-
- if(target-begintime>44100)break;
- bisect=begin; /* *not* begin + 1 */
- }else{
- if(bisect<=begin+1)
- end=begin; /* found it */
- else{
- if(end==vf->offset){ /* we're pretty close - we'd be stuck in */
- end=result;
- bisect-=CHUNKSIZE; /* an endless loop otherwise. */
- if(bisect<=begin)bisect=begin+1;
- _seek_helper(vf,bisect);
- }else{
- end=result;
- endtime=granulepos;
- break;
- }
- }
- }
- }
+ result=_get_next_page(vf,&og,end-vf->offset);
+ if(result==OV_EREAD) goto seek_error;
+ if(result<0){
+ if(bisect<=begin+1)
+ end=begin; /* found it */
+ else{
+ if(bisect==0) goto seek_error;
+ bisect-=CHUNKSIZE;
+ if(bisect<=begin)bisect=begin+1;
+ result=_seek_helper(vf,bisect);
+ if(result) goto seek_error;
+ }
+ }else{
+ ogg_int64_t granulepos;
+
+ if(ogg_page_serialno(&og)!=vf->serialnos[link])
+ continue;
+
+ granulepos=ogg_page_granulepos(&og);
+ if(granulepos==-1)continue;
+
+ if(granulepos<target){
+ best=result; /* raw offset of packet with granulepos */
+ begin=vf->offset; /* raw offset of next page */
+ begintime=granulepos;
+
+ if(target-begintime>44100)break;
+ bisect=begin; /* *not* begin + 1 */
+ }else{
+ if(bisect<=begin+1)
+ end=begin; /* found it */
+ else{
+ if(end==vf->offset){ /* we're pretty close - we'd be stuck in */
+ end=result;
+ bisect-=CHUNKSIZE; /* an endless loop otherwise. */
+ if(bisect<=begin)bisect=begin+1;
+ result=_seek_helper(vf,bisect);
+ if(result) goto seek_error;
+ }else{
+ end=bisect;
+ endtime=granulepos;
+ break;
+ }
+ }
+ }
+ }
}
}
/* found our page. seek to it, update pcm offset. Easier case than
- raw_seek, don't keep packets preceeding granulepos. */
+ raw_seek, don't keep packets preceding granulepos. */
{
-
+ ogg_page og;
+ ogg_packet op;
+
/* seek */
result=_seek_helper(vf,best);
vf->pcm_offset=-1;
@@ -1475,58 +1472,58 @@
if(result<0) goto seek_error;
if(link!=vf->current_link){
- /* Different link; dump entire decode machine */
- _decode_clear(vf);
-
- vf->current_link=link;
- vf->current_serialno=ogg_page_serialno(&og);
- vf->ready_state=STREAMSET;
-
+ /* Different link; dump entire decode machine */
+ _decode_clear(vf);
+
+ vf->current_link=link;
+ vf->current_serialno=vf->serialnos[link];
+ vf->ready_state=STREAMSET;
+
}else{
- vorbis_synthesis_restart(&vf->vd);
+ vorbis_synthesis_restart(&vf->vd);
}
- ogg_stream_reset_serialno(vf->os,vf->current_serialno);
- ogg_stream_pagein(vf->os,&og);
+ ogg_stream_reset_serialno(&vf->os,vf->current_serialno);
+ ogg_stream_pagein(&vf->os,&og);
/* pull out all but last packet; the one with granulepos */
while(1){
- result=ogg_stream_packetpeek(vf->os,&op);
- if(result==0){
- /* !!! the packet finishing this page originated on a
- preceeding page. Keep fetching previous pages until we
+ result=ogg_stream_packetpeek(&vf->os,&op);
+ if(result==0){
+ /* !!! the packet finishing this page originated on a
+ preceding page. Keep fetching previous pages until we
get one with a granulepos or without the 'continued' flag
set. Then just use raw_seek for simplicity. */
-
- result=_seek_helper(vf,best);
+
+ result=_seek_helper(vf,best);
if(result<0) goto seek_error;
- while(1){
- result=_get_prev_page(vf,&og);
- if(result<0) goto seek_error;
+ while(1){
+ result=_get_prev_page(vf,&og);
+ if(result<0) goto seek_error;
if(ogg_page_serialno(&og)==vf->current_serialno &&
(ogg_page_granulepos(&og)>-1 ||
!ogg_page_continued(&og))){
- return ov_raw_seek(vf,result);
- }
- vf->offset=result;
- }
- }
- if(result<0){
- result = OV_EBADPACKET;
- goto seek_error;
- }
- if(op.granulepos!=-1){
- vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
- if(vf->pcm_offset<0)vf->pcm_offset=0;
- vf->pcm_offset+=total;
- break;
- }else
- result=ogg_stream_packetout(vf->os,NULL);
+ return ov_raw_seek(vf,result);
+ }
+ vf->offset=result;
+ }
+ }
+ if(result<0){
+ result = OV_EBADPACKET;
+ goto seek_error;
+ }
+ if(op.granulepos!=-1){
+ vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
+ if(vf->pcm_offset<0)vf->pcm_offset=0;
+ vf->pcm_offset+=total;
+ break;
+ }else
+ result=ogg_stream_packetout(&vf->os,NULL);
}
}
}
-
+
/* verify result */
if(vf->pcm_offset>pos || pos>ov_pcm_total(vf,-1)){
result=OV_EFAULT;
@@ -1534,82 +1531,75 @@
}
vf->bittrack=0;
vf->samptrack=0;
-
- ogg_page_release(&og);
- ogg_packet_release(&op);
return(0);
-
- seek_error:
- ogg_page_release(&og);
- ogg_packet_release(&op);
-
+ seek_error:
/* dump machine so we're in a known state */
vf->pcm_offset=-1;
_decode_clear(vf);
return (int)result;
}
-/* seek to a sample offset relative to the decompressed pcm stream
+/* seek to a sample offset relative to the decompressed pcm stream
returns zero on success, nonzero on failure */
int ov_pcm_seek(OggVorbis_File *vf,ogg_int64_t pos){
- ogg_packet op={0,0,0,0,0,0};
- ogg_page og={0,0,0,0};
int thisblock,lastblock=0;
int ret=ov_pcm_seek_page(vf,pos);
if(ret<0)return(ret);
- _make_decode_ready(vf);
+ if((ret=_make_decode_ready(vf)))return ret;
/* discard leading packets we don't need for the lapping of the
position we want; don't decode them */
while(1){
+ ogg_packet op;
+ ogg_page og;
- int ret=ogg_stream_packetpeek(vf->os,&op);
+ int ret=ogg_stream_packetpeek(&vf->os,&op);
if(ret>0){
thisblock=vorbis_packet_blocksize(vf->vi+vf->current_link,&op);
if(thisblock<0){
- ogg_stream_packetout(vf->os,NULL);
- continue; /* non audio packet */
+ ogg_stream_packetout(&vf->os,NULL);
+ continue; /* non audio packet */
}
if(lastblock)vf->pcm_offset+=(lastblock+thisblock)>>2;
-
+
if(vf->pcm_offset+((thisblock+
- vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
-
+ vorbis_info_blocksize(vf->vi,1))>>2)>=pos)break;
+
/* remove the packet from packet queue and track its granulepos */
- ogg_stream_packetout(vf->os,NULL);
+ ogg_stream_packetout(&vf->os,NULL);
vorbis_synthesis_trackonly(&vf->vb,&op); /* set up a vb with
only tracking, no
pcm_decode */
- vorbis_synthesis_blockin(&vf->vd,&vf->vb);
-
+ vorbis_synthesis_blockin(&vf->vd,&vf->vb);
+
/* end of logical stream case is hard, especially with exact
- length positioning. */
-
+ length positioning. */
+
if(op.granulepos>-1){
- int i;
- /* always believe the stream markers */
- vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
- if(vf->pcm_offset<0)vf->pcm_offset=0;
- for(i=0;i<vf->current_link;i++)
- vf->pcm_offset+=vf->pcmlengths[i*2+1];
+ int i;
+ /* always believe the stream markers */
+ vf->pcm_offset=op.granulepos-vf->pcmlengths[vf->current_link*2];
+ if(vf->pcm_offset<0)vf->pcm_offset=0;
+ for(i=0;i<vf->current_link;i++)
+ vf->pcm_offset+=vf->pcmlengths[i*2+1];
}
-
+
lastblock=thisblock;
-
+
}else{
if(ret<0 && ret!=OV_HOLE)break;
-
+
/* suck in a new page */
if(_get_next_page(vf,&og,-1)<0)break;
if(ogg_page_bos(&og))_decode_clear(vf);
-
+
if(vf->ready_state<STREAMSET){
- long serialno=ogg_page_serialno(&og);
- int link;
-
+ long serialno=ogg_page_serialno(&og);
+ int link;
+
for(link=0;link<vf->links;link++)
if(vf->serialnos[link]==serialno)break;
if(link==vf->links) continue;
@@ -1617,17 +1607,13 @@
vf->ready_state=STREAMSET;
vf->current_serialno=ogg_page_serialno(&og);
- ogg_stream_reset_serialno(vf->os,serialno);
+ ogg_stream_reset_serialno(&vf->os,serialno);
ret=_make_decode_ready(vf);
- if(ret){
- ogg_page_release(&og);
- ogg_packet_release(&op);
- return ret;
- }
+ if(ret)return ret;
lastblock=0;
}
- ogg_stream_pagein(vf->os,&og);
+ ogg_stream_pagein(&vf->os,&og);
}
}
@@ -1642,18 +1628,15 @@
if(samples>target)samples=target;
vorbis_synthesis_read(&vf->vd,samples);
vf->pcm_offset+=samples;
-
+
if(samples<target)
- if(_fetch_and_process_packet(vf,1,1)<=0)
- vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
+ if(_fetch_and_process_packet(vf,NULL,1,1)<=0)
+ vf->pcm_offset=ov_pcm_total(vf,-1); /* eof */
}
-
- ogg_page_release(&og);
- ogg_packet_release(&op);
return 0;
}
-/* seek to a playback time relative to the decompressed pcm stream
+/* seek to a playback time relative to the decompressed pcm stream
returns zero on success, nonzero on failure */
int ov_time_seek(OggVorbis_File *vf,ogg_int64_t milliseconds){
/* translate time to PCM position and call ov_pcm_seek */
@@ -1665,7 +1648,7 @@
if(vf->ready_state<OPENED)return(OV_EINVAL);
if(!vf->seekable)return(OV_ENOSEEK);
if(milliseconds<0)return(OV_EINVAL);
-
+
/* which bitstream section does this time offset occur in? */
for(link=0;link<vf->links;link++){
ogg_int64_t addsec = ov_time_total(vf,link);
@@ -1695,7 +1678,7 @@
if(vf->ready_state<OPENED)return(OV_EINVAL);
if(!vf->seekable)return(OV_ENOSEEK);
if(milliseconds<0)return(OV_EINVAL);
-
+
/* which bitstream section does this time offset occur in? */
for(link=0;link<vf->links;link++){
ogg_int64_t addsec = ov_time_total(vf,link);
@@ -1731,12 +1714,12 @@
int link=0;
ogg_int64_t pcm_total=0;
ogg_int64_t time_total=0;
-
+
if(vf->ready_state<OPENED)return(OV_EINVAL);
if(vf->seekable){
pcm_total=ov_pcm_total(vf,-1);
time_total=ov_time_total(vf,-1);
-
+
/* which bitstream section does this time offset occur in? */
for(link=vf->links-1;link>=0;link--){
pcm_total-=vf->pcmlengths[link*2+1];
@@ -1751,7 +1734,7 @@
/* link: -1) return the vorbis_info struct for the bitstream section
currently being decoded
0-n) to request information for a specific bitstream section
-
+
In the case of a non-seekable bitstream, any call returns the
current bitstream. NULL in the case that the machine is not
initialized */
@@ -1760,31 +1743,32 @@
if(vf->seekable){
if(link<0)
if(vf->ready_state>=STREAMSET)
- return vf->vi+vf->current_link;
+ return vf->vi+vf->current_link;
else
return vf->vi;
else
if(link>=vf->links)
- return NULL;
+ return NULL;
else
- return vf->vi+link;
+ return vf->vi+link;
}else{
return vf->vi;
}
}
+/* grr, strong typing, grr, no templates/inheritence, grr */
vorbis_comment *ov_comment(OggVorbis_File *vf,int link){
if(vf->seekable){
if(link<0)
if(vf->ready_state>=STREAMSET)
- return vf->vc+vf->current_link;
+ return vf->vc+vf->current_link;
else
- return vf->vc;
+ return vf->vc;
else
if(link>=vf->links)
- return NULL;
+ return NULL;
else
- return vf->vc+link;
+ return vf->vc+link;
}else{
return vf->vc;
}
@@ -1806,16 +1790,16 @@
functions above are aware of this dichotomy).
input values: buffer) a buffer to hold packed PCM data for return
- length) the byte length requested to be placed into buffer
+ bytes_req) the byte length requested to be placed into buffer
return values: <0) error/hole in data (OV_HOLE), partial open (OV_EINVAL)
0) EOF
- n) number of bytes of PCM actually returned. The
- below works on a packet-by-packet basis, so the
- return length is not related to the 'length' passed
- in, just guaranteed to fit.
+ n) number of bytes of PCM actually returned. The
+ below works on a packet-by-packet basis, so the
+ return length is not related to the 'length' passed
+ in, just guaranteed to fit.
- *section) set to the logical bitstream number */
+ *section) set to the logical bitstream number */
long ov_read(OggVorbis_File *vf,char *buffer,int bytes_req,int *bitstream){
int i,j;
@@ -1833,24 +1817,24 @@
/* suck in another packet */
{
- int ret=_fetch_and_process_packet(vf,1,1);
+ int ret=_fetch_and_process_packet(vf,NULL,1,1);
if(ret==OV_EOF)
- return(0);
+ return(0);
if(ret<=0)
- return(ret);
+ return(ret);
}
}
if(samples>0){
-
+
/* yay! proceed to pack data into the byte buffer */
-
+
long channels=ov_info(vf,-1)->channels;
if(samples>(bytes_req/(2*channels)))
- samples=bytes_req/(2*channels);
-
+ samples=bytes_req/(2*channels);
+
for(i=0;i<channels;i++) { /* It's faster in this order */
ogg_int32_t *src=pcm[i];
short *dest=((short *)buffer)+i;
@@ -1859,7 +1843,7 @@
dest+=channels;
}
}
-
+
vorbis_synthesis_read(&vf->vd,samples);
vf->pcm_offset+=samples;
if(bitstream)*bitstream=vf->current_link;
Modified: trunk/Tremor/window_lookup.h
===================================================================
--- trunk/Tremor/window_lookup.h 2010-08-31 18:51:40 UTC (rev 17374)
+++ trunk/Tremor/window_lookup.h 2010-08-31 19:10:31 UTC (rev 17375)
@@ -16,7 +16,7 @@
********************************************************************/
-#include "os_types.h"
+#include <ogg/os_types.h>
static LOOKUP_T vwin64[32] = {
X(0x001f0003), X(0x01168c98), X(0x030333c8), X(0x05dfe3a4),
More information about the commits
mailing list