Bug 468296 - Update libogg to SVN r16911. r=chris.double

media/libogg/CHANGES

@@ -1,3 +1,12 @@
+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

media/libogg/README

@@ -23,13 +23,16 @@ Directory:
 
 ./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?:
 
@@ -82,6 +85,33 @@ 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
@@ -100,4 +130,4 @@ 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 $

media/libogg/README_MOZILLA

@@ -1,8 +1,10 @@
-The source from this directory was copied from the libogg-1.1.3 source
+The source from this directory was copied from the libogg subversion
-distribution using the update.sh script. The only changes made were
+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

media/libogg/include/ogg/ogg.h

@@ -5,13 +5,13 @@
  * 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
@@ -21,8 +21,14 @@
 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;
@@ -53,8 +59,8 @@ typedef struct {
 
   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
+                                this way, but it is simple coupled to the
-				lacing fifo */
+                                lacing fifo */
   long    lacing_storage;
   long    lacing_fill;
   long    lacing_packet;
@@ -69,7 +75,7 @@ typedef struct {
                              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
@@ -88,12 +94,12 @@ typedef struct {
   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,
+                                knows where there's a hole in the data,
-				but we need coupling so that the codec
+                                but we need coupling so that the codec
-				(which is in a seperate abstraction
+                                (which is in a seperate abstraction
-				layer) also knows about the gap */
+                                layer) also knows about the gap */
 } ogg_packet;
 
 typedef struct {
@@ -110,6 +116,7 @@ typedef struct {
 /* 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);
@@ -128,6 +135,7 @@ 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);
@@ -148,6 +156,8 @@ 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);
 
@@ -156,7 +166,8 @@ extern int      ogg_stream_flush(ogg_stream_state *os, ogg_page *og);
 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);
@@ -173,18 +184,19 @@ 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_version(const ogg_page *og);
-extern int      ogg_page_continued(ogg_page *og);
+extern int      ogg_page_continued(const ogg_page *og);
-extern int      ogg_page_bos(ogg_page *og);
+extern int      ogg_page_bos(const ogg_page *og);
-extern int      ogg_page_eos(ogg_page *og);
+extern int      ogg_page_eos(const ogg_page *og);
-extern ogg_int64_t  ogg_page_granulepos(ogg_page *og);
+extern ogg_int64_t  ogg_page_granulepos(const ogg_page *og);
-extern int      ogg_page_serialno(ogg_page *og);
+extern int      ogg_page_serialno(const ogg_page *og);
-extern long     ogg_page_pageno(ogg_page *og);
+extern long     ogg_page_pageno(const ogg_page *og);
-extern int      ogg_page_packets(ogg_page *og);
+extern int      ogg_page_packets(const ogg_page *og);
 
 extern void     ogg_packet_clear(ogg_packet *op);
 
@@ -194,9 +206,3 @@ extern void     ogg_packet_clear(ogg_packet *op);
 #endif
 
 #endif  /* _OGG_H */
-
-
-
-
-
-

media/libogg/include/ogg/os_types.h

@@ -11,7 +11,7 @@
  ********************************************************************
 
  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
@@ -27,19 +27,21 @@
 #if defined(_WIN32) 
 
 #  if defined(__CYGWIN__)
-#    include <_G_config.h>
+#    include <stdint.h>
-     typedef _G_int64_t ogg_int64_t;
+     typedef int16_t ogg_int16_t;
-     typedef _G_int32_t ogg_int32_t;
+     typedef uint16_t ogg_uint16_t;
-     typedef _G_uint32_t ogg_uint32_t;
+     typedef int32_t ogg_int32_t;
-     typedef _G_int16_t ogg_int16_t;
+     typedef uint32_t ogg_uint32_t;
-     typedef _G_uint16_t ogg_uint16_t;
+     typedef int64_t ogg_int64_t;
+     typedef uint64_t ogg_uint64_t;
 #  elif defined(__MINGW32__)
-     typedef short ogg_int16_t;                                                                             
+#    include <sys/types.h>
-     typedef unsigned short ogg_uint16_t;                                                                   
+     typedef short ogg_int16_t;
-     typedef int ogg_int32_t;                                                                               
+     typedef unsigned short ogg_uint16_t;
-     typedef unsigned int ogg_uint32_t;                                                                     
+     typedef int ogg_int32_t;
-     typedef long long ogg_int64_t;                                                                         
+     typedef unsigned int ogg_uint32_t;
-     typedef unsigned long long ogg_uint64_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;
@@ -64,7 +66,7 @@
    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;
@@ -73,6 +75,16 @@
    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 */
@@ -117,6 +129,15 @@
    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>

media/libogg/src/ogg_bitwise.c

@@ -5,13 +5,13 @@
  * 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 $
 
  ********************************************************************/
 
@@ -47,28 +47,48 @@ 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;
+  if(b->ptr){
-  b->ptr=b->buffer+bytes;
+    bits-=bytes*8;
-  b->endbit=bits;
+    b->ptr=b->buffer+bytes;
-  b->endbyte=bytes;
+    b->endbit=bits;
-  *b->ptr&=mask[bits];
+    b->endbyte=bytes;
+    *b->ptr&=mask[bits];
+  }
 }
 
 void oggpackB_writetrunc(oggpack_buffer *b,long bits){
   long bytes=bits>>3;
-  bits-=bytes*8;
+  if(b->ptr){
-  b->ptr=b->buffer+bytes;
+    bits-=bytes*8;
-  b->endbit=bits;
+    b->ptr=b->buffer+bytes;
-  b->endbyte=bytes;
+    b->endbit=bits;
-  *b->ptr&=mask8B[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;
   }
@@ -83,13 +103,13 @@ void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
     if(bits>=16){
       b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
       if(bits>=24){
-	b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
+        b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
-	if(bits>=32){
+        if(bits>=32){
-	  if(b->endbit)
+          if(b->endbit)
-	    b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
+            b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
-	  else
+          else
-	    b->ptr[4]=0;
+            b->ptr[4]=0;
-	}
+        }
       }
     }
   }
@@ -102,7 +122,14 @@ void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
 /* 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;
   }
@@ -117,13 +144,13 @@ void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){
     if(bits>=16){
       b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
       if(bits>=24){
-	b->ptr[3]=(unsigned char)(value>>(b->endbit));
+        b->ptr[3]=(unsigned char)(value>>(b->endbit));
-	if(bits>=32){
+        if(bits>=32){
-	  if(b->endbit)
+          if(b->endbit)
-	    b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
+            b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
-	  else
+          else
-	    b->ptr[4]=0;
+            b->ptr[4]=0;
-	}
+        }
       }
     }
   }
@@ -146,12 +173,12 @@ void oggpackB_writealign(oggpack_buffer *b){
 }
 
 static void oggpack_writecopy_helper(oggpack_buffer *b,
-				     void *source,
+                                     void *source,
-				     long bits,
+                                     long bits,
-				     void (*w)(oggpack_buffer *,
+                                     void (*w)(oggpack_buffer *,
-					       unsigned long,
+                                               unsigned long,
-					       int),
+                                               int),
-				     int msb){
+                                     int msb){
   unsigned char *ptr=(unsigned char *)source;
 
   long bytes=bits/8;
@@ -165,8 +192,15 @@ static void oggpack_writecopy_helper(oggpack_buffer *b,
   }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;
     }
 
@@ -193,6 +227,7 @@ void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
 }
 
 void oggpack_reset(oggpack_buffer *b){
+  if(!b->ptr)return;
   b->ptr=b->buffer;
   b->buffer[0]=0;
   b->endbit=b->endbyte=0;
@@ -203,7 +238,7 @@ void oggpackB_reset(oggpack_buffer *b){
 }
 
 void oggpack_writeclear(oggpack_buffer *b){
-  _ogg_free(b->buffer);
+  if(b->buffer)_ogg_free(b->buffer);
   memset(b,0,sizeof(*b));
 }
 
@@ -239,9 +274,9 @@ long oggpack_look(oggpack_buffer *b,int bits){
     if(bits>16){
       ret|=b->ptr[2]<<(16-b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(24-b->endbit);  
+        ret|=b->ptr[3]<<(24-b->endbit);  
-	if(bits>32 && b->endbit)
+        if(bits>32 && b->endbit)
-	  ret|=b->ptr[4]<<(32-b->endbit);
+          ret|=b->ptr[4]<<(32-b->endbit);
       }
     }
   }
@@ -266,9 +301,9 @@ long oggpackB_look(oggpack_buffer *b,int bits){
     if(bits>16){
       ret|=b->ptr[2]<<(8+b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(b->endbit);  
+        ret|=b->ptr[3]<<(b->endbit);  
-	if(bits>32 && b->endbit)
+        if(bits>32 && b->endbit)
-	  ret|=b->ptr[4]>>(8-b->endbit);
+          ret|=b->ptr[4]>>(8-b->endbit);
       }
     }
   }
@@ -327,10 +362,10 @@ long oggpack_read(oggpack_buffer *b,int bits){
     if(bits>16){
       ret|=b->ptr[2]<<(16-b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(24-b->endbit);  
+        ret|=b->ptr[3]<<(24-b->endbit);  
-	if(bits>32 && b->endbit){
+        if(bits>32 && b->endbit){
-	  ret|=b->ptr[4]<<(32-b->endbit);
+          ret|=b->ptr[4]<<(32-b->endbit);
-	}
+        }
       }
     }
   }
@@ -355,6 +390,9 @@ long oggpackB_read(oggpack_buffer *b,int bits){
     /* 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);
@@ -363,9 +401,9 @@ long oggpackB_read(oggpack_buffer *b,int bits){
     if(bits>16){
       ret|=b->ptr[2]<<(8+b->endbit);  
       if(bits>24){
-	ret|=b->ptr[3]<<(b->endbit);  
+        ret|=b->ptr[3]<<(b->endbit);  
-	if(bits>32 && b->endbit)
+        if(bits>32 && b->endbit)
-	  ret|=b->ptr[4]>>(8-b->endbit);
+          ret|=b->ptr[4]>>(8-b->endbit);
       }
     }
   }
@@ -493,10 +531,10 @@ void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){
       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");
@@ -528,10 +566,10 @@ void cliptestB(unsigned long *b,int vals,int bits,int *comp,int compsize){
       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");
@@ -569,8 +607,8 @@ int main(void){
                     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,
+                       8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
-		       245,251,128};
+                       245,251,128};
 
   int twosize=6;
   static int two[6]={61,255,255,251,231,29};
@@ -582,25 +620,25 @@ int main(void){
                       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,
+                         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,
+                         233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
-			 200,20,254,4,58,106,176,144,0};
+                         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,
+                        1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
-			129,10,4,32};
+                        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,
+                        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};
+                        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};
@@ -633,7 +671,7 @@ int main(void){
     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);
@@ -719,7 +757,7 @@ int main(void){
     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);