git.mutantstargoat.com Git - laserbrain_demo/blob - libs/ogg/bitwise.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE Ogg CONTAINER SOURCE CODE.              *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   5  * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   6  * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   7  *                                                                  *
   8  * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010             *
   9  * by the Xiph.Org Foundation http://www.xiph.org/                  *
  10  *                                                                  *
  11  ********************************************************************
  12
  13   function: packing variable sized words into an octet stream
  14   last mod: $Id: bitwise.c 18051 2011-08-04 17:56:39Z giles $
  15
  16  ********************************************************************/
  17
  18 /* We're 'LSb' endian; if we write a word but read individual bits,
  19    then we'll read the lsb first */
  20
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <limits.h>
  24 #include <ogg/ogg.h>
  25
  26 #define BUFFER_INCREMENT 256
  27
  28 static const unsigned long mask[]=
  29 {0x00000000,0x00000001,0x00000003,0x00000007,0x0000000f,
  30  0x0000001f,0x0000003f,0x0000007f,0x000000ff,0x000001ff,
  31  0x000003ff,0x000007ff,0x00000fff,0x00001fff,0x00003fff,
  32  0x00007fff,0x0000ffff,0x0001ffff,0x0003ffff,0x0007ffff,
  33  0x000fffff,0x001fffff,0x003fffff,0x007fffff,0x00ffffff,
  34  0x01ffffff,0x03ffffff,0x07ffffff,0x0fffffff,0x1fffffff,
  35  0x3fffffff,0x7fffffff,0xffffffff };
  36
  37 static const unsigned int mask8B[]=
  38 {0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
  39
  40 void oggpack_writeinit(oggpack_buffer *b){
  41   memset(b,0,sizeof(*b));
  42   b->ptr=b->buffer=_ogg_malloc(BUFFER_INCREMENT);
  43   b->buffer[0]='\0';
  44   b->storage=BUFFER_INCREMENT;
  45 }
  46
  47 void oggpackB_writeinit(oggpack_buffer *b){
  48   oggpack_writeinit(b);
  49 }
  50
  51 int oggpack_writecheck(oggpack_buffer *b){
  52   if(!b->ptr || !b->storage)return -1;
  53   return 0;
  54 }
  55
  56 int oggpackB_writecheck(oggpack_buffer *b){
  57   return oggpack_writecheck(b);
  58 }
  59
  60 void oggpack_writetrunc(oggpack_buffer *b,long bits){
  61   long bytes=bits>>3;
  62   if(b->ptr){
  63     bits-=bytes*8;
  64     b->ptr=b->buffer+bytes;
  65     b->endbit=bits;
  66     b->endbyte=bytes;
  67     *b->ptr&=mask[bits];
  68   }
  69 }
  70
  71 void oggpackB_writetrunc(oggpack_buffer *b,long bits){
  72   long bytes=bits>>3;
  73   if(b->ptr){
  74     bits-=bytes*8;
  75     b->ptr=b->buffer+bytes;
  76     b->endbit=bits;
  77     b->endbyte=bytes;
  78     *b->ptr&=mask8B[bits];
  79   }
  80 }
  81
  82 /* Takes only up to 32 bits. */
  83 void oggpack_write(oggpack_buffer *b,unsigned long value,int bits){
  84   if(bits<0 || bits>32) goto err;
  85   if(b->endbyte>=b->storage-4){
  86     void *ret;
  87     if(!b->ptr)return;
  88     if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
  89     ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
  90     if(!ret) goto err;
  91     b->buffer=ret;
  92     b->storage+=BUFFER_INCREMENT;
  93     b->ptr=b->buffer+b->endbyte;
  94   }
  95
  96   value&=mask[bits];
  97   bits+=b->endbit;
  98
  99   b->ptr[0]|=value<<b->endbit;
 100
 101   if(bits>=8){
 102     b->ptr[1]=(unsigned char)(value>>(8-b->endbit));
 103     if(bits>=16){
 104       b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
 105       if(bits>=24){
 106         b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
 107         if(bits>=32){
 108           if(b->endbit)
 109             b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
 110           else
 111             b->ptr[4]=0;
 112         }
 113       }
 114     }
 115   }
 116
 117   b->endbyte+=bits/8;
 118   b->ptr+=bits/8;
 119   b->endbit=bits&7;
 120   return;
 121  err:
 122   oggpack_writeclear(b);
 123 }
 124
 125 /* Takes only up to 32 bits. */
 126 void oggpackB_write(oggpack_buffer *b,unsigned long value,int bits){
 127   if(bits<0 || bits>32) goto err;
 128   if(b->endbyte>=b->storage-4){
 129     void *ret;
 130     if(!b->ptr)return;
 131     if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
 132     ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
 133     if(!ret) goto err;
 134     b->buffer=ret;
 135     b->storage+=BUFFER_INCREMENT;
 136     b->ptr=b->buffer+b->endbyte;
 137   }
 138
 139   value=(value&mask[bits])<<(32-bits);
 140   bits+=b->endbit;
 141
 142   b->ptr[0]|=value>>(24+b->endbit);
 143
 144   if(bits>=8){
 145     b->ptr[1]=(unsigned char)(value>>(16+b->endbit));
 146     if(bits>=16){
 147       b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
 148       if(bits>=24){
 149         b->ptr[3]=(unsigned char)(value>>(b->endbit));
 150         if(bits>=32){
 151           if(b->endbit)
 152             b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
 153           else
 154             b->ptr[4]=0;
 155         }
 156       }
 157     }
 158   }
 159
 160   b->endbyte+=bits/8;
 161   b->ptr+=bits/8;
 162   b->endbit=bits&7;
 163   return;
 164  err:
 165   oggpack_writeclear(b);
 166 }
 167
 168 void oggpack_writealign(oggpack_buffer *b){
 169   int bits=8-b->endbit;
 170   if(bits<8)
 171     oggpack_write(b,0,bits);
 172 }
 173
 174 void oggpackB_writealign(oggpack_buffer *b){
 175   int bits=8-b->endbit;
 176   if(bits<8)
 177     oggpackB_write(b,0,bits);
 178 }
 179
 180 static void oggpack_writecopy_helper(oggpack_buffer *b,
 181                                      void *source,
 182                                      long bits,
 183                                      void (*w)(oggpack_buffer *,
 184                                                unsigned long,
 185                                                int),
 186                                      int msb){
 187   unsigned char *ptr=(unsigned char *)source;
 188
 189   long bytes=bits/8;
 190   bits-=bytes*8;
 191
 192   if(b->endbit){
 193     int i;
 194     /* unaligned copy.  Do it the hard way. */
 195     for(i=0;i<bytes;i++)
 196       w(b,(unsigned long)(ptr[i]),8);
 197   }else{
 198     /* aligned block copy */
 199     if(b->endbyte+bytes+1>=b->storage){
 200       void *ret;
 201       if(!b->ptr) goto err;
 202       if(b->endbyte+bytes+BUFFER_INCREMENT>b->storage) goto err;
 203       b->storage=b->endbyte+bytes+BUFFER_INCREMENT;
 204       ret=_ogg_realloc(b->buffer,b->storage);
 205       if(!ret) goto err;
 206       b->buffer=ret;
 207       b->ptr=b->buffer+b->endbyte;
 208     }
 209
 210     memmove(b->ptr,source,bytes);
 211     b->ptr+=bytes;
 212     b->endbyte+=bytes;
 213     *b->ptr=0;
 214
 215   }
 216   if(bits){
 217     if(msb)
 218       w(b,(unsigned long)(ptr[bytes]>>(8-bits)),bits);
 219     else
 220       w(b,(unsigned long)(ptr[bytes]),bits);
 221   }
 222   return;
 223  err:
 224   oggpack_writeclear(b);
 225 }
 226
 227 void oggpack_writecopy(oggpack_buffer *b,void *source,long bits){
 228   oggpack_writecopy_helper(b,source,bits,oggpack_write,0);
 229 }
 230
 231 void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
 232   oggpack_writecopy_helper(b,source,bits,oggpackB_write,1);
 233 }
 234
 235 void oggpack_reset(oggpack_buffer *b){
 236   if(!b->ptr)return;
 237   b->ptr=b->buffer;
 238   b->buffer[0]=0;
 239   b->endbit=b->endbyte=0;
 240 }
 241
 242 void oggpackB_reset(oggpack_buffer *b){
 243   oggpack_reset(b);
 244 }
 245
 246 void oggpack_writeclear(oggpack_buffer *b){
 247   if(b->buffer)_ogg_free(b->buffer);
 248   memset(b,0,sizeof(*b));
 249 }
 250
 251 void oggpackB_writeclear(oggpack_buffer *b){
 252   oggpack_writeclear(b);
 253 }
 254
 255 void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
 256   memset(b,0,sizeof(*b));
 257   b->buffer=b->ptr=buf;
 258   b->storage=bytes;
 259 }
 260
 261 void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
 262   oggpack_readinit(b,buf,bytes);
 263 }
 264
 265 /* Read in bits without advancing the bitptr; bits <= 32 */
 266 long oggpack_look(oggpack_buffer *b,int bits){
 267   unsigned long ret;
 268   unsigned long m;
 269
 270   if(bits<0 || bits>32) return -1;
 271   m=mask[bits];
 272   bits+=b->endbit;
 273
 274   if(b->endbyte >= b->storage-4){
 275     /* not the main path */
 276     if(b->endbyte > b->storage-((bits+7)>>3)) return -1;
 277     /* special case to avoid reading b->ptr[0], which might be past the end of
 278         the buffer; also skips some useless accounting */
 279     else if(!bits)return(0L);
 280   }
 281
 282   ret=b->ptr[0]>>b->endbit;
 283   if(bits>8){
 284     ret|=b->ptr[1]<<(8-b->endbit);
 285     if(bits>16){
 286       ret|=b->ptr[2]<<(16-b->endbit);
 287       if(bits>24){
 288         ret|=b->ptr[3]<<(24-b->endbit);
 289         if(bits>32 && b->endbit)
 290           ret|=b->ptr[4]<<(32-b->endbit);
 291       }
 292     }
 293   }
 294   return(m&ret);
 295 }
 296
 297 /* Read in bits without advancing the bitptr; bits <= 32 */
 298 long oggpackB_look(oggpack_buffer *b,int bits){
 299   unsigned long ret;
 300   int m=32-bits;
 301
 302   if(m<0 || m>32) return -1;
 303   bits+=b->endbit;
 304
 305   if(b->endbyte >= b->storage-4){
 306     /* not the main path */
 307     if(b->endbyte > b->storage-((bits+7)>>3)) return -1;
 308     /* special case to avoid reading b->ptr[0], which might be past the end of
 309         the buffer; also skips some useless accounting */
 310     else if(!bits)return(0L);
 311   }
 312
 313   ret=b->ptr[0]<<(24+b->endbit);
 314   if(bits>8){
 315     ret|=b->ptr[1]<<(16+b->endbit);
 316     if(bits>16){
 317       ret|=b->ptr[2]<<(8+b->endbit);
 318       if(bits>24){
 319         ret|=b->ptr[3]<<(b->endbit);
 320         if(bits>32 && b->endbit)
 321           ret|=b->ptr[4]>>(8-b->endbit);
 322       }
 323     }
 324   }
 325   return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1);
 326 }
 327
 328 long oggpack_look1(oggpack_buffer *b){
 329   if(b->endbyte>=b->storage)return(-1);
 330   return((b->ptr[0]>>b->endbit)&1);
 331 }
 332
 333 long oggpackB_look1(oggpack_buffer *b){
 334   if(b->endbyte>=b->storage)return(-1);
 335   return((b->ptr[0]>>(7-b->endbit))&1);
 336 }
 337
 338 void oggpack_adv(oggpack_buffer *b,int bits){
 339   bits+=b->endbit;
 340
 341   if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
 342
 343   b->ptr+=bits/8;
 344   b->endbyte+=bits/8;
 345   b->endbit=bits&7;
 346   return;
 347
 348  overflow:
 349   b->ptr=NULL;
 350   b->endbyte=b->storage;
 351   b->endbit=1;
 352 }
 353
 354 void oggpackB_adv(oggpack_buffer *b,int bits){
 355   oggpack_adv(b,bits);
 356 }
 357
 358 void oggpack_adv1(oggpack_buffer *b){
 359   if(++(b->endbit)>7){
 360     b->endbit=0;
 361     b->ptr++;
 362     b->endbyte++;
 363   }
 364 }
 365
 366 void oggpackB_adv1(oggpack_buffer *b){
 367   oggpack_adv1(b);
 368 }
 369
 370 /* bits <= 32 */
 371 long oggpack_read(oggpack_buffer *b,int bits){
 372   long ret;
 373   unsigned long m;
 374
 375   if(bits<0 || bits>32) goto err;
 376   m=mask[bits];
 377   bits+=b->endbit;
 378
 379   if(b->endbyte >= b->storage-4){
 380     /* not the main path */
 381     if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
 382     /* special case to avoid reading b->ptr[0], which might be past the end of
 383         the buffer; also skips some useless accounting */
 384     else if(!bits)return(0L);
 385   }
 386
 387   ret=b->ptr[0]>>b->endbit;
 388   if(bits>8){
 389     ret|=b->ptr[1]<<(8-b->endbit);
 390     if(bits>16){
 391       ret|=b->ptr[2]<<(16-b->endbit);
 392       if(bits>24){
 393         ret|=b->ptr[3]<<(24-b->endbit);
 394         if(bits>32 && b->endbit){
 395           ret|=b->ptr[4]<<(32-b->endbit);
 396         }
 397       }
 398     }
 399   }
 400   ret&=m;
 401   b->ptr+=bits/8;
 402   b->endbyte+=bits/8;
 403   b->endbit=bits&7;
 404   return ret;
 405
 406  overflow:
 407  err:
 408   b->ptr=NULL;
 409   b->endbyte=b->storage;
 410   b->endbit=1;
 411   return -1L;
 412 }
 413
 414 /* bits <= 32 */
 415 long oggpackB_read(oggpack_buffer *b,int bits){
 416   long ret;
 417   long m=32-bits;
 418
 419   if(m<0 || m>32) goto err;
 420   bits+=b->endbit;
 421
 422   if(b->endbyte+4>=b->storage){
 423     /* not the main path */
 424     if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
 425     /* special case to avoid reading b->ptr[0], which might be past the end of
 426         the buffer; also skips some useless accounting */
 427     else if(!bits)return(0L);
 428   }
 429
 430   ret=b->ptr[0]<<(24+b->endbit);
 431   if(bits>8){
 432     ret|=b->ptr[1]<<(16+b->endbit);
 433     if(bits>16){
 434       ret|=b->ptr[2]<<(8+b->endbit);
 435       if(bits>24){
 436         ret|=b->ptr[3]<<(b->endbit);
 437         if(bits>32 && b->endbit)
 438           ret|=b->ptr[4]>>(8-b->endbit);
 439       }
 440     }
 441   }
 442   ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1);
 443
 444   b->ptr+=bits/8;
 445   b->endbyte+=bits/8;
 446   b->endbit=bits&7;
 447   return ret;
 448
 449  overflow:
 450  err:
 451   b->ptr=NULL;
 452   b->endbyte=b->storage;
 453   b->endbit=1;
 454   return -1L;
 455 }
 456
 457 long oggpack_read1(oggpack_buffer *b){
 458   long ret;
 459
 460   if(b->endbyte >= b->storage) goto overflow;
 461   ret=(b->ptr[0]>>b->endbit)&1;
 462
 463   b->endbit++;
 464   if(b->endbit>7){
 465     b->endbit=0;
 466     b->ptr++;
 467     b->endbyte++;
 468   }
 469   return ret;
 470
 471  overflow:
 472   b->ptr=NULL;
 473   b->endbyte=b->storage;
 474   b->endbit=1;
 475   return -1L;
 476 }
 477
 478 long oggpackB_read1(oggpack_buffer *b){
 479   long ret;
 480
 481   if(b->endbyte >= b->storage) goto overflow;
 482   ret=(b->ptr[0]>>(7-b->endbit))&1;
 483
 484   b->endbit++;
 485   if(b->endbit>7){
 486     b->endbit=0;
 487     b->ptr++;
 488     b->endbyte++;
 489   }
 490   return ret;
 491
 492  overflow:
 493   b->ptr=NULL;
 494   b->endbyte=b->storage;
 495   b->endbit=1;
 496   return -1L;
 497 }
 498
 499 long oggpack_bytes(oggpack_buffer *b){
 500   return(b->endbyte+(b->endbit+7)/8);
 501 }
 502
 503 long oggpack_bits(oggpack_buffer *b){
 504   return(b->endbyte*8+b->endbit);
 505 }
 506
 507 long oggpackB_bytes(oggpack_buffer *b){
 508   return oggpack_bytes(b);
 509 }
 510
 511 long oggpackB_bits(oggpack_buffer *b){
 512   return oggpack_bits(b);
 513 }
 514
 515 unsigned char *oggpack_get_buffer(oggpack_buffer *b){
 516   return(b->buffer);
 517 }
 518
 519 unsigned char *oggpackB_get_buffer(oggpack_buffer *b){
 520   return oggpack_get_buffer(b);
 521 }
 522
 523 /* Self test of the bitwise routines; everything else is based on
 524    them, so they damned well better be solid. */
 525
 526 #ifdef _V_SELFTEST
 527 #include <stdio.h>
 528
 529 static int ilog(unsigned int v){
 530   int ret=0;
 531   while(v){
 532     ret++;
 533     v>>=1;
 534   }
 535   return(ret);
 536 }
 537
 538 oggpack_buffer o;
 539 oggpack_buffer r;
 540
 541 void report(char *in){
 542   fprintf(stderr,"%s",in);
 543   exit(1);
 544 }
 545
 546 void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){
 547   long bytes,i;
 548   unsigned char *buffer;
 549
 550   oggpack_reset(&o);
 551   for(i=0;i<vals;i++)
 552     oggpack_write(&o,b[i],bits?bits:ilog(b[i]));
 553   buffer=oggpack_get_buffer(&o);
 554   bytes=oggpack_bytes(&o);
 555   if(bytes!=compsize)report("wrong number of bytes!\n");
 556   for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){
 557     for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]);
 558     report("wrote incorrect value!\n");
 559   }
 560   oggpack_readinit(&r,buffer,bytes);
 561   for(i=0;i<vals;i++){
 562     int tbit=bits?bits:ilog(b[i]);
 563     if(oggpack_look(&r,tbit)==-1)
 564       report("out of data!\n");
 565     if(oggpack_look(&r,tbit)!=(b[i]&mask[tbit]))
 566       report("looked at incorrect value!\n");
 567     if(tbit==1)
 568       if(oggpack_look1(&r)!=(b[i]&mask[tbit]))
 569         report("looked at single bit incorrect value!\n");
 570     if(tbit==1){
 571       if(oggpack_read1(&r)!=(b[i]&mask[tbit]))
 572         report("read incorrect single bit value!\n");
 573     }else{
 574     if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit]))
 575       report("read incorrect value!\n");
 576     }
 577   }
 578   if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
 579 }
 580
 581 void cliptestB(unsigned long *b,int vals,int bits,int *comp,int compsize){
 582   long bytes,i;
 583   unsigned char *buffer;
 584
 585   oggpackB_reset(&o);
 586   for(i=0;i<vals;i++)
 587     oggpackB_write(&o,b[i],bits?bits:ilog(b[i]));
 588   buffer=oggpackB_get_buffer(&o);
 589   bytes=oggpackB_bytes(&o);
 590   if(bytes!=compsize)report("wrong number of bytes!\n");
 591   for(i=0;i<bytes;i++)if(buffer[i]!=comp[i]){
 592     for(i=0;i<bytes;i++)fprintf(stderr,"%x %x\n",(int)buffer[i],(int)comp[i]);
 593     report("wrote incorrect value!\n");
 594   }
 595   oggpackB_readinit(&r,buffer,bytes);
 596   for(i=0;i<vals;i++){
 597     int tbit=bits?bits:ilog(b[i]);
 598     if(oggpackB_look(&r,tbit)==-1)
 599       report("out of data!\n");
 600     if(oggpackB_look(&r,tbit)!=(b[i]&mask[tbit]))
 601       report("looked at incorrect value!\n");
 602     if(tbit==1)
 603       if(oggpackB_look1(&r)!=(b[i]&mask[tbit]))
 604         report("looked at single bit incorrect value!\n");
 605     if(tbit==1){
 606       if(oggpackB_read1(&r)!=(b[i]&mask[tbit]))
 607         report("read incorrect single bit value!\n");
 608     }else{
 609     if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit]))
 610       report("read incorrect value!\n");
 611     }
 612   }
 613   if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
 614 }
 615
 616 int main(void){
 617   unsigned char *buffer;
 618   long bytes,i;
 619   static unsigned long testbuffer1[]=
 620     {18,12,103948,4325,543,76,432,52,3,65,4,56,32,42,34,21,1,23,32,546,456,7,
 621        567,56,8,8,55,3,52,342,341,4,265,7,67,86,2199,21,7,1,5,1,4};
 622   int test1size=43;
 623
 624   static unsigned long testbuffer2[]=
 625     {216531625L,1237861823,56732452,131,3212421,12325343,34547562,12313212,
 626        1233432,534,5,346435231,14436467,7869299,76326614,167548585,
 627        85525151,0,12321,1,349528352};
 628   int test2size=21;
 629
 630   static unsigned long testbuffer3[]=
 631     {1,0,14,0,1,0,12,0,1,0,0,0,1,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,1,1,1,1,1,0,0,1,
 632        0,1,30,1,1,1,0,0,1,0,0,0,12,0,11,0,1,0,0,1};
 633   int test3size=56;
 634
 635   static unsigned long large[]=
 636     {2136531625L,2137861823,56732452,131,3212421,12325343,34547562,12313212,
 637        1233432,534,5,2146435231,14436467,7869299,76326614,167548585,
 638        85525151,0,12321,1,2146528352};
 639
 640   int onesize=33;
 641   static int one[33]={146,25,44,151,195,15,153,176,233,131,196,65,85,172,47,40,
 642                     34,242,223,136,35,222,211,86,171,50,225,135,214,75,172,
 643                     223,4};
 644   static int oneB[33]={150,101,131,33,203,15,204,216,105,193,156,65,84,85,222,
 645                        8,139,145,227,126,34,55,244,171,85,100,39,195,173,18,
 646                        245,251,128};
 647
 648   int twosize=6;
 649   static int two[6]={61,255,255,251,231,29};
 650   static int twoB[6]={247,63,255,253,249,120};
 651
 652   int threesize=54;
 653   static int three[54]={169,2,232,252,91,132,156,36,89,13,123,176,144,32,254,
 654                       142,224,85,59,121,144,79,124,23,67,90,90,216,79,23,83,
 655                       58,135,196,61,55,129,183,54,101,100,170,37,127,126,10,
 656                       100,52,4,14,18,86,77,1};
 657   static int threeB[54]={206,128,42,153,57,8,183,251,13,89,36,30,32,144,183,
 658                          130,59,240,121,59,85,223,19,228,180,134,33,107,74,98,
 659                          233,253,196,135,63,2,110,114,50,155,90,127,37,170,104,
 660                          200,20,254,4,58,106,176,144,0};
 661
 662   int foursize=38;
 663   static int four[38]={18,6,163,252,97,194,104,131,32,1,7,82,137,42,129,11,72,
 664                      132,60,220,112,8,196,109,64,179,86,9,137,195,208,122,169,
 665                      28,2,133,0,1};
 666   static int fourB[38]={36,48,102,83,243,24,52,7,4,35,132,10,145,21,2,93,2,41,
 667                         1,219,184,16,33,184,54,149,170,132,18,30,29,98,229,67,
 668                         129,10,4,32};
 669
 670   int fivesize=45;
 671   static int five[45]={169,2,126,139,144,172,30,4,80,72,240,59,130,218,73,62,
 672                      241,24,210,44,4,20,0,248,116,49,135,100,110,130,181,169,
 673                      84,75,159,2,1,0,132,192,8,0,0,18,22};
 674   static int fiveB[45]={1,84,145,111,245,100,128,8,56,36,40,71,126,78,213,226,
 675                         124,105,12,0,133,128,0,162,233,242,67,152,77,205,77,
 676                         172,150,169,129,79,128,0,6,4,32,0,27,9,0};
 677
 678   int sixsize=7;
 679   static int six[7]={17,177,170,242,169,19,148};
 680   static int sixB[7]={136,141,85,79,149,200,41};
 681
 682   /* Test read/write together */
 683   /* Later we test against pregenerated bitstreams */
 684   oggpack_writeinit(&o);
 685
 686   fprintf(stderr,"\nSmall preclipped packing (LSb): ");
 687   cliptest(testbuffer1,test1size,0,one,onesize);
 688   fprintf(stderr,"ok.");
 689
 690   fprintf(stderr,"\nNull bit call (LSb): ");
 691   cliptest(testbuffer3,test3size,0,two,twosize);
 692   fprintf(stderr,"ok.");
 693
 694   fprintf(stderr,"\nLarge preclipped packing (LSb): ");
 695   cliptest(testbuffer2,test2size,0,three,threesize);
 696   fprintf(stderr,"ok.");
 697
 698   fprintf(stderr,"\n32 bit preclipped packing (LSb): ");
 699   oggpack_reset(&o);
 700   for(i=0;i<test2size;i++)
 701     oggpack_write(&o,large[i],32);
 702   buffer=oggpack_get_buffer(&o);
 703   bytes=oggpack_bytes(&o);
 704   oggpack_readinit(&r,buffer,bytes);
 705   for(i=0;i<test2size;i++){
 706     if(oggpack_look(&r,32)==-1)report("out of data. failed!");
 707     if(oggpack_look(&r,32)!=large[i]){
 708       fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpack_look(&r,32),large[i],
 709               oggpack_look(&r,32),large[i]);
 710       report("read incorrect value!\n");
 711     }
 712     oggpack_adv(&r,32);
 713   }
 714   if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
 715   fprintf(stderr,"ok.");
 716
 717   fprintf(stderr,"\nSmall unclipped packing (LSb): ");
 718   cliptest(testbuffer1,test1size,7,four,foursize);
 719   fprintf(stderr,"ok.");
 720
 721   fprintf(stderr,"\nLarge unclipped packing (LSb): ");
 722   cliptest(testbuffer2,test2size,17,five,fivesize);
 723   fprintf(stderr,"ok.");
 724
 725   fprintf(stderr,"\nSingle bit unclipped packing (LSb): ");
 726   cliptest(testbuffer3,test3size,1,six,sixsize);
 727   fprintf(stderr,"ok.");
 728
 729   fprintf(stderr,"\nTesting read past end (LSb): ");
 730   oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
 731   for(i=0;i<64;i++){
 732     if(oggpack_read(&r,1)!=0){
 733       fprintf(stderr,"failed; got -1 prematurely.\n");
 734       exit(1);
 735     }
 736   }
 737   if(oggpack_look(&r,1)!=-1 ||
 738      oggpack_read(&r,1)!=-1){
 739       fprintf(stderr,"failed; read past end without -1.\n");
 740       exit(1);
 741   }
 742   oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
 743   if(oggpack_read(&r,30)!=0 || oggpack_read(&r,16)!=0){
 744       fprintf(stderr,"failed 2; got -1 prematurely.\n");
 745       exit(1);
 746   }
 747
 748   if(oggpack_look(&r,18)!=0 ||
 749      oggpack_look(&r,18)!=0){
 750     fprintf(stderr,"failed 3; got -1 prematurely.\n");
 751       exit(1);
 752   }
 753   if(oggpack_look(&r,19)!=-1 ||
 754      oggpack_look(&r,19)!=-1){
 755     fprintf(stderr,"failed; read past end without -1.\n");
 756       exit(1);
 757   }
 758   if(oggpack_look(&r,32)!=-1 ||
 759      oggpack_look(&r,32)!=-1){
 760     fprintf(stderr,"failed; read past end without -1.\n");
 761       exit(1);
 762   }
 763   oggpack_writeclear(&o);
 764   fprintf(stderr,"ok.\n");
 765
 766   /********** lazy, cut-n-paste retest with MSb packing ***********/
 767
 768   /* Test read/write together */
 769   /* Later we test against pregenerated bitstreams */
 770   oggpackB_writeinit(&o);
 771
 772   fprintf(stderr,"\nSmall preclipped packing (MSb): ");
 773   cliptestB(testbuffer1,test1size,0,oneB,onesize);
 774   fprintf(stderr,"ok.");
 775
 776   fprintf(stderr,"\nNull bit call (MSb): ");
 777   cliptestB(testbuffer3,test3size,0,twoB,twosize);
 778   fprintf(stderr,"ok.");
 779
 780   fprintf(stderr,"\nLarge preclipped packing (MSb): ");
 781   cliptestB(testbuffer2,test2size,0,threeB,threesize);
 782   fprintf(stderr,"ok.");
 783
 784   fprintf(stderr,"\n32 bit preclipped packing (MSb): ");
 785   oggpackB_reset(&o);
 786   for(i=0;i<test2size;i++)
 787     oggpackB_write(&o,large[i],32);
 788   buffer=oggpackB_get_buffer(&o);
 789   bytes=oggpackB_bytes(&o);
 790   oggpackB_readinit(&r,buffer,bytes);
 791   for(i=0;i<test2size;i++){
 792     if(oggpackB_look(&r,32)==-1)report("out of data. failed!");
 793     if(oggpackB_look(&r,32)!=large[i]){
 794       fprintf(stderr,"%ld != %ld (%lx!=%lx):",oggpackB_look(&r,32),large[i],
 795               oggpackB_look(&r,32),large[i]);
 796       report("read incorrect value!\n");
 797     }
 798     oggpackB_adv(&r,32);
 799   }
 800   if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
 801   fprintf(stderr,"ok.");
 802
 803   fprintf(stderr,"\nSmall unclipped packing (MSb): ");
 804   cliptestB(testbuffer1,test1size,7,fourB,foursize);
 805   fprintf(stderr,"ok.");
 806
 807   fprintf(stderr,"\nLarge unclipped packing (MSb): ");
 808   cliptestB(testbuffer2,test2size,17,fiveB,fivesize);
 809   fprintf(stderr,"ok.");
 810
 811   fprintf(stderr,"\nSingle bit unclipped packing (MSb): ");
 812   cliptestB(testbuffer3,test3size,1,sixB,sixsize);
 813   fprintf(stderr,"ok.");
 814
 815   fprintf(stderr,"\nTesting read past end (MSb): ");
 816   oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
 817   for(i=0;i<64;i++){
 818     if(oggpackB_read(&r,1)!=0){
 819       fprintf(stderr,"failed; got -1 prematurely.\n");
 820       exit(1);
 821     }
 822   }
 823   if(oggpackB_look(&r,1)!=-1 ||
 824      oggpackB_read(&r,1)!=-1){
 825       fprintf(stderr,"failed; read past end without -1.\n");
 826       exit(1);
 827   }
 828   oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
 829   if(oggpackB_read(&r,30)!=0 || oggpackB_read(&r,16)!=0){
 830       fprintf(stderr,"failed 2; got -1 prematurely.\n");
 831       exit(1);
 832   }
 833
 834   if(oggpackB_look(&r,18)!=0 ||
 835      oggpackB_look(&r,18)!=0){
 836     fprintf(stderr,"failed 3; got -1 prematurely.\n");
 837       exit(1);
 838   }
 839   if(oggpackB_look(&r,19)!=-1 ||
 840      oggpackB_look(&r,19)!=-1){
 841     fprintf(stderr,"failed; read past end without -1.\n");
 842       exit(1);
 843   }
 844   if(oggpackB_look(&r,32)!=-1 ||
 845      oggpackB_look(&r,32)!=-1){
 846     fprintf(stderr,"failed; read past end without -1.\n");
 847       exit(1);
 848   }
 849   oggpackB_writeclear(&o);
 850   fprintf(stderr,"ok.\n\n");
 851
 852
 853   return(0);
 854 }
 855 #endif  /* _V_SELFTEST */
 856
 857 #undef BUFFER_INCREMENT