1--- libmad-0.15.1b/bit.c.mp3-crash 2004-01-23 11:41:32.000000000 +0200 2+++ libmad-0.15.1b/bit.c 2016-06-24 21:47:38.731671829 +0300 3@@ -85,6 +85,176 @@ 4 * NAME: bit->init() 5 * DESCRIPTION: initialize bit pointer struct 6 */ 7+void mad_bit_w_len_init(struct mad_bit_w_lenptr *bitptr, unsigned char const *byte, unsigned int length) 8+{ 9+ bitptr->byte = byte; 10+ bitptr->cache = 0; 11+ bitptr->left = CHAR_BIT; 12+ bitptr->length = length; 13+} 14+ 15+/* 16+ * NAME: bit->length() 17+ * DESCRIPTION: return number of bits between start and end points 18+ */ 19+unsigned int mad_bit_w_len_length(struct mad_bit_w_lenptr const *begin, 20+ struct mad_bit_w_lenptr const *end) 21+{ 22+ return begin->left + 23+ CHAR_BIT * (end->byte - (begin->byte + 1)) + (CHAR_BIT - end->left); 24+} 25+ 26+/* 27+ * NAME: bit->nextbyte() 28+ * DESCRIPTION: return pointer to next unprocessed byte 29+ */ 30+unsigned char const *mad_bit_w_len_nextbyte(struct mad_bit_w_lenptr const *bitptr) 31+{ 32+ if (bitptr->left == CHAR_BIT) 33+ return bitptr->byte; 34+ if (bitptr->length == 0) 35+ return 0; 36+ return bitptr->byte + 1; 37+} 38+ 39+/* 40+ * NAME: bit->skip() 41+ * DESCRIPTION: advance bit pointer 42+ */ 43+void mad_bit_w_len_skip(struct mad_bit_w_lenptr *bitptr, unsigned int len) 44+{ 45+ if (bitptr->length < len / CHAR_BIT) 46+ return; 47+ bitptr->byte += len / CHAR_BIT; 48+ bitptr->left -= len % CHAR_BIT; 49+ bitptr->length -= len / CHAR_BIT; 50+ 51+ if (bitptr->left > CHAR_BIT) { 52+ if (bitptr->length == 0) 53+ return; 54+ bitptr->byte++; 55+ bitptr->length--; 56+ bitptr->left += CHAR_BIT; 57+ } 58+ 59+ if (bitptr->left < CHAR_BIT) 60+ bitptr->cache = *bitptr->byte; 61+} 62+ 63+/* 64+ * NAME: bit->read() 65+ * DESCRIPTION: read an arbitrary number of bits and return their UIMSBF value 66+ */ 67+unsigned long mad_bit_w_len_read(struct mad_bit_w_lenptr *bitptr, unsigned int len) 68+{ 69+ register unsigned long value; 70+ 71+ if (bitptr->left == CHAR_BIT) 72+ bitptr->cache = *bitptr->byte; 73+ 74+ if (len < bitptr->left) { 75+ value = (bitptr->cache & ((1 << bitptr->left) - 1)) >> 76+ (bitptr->left - len); 77+ bitptr->left -= len; 78+ 79+ return value; 80+ } 81+ 82+ /* remaining bits in current byte */ 83+ 84+ value = bitptr->cache & ((1 << bitptr->left) - 1); 85+ len -= bitptr->left; 86+ 87+ if (bitptr->length == 0) 88+ return value; 89+ bitptr->byte++; 90+ bitptr->length--; 91+ bitptr->left = CHAR_BIT; 92+ 93+ /* more bytes */ 94+ 95+ while (len >= CHAR_BIT && bitptr->length > 0) { 96+ value = (value << CHAR_BIT) | *bitptr->byte++; 97+ bitptr->length--; 98+ len -= CHAR_BIT; 99+ } 100+ 101+ if (len > 0 && bitptr->length > 0) { 102+ bitptr->cache = *bitptr->byte; 103+ 104+ value = (value << len) | (bitptr->cache >> (CHAR_BIT - len)); 105+ bitptr->left -= len; 106+ } 107+ 108+ return value; 109+} 110+ 111+# if 0 112+/* 113+ * NAME: bit->write() 114+ * DESCRIPTION: write an arbitrary number of bits 115+ */ 116+void mad_bit_w_len_write(struct mad_bit_w_lenptr *bitptr, unsigned int len, 117+ unsigned long value) 118+{ 119+ unsigned char *ptr; 120+ 121+ ptr = (unsigned char *) bitptr->byte; 122+ 123+ /* ... */ 124+} 125+# endif 126+ 127+/* 128+ * NAME: bit->crc() 129+ * DESCRIPTION: compute CRC-check word 130+ */ 131+unsigned short mad_bit_w_len_crc(struct mad_bit_w_lenptr bitptr, unsigned int len, 132+ unsigned short init) 133+{ 134+ register unsigned int crc; 135+ 136+ for (crc = init; len >= 32; len -= 32) { 137+ register unsigned long data; 138+ 139+ data = mad_bit_w_len_read(&bitptr, 32); 140+ 141+ crc = (crc << 8) ^ crc_table[((crc >> 8) ^ (data >> 24)) & 0xff]; 142+ crc = (crc << 8) ^ crc_table[((crc >> 8) ^ (data >> 16)) & 0xff]; 143+ crc = (crc << 8) ^ crc_table[((crc >> 8) ^ (data >> 8)) & 0xff]; 144+ crc = (crc << 8) ^ crc_table[((crc >> 8) ^ (data >> 0)) & 0xff]; 145+ } 146+ 147+ switch (len / 8) { 148+ case 3: crc = (crc << 8) ^ 149+ crc_table[((crc >> 8) ^ mad_bit_w_len_read(&bitptr, 8)) & 0xff]; 150+ case 2: crc = (crc << 8) ^ 151+ crc_table[((crc >> 8) ^ mad_bit_w_len_read(&bitptr, 8)) & 0xff]; 152+ case 1: crc = (crc << 8) ^ 153+ crc_table[((crc >> 8) ^ mad_bit_w_len_read(&bitptr, 8)) & 0xff]; 154+ 155+ len %= 8; 156+ 157+ case 0: break; 158+ } 159+ 160+ while (len--) { 161+ register unsigned int msb; 162+ 163+ msb = mad_bit_w_len_read(&bitptr, 1) ^ (crc >> 15); 164+ 165+ crc <<= 1; 166+ if (msb & 1) 167+ crc ^= CRC_POLY; 168+ } 169+ 170+ return crc & 0xffff; 171+} 172+ 173+/* 174+ * NAME: bit->init() 175+ * DESCRIPTION: initialize bit pointer struct 176+ */ 177 void mad_bit_init(struct mad_bitptr *bitptr, unsigned char const *byte) 178 { 179 bitptr->byte = byte; 180--- libmad-0.15.1b/bit.h.mp3-crash 2004-01-23 11:41:32.000000000 +0200 181+++ libmad-0.15.1b/bit.h 2016-06-24 21:47:38.731671829 +0300 182@@ -22,6 +22,29 @@ 183 # ifndef LIBMAD_BIT_H 184 # define LIBMAD_BIT_H 185 186+struct mad_bit_w_lenptr { 187+ unsigned char const *byte; 188+ unsigned short cache; 189+ unsigned short left; 190+ unsigned int length; 191+}; 192+ 193+void mad_bit_w_len_init(struct mad_bit_w_lenptr *, unsigned char const *, unsigned int length); 194+ 195+# define mad_bit_w_len_finish(bitptr) /* nothing */ 196+ 197+unsigned int mad_bit_w_len_length(struct mad_bit_w_lenptr const *, 198+ struct mad_bit_w_lenptr const *); 199+ 200+# define mad_bit_w_len_bitsleft(bitptr) ((bitptr)->left) 201+unsigned char const *mad_bit_w_len_nextbyte(struct mad_bit_w_lenptr const *); 202+ 203+void mad_bit_w_len_skip(struct mad_bit_w_lenptr *, unsigned int); 204+unsigned long mad_bit_w_len_read(struct mad_bit_w_lenptr *, unsigned int); 205+void mad_bit_w_len_write(struct mad_bit_w_lenptr *, unsigned int, unsigned long); 206+ 207+unsigned short mad_bit_w_len_crc(struct mad_bit_w_lenptr, unsigned int, unsigned short); 208+ 209 struct mad_bitptr { 210 unsigned char const *byte; 211 unsigned short cache; 212--- libmad-0.15.1b/frame.c.mp3-crash 2004-02-05 00:59:19.000000000 +0200 213+++ libmad-0.15.1b/frame.c 2016-06-24 21:47:38.731671829 +0300 214@@ -127,14 +127,14 @@ 215 /* header() */ 216 217 /* syncword */ 218- mad_bit_skip(&stream->ptr, 11); 219+ mad_bit_w_len_skip(stream->l_ptr, 11); 220 221 /* MPEG 2.5 indicator (really part of syncword) */ 222- if (mad_bit_read(&stream->ptr, 1) == 0) 223+ if (mad_bit_w_len_read(stream->l_ptr, 1) == 0) 224 header->flags |= MAD_FLAG_MPEG_2_5_EXT; 225 226 /* ID */ 227- if (mad_bit_read(&stream->ptr, 1) == 0) 228+ if (mad_bit_w_len_read(stream->l_ptr, 1) == 0) 229 header->flags |= MAD_FLAG_LSF_EXT; 230 else if (header->flags & MAD_FLAG_MPEG_2_5_EXT) { 231 stream->error = MAD_ERROR_LOSTSYNC; 232@@ -142,7 +142,7 @@ 233 } 234 235 /* layer */ 236- header->layer = 4 - mad_bit_read(&stream->ptr, 2); 237+ header->layer = 4 - mad_bit_w_len_read(stream->l_ptr, 2); 238 239 if (header->layer == 4) { 240 stream->error = MAD_ERROR_BADLAYER; 241@@ -150,13 +150,13 @@ 242 } 243 244 /* protection_bit */ 245- if (mad_bit_read(&stream->ptr, 1) == 0) { 246+ if (mad_bit_w_len_read(stream->l_ptr, 1) == 0) { 247 header->flags |= MAD_FLAG_PROTECTION; 248- header->crc_check = mad_bit_crc(stream->ptr, 16, 0xffff); 249+ header->crc_check = mad_bit_w_len_crc(*(stream->l_ptr), 16, 0xffff); 250 } 251 252 /* bitrate_index */ 253- index = mad_bit_read(&stream->ptr, 4); 254+ index = mad_bit_w_len_read(stream->l_ptr, 4); 255 256 if (index == 15) { 257 stream->error = MAD_ERROR_BADBITRATE; 258@@ -169,7 +169,7 @@ 259 header->bitrate = bitrate_table[header->layer - 1][index]; 260 261 /* sampling_frequency */ 262- index = mad_bit_read(&stream->ptr, 2); 263+ index = mad_bit_w_len_read(stream->l_ptr, 2); 264 265 if (index == 3) { 266 stream->error = MAD_ERROR_BADSAMPLERATE; 267@@ -186,29 +186,29 @@ 268 } 269 270 /* padding_bit */ 271- if (mad_bit_read(&stream->ptr, 1)) 272+ if (mad_bit_w_len_read(stream->l_ptr, 1)) 273 header->flags |= MAD_FLAG_PADDING; 274 275 /* private_bit */ 276- if (mad_bit_read(&stream->ptr, 1)) 277+ if (mad_bit_w_len_read(stream->l_ptr, 1)) 278 header->private_bits |= MAD_PRIVATE_HEADER; 279 280 /* mode */ 281- header->mode = 3 - mad_bit_read(&stream->ptr, 2); 282+ header->mode = 3 - mad_bit_w_len_read(stream->l_ptr, 2); 283 284 /* mode_extension */ 285- header->mode_extension = mad_bit_read(&stream->ptr, 2); 286+ header->mode_extension = mad_bit_w_len_read(stream->l_ptr, 2); 287 288 /* copyright */ 289- if (mad_bit_read(&stream->ptr, 1)) 290+ if (mad_bit_w_len_read(stream->l_ptr, 1)) 291 header->flags |= MAD_FLAG_COPYRIGHT; 292 293 /* original/copy */ 294- if (mad_bit_read(&stream->ptr, 1)) 295+ if (mad_bit_w_len_read(stream->l_ptr, 1)) 296 header->flags |= MAD_FLAG_ORIGINAL; 297 298 /* emphasis */ 299- header->emphasis = mad_bit_read(&stream->ptr, 2); 300+ header->emphasis = mad_bit_w_len_read(stream->l_ptr, 2); 301 302 # if defined(OPT_STRICT) 303 /* 304@@ -226,7 +226,7 @@ 305 306 /* crc_check */ 307 if (header->flags & MAD_FLAG_PROTECTION) 308- header->crc_target = mad_bit_read(&stream->ptr, 16); 309+ header->crc_target = mad_bit_w_len_read(stream->l_ptr, 16); 310 311 return 0; 312 } 313@@ -238,12 +238,12 @@ 314 static 315 int free_bitrate(struct mad_stream *stream, struct mad_header const *header) 316 { 317- struct mad_bitptr keep_ptr; 318+ struct mad_bit_w_lenptr keep_ptr; 319 unsigned long rate = 0; 320 unsigned int pad_slot, slots_per_frame; 321 unsigned char const *ptr = 0; 322 323- keep_ptr = stream->ptr; 324+ keep_ptr = *stream->l_ptr; 325 326 pad_slot = (header->flags & MAD_FLAG_PADDING) ? 1 : 0; 327 slots_per_frame = (header->layer == MAD_LAYER_III && 328@@ -261,7 +261,7 @@ 329 peek_header.samplerate == header->samplerate) { 330 unsigned int N; 331 332- ptr = mad_bit_nextbyte(&stream->ptr); 333+ ptr = mad_bit_w_len_nextbyte(stream->l_ptr); 334 335 N = ptr - stream->this_frame; 336 337@@ -278,10 +278,10 @@ 338 break; 339 } 340 341- mad_bit_skip(&stream->ptr, 8); 342+ mad_bit_w_len_skip(stream->l_ptr, 8); 343 } 344 345- stream->ptr = keep_ptr; 346+ *stream->l_ptr = keep_ptr; 347 348 if (rate < 8 || (header->layer == MAD_LAYER_III && rate > 640)) { 349 stream->error = MAD_ERROR_LOSTSYNC; 350@@ -348,7 +348,7 @@ 351 } 352 } 353 else { 354- mad_bit_init(&stream->ptr, ptr); 355+ mad_bit_w_len_init(stream->l_ptr, ptr, stream->bufend - ptr); 356 357 if (mad_stream_sync(stream) == -1) { 358 if (end - stream->next_frame >= MAD_BUFFER_GUARD) 359@@ -358,14 +358,14 @@ 360 goto fail; 361 } 362 363- ptr = mad_bit_nextbyte(&stream->ptr); 364+ ptr = mad_bit_w_len_nextbyte(stream->l_ptr); 365 } 366 367 /* begin processing */ 368 stream->this_frame = ptr; 369 stream->next_frame = ptr + 1; /* possibly bogus sync word */ 370 371- mad_bit_init(&stream->ptr, stream->this_frame); 372+ mad_bit_w_len_init(stream->l_ptr, stream->this_frame, stream->bufend - stream->this_frame); 373 374 if (decode_header(header, stream) == -1) 375 goto fail; 376@@ -460,14 +460,16 @@ 377 /* ancillary_data() */ 378 379 if (frame->header.layer != MAD_LAYER_III) { 380- struct mad_bitptr next_frame; 381+ struct mad_bit_w_lenptr next_frame; 382 383- mad_bit_init(&next_frame, stream->next_frame); 384+ mad_bit_w_len_init(&next_frame, stream->next_frame, stream->bufend - stream->next_frame); 385 386- stream->anc_ptr = stream->ptr; 387- stream->anc_bitlen = mad_bit_length(&stream->ptr, &next_frame); 388+ if (stream->l_ptr != stream->l_anc_ptr) 389+ free(stream->l_anc_ptr); 390+ stream->l_anc_ptr = stream->l_ptr; 391+ stream->anc_bitlen = mad_bit_w_len_length(stream->l_ptr, &next_frame); 392 393- mad_bit_finish(&next_frame); 394+ mad_bit_w_len_finish(&next_frame); 395 } 396 397 return 0; 398--- libmad-0.15.1b/layer12.c.mp3-crash 2004-02-05 11:02:39.000000000 +0200 399+++ libmad-0.15.1b/layer12.c 2016-06-24 21:47:38.731671829 +0300 400@@ -72,11 +72,11 @@ 401 * DESCRIPTION: decode one requantized Layer I sample from a bitstream 402 */ 403 static 404-mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb) 405+mad_fixed_t I_sample(struct mad_bit_w_lenptr *ptr, unsigned int nb) 406 { 407 mad_fixed_t sample; 408 409- sample = mad_bit_read(ptr, nb); 410+ sample = mad_bit_w_len_read(ptr, nb); 411 412 /* invert most significant bit, extend sign, then scale to fixed format */ 413 414@@ -119,7 +119,7 @@ 415 416 if (header->flags & MAD_FLAG_PROTECTION) { 417 header->crc_check = 418- mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)), 419+ mad_bit_w_len_crc(*stream->l_ptr, 4 * (bound * nch + (32 - bound)), 420 header->crc_check); 421 422 if (header->crc_check != header->crc_target && 423@@ -133,7 +133,7 @@ 424 425 for (sb = 0; sb < bound; ++sb) { 426 for (ch = 0; ch < nch; ++ch) { 427- nb = mad_bit_read(&stream->ptr, 4); 428+ nb = mad_bit_w_len_read(stream->l_ptr, 4); 429 430 if (nb == 15) { 431 stream->error = MAD_ERROR_BADBITALLOC; 432@@ -145,7 +145,7 @@ 433 } 434 435 for (sb = bound; sb < 32; ++sb) { 436- nb = mad_bit_read(&stream->ptr, 4); 437+ nb = mad_bit_w_len_read(stream->l_ptr, 4); 438 439 if (nb == 15) { 440 stream->error = MAD_ERROR_BADBITALLOC; 441@@ -161,7 +161,7 @@ 442 for (sb = 0; sb < 32; ++sb) { 443 for (ch = 0; ch < nch; ++ch) { 444 if (allocation[ch][sb]) { 445- scalefactor[ch][sb] = mad_bit_read(&stream->ptr, 6); 446+ scalefactor[ch][sb] = mad_bit_w_len_read(stream->l_ptr, 6); 447 448 # if defined(OPT_STRICT) 449 /* 450@@ -185,7 +185,7 @@ 451 for (ch = 0; ch < nch; ++ch) { 452 nb = allocation[ch][sb]; 453 frame->sbsample[ch][s][sb] = nb ? 454- mad_f_mul(I_sample(&stream->ptr, nb), 455+ mad_f_mul(I_sample(stream->l_ptr, nb), 456 sf_table[scalefactor[ch][sb]]) : 0; 457 } 458 } 459@@ -194,7 +194,7 @@ 460 if ((nb = allocation[0][sb])) { 461 mad_fixed_t sample; 462 463- sample = I_sample(&stream->ptr, nb); 464+ sample = I_sample(stream->l_ptr, nb); 465 466 for (ch = 0; ch < nch; ++ch) { 467 frame->sbsample[ch][s][sb] = 468@@ -278,7 +278,7 @@ 469 * DESCRIPTION: decode three requantized Layer II samples from a bitstream 470 */ 471 static 472-void II_samples(struct mad_bitptr *ptr, 473+void II_samples(struct mad_bit_w_lenptr *ptr, 474 struct quantclass const *quantclass, 475 mad_fixed_t output[3]) 476 { 477@@ -288,7 +288,7 @@ 478 unsigned int c, nlevels; 479 480 /* degrouping */ 481- c = mad_bit_read(ptr, quantclass->bits); 482+ c = mad_bit_w_len_read(ptr, quantclass->bits); 483 nlevels = quantclass->nlevels; 484 485 for (s = 0; s < 3; ++s) { 486@@ -300,7 +300,7 @@ 487 nb = quantclass->bits; 488 489 for (s = 0; s < 3; ++s) 490- sample[s] = mad_bit_read(ptr, nb); 491+ sample[s] = mad_bit_w_len_read(ptr, nb); 492 } 493 494 for (s = 0; s < 3; ++s) { 495@@ -331,7 +331,7 @@ 496 int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame) 497 { 498 struct mad_header *header = &frame->header; 499- struct mad_bitptr start; 500+ struct mad_bit_w_lenptr start; 501 unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb; 502 unsigned char const *offsets; 503 unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3]; 504@@ -395,7 +395,7 @@ 505 if (bound > sblimit) 506 bound = sblimit; 507 508- start = stream->ptr; 509+ start = *stream->l_ptr; 510 511 /* decode bit allocations */ 512 513@@ -403,14 +403,14 @@ 514 nbal = bitalloc_table[offsets[sb]].nbal; 515 516 for (ch = 0; ch < nch; ++ch) 517- allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal); 518+ allocation[ch][sb] = mad_bit_w_len_read(stream->l_ptr, nbal); 519 } 520 521 for (sb = bound; sb < sblimit; ++sb) { 522 nbal = bitalloc_table[offsets[sb]].nbal; 523 524 allocation[0][sb] = 525- allocation[1][sb] = mad_bit_read(&stream->ptr, nbal); 526+ allocation[1][sb] = mad_bit_w_len_read(stream->l_ptr, nbal); 527 } 528 529 /* decode scalefactor selection info */ 530@@ -418,7 +418,7 @@ 531 for (sb = 0; sb < sblimit; ++sb) { 532 for (ch = 0; ch < nch; ++ch) { 533 if (allocation[ch][sb]) 534- scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2); 535+ scfsi[ch][sb] = mad_bit_w_len_read(stream->l_ptr, 2); 536 } 537 } 538 539@@ -426,7 +426,7 @@ 540 541 if (header->flags & MAD_FLAG_PROTECTION) { 542 header->crc_check = 543- mad_bit_crc(start, mad_bit_length(&start, &stream->ptr), 544+ mad_bit_w_len_crc(start, mad_bit_w_len_length(&start, stream->l_ptr), 545 header->crc_check); 546 547 if (header->crc_check != header->crc_target && 548@@ -441,7 +441,7 @@ 549 for (sb = 0; sb < sblimit; ++sb) { 550 for (ch = 0; ch < nch; ++ch) { 551 if (allocation[ch][sb]) { 552- scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6); 553+ scalefactor[ch][sb][0] = mad_bit_w_len_read(stream->l_ptr, 6); 554 555 switch (scfsi[ch][sb]) { 556 case 2: 557@@ -451,12 +451,12 @@ 558 break; 559 560 case 0: 561- scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6); 562+ scalefactor[ch][sb][1] = mad_bit_w_len_read(stream->l_ptr, 6); 563 /* fall through */ 564 565 case 1: 566 case 3: 567- scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6); 568+ scalefactor[ch][sb][2] = mad_bit_w_len_read(stream->l_ptr, 6); 569 } 570 571 if (scfsi[ch][sb] & 1) 572@@ -487,7 +487,7 @@ 573 if ((index = allocation[ch][sb])) { 574 index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1]; 575 576- II_samples(&stream->ptr, &qc_table[index], samples); 577+ II_samples(stream->l_ptr, &qc_table[index], samples); 578 579 for (s = 0; s < 3; ++s) { 580 frame->sbsample[ch][3 * gr + s][sb] = 581@@ -505,7 +505,7 @@ 582 if ((index = allocation[0][sb])) { 583 index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1]; 584 585- II_samples(&stream->ptr, &qc_table[index], samples); 586+ II_samples(stream->l_ptr, &qc_table[index], samples); 587 588 for (ch = 0; ch < nch; ++ch) { 589 for (s = 0; s < 3; ++s) { 590--- libmad-0.15.1b/layer3.c.mp3-crash 2004-01-23 11:41:32.000000000 +0200 591+++ libmad-0.15.1b/layer3.c 2016-06-24 21:47:38.732671821 +0300 592@@ -505,7 +505,7 @@ 593 * DESCRIPTION: decode frame side information from a bitstream 594 */ 595 static 596-enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch, 597+enum mad_error III_sideinfo(struct mad_bit_w_lenptr *ptr, unsigned int nch, 598 int lsf, struct sideinfo *si, 599 unsigned int *data_bitlen, 600 unsigned int *priv_bitlen) 601@@ -516,15 +516,15 @@ 602 *data_bitlen = 0; 603 *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3); 604 605- si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9); 606- si->private_bits = mad_bit_read(ptr, *priv_bitlen); 607+ si->main_data_begin = mad_bit_w_len_read(ptr, lsf ? 8 : 9); 608+ si->private_bits = mad_bit_w_len_read(ptr, *priv_bitlen); 609 610 ngr = 1; 611 if (!lsf) { 612 ngr = 2; 613 614 for (ch = 0; ch < nch; ++ch) 615- si->scfsi[ch] = mad_bit_read(ptr, 4); 616+ si->scfsi[ch] = mad_bit_w_len_read(ptr, 4); 617 } 618 619 for (gr = 0; gr < ngr; ++gr) { 620@@ -533,10 +533,10 @@ 621 for (ch = 0; ch < nch; ++ch) { 622 struct channel *channel = &granule->ch[ch]; 623 624- channel->part2_3_length = mad_bit_read(ptr, 12); 625- channel->big_values = mad_bit_read(ptr, 9); 626- channel->global_gain = mad_bit_read(ptr, 8); 627- channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4); 628+ channel->part2_3_length = mad_bit_w_len_read(ptr, 12); 629+ channel->big_values = mad_bit_w_len_read(ptr, 9); 630+ channel->global_gain = mad_bit_w_len_read(ptr, 8); 631+ channel->scalefac_compress = mad_bit_w_len_read(ptr, lsf ? 9 : 4); 632 633 *data_bitlen += channel->part2_3_length; 634 635@@ -546,8 +546,8 @@ 636 channel->flags = 0; 637 638 /* window_switching_flag */ 639- if (mad_bit_read(ptr, 1)) { 640- channel->block_type = mad_bit_read(ptr, 2); 641+ if (mad_bit_w_len_read(ptr, 1)) { 642+ channel->block_type = mad_bit_w_len_read(ptr, 2); 643 644 if (channel->block_type == 0 && result == 0) 645 result = MAD_ERROR_BADBLOCKTYPE; 646@@ -558,33 +558,33 @@ 647 channel->region0_count = 7; 648 channel->region1_count = 36; 649 650- if (mad_bit_read(ptr, 1)) 651+ if (mad_bit_w_len_read(ptr, 1)) 652 channel->flags |= mixed_block_flag; 653 else if (channel->block_type == 2) 654 channel->region0_count = 8; 655 656 for (i = 0; i < 2; ++i) 657- channel->table_select[i] = mad_bit_read(ptr, 5); 658+ channel->table_select[i] = mad_bit_w_len_read(ptr, 5); 659 660 # if defined(DEBUG) 661 channel->table_select[2] = 4; /* not used */ 662 # endif 663 664 for (i = 0; i < 3; ++i) 665- channel->subblock_gain[i] = mad_bit_read(ptr, 3); 666+ channel->subblock_gain[i] = mad_bit_w_len_read(ptr, 3); 667 } 668 else { 669 channel->block_type = 0; 670 671 for (i = 0; i < 3; ++i) 672- channel->table_select[i] = mad_bit_read(ptr, 5); 673+ channel->table_select[i] = mad_bit_w_len_read(ptr, 5); 674 675- channel->region0_count = mad_bit_read(ptr, 4); 676- channel->region1_count = mad_bit_read(ptr, 3); 677+ channel->region0_count = mad_bit_w_len_read(ptr, 4); 678+ channel->region1_count = mad_bit_w_len_read(ptr, 3); 679 } 680 681 /* [preflag,] scalefac_scale, count1table_select */ 682- channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3); 683+ channel->flags |= mad_bit_w_len_read(ptr, lsf ? 2 : 3); 684 } 685 } 686 687@@ -596,11 +596,11 @@ 688 * DESCRIPTION: decode channel scalefactors for LSF from a bitstream 689 */ 690 static 691-unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr, 692+unsigned int III_scalefactors_lsf(struct mad_bit_w_lenptr *ptr, 693 struct channel *channel, 694 struct channel *gr1ch, int mode_extension) 695 { 696- struct mad_bitptr start; 697+ struct mad_bit_w_lenptr start; 698 unsigned int scalefac_compress, index, slen[4], part, n, i; 699 unsigned char const *nsfb; 700 701@@ -645,7 +645,7 @@ 702 n = 0; 703 for (part = 0; part < 4; ++part) { 704 for (i = 0; i < nsfb[part]; ++i) 705- channel->scalefac[n++] = mad_bit_read(ptr, slen[part]); 706+ channel->scalefac[n++] = mad_bit_w_len_read(ptr, slen[part]); 707 } 708 709 while (n < 39) 710@@ -690,7 +690,7 @@ 711 max = (1 << slen[part]) - 1; 712 713 for (i = 0; i < nsfb[part]; ++i) { 714- is_pos = mad_bit_read(ptr, slen[part]); 715+ is_pos = mad_bit_w_len_read(ptr, slen[part]); 716 717 channel->scalefac[n] = is_pos; 718 gr1ch->scalefac[n++] = (is_pos == max); 719@@ -703,7 +703,7 @@ 720 } 721 } 722 723- return mad_bit_length(&start, ptr); 724+ return mad_bit_w_len_length(&start, ptr); 725 } 726 727 /* 728@@ -711,10 +711,10 @@ 729 * DESCRIPTION: decode channel scalefactors of one granule from a bitstream 730 */ 731 static 732-unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel, 733+unsigned int III_scalefactors(struct mad_bit_w_lenptr *ptr, struct channel *channel, 734 struct channel const *gr0ch, unsigned int scfsi) 735 { 736- struct mad_bitptr start; 737+ struct mad_bit_w_lenptr start; 738 unsigned int slen1, slen2, sfbi; 739 740 start = *ptr; 741@@ -729,11 +729,11 @@ 742 743 nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3; 744 while (nsfb--) 745- channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1); 746+ channel->scalefac[sfbi++] = mad_bit_w_len_read(ptr, slen1); 747 748 nsfb = 6 * 3; 749 while (nsfb--) 750- channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2); 751+ channel->scalefac[sfbi++] = mad_bit_w_len_read(ptr, slen2); 752 753 nsfb = 1 * 3; 754 while (nsfb--) 755@@ -746,7 +746,7 @@ 756 } 757 else { 758 for (sfbi = 0; sfbi < 6; ++sfbi) 759- channel->scalefac[sfbi] = mad_bit_read(ptr, slen1); 760+ channel->scalefac[sfbi] = mad_bit_w_len_read(ptr, slen1); 761 } 762 763 if (scfsi & 0x4) { 764@@ -755,7 +755,7 @@ 765 } 766 else { 767 for (sfbi = 6; sfbi < 11; ++sfbi) 768- channel->scalefac[sfbi] = mad_bit_read(ptr, slen1); 769+ channel->scalefac[sfbi] = mad_bit_w_len_read(ptr, slen1); 770 } 771 772 if (scfsi & 0x2) { 773@@ -764,7 +764,7 @@ 774 } 775 else { 776 for (sfbi = 11; sfbi < 16; ++sfbi) 777- channel->scalefac[sfbi] = mad_bit_read(ptr, slen2); 778+ channel->scalefac[sfbi] = mad_bit_w_len_read(ptr, slen2); 779 } 780 781 if (scfsi & 0x1) { 782@@ -773,13 +773,13 @@ 783 } 784 else { 785 for (sfbi = 16; sfbi < 21; ++sfbi) 786- channel->scalefac[sfbi] = mad_bit_read(ptr, slen2); 787+ channel->scalefac[sfbi] = mad_bit_w_len_read(ptr, slen2); 788 } 789 790 channel->scalefac[21] = 0; 791 } 792 793- return mad_bit_length(&start, ptr); 794+ return mad_bit_w_len_length(&start, ptr); 795 } 796 797 /* 798@@ -930,14 +930,14 @@ 799 * DESCRIPTION: decode Huffman code words of one channel of one granule 800 */ 801 static 802-enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576], 803+enum mad_error III_huffdecode(struct mad_bit_w_lenptr *ptr, mad_fixed_t xr[576], 804 struct channel *channel, 805 unsigned char const *sfbwidth, 806 unsigned int part2_length) 807 { 808 signed int exponents[39], exp; 809 signed int const *expptr; 810- struct mad_bitptr peek; 811+ struct mad_bit_w_lenptr peek; 812 signed int bits_left, cachesz; 813 register mad_fixed_t *xrptr; 814 mad_fixed_t const *sfbound; 815@@ -950,13 +950,13 @@ 816 III_exponents(channel, sfbwidth, exponents); 817 818 peek = *ptr; 819- mad_bit_skip(ptr, bits_left); 820+ mad_bit_w_len_skip(ptr, bits_left); 821 822 /* align bit reads to byte boundaries */ 823- cachesz = mad_bit_bitsleft(&peek); 824+ cachesz = mad_bit_w_len_bitsleft(&peek); 825 cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7; 826 827- bitcache = mad_bit_read(&peek, cachesz); 828+ bitcache = mad_bit_w_len_read(&peek, cachesz); 829 bits_left -= cachesz; 830 831 xrptr = &xr[0]; 832@@ -1023,7 +1023,7 @@ 833 unsigned int bits; 834 835 bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7; 836- bitcache = (bitcache << bits) | mad_bit_read(&peek, bits); 837+ bitcache = (bitcache << bits) | mad_bit_w_len_read(&peek, bits); 838 cachesz += bits; 839 bits_left -= bits; 840 } 841@@ -1054,7 +1054,7 @@ 842 843 case 15: 844 if (cachesz < linbits + 2) { 845- bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 846+ bitcache = (bitcache << 16) | mad_bit_w_len_read(&peek, 16); 847 cachesz += 16; 848 bits_left -= 16; 849 } 850@@ -1089,7 +1089,7 @@ 851 852 case 15: 853 if (cachesz < linbits + 1) { 854- bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 855+ bitcache = (bitcache << 16) | mad_bit_w_len_read(&peek, 16); 856 cachesz += 16; 857 bits_left -= 16; 858 } 859@@ -1173,7 +1173,7 @@ 860 /* hcod (1..6) */ 861 862 if (cachesz < 10) { 863- bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); 864+ bitcache = (bitcache << 16) | mad_bit_w_len_read(&peek, 16); 865 cachesz += 16; 866 bits_left -= 16; 867 } 868@@ -2347,7 +2347,7 @@ 869 * DESCRIPTION: decode frame main_data 870 */ 871 static 872-enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame, 873+enum mad_error III_decode(struct mad_bit_w_lenptr *ptr, struct mad_frame *frame, 874 struct sideinfo *si, unsigned int nch) 875 { 876 struct mad_header *header = &frame->header; 877@@ -2519,7 +2519,7 @@ 878 unsigned int nch, priv_bitlen, next_md_begin = 0; 879 unsigned int si_len, data_bitlen, md_len; 880 unsigned int frame_space, frame_used, frame_free; 881- struct mad_bitptr ptr; 882+ struct mad_bit_w_lenptr ptr; 883 struct sideinfo si; 884 enum mad_error error; 885 int result = 0; 886@@ -2548,7 +2548,7 @@ 887 888 /* check frame sanity */ 889 890- if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) < 891+ if (stream->next_frame - mad_bit_w_len_nextbyte(stream->l_ptr) < 892 (signed int) si_len) { 893 stream->error = MAD_ERROR_BADFRAMELEN; 894 stream->md_len = 0; 895@@ -2559,7 +2559,7 @@ 896 897 if (header->flags & MAD_FLAG_PROTECTION) { 898 header->crc_check = 899- mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check); 900+ mad_bit_w_len_crc(*stream->l_ptr, si_len * CHAR_BIT, header->crc_check); 901 902 if (header->crc_check != header->crc_target && 903 !(frame->options & MAD_OPTION_IGNORECRC)) { 904@@ -2570,7 +2570,7 @@ 905 906 /* decode frame side information */ 907 908- error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT, 909+ error = III_sideinfo(stream->l_ptr, nch, header->flags & MAD_FLAG_LSF_EXT, 910 &si, &data_bitlen, &priv_bitlen); 911 if (error && result == 0) { 912 stream->error = error; 913@@ -2583,26 +2583,26 @@ 914 /* find main_data of next frame */ 915 916 { 917- struct mad_bitptr peek; 918+ struct mad_bit_w_lenptr peek; 919 unsigned long header; 920 921- mad_bit_init(&peek, stream->next_frame); 922+ mad_bit_w_len_init(&peek, stream->next_frame, stream->bufend - stream->next_frame); 923 924- header = mad_bit_read(&peek, 32); 925+ header = mad_bit_w_len_read(&peek, 32); 926 if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) { 927 if (!(header & 0x00010000L)) /* protection_bit */ 928- mad_bit_skip(&peek, 16); /* crc_check */ 929+ mad_bit_w_len_skip(&peek, 16); /* crc_check */ 930 931 next_md_begin = 932- mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8); 933+ mad_bit_w_len_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8); 934 } 935 936- mad_bit_finish(&peek); 937+ mad_bit_w_len_finish(&peek); 938 } 939 940 /* find main_data of this frame */ 941 942- frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr); 943+ frame_space = stream->next_frame - mad_bit_w_len_nextbyte(stream->l_ptr); 944 945 if (next_md_begin > si.main_data_begin + frame_space) 946 next_md_begin = 0; 947@@ -2612,7 +2612,7 @@ 948 frame_used = 0; 949 950 if (si.main_data_begin == 0) { 951- ptr = stream->ptr; 952+ ptr = *stream->l_ptr; 953 stream->md_len = 0; 954 955 frame_used = md_len; 956@@ -2625,15 +2625,15 @@ 957 } 958 } 959 else { 960- mad_bit_init(&ptr, 961- *stream->main_data + stream->md_len - si.main_data_begin); 962+ unsigned char * start = *stream->main_data + stream->md_len - si.main_data_begin; 963+ mad_bit_w_len_init(&ptr, start, stream->bufend - start); 964 965 if (md_len > si.main_data_begin) { 966 assert(stream->md_len + md_len - 967 si.main_data_begin <= MAD_BUFFER_MDLEN); 968 969 memcpy(*stream->main_data + stream->md_len, 970- mad_bit_nextbyte(&stream->ptr), 971+ mad_bit_w_len_nextbyte(stream->l_ptr), 972 frame_used = md_len - si.main_data_begin); 973 stream->md_len += frame_used; 974 } 975@@ -2653,7 +2653,7 @@ 976 977 /* designate ancillary bits */ 978 979- stream->anc_ptr = ptr; 980+ *(stream->l_anc_ptr) = ptr; 981 stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen; 982 } 983 984--- libmad-0.15.1b/stream.c.mp3-crash 2004-02-05 11:02:39.000000000 +0200 985+++ libmad-0.15.1b/stream.c 2016-06-24 21:47:38.732671821 +0300 986@@ -45,9 +45,11 @@ 987 988 stream->this_frame = 0; 989 stream->next_frame = 0; 990- mad_bit_init(&stream->ptr, 0); 991+ stream->l_ptr = malloc(sizeof(*(stream->l_ptr))); 992+ stream->l_anc_ptr = malloc(sizeof(*(stream->l_anc_ptr))); 993+ mad_bit_w_len_init(stream->l_ptr, 0, 0); 994 995- mad_bit_init(&stream->anc_ptr, 0); 996+ mad_bit_w_len_init(stream->l_anc_ptr, 0, 0); 997 stream->anc_bitlen = 0; 998 999 stream->main_data = 0; 1000@@ -68,8 +70,15 @@ 1001 stream->main_data = 0; 1002 } 1003 1004- mad_bit_finish(&stream->anc_ptr); 1005- mad_bit_finish(&stream->ptr); 1006+ mad_bit_w_len_finish(stream->l_anc_ptr); 1007+ mad_bit_w_len_finish(stream->l_ptr); 1008+ free(stream->l_ptr); 1009+ 1010+ if (stream->l_ptr != stream->l_anc_ptr) 1011+ free(stream->l_anc_ptr); 1012+ 1013+ stream->l_anc_ptr = NULL; 1014+ stream->l_ptr = NULL; 1015 } 1016 1017 /* 1018@@ -87,7 +96,7 @@ 1019 1020 stream->sync = 1; 1021 1022- mad_bit_init(&stream->ptr, buffer); 1023+ mad_bit_w_len_init(stream->l_ptr, buffer, length); 1024 } 1025 1026 /* 1027@@ -107,7 +116,7 @@ 1028 { 1029 register unsigned char const *ptr, *end; 1030 1031- ptr = mad_bit_nextbyte(&stream->ptr); 1032+ ptr = mad_bit_w_len_nextbyte(stream->l_ptr); 1033 end = stream->bufend; 1034 1035 while (ptr < end - 1 && 1036@@ -117,7 +126,7 @@ 1037 if (end - ptr < MAD_BUFFER_GUARD) 1038 return -1; 1039 1040- mad_bit_init(&stream->ptr, ptr); 1041+ mad_bit_w_len_init(stream->l_ptr, ptr, stream->bufend - stream->buffer); 1042 1043 return 0; 1044 } 1045--- libmad-0.15.1b/stream.h.mp3-crash 2004-02-05 11:02:39.000000000 +0200 1046+++ libmad-0.15.1b/stream.h 2016-06-24 21:47:38.732671821 +0300 1047@@ -68,9 +68,17 @@ 1048 1049 unsigned char const *this_frame; /* start of current frame */ 1050 unsigned char const *next_frame; /* start of next frame */ 1051+ union 1052+ { 1053 struct mad_bitptr ptr; /* current processing bit pointer */ 1054+ struct mad_bit_w_lenptr * l_ptr; 1055+ }; 1056 1057+ union 1058+ { 1059 struct mad_bitptr anc_ptr; /* ancillary bits pointer */ 1060+ struct mad_bit_w_lenptr * l_anc_ptr; /* ancillary bits pointer */ 1061+ }; 1062 unsigned int anc_bitlen; /* number of ancillary bits */ 1063 1064 unsigned char (*main_data)[MAD_BUFFER_MDLEN]; 1065