The Tor Browser / file comparison

comparison: media/libogg/src/ogg_bitwise.c

media/libogg/src/ogg_bitwise.c

branch
TOR_BUG_9701
changeset 10
ac0c01689b40
equal deleted inserted replaced
-1:000000000000 0:fae81266a1b0
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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial