1 /********************************************************************
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. *
8 * THE OggVorbis SOURCE CODE IS (C) COPYRIGHT 1994-2010 *
9 * by the Xiph.Org Foundation http://www.xiph.org/ *
11 ********************************************************************
13 function: packing variable sized words into an octet stream
14 last mod: $Id: bitwise.c 18051 2011-08-04 17:56:39Z giles $
16 ********************************************************************/
18 /* We're 'LSb' endian; if we write a word but read individual bits,
19 then we'll read the lsb first */
26 #define BUFFER_INCREMENT 256
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 };
37 static const unsigned int mask8B[]=
38 {0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff};
40 void oggpack_writeinit(oggpack_buffer *b){
41 memset(b,0,sizeof(*b));
42 b->ptr=b->buffer=_ogg_malloc(BUFFER_INCREMENT);
44 b->storage=BUFFER_INCREMENT;
47 void oggpackB_writeinit(oggpack_buffer *b){
51 int oggpack_writecheck(oggpack_buffer *b){
52 if(!b->ptr || !b->storage)return -1;
56 int oggpackB_writecheck(oggpack_buffer *b){
57 return oggpack_writecheck(b);
60 void oggpack_writetrunc(oggpack_buffer *b,long bits){
64 b->ptr=b->buffer+bytes;
71 void oggpackB_writetrunc(oggpack_buffer *b,long bits){
75 b->ptr=b->buffer+bytes;
78 *b->ptr&=mask8B[bits];
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){
88 if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
89 ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
92 b->storage+=BUFFER_INCREMENT;
93 b->ptr=b->buffer+b->endbyte;
99 b->ptr[0]|=value<<b->endbit;
102 b->ptr[1]=(unsigned char)(value>>(8-b->endbit));
104 b->ptr[2]=(unsigned char)(value>>(16-b->endbit));
106 b->ptr[3]=(unsigned char)(value>>(24-b->endbit));
109 b->ptr[4]=(unsigned char)(value>>(32-b->endbit));
122 oggpack_writeclear(b);
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){
131 if(b->storage>LONG_MAX-BUFFER_INCREMENT) goto err;
132 ret=_ogg_realloc(b->buffer,b->storage+BUFFER_INCREMENT);
135 b->storage+=BUFFER_INCREMENT;
136 b->ptr=b->buffer+b->endbyte;
139 value=(value&mask[bits])<<(32-bits);
142 b->ptr[0]|=value>>(24+b->endbit);
145 b->ptr[1]=(unsigned char)(value>>(16+b->endbit));
147 b->ptr[2]=(unsigned char)(value>>(8+b->endbit));
149 b->ptr[3]=(unsigned char)(value>>(b->endbit));
152 b->ptr[4]=(unsigned char)(value<<(8-b->endbit));
165 oggpack_writeclear(b);
168 void oggpack_writealign(oggpack_buffer *b){
169 int bits=8-b->endbit;
171 oggpack_write(b,0,bits);
174 void oggpackB_writealign(oggpack_buffer *b){
175 int bits=8-b->endbit;
177 oggpackB_write(b,0,bits);
180 static void oggpack_writecopy_helper(oggpack_buffer *b,
183 void (*w)(oggpack_buffer *,
187 unsigned char *ptr=(unsigned char *)source;
194 /* unaligned copy. Do it the hard way. */
196 w(b,(unsigned long)(ptr[i]),8);
198 /* aligned block copy */
199 if(b->endbyte+bytes+1>=b->storage){
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);
207 b->ptr=b->buffer+b->endbyte;
210 memmove(b->ptr,source,bytes);
218 w(b,(unsigned long)(ptr[bytes]>>(8-bits)),bits);
220 w(b,(unsigned long)(ptr[bytes]),bits);
224 oggpack_writeclear(b);
227 void oggpack_writecopy(oggpack_buffer *b,void *source,long bits){
228 oggpack_writecopy_helper(b,source,bits,oggpack_write,0);
231 void oggpackB_writecopy(oggpack_buffer *b,void *source,long bits){
232 oggpack_writecopy_helper(b,source,bits,oggpackB_write,1);
235 void oggpack_reset(oggpack_buffer *b){
239 b->endbit=b->endbyte=0;
242 void oggpackB_reset(oggpack_buffer *b){
246 void oggpack_writeclear(oggpack_buffer *b){
247 if(b->buffer)_ogg_free(b->buffer);
248 memset(b,0,sizeof(*b));
251 void oggpackB_writeclear(oggpack_buffer *b){
252 oggpack_writeclear(b);
255 void oggpack_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
256 memset(b,0,sizeof(*b));
257 b->buffer=b->ptr=buf;
261 void oggpackB_readinit(oggpack_buffer *b,unsigned char *buf,int bytes){
262 oggpack_readinit(b,buf,bytes);
265 /* Read in bits without advancing the bitptr; bits <= 32 */
266 long oggpack_look(oggpack_buffer *b,int bits){
270 if(bits<0 || bits>32) return -1;
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);
282 ret=b->ptr[0]>>b->endbit;
284 ret|=b->ptr[1]<<(8-b->endbit);
286 ret|=b->ptr[2]<<(16-b->endbit);
288 ret|=b->ptr[3]<<(24-b->endbit);
289 if(bits>32 && b->endbit)
290 ret|=b->ptr[4]<<(32-b->endbit);
297 /* Read in bits without advancing the bitptr; bits <= 32 */
298 long oggpackB_look(oggpack_buffer *b,int bits){
302 if(m<0 || m>32) return -1;
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);
313 ret=b->ptr[0]<<(24+b->endbit);
315 ret|=b->ptr[1]<<(16+b->endbit);
317 ret|=b->ptr[2]<<(8+b->endbit);
319 ret|=b->ptr[3]<<(b->endbit);
320 if(bits>32 && b->endbit)
321 ret|=b->ptr[4]>>(8-b->endbit);
325 return ((ret&0xffffffff)>>(m>>1))>>((m+1)>>1);
328 long oggpack_look1(oggpack_buffer *b){
329 if(b->endbyte>=b->storage)return(-1);
330 return((b->ptr[0]>>b->endbit)&1);
333 long oggpackB_look1(oggpack_buffer *b){
334 if(b->endbyte>=b->storage)return(-1);
335 return((b->ptr[0]>>(7-b->endbit))&1);
338 void oggpack_adv(oggpack_buffer *b,int bits){
341 if(b->endbyte > b->storage-((bits+7)>>3)) goto overflow;
350 b->endbyte=b->storage;
354 void oggpackB_adv(oggpack_buffer *b,int bits){
358 void oggpack_adv1(oggpack_buffer *b){
366 void oggpackB_adv1(oggpack_buffer *b){
371 long oggpack_read(oggpack_buffer *b,int bits){
375 if(bits<0 || bits>32) goto err;
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);
387 ret=b->ptr[0]>>b->endbit;
389 ret|=b->ptr[1]<<(8-b->endbit);
391 ret|=b->ptr[2]<<(16-b->endbit);
393 ret|=b->ptr[3]<<(24-b->endbit);
394 if(bits>32 && b->endbit){
395 ret|=b->ptr[4]<<(32-b->endbit);
409 b->endbyte=b->storage;
415 long oggpackB_read(oggpack_buffer *b,int bits){
419 if(m<0 || m>32) goto err;
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);
430 ret=b->ptr[0]<<(24+b->endbit);
432 ret|=b->ptr[1]<<(16+b->endbit);
434 ret|=b->ptr[2]<<(8+b->endbit);
436 ret|=b->ptr[3]<<(b->endbit);
437 if(bits>32 && b->endbit)
438 ret|=b->ptr[4]>>(8-b->endbit);
442 ret=((ret&0xffffffffUL)>>(m>>1))>>((m+1)>>1);
452 b->endbyte=b->storage;
457 long oggpack_read1(oggpack_buffer *b){
460 if(b->endbyte >= b->storage) goto overflow;
461 ret=(b->ptr[0]>>b->endbit)&1;
473 b->endbyte=b->storage;
478 long oggpackB_read1(oggpack_buffer *b){
481 if(b->endbyte >= b->storage) goto overflow;
482 ret=(b->ptr[0]>>(7-b->endbit))&1;
494 b->endbyte=b->storage;
499 long oggpack_bytes(oggpack_buffer *b){
500 return(b->endbyte+(b->endbit+7)/8);
503 long oggpack_bits(oggpack_buffer *b){
504 return(b->endbyte*8+b->endbit);
507 long oggpackB_bytes(oggpack_buffer *b){
508 return oggpack_bytes(b);
511 long oggpackB_bits(oggpack_buffer *b){
512 return oggpack_bits(b);
515 unsigned char *oggpack_get_buffer(oggpack_buffer *b){
519 unsigned char *oggpackB_get_buffer(oggpack_buffer *b){
520 return oggpack_get_buffer(b);
523 /* Self test of the bitwise routines; everything else is based on
524 them, so they damned well better be solid. */
529 static int ilog(unsigned int v){
541 void report(char *in){
542 fprintf(stderr,"%s",in);
546 void cliptest(unsigned long *b,int vals,int bits,int *comp,int compsize){
548 unsigned char *buffer;
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");
560 oggpack_readinit(&r,buffer,bytes);
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");
568 if(oggpack_look1(&r)!=(b[i]&mask[tbit]))
569 report("looked at single bit incorrect value!\n");
571 if(oggpack_read1(&r)!=(b[i]&mask[tbit]))
572 report("read incorrect single bit value!\n");
574 if(oggpack_read(&r,tbit)!=(b[i]&mask[tbit]))
575 report("read incorrect value!\n");
578 if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
581 void cliptestB(unsigned long *b,int vals,int bits,int *comp,int compsize){
583 unsigned char *buffer;
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");
595 oggpackB_readinit(&r,buffer,bytes);
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");
603 if(oggpackB_look1(&r)!=(b[i]&mask[tbit]))
604 report("looked at single bit incorrect value!\n");
606 if(oggpackB_read1(&r)!=(b[i]&mask[tbit]))
607 report("read incorrect single bit value!\n");
609 if(oggpackB_read(&r,tbit)!=(b[i]&mask[tbit]))
610 report("read incorrect value!\n");
613 if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
617 unsigned char *buffer;
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};
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};
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};
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};
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,
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,
649 static int two[6]={61,255,255,251,231,29};
650 static int twoB[6]={247,63,255,253,249,120};
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};
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,
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,
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};
679 static int six[7]={17,177,170,242,169,19,148};
680 static int sixB[7]={136,141,85,79,149,200,41};
682 /* Test read/write together */
683 /* Later we test against pregenerated bitstreams */
684 oggpack_writeinit(&o);
686 fprintf(stderr,"\nSmall preclipped packing (LSb): ");
687 cliptest(testbuffer1,test1size,0,one,onesize);
688 fprintf(stderr,"ok.");
690 fprintf(stderr,"\nNull bit call (LSb): ");
691 cliptest(testbuffer3,test3size,0,two,twosize);
692 fprintf(stderr,"ok.");
694 fprintf(stderr,"\nLarge preclipped packing (LSb): ");
695 cliptest(testbuffer2,test2size,0,three,threesize);
696 fprintf(stderr,"ok.");
698 fprintf(stderr,"\n32 bit preclipped packing (LSb): ");
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");
714 if(oggpack_bytes(&r)!=bytes)report("leftover bytes after read!\n");
715 fprintf(stderr,"ok.");
717 fprintf(stderr,"\nSmall unclipped packing (LSb): ");
718 cliptest(testbuffer1,test1size,7,four,foursize);
719 fprintf(stderr,"ok.");
721 fprintf(stderr,"\nLarge unclipped packing (LSb): ");
722 cliptest(testbuffer2,test2size,17,five,fivesize);
723 fprintf(stderr,"ok.");
725 fprintf(stderr,"\nSingle bit unclipped packing (LSb): ");
726 cliptest(testbuffer3,test3size,1,six,sixsize);
727 fprintf(stderr,"ok.");
729 fprintf(stderr,"\nTesting read past end (LSb): ");
730 oggpack_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
732 if(oggpack_read(&r,1)!=0){
733 fprintf(stderr,"failed; got -1 prematurely.\n");
737 if(oggpack_look(&r,1)!=-1 ||
738 oggpack_read(&r,1)!=-1){
739 fprintf(stderr,"failed; read past end without -1.\n");
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");
748 if(oggpack_look(&r,18)!=0 ||
749 oggpack_look(&r,18)!=0){
750 fprintf(stderr,"failed 3; got -1 prematurely.\n");
753 if(oggpack_look(&r,19)!=-1 ||
754 oggpack_look(&r,19)!=-1){
755 fprintf(stderr,"failed; read past end without -1.\n");
758 if(oggpack_look(&r,32)!=-1 ||
759 oggpack_look(&r,32)!=-1){
760 fprintf(stderr,"failed; read past end without -1.\n");
763 oggpack_writeclear(&o);
764 fprintf(stderr,"ok.\n");
766 /********** lazy, cut-n-paste retest with MSb packing ***********/
768 /* Test read/write together */
769 /* Later we test against pregenerated bitstreams */
770 oggpackB_writeinit(&o);
772 fprintf(stderr,"\nSmall preclipped packing (MSb): ");
773 cliptestB(testbuffer1,test1size,0,oneB,onesize);
774 fprintf(stderr,"ok.");
776 fprintf(stderr,"\nNull bit call (MSb): ");
777 cliptestB(testbuffer3,test3size,0,twoB,twosize);
778 fprintf(stderr,"ok.");
780 fprintf(stderr,"\nLarge preclipped packing (MSb): ");
781 cliptestB(testbuffer2,test2size,0,threeB,threesize);
782 fprintf(stderr,"ok.");
784 fprintf(stderr,"\n32 bit preclipped packing (MSb): ");
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");
800 if(oggpackB_bytes(&r)!=bytes)report("leftover bytes after read!\n");
801 fprintf(stderr,"ok.");
803 fprintf(stderr,"\nSmall unclipped packing (MSb): ");
804 cliptestB(testbuffer1,test1size,7,fourB,foursize);
805 fprintf(stderr,"ok.");
807 fprintf(stderr,"\nLarge unclipped packing (MSb): ");
808 cliptestB(testbuffer2,test2size,17,fiveB,fivesize);
809 fprintf(stderr,"ok.");
811 fprintf(stderr,"\nSingle bit unclipped packing (MSb): ");
812 cliptestB(testbuffer3,test3size,1,sixB,sixsize);
813 fprintf(stderr,"ok.");
815 fprintf(stderr,"\nTesting read past end (MSb): ");
816 oggpackB_readinit(&r,(unsigned char *)"\0\0\0\0\0\0\0\0",8);
818 if(oggpackB_read(&r,1)!=0){
819 fprintf(stderr,"failed; got -1 prematurely.\n");
823 if(oggpackB_look(&r,1)!=-1 ||
824 oggpackB_read(&r,1)!=-1){
825 fprintf(stderr,"failed; read past end without -1.\n");
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");
834 if(oggpackB_look(&r,18)!=0 ||
835 oggpackB_look(&r,18)!=0){
836 fprintf(stderr,"failed 3; got -1 prematurely.\n");
839 if(oggpackB_look(&r,19)!=-1 ||
840 oggpackB_look(&r,19)!=-1){
841 fprintf(stderr,"failed; read past end without -1.\n");
844 if(oggpackB_look(&r,32)!=-1 ||
845 oggpackB_look(&r,32)!=-1){
846 fprintf(stderr,"failed; read past end without -1.\n");
849 oggpackB_writeclear(&o);
850 fprintf(stderr,"ok.\n\n");
855 #endif /* _V_SELFTEST */
857 #undef BUFFER_INCREMENT