PageRenderTime 83ms CodeModel.GetById 16ms app.highlight 60ms RepoModel.GetById 1ms app.codeStats 0ms

/media/libogg/src/ogg_bitwise.c

http://github.com/zpao/v8monkey
C | 857 lines | 691 code | 121 blank | 45 comment | 142 complexity | a0cb26df034b682e146f032002ed2118 MD5 | raw file
  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
 28static 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
 37static const unsigned int mask8B[]=
 38{0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
 39
 40void 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
 47void oggpackB_writeinit(oggpack_buffer *b){
 48  oggpack_writeinit(b);
 49}
 50
 51int oggpack_writecheck(oggpack_buffer *b){
 52  if(!b->ptr || !b->storage)return -1;
 53  return 0;
 54}
 55
 56int oggpackB_writecheck(oggpack_buffer *b){
 57  return oggpack_writecheck(b);
 58}
 59
 60void 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
 71void 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. */
 83void 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. */
126void 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
168void oggpack_writealign(oggpack_buffer *b){
169  int bits=8-b->endbit;
170  if(bits<8)
171    oggpack_write(b,0,bits);
172}
173
174void oggpackB_writealign(oggpack_buffer *b){
175  int bits=8-b->endbit;
176  if(bits<8)
177    oggpackB_write(b,0,bits);
178}
179
180static 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
227void oggpack_writecopy(oggpack_buffer *b,void *source,long bits){
228  oggpack_writecopy_helper(b,source,bits,oggpack_write,0);
229}
230
231void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
232  oggpack_writecopy_helper(b,source,bits,oggpackB_write,1);
233}
234
235void 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
242void oggpackB_reset(oggpack_buffer *b){
243  oggpack_reset(b);
244}
245
246void oggpack_writeclear(oggpack_buffer *b){
247  if(b->buffer)_ogg_free(b->buffer);
248  memset(b,0,sizeof(*b));
249}
250
251void oggpackB_writeclear(oggpack_buffer *b){
252  oggpack_writeclear(b);
253}
254
255void 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
261void 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 */
266long 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 */
298long 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
328long oggpack_look1(oggpack_buffer *b){
329  if(b->endbyte>=b->storage)return(-1);
330  return((b->ptr[0]>>b->endbit)&1);
331}
332
333long oggpackB_look1(oggpack_buffer *b){
334  if(b->endbyte>=b->storage)return(-1);
335  return((b->ptr[0]>>(7-b->endbit))&1);
336}
337
338void 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
354void oggpackB_adv(oggpack_buffer *b,int bits){
355  oggpack_adv(b,bits);
356}
357
358void oggpack_adv1(oggpack_buffer *b){
359  if(++(b->endbit)>7){
360    b->endbit=0;
361    b->ptr++;
362    b->endbyte++;
363  }
364}
365
366void oggpackB_adv1(oggpack_buffer *b){
367  oggpack_adv1(b);
368}
369
370/* bits <= 32 */
371long 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 */
415long 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
457long 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
478long 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
499long oggpack_bytes(oggpack_buffer *b){
500  return(b->endbyte+(b->endbit+7)/8);
501}
502
503long oggpack_bits(oggpack_buffer *b){
504  return(b->endbyte*8+b->endbit);
505}
506
507long oggpackB_bytes(oggpack_buffer *b){
508  return oggpack_bytes(b);
509}
510
511long oggpackB_bits(oggpack_buffer *b){
512  return oggpack_bits(b);
513}
514
515unsigned char *oggpack_get_buffer(oggpack_buffer *b){
516  return(b->buffer);
517}
518
519unsigned 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
529static int ilog(unsigned int v){
530  int ret=0;
531  while(v){
532    ret++;
533    v>>=1;
534  }
535  return(ret);
536}
537
538oggpack_buffer o;
539oggpack_buffer r;
540
541void report(char *in){
542  fprintf(stderr,"%s",in);
543  exit(1);
544}
545
546void 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
581void 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
616int 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