Lines Matching defs:br
178 static FLaC__INLINE void crc16_update_word_(FLAC__BitReader *br, brword word)
180 register unsigned crc = br->read_crc16;
182 switch(br->crc16_align) {
186 case 24: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
189 switch(br->crc16_align) {
197 case 56: br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)(word & 0xff), crc);
200 for( ; br->crc16_align < FLAC__BITS_PER_WORD; br->crc16_align += 8)
201 crc = FLAC__CRC16_UPDATE((unsigned)((word >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), crc);
202 br->read_crc16 = crc;
204 br->crc16_align = 0;
208 FLAC__bool bitreader_read_from_client_(FLAC__BitReader *br)
215 if(br->consumed_words > 0) {
216 start = br->consumed_words;
217 end = br->words + (br->bytes? 1:0);
218 memmove(br->buffer, br->buffer+start, FLAC__BYTES_PER_WORD * (end - start));
220 br->words -= start;
221 br->consumed_words = 0;
227 bytes = (br->capacity - br->words) * FLAC__BYTES_PER_WORD - br->bytes;
230 target = ((FLAC__byte*)(br->buffer+br->words)) + br->bytes;
233 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1 (partial tail word is left-justified)
242 if(br->bytes)
243 br->buffer[br->words] = SWAP_BE_WORD_TO_HOST(br->buffer[br->words]);
247 * bitstream : 11 22 33 44 55 br->words=1 br->bytes=1
254 if(!br->read_callback(target, &bytes, br->client_data))
265 end = (br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes + (FLAC__BYTES_PER_WORD-1)) / FLAC__BYTES_PER_WORD;
267 if(br->cpu_info.type == FLAC__CPUINFO_TYPE_IA32 && br->cpu_info.data.ia32.bswap) {
268 start = br->words;
269 local_swap32_block_(br->buffer + start, end - start);
273 for(start = br->words; start < end; start++)
274 br->buffer[start] = SWAP_BE_WORD_TO_HOST(br->buffer[start]);
283 end = br->words*FLAC__BYTES_PER_WORD + br->bytes + bytes;
284 br->words = end / FLAC__BYTES_PER_WORD;
285 br->bytes = end % FLAC__BYTES_PER_WORD;
298 FLAC__BitReader *br = (FLAC__BitReader*)calloc(1, sizeof(FLAC__BitReader));
301 memset(br, 0, sizeof(FLAC__BitReader));
302 br->buffer = 0;
303 br->capacity = 0;
304 br->words = br->bytes = 0;
305 br->consumed_words = br->consumed_bits = 0;
306 br->read_callback = 0;
307 br->client_data = 0;
309 return br;
312 void FLAC__bitreader_delete(FLAC__BitReader *br)
314 FLAC__ASSERT(0 != br);
316 FLAC__bitreader_free(br);
317 free(br);
326 FLAC__bool FLAC__bitreader_init(FLAC__BitReader *br, FLAC__CPUInfo cpu, FLAC__BitReaderReadCallback rcb, void *cd)
328 FLAC__ASSERT(0 != br);
330 br->words = br->bytes = 0;
331 br->consumed_words = br->consumed_bits = 0;
332 br->capacity = FLAC__BITREADER_DEFAULT_CAPACITY;
333 br->buffer = (brword*)malloc(sizeof(brword) * br->capacity);
334 if(br->buffer == 0)
336 br->read_callback = rcb;
337 br->client_data = cd;
338 br->cpu_info = cpu;
343 void FLAC__bitreader_free(FLAC__BitReader *br)
345 FLAC__ASSERT(0 != br);
347 if(0 != br->buffer)
348 free(br->buffer);
349 br->buffer = 0;
350 br->capacity = 0;
351 br->words = br->bytes = 0;
352 br->consumed_words = br->consumed_bits = 0;
353 br->read_callback = 0;
354 br->client_data = 0;
357 FLAC__bool FLAC__bitreader_clear(FLAC__BitReader *br)
359 br->words = br->bytes = 0;
360 br->consumed_words = br->consumed_bits = 0;
364 void FLAC__bitreader_dump(const FLAC__BitReader *br, FILE *out)
367 if(br == 0) {
371 fprintf(out, "bitreader: capacity=%u words=%u bytes=%u consumed: words=%u, bits=%u\n", br->capacity, br->words, br->bytes, br->consumed_words, br->consumed_bits);
373 for(i = 0; i < br->words; i++) {
376 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
379 fprintf(out, "%01u", br->buffer[i] & (1 << (FLAC__BITS_PER_WORD-j-1)) ? 1:0);
382 if(br->bytes > 0) {
384 for(j = 0; j < br->bytes*8; j++)
385 if(i < br->consumed_words || (i == br->consumed_words && j < br->consumed_bits))
388 fprintf(out, "%01u", br->buffer[i] & (1 << (br->bytes*8-j-1)) ? 1:0);
394 void FLAC__bitreader_reset_read_crc16(FLAC__BitReader *br, FLAC__uint16 seed)
396 FLAC__ASSERT(0 != br);
397 FLAC__ASSERT(0 != br->buffer);
398 FLAC__ASSERT((br->consumed_bits & 7) == 0);
400 br->read_crc16 = (unsigned)seed;
401 br->crc16_align = br->consumed_bits;
404 FLAC__uint16 FLAC__bitreader_get_read_crc16(FLAC__BitReader *br)
406 FLAC__ASSERT(0 != br);
407 FLAC__ASSERT(0 != br->buffer);
408 FLAC__ASSERT((br->consumed_bits & 7) == 0);
409 FLAC__ASSERT(br->crc16_align <= br->consumed_bits);
412 if(br->consumed_bits) {
413 const brword tail = br->buffer[br->consumed_words];
414 for( ; br->crc16_align < br->consumed_bits; br->crc16_align += 8)
415 br->read_crc16 = FLAC__CRC16_UPDATE((unsigned)((tail >> (FLAC__BITS_PER_WORD-8-br->crc16_align)) & 0xff), br->read_crc16);
417 return br->read_crc16;
420 FLaC__INLINE FLAC__bool FLAC__bitreader_is_consumed_byte_aligned(const FLAC__BitReader *br)
422 return ((br->consumed_bits & 7) == 0);
425 FLaC__INLINE unsigned FLAC__bitreader_bits_left_for_byte_alignment(const FLAC__BitReader *br)
427 return 8 - (br->consumed_bits & 7);
430 FLaC__INLINE unsigned FLAC__bitreader_get_input_bits_unconsumed(const FLAC__BitReader *br)
432 return (br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits;
435 FLaC__INLINE FLAC__bool FLAC__bitreader_read_raw_uint32(FLAC__BitReader *br, FLAC__uint32 *val, unsigned bits)
437 FLAC__ASSERT(0 != br);
438 FLAC__ASSERT(0 != br->buffer);
441 FLAC__ASSERT((br->capacity*FLAC__BITS_PER_WORD) * 2 >= bits);
442 FLAC__ASSERT(br->consumed_words <= br->words);
452 while((br->words-br->consumed_words)*FLAC__BITS_PER_WORD + br->bytes*8 - br->consumed_bits < bits) {
453 if(!bitreader_read_from_client_(br))
456 if(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
458 if(br->consumed_bits) {
460 const unsigned n = FLAC__BITS_PER_WORD - br->consumed_bits;
461 const brword word = br->buffer[br->consumed_words];
463 *val = (word & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (n-bits);
464 br->consumed_bits += bits;
467 *val = word & (FLAC__WORD_ALL_ONES >> br->consumed_bits);
469 crc16_update_word_(br, word);
470 br->consumed_words++;
471 br->consumed_bits = 0;
474 *val |= (br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits));
475 br->consumed_bits = bits;
480 const brword word = br->buffer[br->consumed_words];
483 br->consumed_bits = bits;
488 crc16_update_word_(br, word);
489 br->consumed_words++;
499 if(br->consumed_bits) {
501 FLAC__ASSERT(br->consumed_bits + bits <= br->bytes*8);
502 *val = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES >> br->consumed_bits)) >> (FLAC__BITS_PER_WORD-br->consumed_bits-bits);
503 br->consumed_bits += bits;
507 *val = br->buffer[br->consumed_words] >> (FLAC__BITS_PER_WORD-bits);
508 br->consumed_bits += bits;
514 FLAC__bool FLAC__bitreader_read_raw_int32(FLAC__BitReader *br, FLAC__int32 *val, unsigned bits)
517 if(!FLAC__bitreader_read_raw_uint32(br, (FLAC__uint32*)val, bits))
525 FLAC__bool FLAC__bitreader_read_raw_uint64(FLAC__BitReader *br, FLAC__uint64 *val, unsigned bits)
530 if(!FLAC__bitreader_read_raw_uint32(br, &hi, bits-32))
532 if(!FLAC__bitreader_read_raw_uint32(br, &lo, 32))
539 if(!FLAC__bitreader_read_raw_uint32(br, &lo, bits))
546 FLaC__INLINE FLAC__bool FLAC__bitreader_read_uint32_little_endian(FLAC__BitReader *br, FLAC__uint32 *val)
552 if(!FLAC__bitreader_read_raw_uint32(br, &x32, 8))
555 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
559 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
563 if(!FLAC__bitreader_read_raw_uint32(br, &x8, 8))
571 FLAC__bool FLAC__bitreader_skip_bits_no_crc(FLAC__BitReader *br, unsigned bits)
577 FLAC__ASSERT(0 != br);
578 FLAC__ASSERT(0 != br->buffer);
581 const unsigned n = br->consumed_bits & 7;
587 if(!FLAC__bitreader_read_raw_uint32(br, &x, m))
593 if(!FLAC__bitreader_skip_byte_block_aligned_no_crc(br, m))
598 if(!FLAC__bitreader_read_raw_uint32(br, &x, bits))
606 FLAC__bool FLAC__bitreader_skip_byte_block_aligned_no_crc(FLAC__BitReader *br, unsigned nvals)
610 FLAC__ASSERT(0 != br);
611 FLAC__ASSERT(0 != br->buffer);
612 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
615 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
616 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
624 if(br->consumed_words < br->words) {
625 br->consumed_words++;
628 else if(!bitreader_read_from_client_(br))
633 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
641 FLAC__bool FLAC__bitreader_read_byte_block_aligned_no_crc(FLAC__BitReader *br, FLAC__byte *val, unsigned nvals)
645 FLAC__ASSERT(0 != br);
646 FLAC__ASSERT(0 != br->buffer);
647 FLAC__ASSERT(FLAC__bitreader_is_consumed_byte_aligned(br));
650 while(nvals && br->consumed_bits) { /* i.e. run until we read 'nvals' bytes or we hit the end of the head word */
651 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
660 if(br->consumed_words < br->words) {
661 const brword word = br->buffer[br->consumed_words++];
683 else if(!bitreader_read_from_client_(br))
688 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
697 FLaC__INLINE FLAC__bool FLAC__bitreader_read_unary_unsigned(FLAC__BitReader *br, unsigned *val)
702 FLAC__ASSERT(0 != br);
703 FLAC__ASSERT(0 != br->buffer);
707 if(!FLAC__bitreader_read_bit(br, &bit))
720 FLAC__ASSERT(0 != br);
721 FLAC__ASSERT(0 != br->buffer);
725 while(br->consumed_words < br->words) { /* if we've not consumed up to a partial tail word... */
726 brword b = br->buffer[br->consumed_words] << br->consumed_bits;
731 br->consumed_bits += i;
732 if(br->consumed_bits >= FLAC__BITS_PER_WORD) { /* faster way of testing if(br->consumed_bits == FLAC__BITS_PER_WORD) */
733 crc16_update_word_(br, br->buffer[br->consumed_words]);
734 br->consumed_words++;
735 br->consumed_bits = 0;
740 *val += FLAC__BITS_PER_WORD - br->consumed_bits;
741 crc16_update_word_(br, br->buffer[br->consumed_words]);
742 br->consumed_words++;
743 br->consumed_bits = 0;
751 * us data a byte at a time (unlikely), br->consumed_bits may not
754 if(br->bytes) {
755 const unsigned end = br->bytes * 8;
756 brword b = (br->buffer[br->consumed_words] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << br->consumed_bits;
761 br->consumed_bits += i;
762 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
766 *val += end - br->consumed_bits;
767 br->consumed_bits += end;
768 FLAC__ASSERT(br->consumed_bits < FLAC__BITS_PER_WORD);
772 if(!bitreader_read_from_client_(br))
778 FLAC__bool FLAC__bitreader_read_rice_signed(FLAC__BitReader *br, int *val, unsigned parameter)
783 FLAC__ASSERT(0 != br);
784 FLAC__ASSERT(0 != br->buffer);
788 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
792 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, parameter))
807 FLAC__bool FLAC__bitreader_read_rice_signed_block(FLAC__BitReader *br, int vals[], unsigned nvals, unsigned parameter)
815 /* try and get br->consumed_words and br->consumed_bits into register;
816 * must remember to flush them back to *br before calling other
821 FLAC__ASSERT(0 != br);
822 FLAC__ASSERT(0 != br->buffer);
831 cbits = br->consumed_bits;
832 cwords = br->consumed_words;
838 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
839 brword b = br->buffer[cwords] << cbits;
856 crc16_update_word_(br, br->buffer[cwords]);
864 crc16_update_word_(br, br->buffer[cwords]);
874 * us data a byte at a time (unlikely), br->consumed_bits may not
877 if(br->bytes) {
878 const unsigned end = br->bytes * 8;
879 brword b = (br->buffer[cwords] & (FLAC__WORD_ALL_ONES << (FLAC__BITS_PER_WORD-end))) << cbits;
897 * not touch br->consumed_bits at all but we still need to set
900 br->consumed_bits = cbits;
901 br->consumed_words = cwords;
902 if(!bitreader_read_from_client_(br))
904 cwords = br->consumed_words;
908 FLAC__ASSERT(cwords <= br->words);
911 while((br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits < bits) {
913 * not touch br->consumed_bits at all but we still need to set
916 br->consumed_bits = cbits;
917 br->consumed_words = cwords;
918 if(!bitreader_read_from_client_(br))
920 cwords = br->consumed_words;
922 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
926 const brword word = br->buffer[cwords];
936 crc16_update_word_(br, word);
941 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits));
949 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
962 FLAC__ASSERT(cbits + bits <= br->bytes*8);
963 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-bits);
968 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-bits);
981 br->consumed_bits = cbits;
982 br->consumed_words = cwords;
996 /* try and get br->consumed_words and br->consumed_bits into register;
997 * must remember to flush them back to *br before calling other
1003 FLAC__ASSERT(0 != br);
1004 FLAC__ASSERT(0 != br->buffer);
1013 cbits = br->consumed_bits;
1014 cwords = br->consumed_words;
1015 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;
1021 while(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
1022 brword b = br->buffer[cwords] << cbits;
1039 crc16_update_word_(br, br->buffer[cwords]);
1047 crc16_update_word_(br, br->buffer[cwords]);
1057 * us data a byte at a time (unlikely), br->consumed_bits may not
1060 if(br->bytes) {
1061 const unsigned end = br->bytes * 8;
1062 brword b = (br->buffer[cwords] & ~(FLAC__WORD_ALL_ONES >> end)) << cbits;
1079 * not touch br->consumed_bits at all but we still need to set
1082 br->consumed_bits = cbits;
1083 br->consumed_words = cwords;
1084 if(!bitreader_read_from_client_(br))
1086 cwords = br->consumed_words;
1087 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits + uval;
1098 FLAC__ASSERT(cwords <= br->words);
1103 * not touch br->consumed_bits at all but we still need to set
1106 br->consumed_bits = cbits;
1107 br->consumed_words = cwords;
1108 if(!bitreader_read_from_client_(br))
1110 cwords = br->consumed_words;
1111 ucbits = (br->words-cwords)*FLAC__BITS_PER_WORD + br->bytes*8 - cbits;
1113 if(cwords < br->words) { /* if we've not consumed up to a partial tail word... */
1117 const brword word = br->buffer[cwords];
1126 crc16_update_word_(br, word);
1131 uval |= (br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits));
1138 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);
1149 FLAC__ASSERT(cbits + parameter <= br->bytes*8);
1150 uval |= (br->buffer[cwords] & (FLAC__WORD_ALL_ONES >> cbits)) >> (FLAC__BITS_PER_WORD-cbits-parameter);
1155 uval |= br->buffer[cwords] >> (FLAC__BITS_PER_WORD-cbits);
1168 br->consumed_bits = cbits;
1169 br->consumed_words = cwords;
1181 FLAC__bool FLAC__bitreader_read_golomb_signed(FLAC__BitReader *br, int *val, unsigned parameter)
1186 FLAC__ASSERT(0 != br);
1187 FLAC__ASSERT(0 != br->buffer);
1192 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
1196 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
1206 if(!FLAC__bitreader_read_bit(br, &bit))
1225 FLAC__bool FLAC__bitreader_read_golomb_unsigned(FLAC__BitReader *br, unsigned *val, unsigned parameter)
1230 FLAC__ASSERT(0 != br);
1231 FLAC__ASSERT(0 != br->buffer);
1236 if(!FLAC__bitreader_read_unary_unsigned(br, &msbs))
1240 if(!FLAC__bitreader_read_raw_uint32(br, &lsbs, k))
1250 if(!FLAC__bitreader_read_bit(br, &bit))
1265 FLAC__bool FLAC__bitreader_read_utf8_uint32(FLAC__BitReader *br, FLAC__uint32 *val, FLAC__byte *raw, unsigned *rawlen)
1271 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1304 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1320 FLAC__bool FLAC__bitreader_read_utf8_uint64(FLAC__BitReader *br, FLAC__uint64 *val, FLAC__byte *raw, unsigned *rawlen)
1326 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))
1363 if(!FLAC__bitreader_read_raw_uint32(br, &x, 8))