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