vrshoot: b2f14e535253 libs/ogg/bitwise.c

vrshoot

view libs/ogg/bitwise.c @ 0:b2f14e535253

initial commit

author	John Tsiombikas <nuclear@member.fsf.org>
date	Sat, 01 Feb 2014 19:58:19 +0200
parents
children

line source

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 * *

9 * by the Xiph.Org Foundation http://www.xiph.org/ *

10 * *

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 */

21 #include <string.h>

22 #include <stdlib.h>

23 #include <limits.h>

24 #include <ogg/ogg.h>

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);

43 b->buffer[0]='\0';

44 b->storage=BUFFER_INCREMENT;

45 }

47 void oggpackB_writeinit(oggpack_buffer *b){

48 oggpack_writeinit(b);

49 }

51 int oggpack_writecheck(oggpack_buffer *b){

52 if(!b->ptr || !b->storage)return -1;

53 return 0;

54 }

56 int oggpackB_writecheck(oggpack_buffer *b){

57 return oggpack_writecheck(b);

58 }

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 }

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 }

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 }

96 value&=mask[bits];

97 bits+=b->endbit;

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