Bug 468296 - Update libogg to SVN r16911. r=chris.double
authorMatthew Gregan <kinetik@flim.org>
Thu, 18 Mar 2010 15:23:19 +1300
changeset 39560 bf58973256dffebf36e122c2a01a05ba474d5171
parent 39559 06634ae6070ccb9acc54c4248b35d2cb5d44194c
child 39561 e93efbc87c8879f5cb643b29fb923ad82acfca3e
push id12265
push usermgregan@mozilla.com
push dateThu, 18 Mar 2010 03:01:38 +0000
treeherdermozilla-central@bf58973256df [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerschris.double
bugs468296
milestone1.9.3a4pre
Bug 468296 - Update libogg to SVN r16911. r=chris.double
media/libogg/CHANGES
media/libogg/README
media/libogg/README_MOZILLA
media/libogg/include/ogg/ogg.h
media/libogg/include/ogg/os_types.h
media/libogg/src/ogg_bitwise.c
media/libogg/src/ogg_framing.c
--- a/media/libogg/CHANGES
+++ b/media/libogg/CHANGES
@@ -1,8 +1,17 @@
+Version 1.1.4 (2009 June 24)
+
+* New async error reporting mechanism. Calls made after a fatal error are 
+  now safely handled in the event an error code is ignored
+* Added allocation checks useful to some embedded applications
+* fix possible read past end of buffer when reading 0 bits
+* Updates to API documentation
+* Build fixes
+
 Version 1.1.3 (2005 November 27)
 
  * Correct a bug in the granulepos field of pages where no packet ends
  * New VS2003 and XCode builds, minor fixes to other builds
  * documentation fixes and cleanup
  
 Version 1.1.2 (2004 September 23)
 
--- a/media/libogg/README
+++ b/media/libogg/README
@@ -18,23 +18,26 @@ codec) contain the codec libraries for u
 
 Directory:
 
 ./src  		The source for libogg, a BSD-license inplementation of 
 		the public domain Ogg bitstream format
 
 ./include       Library API headers and codebooks
 
-./debian        Rules/spec files for building Debian .deb packages
-
 ./doc           Ogg specification documents
 
 ./win32		Win32 projects and build automation
 
-./mac		MacOS 9 projects and build automation
+./macosx	MacOS X project and build files
+
+./macos		Classic MacOS 9 projects and build automation
+
+./debian        Rules/spec files for building Debian .deb packages
+		(may not be present, depending on your distribution)
 
 WHAT IS OGG?:
 
 Ogg project codecs use the Ogg bitstream format to arrange the raw,
 compressed bitstream into a more robust, useful form.  For example,
 the Ogg bitstream makes seeking, time stamping and error recovery
 possible, as well as mixing several sepearate, concurrent media
 streams into a single physical bitstream.
@@ -77,16 +80,43 @@ rpm -ta libogg-<version>.tar.gz
 
 BUILDING ON WIN32:
 
 Use the project file in the win32 directory.  It should compile out of the box.
 You can also run one of the batch files from the commandline.
 
 E.g.: build_ogg_dynamic
 
+CROSS COMPILING FROM LINUX TO WIN32:
+
+It is also possible to cross compile from Linux to windows using the MinGW
+cross tools and even to run the test suite under Wine, the Linux/*nix
+windows emulator.
+
+On Debian and Ubuntu systems, these cross compiler tools can be installed
+by doing:
+
+    sudo apt-get mingw32 mingw32-binutils mingw32-runtime wine
+
+Once these tools are installed its possible to compile and test by
+executing the following commands:
+
+    ./configure --host=i586-mingw32msvc --target=i586-mingw32msvc \
+         --build=i586-linux
+    make
+    make check
+
+The above has been tested with the following versions of the tools on
+Ubuntu's Hardy Heron release:
+
+    mingw32             4.2.1.dfsg-1ubuntu1
+    mingw32-binutils    2.17.50-20070129.1-1
+    mingw32-runtime     3.13-1
+    wine                0.9.59-0ubuntu4
+
 BUILDING ON MACOS 9:
 
 Ogg on MacOS 9 is built using CodeWarrior 5.3.  To build it, first
 open ogg/mac/libogg.mcp, switch to the "Targets" pane, select
 everything, and make the project.  In ogg/mac/Output you will now have
 both debug and final versions of Ogg shared libraries to link your
 projects against.
 
@@ -95,9 +125,9 @@ project for the ogg/include and ogg/mac/
 "interpret DOS and Unix paths" is turned on in your project; it can be
 found in the "access paths" pane in your project settings.  Now simply
 add the shared libraries you need to your project (OggLib at least)
 and #include "ogg/ogg.h" wherever you need to acces Ogg functionality.
 
 (Build instructions for Ogg codecs such as vorbis are similar and may
 be found in those source modules' README files)
 
-$Id: README 10478 2005-11-28 04:23:35Z giles $
+$Id: README 14726 2008-04-14 08:40:46Z erikd $
--- a/media/libogg/README_MOZILLA
+++ b/media/libogg/README_MOZILLA
@@ -1,8 +1,10 @@
-The source from this directory was copied from the libogg-1.1.3 source
-distribution using the update.sh script. The only changes made were
+The source from this directory was copied from the libogg subversion
+repository using the update.sh script. The only changes made were
 those applied by update.sh and the addition/upate of Makefile.in files
 for the Mozilla build system.
 
+The svn revision number used was r16911.
+
 The int-types.patch address a bug that config_types.h generated from
 Linux platform can't be used on OpenSolaris directly see Mozilla bug
 449754
--- a/media/libogg/include/ogg/ogg.h
+++ b/media/libogg/include/ogg/ogg.h
@@ -1,34 +1,40 @@
 /********************************************************************
  *                                                                  *
  * THIS FILE IS PART OF THE OggVorbis SOFTWARE 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 SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2007             *
  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
  function: toplevel libogg include
- last mod: $Id: ogg.h 7188 2004-07-20 07:26:04Z xiphmont $
+ last mod: $Id: ogg.h 16051 2009-05-27 05:00:06Z xiphmont $
 
  ********************************************************************/
 #ifndef _OGG_H
 #define _OGG_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#include <stddef.h>
 #include <ogg/os_types.h>
 
 typedef struct {
+  void *iov_base;
+  size_t iov_len;
+} ogg_iovec_t;
+
+typedef struct {
   long endbyte;
   int  endbit;
 
   unsigned char *buffer;
   unsigned char *ptr;
   long storage;
 } oggpack_buffer;
 
@@ -48,33 +54,33 @@ typedef struct {
   unsigned char   *body_data;    /* bytes from packet bodies */
   long    body_storage;          /* storage elements allocated */
   long    body_fill;             /* elements stored; fill mark */
   long    body_returned;         /* elements of fill returned */
 
 
   int     *lacing_vals;      /* The values that will go to the segment table */
   ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact
-				this way, but it is simple coupled to the
-				lacing fifo */
+                                this way, but it is simple coupled to the
+                                lacing fifo */
   long    lacing_storage;
   long    lacing_fill;
   long    lacing_packet;
   long    lacing_returned;
 
   unsigned char    header[282];      /* working space for header encode */
   int              header_fill;
 
   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
+  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;
 
 } ogg_stream_state;
 
@@ -83,38 +89,39 @@ typedef struct {
 
 typedef struct {
   unsigned char *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 */
+                                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 {
   unsigned char *data;
   int storage;
   int fill;
   int returned;
 
   int unsynced;
   int headerbytes;
   int bodybytes;
 } ogg_sync_state;
 
 /* Ogg BITSTREAM PRIMITIVES: bitstream ************************/
 
 extern void  oggpack_writeinit(oggpack_buffer *b);
+extern int   oggpack_writecheck(oggpack_buffer *b);
 extern void  oggpack_writetrunc(oggpack_buffer *b,long bits);
 extern void  oggpack_writealign(oggpack_buffer *b);
 extern void  oggpack_writecopy(oggpack_buffer *b,void *source,long bits);
 extern void  oggpack_reset(oggpack_buffer *b);
 extern void  oggpack_writeclear(oggpack_buffer *b);
 extern void  oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
 extern void  oggpack_write(oggpack_buffer *b,unsigned long value,int bits);
 extern long  oggpack_look(oggpack_buffer *b,int bits);
@@ -123,16 +130,17 @@ extern void  oggpack_adv(oggpack_buffer 
 extern void  oggpack_adv1(oggpack_buffer *b);
 extern long  oggpack_read(oggpack_buffer *b,int bits);
 extern long  oggpack_read1(oggpack_buffer *b);
 extern long  oggpack_bytes(oggpack_buffer *b);
 extern long  oggpack_bits(oggpack_buffer *b);
 extern unsigned char *oggpack_get_buffer(oggpack_buffer *b);
 
 extern void  oggpackB_writeinit(oggpack_buffer *b);
+extern int   oggpackB_writecheck(oggpack_buffer *b);
 extern void  oggpackB_writetrunc(oggpack_buffer *b,long bits);
 extern void  oggpackB_writealign(oggpack_buffer *b);
 extern void  oggpackB_writecopy(oggpack_buffer *b,void *source,long bits);
 extern void  oggpackB_reset(oggpack_buffer *b);
 extern void  oggpackB_writeclear(oggpack_buffer *b);
 extern void  oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes);
 extern void  oggpackB_write(oggpack_buffer *b,unsigned long value,int bits);
 extern long  oggpackB_look(oggpack_buffer *b,int bits);
@@ -143,60 +151,58 @@ extern long  oggpackB_read(oggpack_buffe
 extern long  oggpackB_read1(oggpack_buffer *b);
 extern long  oggpackB_bytes(oggpack_buffer *b);
 extern long  oggpackB_bits(oggpack_buffer *b);
 extern unsigned char *oggpackB_get_buffer(oggpack_buffer *b);
 
 /* Ogg BITSTREAM PRIMITIVES: encoding **************************/
 
 extern int      ogg_stream_packetin(ogg_stream_state *os, ogg_packet *op);
+extern int      ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov,
+                                   int count, long e_o_s, ogg_int64_t granulepos);
 extern int      ogg_stream_pageout(ogg_stream_state *os, ogg_page *og);
 extern int      ogg_stream_flush(ogg_stream_state *os, ogg_page *og);
 
 /* Ogg BITSTREAM PRIMITIVES: decoding **************************/
 
 extern int      ogg_sync_init(ogg_sync_state *oy);
 extern int      ogg_sync_clear(ogg_sync_state *oy);
 extern int      ogg_sync_reset(ogg_sync_state *oy);
-extern int	ogg_sync_destroy(ogg_sync_state *oy);
+extern int      ogg_sync_destroy(ogg_sync_state *oy);
+extern int      ogg_sync_check(ogg_sync_state *oy);
 
 extern char    *ogg_sync_buffer(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 int      ogg_stream_init(ogg_stream_state *os,int serialno);
 extern int      ogg_stream_clear(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_destroy(ogg_stream_state *os);
+extern int      ogg_stream_check(ogg_stream_state *os);
 extern int      ogg_stream_eos(ogg_stream_state *os);
 
 extern void     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 int      ogg_page_serialno(ogg_page *og);
-extern long     ogg_page_pageno(ogg_page *og);
-extern int      ogg_page_packets(ogg_page *og);
+extern int      ogg_page_version(const ogg_page *og);
+extern int      ogg_page_continued(const ogg_page *og);
+extern int      ogg_page_bos(const ogg_page *og);
+extern int      ogg_page_eos(const ogg_page *og);
+extern ogg_int64_t  ogg_page_granulepos(const ogg_page *og);
+extern int      ogg_page_serialno(const ogg_page *og);
+extern long     ogg_page_pageno(const ogg_page *og);
+extern int      ogg_page_packets(const ogg_page *og);
 
 extern void     ogg_packet_clear(ogg_packet *op);
 
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif  /* _OGG_H */
-
-
-
-
-
-
--- a/media/libogg/include/ogg/os_types.h
+++ b/media/libogg/include/ogg/os_types.h
@@ -6,45 +6,47 @@
  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
  *                                                                  *
  * THE OggVorbis 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.
- last mod: $Id: os_types.h 7524 2004-08-11 04:20:36Z conrad $
+ last mod: $Id: os_types.h 16649 2009-10-25 00:49:58Z ds $
 
  ********************************************************************/
 #ifndef _OS_TYPES_H
 #define _OS_TYPES_H
 
 /* 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
 
 #if defined(_WIN32) 
 
 #  if defined(__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;
-     typedef _G_uint16_t ogg_uint16_t;
+#    include <stdint.h>
+     typedef int16_t ogg_int16_t;
+     typedef uint16_t ogg_uint16_t;
+     typedef int32_t ogg_int32_t;
+     typedef uint32_t ogg_uint32_t;
+     typedef int64_t ogg_int64_t;
+     typedef uint64_t ogg_uint64_t;
 #  elif defined(__MINGW32__)
-     typedef short ogg_int16_t;                                                                             
-     typedef unsigned short ogg_uint16_t;                                                                   
-     typedef int ogg_int32_t;                                                                               
-     typedef unsigned int ogg_uint32_t;                                                                     
-     typedef long long ogg_int64_t;                                                                         
-     typedef unsigned long long ogg_uint64_t;  
+#    include <sys/types.h>
+     typedef short ogg_int16_t;
+     typedef unsigned short ogg_uint16_t;
+     typedef int ogg_int32_t;
+     typedef unsigned int ogg_uint32_t;
+     typedef long long ogg_int64_t;
+     typedef unsigned long long ogg_uint64_t;
 #  elif defined(__MWERKS__)
      typedef long long ogg_int64_t;
      typedef int ogg_int32_t;
      typedef unsigned int ogg_uint32_t;
      typedef short ogg_int16_t;
      typedef unsigned short ogg_uint16_t;
 #  else
      /* MSVC/Borland */
@@ -59,25 +61,35 @@
 
 #  include <sys/types.h>
    typedef SInt16 ogg_int16_t;
    typedef UInt16 ogg_uint16_t;
    typedef SInt32 ogg_int32_t;
    typedef UInt32 ogg_uint32_t;
    typedef SInt64 ogg_int64_t;
 
-#elif defined(__MACOSX__) /* MacOS X Framework build */
+#elif (defined(__APPLE__) && defined(__MACH__)) /* MacOS X Framework build */
 
 #  include <sys/types.h>
    typedef int16_t ogg_int16_t;
    typedef u_int16_t ogg_uint16_t;
    typedef int32_t ogg_int32_t;
    typedef u_int32_t ogg_uint32_t;
    typedef int64_t ogg_int64_t;
 
+#elif defined(__HAIKU__)
+
+  /* Haiku */
+#  include <sys/types.h>
+   typedef short ogg_int16_t;
+   typedef unsigned short ogg_uint16_t;
+   typedef int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long ogg_int64_t;
+
 #elif defined(__BEOS__)
 
    /* Be */
 #  include <inttypes.h>
    typedef int16_t ogg_int16_t;
    typedef u_int16_t ogg_uint16_t;
    typedef int32_t ogg_int32_t;
    typedef u_int32_t ogg_uint32_t;
@@ -112,16 +124,25 @@
 
    /* Symbian GCC */
    typedef signed short ogg_int16_t;
    typedef unsigned short ogg_uint16_t;
    typedef signed int ogg_int32_t;
    typedef unsigned int ogg_uint32_t;
    typedef long long int ogg_int64_t;
 
+#elif defined(__TMS320C6X__)
+
+   /* TI C64x compiler */
+   typedef signed short ogg_int16_t;
+   typedef unsigned short ogg_uint16_t;
+   typedef signed int ogg_int32_t;
+   typedef unsigned int ogg_uint32_t;
+   typedef long long int ogg_int64_t;
+
 #else
 
 #  include <sys/types.h>
 #  include <ogg/config_types.h>
 
 #endif
 
 #endif  /* _OS_TYPES_H */
--- a/media/libogg/src/ogg_bitwise.c
+++ b/media/libogg/src/ogg_bitwise.c
@@ -1,22 +1,22 @@
 /********************************************************************
  *                                                                  *
  * THIS FILE IS PART OF THE OggVorbis SOFTWARE 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 SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
   function: packing variable sized words into an octet stream
-  last mod: $Id: bitwise.c 7675 2004-09-01 00:34:39Z xiphmont $
+  last mod: $Id: bitwise.c 16051 2009-05-27 05:00:06Z xiphmont $
 
  ********************************************************************/
 
 /* 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>
@@ -42,93 +42,120 @@ void oggpack_writeinit(oggpack_buffer *b
   b->buffer[0]='\0';
   b->storage=BUFFER_INCREMENT;
 }
 
 void oggpackB_writeinit(oggpack_buffer *b){
   oggpack_writeinit(b);
 }
 
+int oggpack_writecheck(oggpack_buffer *b){
+  if(!b->ptr || !b->storage)return -1;
+  return 0;
+}
+
+int oggpackB_writecheck(oggpack_buffer *b){
+  return oggpack_writecheck(b);
+}
+
 void oggpack_writetrunc(oggpack_buffer *b,long bits){
   long bytes=bits>>3;
-  bits-=bytes*8;
-  b->ptr=b->buffer+bytes;
-  b->endbit=bits;
-  b->endbyte=bytes;
-  *b->ptr&=mask[bits];
+  if(b->ptr){
+    bits-=bytes*8;
+    b->ptr=b->buffer+bytes;
+    b->endbit=bits;
+    b->endbyte=bytes;
+    *b->ptr&=mask[bits];
+  }
 }
 
 void oggpackB_writetrunc(oggpack_buffer *b,long bits){
   long bytes=bits>>3;
-  bits-=bytes*8;
-  b->ptr=b->buffer+bytes;
-  b->endbit=bits;
-  b->endbyte=bytes;
-  *b->ptr&=mask8B[bits];
+  if(b->ptr){
+    bits-=bytes*8;
+    b->ptr=b->buffer+bytes;
+    b->endbit=bits;
+    b->endbyte=bytes;
+    *b->ptr&=mask8B[bits];
+  }
 }
 
 /* Takes only up to 32 bits. */
 void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
   if(b->endbyte+4>=b->storage){
-    b->buffer=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+    void *ret;
+    if(!b->ptr)return;
+    ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+    if(!ret){
+      oggpack_writeclear(b);
+      return;
+    }
+    b->buffer=ret;
     b->storage+=BUFFER_INCREMENT;
     b->ptr=b->buffer+b->endbyte;
   }
 
   value&=mask[bits]; 
   bits+=b->endbit;
 
   b->ptr[0]|=value<<b->endbit;  
   
   if(bits>=8){
     b->ptr[1]=(unsigned char)(value>>(8-b->endbit));
     if(bits>=16){
       b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
       if(bits>=24){
-	b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
-	if(bits>=32){
-	  if(b->endbit)
-	    b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
-	  else
-	    b->ptr[4]=0;
-	}
+        b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
+        if(bits>=32){
+          if(b->endbit)
+            b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
+          else
+            b->ptr[4]=0;
+        }
       }
     }
   }
 
   b->endbyte+=bits/8;
   b->ptr+=bits/8;
   b->endbit=bits&7;
 }
 
 /* Takes only up to 32 bits. */
 void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){
   if(b->endbyte+4>=b->storage){
-    b->buffer=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+    void *ret;
+    if(!b->ptr)return;
+    ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
+    if(!ret){
+      oggpack_writeclear(b);
+      return;
+    }
+    b->buffer=ret;
     b->storage+=BUFFER_INCREMENT;
     b->ptr=b->buffer+b->endbyte;
   }
 
   value=(value&mask[bits])<<(32-bits); 
   bits+=b->endbit;
 
   b->ptr[0]|=value>>(24+b->endbit);  
   
   if(bits>=8){
     b->ptr[1]=(unsigned char)(value>>(16+b->endbit));
     if(bits>=16){
       b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
       if(bits>=24){
-	b->ptr[3]=(unsigned char)(value>>(b->endbit));
-	if(bits>=32){
-	  if(b->endbit)
-	    b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
-	  else
-	    b->ptr[4]=0;
-	}
+        b->ptr[3]=(unsigned char)(value>>(b->endbit));
+        if(bits>=32){
+          if(b->endbit)
+            b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
+          else
+            b->ptr[4]=0;
+        }
       }
     }
   }
 
   b->endbyte+=bits/8;
   b->ptr+=bits/8;
   b->endbit=bits&7;
 }
@@ -141,37 +168,44 @@ void oggpack_writealign(oggpack_buffer *
 
 void oggpackB_writealign(oggpack_buffer *b){
   int bits=8-b->endbit;
   if(bits<8)
     oggpackB_write(b,0,bits);
 }
 
 static void oggpack_writecopy_helper(oggpack_buffer *b,
-				     void *source,
-				     long bits,
-				     void (*w)(oggpack_buffer *,
-					       unsigned long,
-					       int),
-				     int msb){
+                                     void *source,
+                                     long bits,
+                                     void (*w)(oggpack_buffer *,
+                                               unsigned long,
+                                               int),
+                                     int msb){
   unsigned char *ptr=(unsigned char *)source;
 
   long bytes=bits/8;
   bits-=bytes*8;
 
   if(b->endbit){
     int i;
     /* unaligned copy.  Do it the hard way. */
     for(i=0;i<bytes;i++)
       w(b,(unsigned long)(ptr[i]),8);    
   }else{
     /* aligned block copy */
     if(b->endbyte+bytes+1>=b->storage){
+      void *ret;
+      if(!b->ptr)return;
       b->storage=b->endbyte+bytes+BUFFER_INCREMENT;
-      b->buffer=_ogg_realloc(b->buffer,b->storage);
+      ret=_ogg_realloc(b->buffer,b->storage);
+      if(!ret){
+        oggpack_writeclear(b);
+        return;
+      }
+      b->buffer=ret;
       b->ptr=b->buffer+b->endbyte;
     }
 
     memmove(b->ptr,source,bytes);
     b->ptr+=bytes;
     b->endbyte+=bytes;
     *b->ptr=0;
 
@@ -188,27 +222,28 @@ void oggpack_writecopy(oggpack_buffer *b
   oggpack_writecopy_helper(b,source,bits,oggpack_write,0);
 }
 
 void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
   oggpack_writecopy_helper(b,source,bits,oggpackB_write,1);
 }
 
 void oggpack_reset(oggpack_buffer *b){
+  if(!b->ptr)return;
   b->ptr=b->buffer;
   b->buffer[0]=0;
   b->endbit=b->endbyte=0;
 }
 
 void oggpackB_reset(oggpack_buffer *b){
   oggpack_reset(b);
 }
 
 void oggpack_writeclear(oggpack_buffer *b){
-  _ogg_free(b->buffer);
+  if(b->buffer)_ogg_free(b->buffer);
   memset(b,0,sizeof(*b));
 }
 
 void oggpackB_writeclear(oggpack_buffer *b){
   oggpack_writeclear(b);
 }
 
 void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
@@ -234,19 +269,19 @@ long oggpack_look(oggpack_buffer *b,int 
   }
   
   ret=b->ptr[0]>>b->endbit;
   if(bits>8){
     ret|=b->ptr[1]<<(8-b->endbit);  
     if(bits>16){
       ret|=b->ptr[2]<<(16-b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(24-b->endbit);  
-	if(bits>32 && b->endbit)
-	  ret|=b->ptr[4]<<(32-b->endbit);
+        ret|=b->ptr[3]<<(24-b->endbit);  
+        if(bits>32 && b->endbit)
+          ret|=b->ptr[4]<<(32-b->endbit);
       }
     }
   }
   return(m&ret);
 }
 
 /* Read in bits without advancing the bitptr; bits <= 32 */
 long oggpackB_look(oggpack_buffer *b,int bits){
@@ -261,19 +296,19 @@ long oggpackB_look(oggpack_buffer *b,int
   }
   
   ret=b->ptr[0]<<(24+b->endbit);
   if(bits>8){
     ret|=b->ptr[1]<<(16+b->endbit);  
     if(bits>16){
       ret|=b->ptr[2]<<(8+b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(b->endbit);  
-	if(bits>32 && b->endbit)
-	  ret|=b->ptr[4]>>(8-b->endbit);
+        ret|=b->ptr[3]<<(b->endbit);  
+        if(bits>32 && b->endbit)
+          ret|=b->ptr[4]>>(8-b->endbit);
       }
     }
   }
   return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1);
 }
 
 long oggpack_look1(oggpack_buffer *b){
   if(b->endbyte>=b->storage)return(-1);
@@ -322,20 +357,20 @@ long oggpack_read(oggpack_buffer *b,int 
   }
   
   ret=b->ptr[0]>>b->endbit;
   if(bits>8){
     ret|=b->ptr[1]<<(8-b->endbit);  
     if(bits>16){
       ret|=b->ptr[2]<<(16-b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(24-b->endbit);  
-	if(bits>32 && b->endbit){
-	  ret|=b->ptr[4]<<(32-b->endbit);
-	}
+        ret|=b->ptr[3]<<(24-b->endbit);  
+        if(bits>32 && b->endbit){
+          ret|=b->ptr[4]<<(32-b->endbit);
+        }
       }
     }
   }
   ret&=m;
   
  overflow:
 
   b->ptr+=bits/8;
@@ -350,27 +385,30 @@ long oggpackB_read(oggpack_buffer *b,int
   long m=32-bits;
   
   bits+=b->endbit;
 
   if(b->endbyte+4>=b->storage){
     /* not the main path */
     ret=-1L;
     if(b->endbyte*8+bits>b->storage*8)goto overflow;
+    /* special case to avoid reading b->ptr[0], which might be past the end of
+        the buffer; also skips some useless accounting */
+    else if(!bits)return(0L);
   }
   
   ret=b->ptr[0]<<(24+b->endbit);
   if(bits>8){
     ret|=b->ptr[1]<<(16+b->endbit);  
     if(bits>16){
       ret|=b->ptr[2]<<(8+b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(b->endbit);  
-	if(bits>32 && b->endbit)
-	  ret|=b->ptr[4]>>(8-b->endbit);
+        ret|=b->ptr[3]<<(b->endbit);  
+        if(bits>32 && b->endbit)
+          ret|=b->ptr[4]>>(8-b->endbit);
       }
     }
   }
   ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1);
   
  overflow:
 
   b->ptr+=bits/8;
@@ -488,20 +526,20 @@ void cliptest(unsigned long *b,int vals,
   for(i=0;i<vals;i++){
     int tbit=bits?bits:ilog(b[i]);
     if(oggpack_look(&r,tbit)==-1)
       report("out of data!\n");
     if(oggpack_look(&r,tbit)!=(b[i]&mask[tbit]))
       report("looked at incorrect value!\n");
     if(tbit==1)
       if(oggpack_look1(&r)!=(b[i]&mask[tbit]))
-	report("looked at single bit incorrect value!\n");
+        report("looked at single bit incorrect value!\n");
     if(tbit==1){
       if(oggpack_read1(&r)!=(b[i]&mask[tbit]))
-	report("read incorrect single bit value!\n");
+        report("read incorrect single bit value!\n");
     }else{
     if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit]))
       report("read incorrect value!\n");
     }
   }
   if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
 }
 
@@ -523,20 +561,20 @@ void cliptestB(unsigned long *b,int vals
   for(i=0;i<vals;i++){
     int tbit=bits?bits:ilog(b[i]);
     if(oggpackB_look(&r,tbit)==-1)
       report("out of data!\n");
     if(oggpackB_look(&r,tbit)!=(b[i]&mask[tbit]))
       report("looked at incorrect value!\n");
     if(tbit==1)
       if(oggpackB_look1(&r)!=(b[i]&mask[tbit]))
-	report("looked at single bit incorrect value!\n");
+        report("looked at single bit incorrect value!\n");
     if(tbit==1){
       if(oggpackB_read1(&r)!=(b[i]&mask[tbit]))
-	report("read incorrect single bit value!\n");
+        report("read incorrect single bit value!\n");
     }else{
     if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit]))
       report("read incorrect value!\n");
     }
   }
   if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
 }
 
@@ -564,48 +602,48 @@ int main(void){
        1233432,534,5,2146435231,14436467,7869299,76326614,167548585,
        85525151,0,12321,1,2146528352};
 
   int onesize=33;
   static int one[33]={146,25,44,151,195,15,153,176,233,131,196,65,85,172,47,40,
                     34,242,223,136,35,222,211,86,171,50,225,135,214,75,172,
                     223,4};
   static int oneB[33]={150,101,131,33,203,15,204,216,105,193,156,65,84,85,222,
-		       8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
-		       245,251,128};
+                       8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
+                       245,251,128};
 
   int twosize=6;
   static int two[6]={61,255,255,251,231,29};
   static int twoB[6]={247,63,255,253,249,120};
 
   int threesize=54;
   static int three[54]={169,2,232,252,91,132,156,36,89,13,123,176,144,32,254,
                       142,224,85,59,121,144,79,124,23,67,90,90,216,79,23,83,
                       58,135,196,61,55,129,183,54,101,100,170,37,127,126,10,
                       100,52,4,14,18,86,77,1};
   static int threeB[54]={206,128,42,153,57,8,183,251,13,89,36,30,32,144,183,
-			 130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
-			 233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
-			 200,20,254,4,58,106,176,144,0};
+                         130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
+                         233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
+                         200,20,254,4,58,106,176,144,0};
 
   int foursize=38;
   static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72,
                      132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169,
                      28,2,133,0,1};
   static int fourB[38]={36,48,102,83,243,24,52,7,4,35,132,10,145,21,2,93,2,41,
-			1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
-			129,10,4,32};
+                        1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
+                        129,10,4,32};
 
   int fivesize=45;
   static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62,
                      241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169,
                      84,75,159,2,1,0,132,192,8,0,0,18,22};
   static int fiveB[45]={1,84,145,111,245,100,128,8,56,36,40,71,126,78,213,226,
-			124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
-			172,150,169,129,79,128,0,6,4,32,0,27,9,0};
+                        124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
+                        172,150,169,129,79,128,0,6,4,32,0,27,9,0};
 
   int sixsize=7;
   static int six[7]={17,177,170,242,169,19,148};
   static int sixB[7]={136,141,85,79,149,200,41};
 
   /* Test read/write together */
   /* Later we test against pregenerated bitstreams */
   oggpack_writeinit(&o);
@@ -628,17 +666,17 @@ int main(void){
     oggpack_write(&o,large[i],32);
   buffer=oggpack_get_buffer(&o);
   bytes=oggpack_bytes(&o);
   oggpack_readinit(&r,buffer,bytes);
   for(i=0;i<test2size;i++){
     if(oggpack_look(&r,32)==-1)report("out of data. failed!");
     if(oggpack_look(&r,32)!=large[i]){
       fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpack_look(&r,32),large[i],
-	      oggpack_look(&r,32),large[i]);
+              oggpack_look(&r,32),large[i]);
       report("read incorrect value!\n");
     }
     oggpack_adv(&r,32);
   }
   if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
   fprintf(stderr,"ok.");
 
   fprintf(stderr,"\nSmall unclipped packing (LSb): ");
@@ -714,17 +752,17 @@ int main(void){
     oggpackB_write(&o,large[i],32);
   buffer=oggpackB_get_buffer(&o);
   bytes=oggpackB_bytes(&o);
   oggpackB_readinit(&r,buffer,bytes);
   for(i=0;i<test2size;i++){
     if(oggpackB_look(&r,32)==-1)report("out of data. failed!");
     if(oggpackB_look(&r,32)!=large[i]){
       fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpackB_look(&r,32),large[i],
-	      oggpackB_look(&r,32),large[i]);
+              oggpackB_look(&r,32),large[i]);
       report("read incorrect value!\n");
     }
     oggpackB_adv(&r,32);
   }
   if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
   fprintf(stderr,"ok.");
 
   fprintf(stderr,"\nSmall unclipped packing (MSb): ");
--- a/media/libogg/src/ogg_framing.c
+++ b/media/libogg/src/ogg_framing.c
@@ -1,77 +1,77 @@
 /********************************************************************
  *                                                                  *
  * THIS FILE IS PART OF THE OggVorbis SOFTWARE 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 SOURCE CODE IS (C) COPYRIGHT 1994-2002             *
+ * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2009             *
  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  *                                                                  *
  ********************************************************************
 
- function: code raw [Vorbis] packets into framed OggSquish stream and
+ function: code raw packets into framed OggSquish stream and
            decode Ogg streams back into raw packets
- last mod: $Id: framing.c 9601 2005-07-23 00:19:14Z giles $
+ last mod: $Id: framing.c 16051 2009-05-27 05:00:06Z xiphmont $
 
  note: The CRC code is directly derived from public domain code by
  Ross Williams (ross@guest.adelaide.edu.au).  See docs/framing.html
  for details.
 
  ********************************************************************/
 
 #include <stdlib.h>
 #include <string.h>
 #include <ogg/ogg.h>
 
 /* A complete description of Ogg framing exists in docs/framing.html */
 
-int ogg_page_version(ogg_page *og){
+int ogg_page_version(const ogg_page *og){
   return((int)(og->header[4]));
 }
 
-int ogg_page_continued(ogg_page *og){
+int ogg_page_continued(const ogg_page *og){
   return((int)(og->header[5]&0x01));
 }
 
-int ogg_page_bos(ogg_page *og){
+int ogg_page_bos(const ogg_page *og){
   return((int)(og->header[5]&0x02));
 }
 
-int ogg_page_eos(ogg_page *og){
+int ogg_page_eos(const ogg_page *og){
   return((int)(og->header[5]&0x04));
 }
 
-ogg_int64_t ogg_page_granulepos(ogg_page *og){
+ogg_int64_t ogg_page_granulepos(const ogg_page *og){
   unsigned char *page=og->header;
   ogg_int64_t granulepos=page[13]&(0xff);
   granulepos= (granulepos<<8)|(page[12]&0xff);
   granulepos= (granulepos<<8)|(page[11]&0xff);
   granulepos= (granulepos<<8)|(page[10]&0xff);
   granulepos= (granulepos<<8)|(page[9]&0xff);
   granulepos= (granulepos<<8)|(page[8]&0xff);
   granulepos= (granulepos<<8)|(page[7]&0xff);
   granulepos= (granulepos<<8)|(page[6]&0xff);
   return(granulepos);
 }
 
-int ogg_page_serialno(ogg_page *og){
+int ogg_page_serialno(const ogg_page *og){
   return(og->header[14] |
-	 (og->header[15]<<8) |
-	 (og->header[16]<<16) |
-	 (og->header[17]<<24));
+         (og->header[15]<<8) |
+         (og->header[16]<<16) |
+         (og->header[17]<<24));
 }
  
-long ogg_page_pageno(ogg_page *og){
+long ogg_page_pageno(const ogg_page *og){
   return(og->header[18] |
-	 (og->header[19]<<8) |
-	 (og->header[20]<<16) |
-	 (og->header[21]<<24));
+         (og->header[19]<<8) |
+         (og->header[20]<<16) |
+         (og->header[21]<<24));
 }
 
 
 
 /* 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 */
 
@@ -83,17 +83,17 @@ packet begun (but not completed) on this
 
 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 ogg_page_packets(const ogg_page *og){
   int i,n=og->header[26],count=0;
   for(i=0;i<n;i++)
     if(og->header[27+i]<255)count++;
   return(count);
 }
 
 
 #if 0
@@ -103,19 +103,19 @@ int ogg_page_packets(ogg_page *og){
 static ogg_uint32_t _ogg_crc_entry(unsigned long index){
   int           i;
   unsigned long r;
 
   r = index << 24;
   for (i=0; i<8; i++)
     if (r & 0x80000000UL)
       r = (r << 1) ^ 0x04c11db7; /* The same as the ethernet generator
-				    polynomial, although we use an
-				    unreflected alg and an init/final
-				    of 0, not 0xffffffff */
+                                    polynomial, although we use an
+                                    unreflected alg and an init/final
+                                    of 0, not 0xffffffff */
     else
        r<<=1;
  return (r & 0xffffffffUL);
 }
 #endif
 
 static const ogg_uint32_t crc_lookup[256]={
   0x00000000,0x04c11db7,0x09823b6e,0x0d4326d9,
@@ -184,29 +184,40 @@ static const ogg_uint32_t crc_lookup[256
   0xbcb4666d,0xb8757bda,0xb5365d03,0xb1f740b4};
 
 /* init the encode/decode logical stream state */
 
 int ogg_stream_init(ogg_stream_state *os,int serialno){
   if(os){
     memset(os,0,sizeof(*os));
     os->body_storage=16*1024;
-    os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
+    os->lacing_storage=1024;
 
-    os->lacing_storage=1024;
+    os->body_data=_ogg_malloc(os->body_storage*sizeof(*os->body_data));
     os->lacing_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->lacing_vals));
     os->granule_vals=_ogg_malloc(os->lacing_storage*sizeof(*os->granule_vals));
 
+    if(!os->body_data || !os->lacing_vals || !os->granule_vals){
+      ogg_stream_clear(os);
+      return -1;
+    }
+
     os->serialno=serialno;
 
     return(0);
   }
   return(-1);
 } 
 
+/* async/delayed error detection for the ogg_stream_state */
+int ogg_stream_check(ogg_stream_state *os){
+  if(!os || !os->body_data) return -1;
+  return 0;
+}
+
 /* _clear does not free os, only the non-flat storage within */
 int ogg_stream_clear(ogg_stream_state *os){
   if(os){
     if(os->body_data)_ogg_free(os->body_data);
     if(os->lacing_vals)_ogg_free(os->lacing_vals);
     if(os->granule_vals)_ogg_free(os->granule_vals);
 
     memset(os,0,sizeof(*os));    
@@ -220,29 +231,51 @@ int ogg_stream_destroy(ogg_stream_state 
     _ogg_free(os);
   }
   return(0);
 } 
 
 /* Helpers for ogg_stream_encode; this keeps the structure and
    what's happening fairly clear */
 
-static void _os_body_expand(ogg_stream_state *os,int needed){
+static int _os_body_expand(ogg_stream_state *os,int needed){
   if(os->body_storage<=os->body_fill+needed){
+    void *ret;
+    ret=_ogg_realloc(os->body_data,(os->body_storage+needed+1024)*
+                     sizeof(*os->body_data));
+    if(!ret){
+      ogg_stream_clear(os);
+      return -1;
+    }
     os->body_storage+=(needed+1024);
-    os->body_data=_ogg_realloc(os->body_data,os->body_storage*sizeof(*os->body_data));
+    os->body_data=ret;
   }
+  return 0;
 }
 
-static void _os_lacing_expand(ogg_stream_state *os,int needed){
+static int _os_lacing_expand(ogg_stream_state *os,int needed){
   if(os->lacing_storage<=os->lacing_fill+needed){
+    void *ret;
+    ret=_ogg_realloc(os->lacing_vals,(os->lacing_storage+needed+32)*
+                     sizeof(*os->lacing_vals));
+    if(!ret){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    os->lacing_vals=ret;
+    ret=_ogg_realloc(os->granule_vals,(os->lacing_storage+needed+32)*
+                     sizeof(*os->granule_vals));
+    if(!ret){
+      ogg_stream_clear(os);
+      return -1;
+    }
+    os->granule_vals=ret;
     os->lacing_storage+=(needed+32);
-    os->lacing_vals=_ogg_realloc(os->lacing_vals,os->lacing_storage*sizeof(*os->lacing_vals));
-    os->granule_vals=_ogg_realloc(os->granule_vals,os->lacing_storage*sizeof(*os->granule_vals));
   }
+  return 0;
 }
 
 /* checksum the page */
 /* Direct table CRC; note that this will be faster in the future if we
    perform the checksum silmultaneously with other copies */
 
 void ogg_page_checksum_set(ogg_page *og){
   if(og){
@@ -263,64 +296,81 @@ void ogg_page_checksum_set(ogg_page *og)
     og->header[22]=(unsigned char)(crc_reg&0xff);
     og->header[23]=(unsigned char)((crc_reg>>8)&0xff);
     og->header[24]=(unsigned char)((crc_reg>>16)&0xff);
     og->header[25]=(unsigned char)((crc_reg>>24)&0xff);
   }
 }
 
 /* submit data to the internal buffer of the framing engine */
-int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
-  int lacing_vals=op->bytes/255+1,i;
+int ogg_stream_iovecin(ogg_stream_state *os, ogg_iovec_t *iov, int count,
+                       long e_o_s, ogg_int64_t granulepos){
+
+  int bytes = 0, lacing_vals, i;
+
+  if(ogg_stream_check(os)) return -1;
+  if(!iov) return 0;
+ 
+  for (i = 0; i < count; ++i) bytes += (int)iov[i].iov_len;
+  lacing_vals=bytes/255+1;
 
   if(os->body_returned){
     /* advance packet data according to the body_returned pointer. We
        had to keep it around to return a pointer into the buffer last
        call */
     
     os->body_fill-=os->body_returned;
     if(os->body_fill)
       memmove(os->body_data,os->body_data+os->body_returned,
-	      os->body_fill);
+              os->body_fill);
     os->body_returned=0;
   }
  
   /* make sure we have the buffer storage */
-  _os_body_expand(os,op->bytes);
-  _os_lacing_expand(os,lacing_vals);
+  if(_os_body_expand(os,bytes) || _os_lacing_expand(os,lacing_vals))
+    return -1;
 
   /* Copy in the submitted packet.  Yes, the copy is a waste; this is
      the liability of overly clean abstraction for the time being.  It
      will actually be fairly easy to eliminate the extra copy in the
      future */
 
-  memcpy(os->body_data+os->body_fill,op->packet,op->bytes);
-  os->body_fill+=op->bytes;
+  for (i = 0; i < count; ++i) {
+    memcpy(os->body_data+os->body_fill, iov[i].iov_base, iov[i].iov_len);
+    os->body_fill += (int)iov[i].iov_len;
+  }
 
   /* Store lacing vals for this packet */
   for(i=0;i<lacing_vals-1;i++){
     os->lacing_vals[os->lacing_fill+i]=255;
     os->granule_vals[os->lacing_fill+i]=os->granulepos;
   }
-  os->lacing_vals[os->lacing_fill+i]=(op->bytes)%255;
-  os->granulepos=os->granule_vals[os->lacing_fill+i]=op->granulepos;
+  os->lacing_vals[os->lacing_fill+i]=bytes%255;
+  os->granulepos=os->granule_vals[os->lacing_fill+i]=granulepos;
 
   /* flag the first segment as the beginning of the packet */
   os->lacing_vals[os->lacing_fill]|= 0x100;
 
   os->lacing_fill+=lacing_vals;
 
   /* for the sake of completeness */
   os->packetno++;
 
-  if(op->e_o_s)os->e_o_s=1;
+  if(e_o_s)os->e_o_s=1;
 
   return(0);
 }
 
+int ogg_stream_packetin(ogg_stream_state *os,ogg_packet *op){
+  ogg_iovec_t iov;
+  iov.iov_base = op->packet;
+  iov.iov_len = op->bytes;
+  return ogg_stream_iovecin(os, &iov, 1, op->e_o_s, op->granulepos);
+}
+
 /* This will flush remaining packets into a page (returning nonzero),
    even if there is not enough data to trigger a flush normally
    (undersized page). If there are no packets or partial packets to
    flush, ogg_stream_flush returns 0.  Note that ogg_stream_flush will
    try to flush a normal sized page like ogg_stream_pageout; a call to
    ogg_stream_flush does not guarantee that all packets have flushed.
    Only a return value of 0 from ogg_stream_flush indicates all packet
    data is flushed into pages.
@@ -333,29 +383,30 @@ int ogg_stream_packetin(ogg_stream_state
 int ogg_stream_flush(ogg_stream_state *os,ogg_page *og){
   int i;
   int vals=0;
   int maxvals=(os->lacing_fill>255?255:os->lacing_fill);
   int bytes=0;
   long acc=0;
   ogg_int64_t granule_pos=-1;
 
-  if(maxvals==0)return(0);
+  if(ogg_stream_check(os)) return 0;
+  if(maxvals==0)return 0;
   
   /* construct a page */
   /* decide how many segments to include */
   
   /* If this is the initial header case, the first page must only include
      the initial header packet */
   if(os->b_o_s==0){  /* 'initial header page' case */
     granule_pos=0;
     for(vals=0;vals<maxvals;vals++){
       if((os->lacing_vals[vals]&0x0ff)<255){
-	vals++;
-	break;
+        vals++;
+        break;
       }
     }
   }else{
     for(vals=0;vals<maxvals;vals++){
       if(acc>4096)break;
       acc+=os->lacing_vals[vals]&0x0ff;
       if((os->lacing_vals[vals]&0xff)<255)
         granule_pos=os->granule_vals[vals];
@@ -390,20 +441,20 @@ int ogg_stream_flush(ogg_stream_state *o
       os->header[i]=(unsigned char)(serialno&0xff);
       serialno>>=8;
     }
   }
 
   /* 32 bits of page counter (we have both counter and page header
      because this val can roll over) */
   if(os->pageno==-1)os->pageno=0; /* because someone called
-				     stream_reset; this would be a
-				     strange thing to do in an
-				     encode stream, but it has
-				     plausible uses */
+                                     stream_reset; this would be a
+                                     strange thing to do in an
+                                     encode stream, but it has
+                                     plausible uses */
   {
     long pageno=os->pageno++;
     for(i=18;i<22;i++){
       os->header[i]=(unsigned char)(pageno&0xff);
       pageno>>=8;
     }
   }
   
@@ -440,30 +491,32 @@ int ogg_stream_flush(ogg_stream_state *o
 }
 
 
 /* This constructs pages from buffered packet segments.  The pointers
 returned are to static buffers; do not free. The returned buffers are
 good only until the next call (using the same ogg_stream_state) */
 
 int ogg_stream_pageout(ogg_stream_state *os, ogg_page *og){
+  if(ogg_stream_check(os)) return 0;
 
   if((os->e_o_s&&os->lacing_fill) ||          /* 'were done, now flush' case */
      os->body_fill-os->body_returned > 4096 ||/* 'page nominal size' case */
      os->lacing_fill>=255 ||                  /* 'segment table full' case */
      (os->lacing_fill&&!os->b_o_s)){          /* 'initial header page' case */
         
     return(ogg_stream_flush(os,og));
   }
   
   /* not enough data to construct a page and not end of stream */
-  return(0);
+  return 0;
 }
 
 int ogg_stream_eos(ogg_stream_state *os){
+  if(ogg_stream_check(os)) return 1;
   return os->e_o_s;
 }
 
 /* DECODING PRIMITIVES: packet streaming layer **********************/
 
 /* This has two layers to place more of the multi-serialno and paging
    control in the application's hands.  First, we expose a data buffer
    using ogg_sync_buffer().  The app either copies into the
@@ -475,65 +528,79 @@ int ogg_stream_eos(ogg_stream_state *os)
    ogg_stream_pagein() along with the appropriate
    ogg_stream_state* (ie, matching serialno).  We then get raw
    packets out calling ogg_stream_packetout() with a
    ogg_stream_state. */
 
 /* initialize the struct to a known state */
 int ogg_sync_init(ogg_sync_state *oy){
   if(oy){
+    oy->storage = -1; /* used as a readiness flag */
     memset(oy,0,sizeof(*oy));
   }
   return(0);
 }
 
 /* clear non-flat storage within */
 int ogg_sync_clear(ogg_sync_state *oy){
   if(oy){
     if(oy->data)_ogg_free(oy->data);
-    ogg_sync_init(oy);
+    memset(oy,0,sizeof(*oy));
   }
   return(0);
 }
 
 int ogg_sync_destroy(ogg_sync_state *oy){
   if(oy){
     ogg_sync_clear(oy);
     _ogg_free(oy);
   }
   return(0);
 }
 
+int ogg_sync_check(ogg_sync_state *oy){
+  if(oy->storage<0) return -1;
+  return 0;
+}
+
 char *ogg_sync_buffer(ogg_sync_state *oy, long size){
+  if(ogg_sync_check(oy)) return NULL;
 
   /* first, clear out any space that has been previously returned */
   if(oy->returned){
     oy->fill-=oy->returned;
     if(oy->fill>0)
       memmove(oy->data,oy->data+oy->returned,oy->fill);
     oy->returned=0;
   }
 
   if(size>oy->storage-oy->fill){
     /* We need to extend the internal buffer */
     long newsize=size+oy->fill+4096; /* an extra page to be nice */
+    void *ret;
 
     if(oy->data)
-      oy->data=_ogg_realloc(oy->data,newsize);
+      ret=_ogg_realloc(oy->data,newsize);
     else
-      oy->data=_ogg_malloc(newsize);
+      ret=_ogg_malloc(newsize);
+    if(!ret){
+      ogg_sync_clear(oy);
+      return NULL;
+    }
+    oy->data=ret;
     oy->storage=newsize;
   }
 
   /* expose a segment at least as large as requested at the fill mark */
   return((char *)oy->data+oy->fill);
 }
 
 int ogg_sync_wrote(ogg_sync_state *oy, long bytes){
-  if(oy->fill+bytes>oy->storage)return(-1);
+  if(ogg_sync_check(oy))return -1;
+  if(oy->fill+bytes>oy->storage)return -1;
   oy->fill+=bytes;
   return(0);
 }
 
 /* sync the stream.  This is meant to be useful for finding page
    boundaries.
 
    return values for this:
@@ -542,16 +609,18 @@ int ogg_sync_wrote(ogg_sync_state *oy, l
    n) page synced at current location; page length n bytes
    
 */
 
 long ogg_sync_pageseek(ogg_sync_state *oy,ogg_page *og){
   unsigned char *page=oy->data+oy->returned;
   unsigned char *next;
   long bytes=oy->fill-oy->returned;
+
+  if(ogg_sync_check(oy))return 0;
   
   if(oy->headerbytes==0){
     int headerbytes,i;
     if(bytes<27)return(0); /* not enough for a header */
     
     /* verify capture pattern */
     if(memcmp(page,"OggS",4))goto sync_fail;
     
@@ -581,17 +650,17 @@ long ogg_sync_pageseek(ogg_sync_state *o
     log.header_len=oy->headerbytes;
     log.body=page+oy->headerbytes;
     log.body_len=oy->bodybytes;
     ogg_page_checksum_set(&log);
     
     /* Compare */
     if(memcmp(chksum,page+22,4)){
       /* D'oh.  Mismatch! Corrupt page (or miscapture and not a page
-	 at all) */
+         at all) */
       /* replace the computed checksum with the one actually read in */
       memcpy(page+22,chksum,4);
       
       /* Bad checksum. Lose sync */
       goto sync_fail;
     }
   }
   
@@ -619,33 +688,35 @@ long ogg_sync_pageseek(ogg_sync_state *o
   oy->headerbytes=0;
   oy->bodybytes=0;
   
   /* search for possible capture */
   next=memchr(page+1,'O',bytes-1);
   if(!next)
     next=oy->data+oy->fill;
 
-  oy->returned=next-oy->data;
-  return(-(next-page));
+  oy->returned=(int)(next-oy->data);
+  return((long)-(next-page));
 }
 
 /* sync the stream and get a page.  Keep trying until we find a page.
    Supress 'sync errors' after reporting the first.
 
    return values:
    -1) 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){
 
+  if(ogg_sync_check(oy))return 0;
+
   /* 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 */
 
   for(;;){
     long ret=ogg_sync_pageseek(oy,og);
     if(ret>0){
       /* have a page */
@@ -680,48 +751,50 @@ int ogg_stream_pagein(ogg_stream_state *
   int continued=ogg_page_continued(og);
   int bos=ogg_page_bos(og);
   int eos=ogg_page_eos(og);
   ogg_int64_t granulepos=ogg_page_granulepos(og);
   int serialno=ogg_page_serialno(og);
   long pageno=ogg_page_pageno(og);
   int segments=header[26];
   
+  if(ogg_stream_check(os)) return -1;
+
   /* clean up 'returned data' */
   {
     long lr=os->lacing_returned;
     long br=os->body_returned;
 
     /* body data */
     if(br){
       os->body_fill-=br;
       if(os->body_fill)
-	memmove(os->body_data,os->body_data+br,os->body_fill);
+        memmove(os->body_data,os->body_data+br,os->body_fill);
       os->body_returned=0;
     }
 
     if(lr){
       /* segment table */
       if(os->lacing_fill-lr){
-	memmove(os->lacing_vals,os->lacing_vals+lr,
-		(os->lacing_fill-lr)*sizeof(*os->lacing_vals));
-	memmove(os->granule_vals,os->granule_vals+lr,
-		(os->lacing_fill-lr)*sizeof(*os->granule_vals));
+        memmove(os->lacing_vals,os->lacing_vals+lr,
+                (os->lacing_fill-lr)*sizeof(*os->lacing_vals));
+        memmove(os->granule_vals,os->granule_vals+lr,
+                (os->lacing_fill-lr)*sizeof(*os->granule_vals));
       }
       os->lacing_fill-=lr;
       os->lacing_packet-=lr;
       os->lacing_returned=0;
     }
   }
 
   /* check the serial number */
   if(serialno!=os->serialno)return(-1);
   if(version>0)return(-1);
 
-  _os_lacing_expand(os,segments+1);
+  if(_os_lacing_expand(os,segments+1)) return -1;
 
   /* are we in sequence? */
   if(pageno!=os->pageno){
     int i;
 
     /* unroll previous partial packet (if any) */
     for(i=os->lacing_packet;i<os->lacing_fill;i++)
       os->body_fill-=os->lacing_vals[i]&0xff;
@@ -736,43 +809,43 @@ int ogg_stream_pagein(ogg_stream_state *
 
   /* are we a 'continued packet' page?  If so, we may need to skip
      some segments */
   if(continued){
     if(os->lacing_fill<1 || 
        os->lacing_vals[os->lacing_fill-1]==0x400){
       bos=0;
       for(;segptr<segments;segptr++){
-	int val=header[27+segptr];
-	body+=val;
-	bodysize-=val;
-	if(val<255){
-	  segptr++;
-	  break;
-	}
+        int val=header[27+segptr];
+        body+=val;
+        bodysize-=val;
+        if(val<255){
+          segptr++;
+          break;
+        }
       }
     }
   }
   
   if(bodysize){
-    _os_body_expand(os,bodysize);
+    if(_os_body_expand(os,bodysize)) return -1;
     memcpy(os->body_data+os->body_fill,body,bodysize);
     os->body_fill+=bodysize;
   }
 
   {
     int saved=-1;
     while(segptr<segments){
       int val=header[27+segptr];
       os->lacing_vals[os->lacing_fill]=val;
       os->granule_vals[os->lacing_fill]=-1;
       
       if(bos){
-	os->lacing_vals[os->lacing_fill]|=0x100;
-	bos=0;
+        os->lacing_vals[os->lacing_fill]|=0x100;
+        bos=0;
       }
       
       if(val<255)saved=os->lacing_fill;
       
       os->lacing_fill++;
       segptr++;
       
       if(val<255)os->lacing_packet=os->lacing_fill;
@@ -793,25 +866,29 @@ int ogg_stream_pagein(ogg_stream_state *
 
   os->pageno=pageno+1;
 
   return(0);
 }
 
 /* clear things to an initial state.  Good to call, eg, before seeking */
 int ogg_sync_reset(ogg_sync_state *oy){
+  if(ogg_sync_check(oy))return -1;
+
   oy->fill=0;
   oy->returned=0;
   oy->unsynced=0;
   oy->headerbytes=0;
   oy->bodybytes=0;
   return(0);
 }
 
 int ogg_stream_reset(ogg_stream_state *os){
+  if(ogg_stream_check(os)) return -1;
+
   os->body_fill=0;
   os->body_returned=0;
 
   os->lacing_fill=0;
   os->lacing_packet=0;
   os->lacing_returned=0;
 
   os->header_fill=0;
@@ -821,16 +898,17 @@ int ogg_stream_reset(ogg_stream_state *o
   os->pageno=-1;
   os->packetno=0;
   os->granulepos=0;
 
   return(0);
 }
 
 int ogg_stream_reset_serialno(ogg_stream_state *os,int serialno){
+  if(ogg_stream_check(os)) return -1;
   ogg_stream_reset(os);
   os->serialno=serialno;
   return(0);
 }
 
 static int _packetout(ogg_stream_state *os,ogg_packet *op,int adv){
 
   /* The last part of decode. We have the stream broken into packet
@@ -881,20 +959,22 @@ static int _packetout(ogg_stream_state *
       os->lacing_returned=ptr+1;
       os->packetno++;
     }
   }
   return(1);
 }
 
 int ogg_stream_packetout(ogg_stream_state *os,ogg_packet *op){
+  if(ogg_stream_check(os)) return 0;
   return _packetout(os,op,1);
 }
 
 int ogg_stream_packetpeek(ogg_stream_state *os,ogg_packet *op){
+  if(ogg_stream_check(os)) return 0;
   return _packetout(os,op,0);
 }
 
 void ogg_packet_clear(ogg_packet *op) {
   _ogg_free(op->packet);
   memset(op, 0, sizeof(*op));
 }
 
@@ -925,75 +1005,75 @@ void checkpacket(ogg_packet *op,int len,
   }else{
     sequence++;
     if(no>lastno+1)
       sequence++;
   }
   lastno=no;
   if(op->packetno!=sequence){
     fprintf(stderr,"incorrect packet sequence %ld != %d\n",
-	    (long)(op->packetno),sequence);
+            (long)(op->packetno),sequence);
     exit(1);
   }
 
   /* Test data */
   for(j=0;j<op->bytes;j++)
     if(op->packet[j]!=((j+no)&0xff)){
       fprintf(stderr,"body data mismatch (1) at pos %ld: %x!=%lx!\n\n",
-	      j,op->packet[j],(j+no)&0xff);
+              j,op->packet[j],(j+no)&0xff);
       exit(1);
     }
 }
 
 void check_page(unsigned char *data,const int *header,ogg_page *og){
   long j;
   /* Test data */
   for(j=0;j<og->body_len;j++)
     if(og->body[j]!=data[j]){
       fprintf(stderr,"body data mismatch (2) at pos %ld: %x!=%x!\n\n",
-	      j,data[j],og->body[j]);
+              j,data[j],og->body[j]);
       exit(1);
     }
 
   /* Test header */
   for(j=0;j<og->header_len;j++){
     if(og->header[j]!=header[j]){
       fprintf(stderr,"header content mismatch at pos %ld:\n",j);
       for(j=0;j<header[26]+27;j++)
-	fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
+        fprintf(stderr," (%ld)%02x:%02x",j,header[j],og->header[j]);
       fprintf(stderr,"\n");
       exit(1);
     }
   }
   if(og->header_len!=header[26]+27){
     fprintf(stderr,"header length incorrect! (%ld!=%d)\n",
-	    og->header_len,header[26]+27);
+            og->header_len,header[26]+27);
     exit(1);
   }
 }
 
 void print_header(ogg_page *og){
   int j;
   fprintf(stderr,"\nHEADER:\n");
   fprintf(stderr,"  capture: %c %c %c %c  version: %d  flags: %x\n",
-	  og->header[0],og->header[1],og->header[2],og->header[3],
-	  (int)og->header[4],(int)og->header[5]);
+          og->header[0],og->header[1],og->header[2],og->header[3],
+          (int)og->header[4],(int)og->header[5]);
 
   fprintf(stderr,"  granulepos: %d  serialno: %d  pageno: %ld\n",
-	  (og->header[9]<<24)|(og->header[8]<<16)|
-	  (og->header[7]<<8)|og->header[6],
-	  (og->header[17]<<24)|(og->header[16]<<16)|
-	  (og->header[15]<<8)|og->header[14],
-	  ((long)(og->header[21])<<24)|(og->header[20]<<16)|
-	  (og->header[19]<<8)|og->header[18]);
+          (og->header[9]<<24)|(og->header[8]<<16)|
+          (og->header[7]<<8)|og->header[6],
+          (og->header[17]<<24)|(og->header[16]<<16)|
+          (og->header[15]<<8)|og->header[14],
+          ((long)(og->header[21])<<24)|(og->header[20]<<16)|
+          (og->header[19]<<8)|og->header[18]);
 
   fprintf(stderr,"  checksum: %02x:%02x:%02x:%02x\n  segments: %d (",
-	  (int)og->header[22],(int)og->header[23],
-	  (int)og->header[24],(int)og->header[25],
-	  (int)og->header[26]);
+          (int)og->header[22],(int)og->header[23],
+          (int)og->header[24],(int)og->header[25],
+          (int)og->header[26]);
 
   for(j=27;j<og->header_len;j++)
     fprintf(stderr,"%d ",(int)og->header[j]);
   fprintf(stderr,")\n\n");
 }
 
 void copy_page(ogg_page *og){
   unsigned char *temp=_ogg_malloc(og->header_len);
@@ -1012,202 +1092,202 @@ void free_page(ogg_page *og){
 
 void error(void){
   fprintf(stderr,"error!\n");
   exit(1);
 }
 
 /* 17 only */
 const int head1_0[] = {0x4f,0x67,0x67,0x53,0,0x06,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0x15,0xed,0xec,0x91,
-		       1,
-		       17};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0x15,0xed,0xec,0x91,
+                       1,
+                       17};
 
 /* 17, 254, 255, 256, 500, 510, 600 byte, pad */
 const int head1_1[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0x59,0x10,0x6c,0x2c,
-		       1,
-		       17};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0x59,0x10,0x6c,0x2c,
+                       1,
+                       17};
 const int head2_1[] = {0x4f,0x67,0x67,0x53,0,0x04,
-		       0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0x89,0x33,0x85,0xce,
-		       13,
-		       254,255,0,255,1,255,245,255,255,0,
-		       255,255,90};
+                       0x07,0x18,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x89,0x33,0x85,0xce,
+                       13,
+                       254,255,0,255,1,255,245,255,255,0,
+                       255,255,90};
 
 /* nil packets; beginning,middle,end */
 const int head1_2[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0xff,0x7b,0x23,0x17,
-		       1,
-		       0};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
 const int head2_2[] = {0x4f,0x67,0x67,0x53,0,0x04,
-		       0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0x5c,0x3f,0x66,0xcb,
-		       17,
-		       17,254,255,0,0,255,1,0,255,245,255,255,0,
-		       255,255,90,0};
+                       0x07,0x28,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x5c,0x3f,0x66,0xcb,
+                       17,
+                       17,254,255,0,0,255,1,0,255,245,255,255,0,
+                       255,255,90,0};
 
 /* large initial packet */
 const int head1_3[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0x01,0x27,0x31,0xaa,
-		       18,
-		       255,255,255,255,255,255,255,255,
-		       255,255,255,255,255,255,255,255,255,10};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0x01,0x27,0x31,0xaa,
+                       18,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,255,10};
 
 const int head2_3[] = {0x4f,0x67,0x67,0x53,0,0x04,
-		       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0x7f,0x4e,0x8a,0xd2,
-		       4,
-		       255,4,255,0};
+                       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x7f,0x4e,0x8a,0xd2,
+                       4,
+                       255,4,255,0};
 
 
 /* continuing packet test */
 const int head1_4[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0xff,0x7b,0x23,0x17,
-		       1,
-		       0};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
 
 const int head2_4[] = {0x4f,0x67,0x67,0x53,0,0x00,
-		       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0x54,0x05,0x51,0xc8,
-		       17,
-		       255,255,255,255,255,255,255,255,
-		       255,255,255,255,255,255,255,255,255};
+                       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x54,0x05,0x51,0xc8,
+                       17,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,255};
 
 const int head3_4[] = {0x4f,0x67,0x67,0x53,0,0x05,
-		       0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,2,0,0,0,
-		       0xc8,0xc3,0xcb,0xed,
-		       5,
-		       10,255,4,255,0};
+                       0x07,0x0c,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0xc8,0xc3,0xcb,0xed,
+                       5,
+                       10,255,4,255,0};
 
 
 /* page with the 255 segment limit */
 const int head1_5[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0xff,0x7b,0x23,0x17,
-		       1,
-		       0};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
 
 const int head2_5[] = {0x4f,0x67,0x67,0x53,0,0x00,
-		       0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0xed,0x2a,0x2e,0xa7,
-		       255,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10,10,
-		       10,10,10,10,10,10,10};
+                       0x07,0xfc,0x03,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0xed,0x2a,0x2e,0xa7,
+                       255,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10,10,
+                       10,10,10,10,10,10,10};
 
 const int head3_5[] = {0x4f,0x67,0x67,0x53,0,0x04,
-		       0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,2,0,0,0,
-		       0x6c,0x3b,0x82,0x3d,
-		       1,
-		       50};
+                       0x07,0x00,0x04,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0x6c,0x3b,0x82,0x3d,
+                       1,
+                       50};
 
 
 /* packet that overspans over an entire page */
 const int head1_6[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0xff,0x7b,0x23,0x17,
-		       1,
-		       0};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
 
 const int head2_6[] = {0x4f,0x67,0x67,0x53,0,0x00,
-		       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0x3c,0xd9,0x4d,0x3f,
-		       17,
-		       100,255,255,255,255,255,255,255,255,
-		       255,255,255,255,255,255,255,255};
+                       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x3c,0xd9,0x4d,0x3f,
+                       17,
+                       100,255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255};
 
 const int head3_6[] = {0x4f,0x67,0x67,0x53,0,0x01,
-		       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
-		       0x01,0x02,0x03,0x04,2,0,0,0,
-		       0x01,0xd2,0xe5,0xe5,
-		       17,
-		       255,255,255,255,255,255,255,255,
-		       255,255,255,255,255,255,255,255,255};
+                       0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0x01,0xd2,0xe5,0xe5,
+                       17,
+                       255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255,255};
 
 const int head4_6[] = {0x4f,0x67,0x67,0x53,0,0x05,
-		       0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,3,0,0,0,
-		       0xef,0xdd,0x88,0xde,
-		       7,
-		       255,255,75,255,4,255,0};
+                       0x07,0x10,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,3,0,0,0,
+                       0xef,0xdd,0x88,0xde,
+                       7,
+                       255,255,75,255,4,255,0};
 
 /* packet that overspans over an entire page */
 const int head1_7[] = {0x4f,0x67,0x67,0x53,0,0x02,
-		       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,0,0,0,0,
-		       0xff,0x7b,0x23,0x17,
-		       1,
-		       0};
+                       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,0,0,0,0,
+                       0xff,0x7b,0x23,0x17,
+                       1,
+                       0};
 
 const int head2_7[] = {0x4f,0x67,0x67,0x53,0,0x00,
-		       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,1,0,0,0,
-		       0x3c,0xd9,0x4d,0x3f,
-		       17,
-		       100,255,255,255,255,255,255,255,255,
-		       255,255,255,255,255,255,255,255};
+                       0x07,0x04,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,1,0,0,0,
+                       0x3c,0xd9,0x4d,0x3f,
+                       17,
+                       100,255,255,255,255,255,255,255,255,
+                       255,255,255,255,255,255,255,255};
 
 const int head3_7[] = {0x4f,0x67,0x67,0x53,0,0x05,
-		       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
-		       0x01,0x02,0x03,0x04,2,0,0,0,
-		       0xd4,0xe0,0x60,0xe5,
-		       1,0};
+                       0x07,0x08,0x00,0x00,0x00,0x00,0x00,0x00,
+                       0x01,0x02,0x03,0x04,2,0,0,0,
+                       0xd4,0xe0,0x60,0xe5,
+                       1,0};
 
 void test_pack(const int *pl, const int **headers, int byteskip, 
-	       int pageskip, int packetskip){
+               int pageskip, int packetskip){
   unsigned char *data=_ogg_malloc(1024*1024); /* for scripted test cases only */
   long inptr=0;
   long outptr=0;
   long deptr=0;
   long depacket=0;
   long granule_pos=7,pageno=0;
   int i,j,packets,pageout=pageskip;
   int eosflag=0;
@@ -1241,119 +1321,119 @@ void test_pack(const int *pl, const int 
     /* submit the test packet */
     ogg_stream_packetin(&os_en,&op);
 
     /* retrieve any finished pages */
     {
       ogg_page og;
       
       while(ogg_stream_pageout(&os_en,&og)){
-	/* We have a page.  Check it carefully */
+        /* We have a page.  Check it carefully */
 
-	fprintf(stderr,"%ld, ",pageno);
+        fprintf(stderr,"%ld, ",pageno);
 
-	if(headers[pageno]==NULL){
-	  fprintf(stderr,"coded too many pages!\n");
-	  exit(1);
-	}
+        if(headers[pageno]==NULL){
+          fprintf(stderr,"coded too many pages!\n");
+          exit(1);
+        }
 
-	check_page(data+outptr,headers[pageno],&og);
+        check_page(data+outptr,headers[pageno],&og);
 
-	outptr+=og.body_len;
-	pageno++;
-	if(pageskip){
-	  bosflag=1;
-	  pageskip--;
-	  deptr+=og.body_len;
-	}
+        outptr+=og.body_len;
+        pageno++;
+        if(pageskip){
+          bosflag=1;
+          pageskip--;
+          deptr+=og.body_len;
+        }
 
-	/* have a complete page; submit it to sync/decode */
+        /* have a complete page; submit it to sync/decode */
 
-	{
-	  ogg_page og_de;
-	  ogg_packet op_de,op_de2;
-	  char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
-	  char *next=buf;
-	  byteskipcount+=og.header_len;
-	  if(byteskipcount>byteskip){
-	    memcpy(next,og.header,byteskipcount-byteskip);
-	    next+=byteskipcount-byteskip;
-	    byteskipcount=byteskip;
-	  }
+        {
+          ogg_page og_de;
+          ogg_packet op_de,op_de2;
+          char *buf=ogg_sync_buffer(&oy,og.header_len+og.body_len);
+          char *next=buf;
+          byteskipcount+=og.header_len;
+          if(byteskipcount>byteskip){
+            memcpy(next,og.header,byteskipcount-byteskip);
+            next+=byteskipcount-byteskip;
+            byteskipcount=byteskip;
+          }
 
-	  byteskipcount+=og.body_len;
-	  if(byteskipcount>byteskip){
-	    memcpy(next,og.body,byteskipcount-byteskip);
-	    next+=byteskipcount-byteskip;
-	    byteskipcount=byteskip;
-	  }
+          byteskipcount+=og.body_len;
+          if(byteskipcount>byteskip){
+            memcpy(next,og.body,byteskipcount-byteskip);
+            next+=byteskipcount-byteskip;
+            byteskipcount=byteskip;
+          }
 
-	  ogg_sync_wrote(&oy,next-buf);
+          ogg_sync_wrote(&oy,next-buf);
 
-	  while(1){
-	    int ret=ogg_sync_pageout(&oy,&og_de);
-	    if(ret==0)break;
-	    if(ret<0)continue;
-	    /* got a page.  Happy happy.  Verify that it's good. */
-	    
-	    fprintf(stderr,"(%ld), ",pageout);
+          while(1){
+            int ret=ogg_sync_pageout(&oy,&og_de);
+            if(ret==0)break;
+            if(ret<0)continue;
+            /* got a page.  Happy happy.  Verify that it's good. */
+            
+            fprintf(stderr,"(%ld), ",pageout);
 
-	    check_page(data+deptr,headers[pageout],&og_de);
-	    deptr+=og_de.body_len;
-	    pageout++;
+            check_page(data+deptr,headers[pageout],&og_de);
+            deptr+=og_de.body_len;
+            pageout++;
 
-	    /* submit it to deconstitution */
-	    ogg_stream_pagein(&os_de,&og_de);
+            /* submit it to deconstitution */
+            ogg_stream_pagein(&os_de,&og_de);
 
-	    /* packets out? */
-	    while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
-	      ogg_stream_packetpeek(&os_de,NULL);
-	      ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
-	      
-	      /* verify peek and out match */
-	      if(memcmp(&op_de,&op_de2,sizeof(op_de))){
-		fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
-			depacket);
-		exit(1);
-	      }
+            /* packets out? */
+            while(ogg_stream_packetpeek(&os_de,&op_de2)>0){
+              ogg_stream_packetpeek(&os_de,NULL);
+              ogg_stream_packetout(&os_de,&op_de); /* just catching them all */
+              
+              /* verify peek and out match */
+              if(memcmp(&op_de,&op_de2,sizeof(op_de))){
+                fprintf(stderr,"packetout != packetpeek! pos=%ld\n",
+                        depacket);
+                exit(1);
+              }
 
-	      /* verify the packet! */
-	      /* check data */
-	      if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
-		fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
-			depacket);
-		exit(1);
-	      }
-	      /* check bos flag */
-	      if(bosflag==0 && op_de.b_o_s==0){
-		fprintf(stderr,"b_o_s flag not set on packet!\n");
-		exit(1);
-	      }
-	      if(bosflag && op_de.b_o_s){
-		fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
-		exit(1);
-	      }
-	      bosflag=1;
-	      depacket+=op_de.bytes;
-	      
-	      /* check eos flag */
-	      if(eosflag){
-		fprintf(stderr,"Multiple decoded packets with eos flag!\n");
-		exit(1);
-	      }
+              /* verify the packet! */
+              /* check data */
+              if(memcmp(data+depacket,op_de.packet,op_de.bytes)){
+                fprintf(stderr,"packet data mismatch in decode! pos=%ld\n",
+                        depacket);
+                exit(1);
+              }
+              /* check bos flag */
+              if(bosflag==0 && op_de.b_o_s==0){
+                fprintf(stderr,"b_o_s flag not set on packet!\n");
+                exit(1);
+              }
+              if(bosflag && op_de.b_o_s){
+                fprintf(stderr,"b_o_s flag incorrectly set on packet!\n");
+                exit(1);
+              }
+              bosflag=1;
+              depacket+=op_de.bytes;
+              
+              /* check eos flag */
+              if(eosflag){
+                fprintf(stderr,"Multiple decoded packets with eos flag!\n");
+                exit(1);
+              }
 
-	      if(op_de.e_o_s)eosflag=1;
+              if(op_de.e_o_s)eosflag=1;
 
-	      /* check granulepos flag */
-	      if(op_de.granulepos!=-1){
-		fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
-	      }
-	    }
-	  }
-	}
+              /* check granulepos flag */
+              if(op_de.granulepos!=-1){
+                fprintf(stderr," granule:%ld ",(long)op_de.granulepos);
+              }
+            }
+          }
+        }
       }
     }
   }
   _ogg_free(data);
   if(headers[pageno]!=NULL){
     fprintf(stderr,"did not write last page!\n");
     exit(1);
   }
@@ -1433,47 +1513,47 @@ int main(void){
     fprintf(stderr,"testing single packet page span... ");
     test_pack(packets,headret,0,0,0);
   }
 
   /* page with the 255 segment limit */
   {
 
     const int packets[]={0,10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,10,
-		   10,10,10,10,10,10,10,50,-1};
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,10,
+                   10,10,10,10,10,10,10,50,-1};
     const int *headret[]={head1_5,head2_5,head3_5,NULL};
     
     fprintf(stderr,"testing max packet segments... ");
     test_pack(packets,headret,0,0,0);
   }
 
   {
     /* packet that overspans over an entire page */
@@ -1527,37 +1607,37 @@ int main(void){
       ogg_stream_packetin(&os_en,&op);
     }
 
     _ogg_free(data);
 
     /* retrieve finished pages */
     for(i=0;i<5;i++){
       if(ogg_stream_pageout(&os_en,&og[i])==0){
-	fprintf(stderr,"Too few pages output building sync tests!\n");
-	exit(1);
+        fprintf(stderr,"Too few pages output building sync tests!\n");
+        exit(1);
       }
       copy_page(&og[i]);
     }
 
     /* Test lost pages on pagein/packetout: no rollback */
     {
       ogg_page temp;
       ogg_packet test;
 
       fprintf(stderr,"Testing loss of pages... ");
 
       ogg_sync_reset(&oy);
       ogg_stream_reset(&os_de);
       for(i=0;i<5;i++){
-	memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
-	       og[i].header_len);
-	ogg_sync_wrote(&oy,og[i].header_len);
-	memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
-	ogg_sync_wrote(&oy,og[i].body_len);
+        memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
+               og[i].header_len);
+        ogg_sync_wrote(&oy,og[i].header_len);
+        memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
+        ogg_sync_wrote(&oy,og[i].body_len);
       }
 
       ogg_sync_pageout(&oy,&temp);
       ogg_stream_pagein(&os_de,&temp);
       ogg_sync_pageout(&oy,&temp);
       ogg_stream_pagein(&os_de,&temp);
       ogg_sync_pageout(&oy,&temp);
       /* skip */
@@ -1568,18 +1648,18 @@ int main(void){
       
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,0,0,0);
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,100,1,-1);
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,4079,2,3000);
       if(ogg_stream_packetout(&os_de,&test)!=-1){
-	fprintf(stderr,"Error: loss of page did not return error\n");
-	exit(1);
+        fprintf(stderr,"Error: loss of page did not return error\n");
+        exit(1);
       }
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,76,5,-1);
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,34,6,-1);
       fprintf(stderr,"ok.\n");
     }
 
@@ -1588,21 +1668,21 @@ int main(void){
       ogg_page temp;
       ogg_packet test;
 
       fprintf(stderr,"Testing loss of pages (rollback required)... ");
 
       ogg_sync_reset(&oy);
       ogg_stream_reset(&os_de);
       for(i=0;i<5;i++){
-	memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
-	       og[i].header_len);
-	ogg_sync_wrote(&oy,og[i].header_len);
-	memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
-	ogg_sync_wrote(&oy,og[i].body_len);
+        memcpy(ogg_sync_buffer(&oy,og[i].header_len),og[i].header,
+               og[i].header_len);
+        ogg_sync_wrote(&oy,og[i].header_len);
+        memcpy(ogg_sync_buffer(&oy,og[i].body_len),og[i].body,og[i].body_len);
+        ogg_sync_wrote(&oy,og[i].body_len);
       }
 
       ogg_sync_pageout(&oy,&temp);
       ogg_stream_pagein(&os_de,&temp);
       ogg_sync_pageout(&oy,&temp);
       ogg_stream_pagein(&os_de,&temp);
       ogg_sync_pageout(&oy,&temp);
       ogg_stream_pagein(&os_de,&temp);
@@ -1617,180 +1697,180 @@ int main(void){
       checkpacket(&test,0,0,0);
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,100,1,-1);
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,4079,2,3000);
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,2956,3,4000);
       if(ogg_stream_packetout(&os_de,&test)!=-1){
-	fprintf(stderr,"Error: loss of page did not return error\n");
-	exit(1);
+        fprintf(stderr,"Error: loss of page did not return error\n");
+        exit(1);
       }
       if(ogg_stream_packetout(&os_de,&test)!=1)error();
       checkpacket(&test,300,13,14000);
       fprintf(stderr,"ok.\n");
     }
     
     /* the rest only test sync */
     {
       ogg_page og_de;
       /* Test fractional page inputs: incomplete capture */
       fprintf(stderr,"Testing sync on partial inputs... ");
       ogg_sync_reset(&oy);
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
-	     3);
+             3);
       ogg_sync_wrote(&oy,3);
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       
       /* Test fractional page inputs: incomplete fixed header */
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+3,
-	     20);
+             20);
       ogg_sync_wrote(&oy,20);
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       
       /* Test fractional page inputs: incomplete header */
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+23,
-	     5);
+             5);
       ogg_sync_wrote(&oy,5);
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       
       /* Test fractional page inputs: incomplete body */
       
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+28,
-	     og[1].header_len-28);
+             og[1].header_len-28);
       ogg_sync_wrote(&oy,og[1].header_len-28);
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,1000);
       ogg_sync_wrote(&oy,1000);
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body+1000,
-	     og[1].body_len-1000);
+             og[1].body_len-1000);
       ogg_sync_wrote(&oy,og[1].body_len-1000);
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
       
       fprintf(stderr,"ok.\n");
     }
 
     /* Test fractional page inputs: page + incomplete capture */
     {
       ogg_page og_de;
       fprintf(stderr,"Testing sync on 1+partial inputs... ");
       ogg_sync_reset(&oy); 
 
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
-	     og[1].header_len);
+             og[1].header_len);
       ogg_sync_wrote(&oy,og[1].header_len);
 
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
-	     og[1].body_len);
+             og[1].body_len);
       ogg_sync_wrote(&oy,og[1].body_len);
 
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
-	     20);
+             20);
       ogg_sync_wrote(&oy,20);
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
 
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header+20,
-	     og[1].header_len-20);
+             og[1].header_len-20);
       ogg_sync_wrote(&oy,og[1].header_len-20);
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
-	     og[1].body_len);
+             og[1].body_len);
       ogg_sync_wrote(&oy,og[1].body_len);
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
 
       fprintf(stderr,"ok.\n");
     }
     
     /* Test recapture: garbage + page */
     {
       ogg_page og_de;
       fprintf(stderr,"Testing search for capture... ");
       ogg_sync_reset(&oy); 
       
       /* 'garbage' */
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
-	     og[1].body_len);
+             og[1].body_len);
       ogg_sync_wrote(&oy,og[1].body_len);
 
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
-	     og[1].header_len);
+             og[1].header_len);
       ogg_sync_wrote(&oy,og[1].header_len);
 
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
-	     og[1].body_len);
+             og[1].body_len);
       ogg_sync_wrote(&oy,og[1].body_len);
 
       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
-	     20);
+             20);
       ogg_sync_wrote(&oy,20);
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
 
       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header+20,
-	     og[2].header_len-20);
+             og[2].header_len-20);
       ogg_sync_wrote(&oy,og[2].header_len-20);
       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
-	     og[2].body_len);
+             og[2].body_len);
       ogg_sync_wrote(&oy,og[2].body_len);
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
 
       fprintf(stderr,"ok.\n");
     }
 
     /* Test recapture: page + garbage + page */
     {
       ogg_page og_de;
       fprintf(stderr,"Testing recapture... ");
       ogg_sync_reset(&oy); 
 
       memcpy(ogg_sync_buffer(&oy,og[1].header_len),og[1].header,
-	     og[1].header_len);
+             og[1].header_len);
       ogg_sync_wrote(&oy,og[1].header_len);
 
       memcpy(ogg_sync_buffer(&oy,og[1].body_len),og[1].body,
-	     og[1].body_len);
+             og[1].body_len);
       ogg_sync_wrote(&oy,og[1].body_len);
 
       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
-	     og[2].header_len);
+             og[2].header_len);
       ogg_sync_wrote(&oy,og[2].header_len);
 
       memcpy(ogg_sync_buffer(&oy,og[2].header_len),og[2].header,
-	     og[2].header_len);
+             og[2].header_len);
       ogg_sync_wrote(&oy,og[2].header_len);
 
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
 
       memcpy(ogg_sync_buffer(&oy,og[2].body_len),og[2].body,
-	     og[2].body_len-5);
+             og[2].body_len-5);
       ogg_sync_wrote(&oy,og[2].body_len-5);
 
       memcpy(ogg_sync_buffer(&oy,og[3].header_len),og[3].header,
-	     og[3].header_len);
+             og[3].header_len);
       ogg_sync_wrote(&oy,og[3].header_len);
 
       memcpy(ogg_sync_buffer(&oy,og[3].body_len),og[3].body,
-	     og[3].body_len);
+             og[3].body_len);
       ogg_sync_wrote(&oy,og[3].body_len);
 
       if(ogg_sync_pageout(&oy,&og_de)>0)error();
       if(ogg_sync_pageout(&oy,&og_de)<=0)error();
 
       fprintf(stderr,"ok.\n");
     }
 
     /* Free page data that was previously copied */
     {
       for(i=0;i<5;i++){
-	free_page(&og[i]);
+        free_page(&og[i]);
       }
     }
   }    
 
   return(0);
 }
 
 #endif