*/
/*
+ * Some optimization strategies are slower with older versions of MSVC
+ */
+#if defined _MSC_VER && _MSC_VER <= 1200
+#define FLAC__OLD_MSVC_FLAVOR
+#endif
+
+/*
* This should be at least twice as large as the largest number of blurbs
* required to represent any 'number' (in any encoding) you are going to
* read. With FLAC this is on the order of maybe a few hundred bits.
*/
static const unsigned FLAC__BITBUFFER_DEFAULT_CAPACITY = ((65536 - 64) * 8) / FLAC__BITS_PER_BLURB; /* blurbs */
+#ifndef FLAC__OLD_MSVC_FLAVOR
static const unsigned char byte_to_unary_table[] = {
8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
+#endif
#if FLAC__BITS_PER_BLURB == 8
#define FLAC__BITS_PER_BLURB_LOG2 3
#define FLAC__BLURB_TOP_BIT_ONE ((FLAC__byte)0x80)
#define BLURB_BIT_TO_MASK(b) (((FLAC__blurb)'\x80') >> (b))
#define CRC16_UPDATE_BLURB(bb, blurb, crc) FLAC__CRC16_UPDATE((blurb), (crc));
+#ifndef FLAC__OLD_MSVC_FLAVOR
#define FLAC__ALIGNED_BLURB_UNARY(blurb) (byte_to_unary_table[blurb])
+#endif
#elif FLAC__BITS_PER_BLURB == 32
#define FLAC__BITS_PER_BLURB_LOG2 5
#define FLAC__BYTES_PER_BLURB 4
#define FLAC__BLURB_TOP_BIT_ONE ((FLAC__uint32)0x80000000)
#define BLURB_BIT_TO_MASK(b) (((FLAC__blurb)0x80000000) >> (b))
#define CRC16_UPDATE_BLURB(bb, blurb, crc) crc16_update_blurb((bb), (blurb));
+#ifndef FLAC__OLD_MSVC_FLAVOR
#define FLAC__ALIGNED_BLURB_UNARY(blurb) ((blurb) <= 0xff ? byte_to_unary_table[blurb] + 24 : ((blurb) <= 0xffff ? byte_to_unary_table[(blurb) >> 8] + 16 : ((blurb) <= 0xffffff ? byte_to_unary_table[(blurb) >> 16] + 8 : byte_to_unary_table[(blurb) >> 24])))
+#endif
#else
/* ERROR, only sizes of 8 and 32 are supported */
#endif
}
FLAC__bool FLAC__bitbuffer_read_rice_signed_block(FLAC__BitBuffer *bb, int vals[], unsigned nvals, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
+#ifdef FLAC__OLD_MSVC_FLAVOR
+{
+ const FLAC__blurb *buffer = bb->buffer;
+
+ unsigned i, j, val_i = 0;
+ unsigned cbits = 0, uval = 0, msbs = 0, lsbs_left = 0;
+ FLAC__blurb blurb, save_blurb;
+ unsigned state = 0; /* 0 = getting unary MSBs, 1 = getting binary LSBs */
+
+ FLAC__ASSERT(0 != bb);
+ FLAC__ASSERT(0 != bb->buffer);
+ FLAC__ASSERT(parameter <= 31);
+
+ if(nvals == 0)
+ return true;
+
+ i = bb->consumed_blurbs;
+ /*
+ * We unroll the main loop to take care of partially consumed blurbs here.
+ */
+ if(bb->consumed_bits > 0) {
+ save_blurb = blurb = buffer[i];
+ cbits = bb->consumed_bits;
+ blurb <<= cbits;
+
+ while(1) {
+ if(state == 0) {
+ if(blurb) {
+ for(j = 0; !(blurb & FLAC__BLURB_TOP_BIT_ONE); j++)
+ blurb <<= 1;
+ msbs += j;
+
+ /* dispose of the unary end bit */
+ blurb <<= 1;
+ j++;
+ cbits += j;
+
+ uval = 0;
+ lsbs_left = parameter;
+ state++;
+ if(cbits == FLAC__BITS_PER_BLURB) {
+ cbits = 0;
+ CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
+ break;
+ }
+ }
+ else {
+ msbs += FLAC__BITS_PER_BLURB - cbits;
+ cbits = 0;
+ CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
+ break;
+ }
+ }
+ else {
+ const unsigned available_bits = FLAC__BITS_PER_BLURB - cbits;
+ if(lsbs_left >= available_bits) {
+ uval <<= available_bits;
+ uval |= (blurb >> cbits);
+ cbits = 0;
+ CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
+
+ if(lsbs_left == available_bits) {
+ /* compose the value */
+ uval |= (msbs << parameter);
+ if(uval & 1)
+ vals[val_i++] = -((int)(uval >> 1)) - 1;
+ else
+ vals[val_i++] = (int)(uval >> 1);
+ if(val_i == nvals)
+ break;
+
+ msbs = 0;
+ state = 0;
+ }
+
+ lsbs_left -= available_bits;
+ break;
+ }
+ else {
+ uval <<= lsbs_left;
+ uval |= (blurb >> (FLAC__BITS_PER_BLURB - lsbs_left));
+ blurb <<= lsbs_left;
+ cbits += lsbs_left;
+
+ /* compose the value */
+ uval |= (msbs << parameter);
+ if(uval & 1)
+ vals[val_i++] = -((int)(uval >> 1)) - 1;
+ else
+ vals[val_i++] = (int)(uval >> 1);
+ if(val_i == nvals) {
+ /* back up one if we exited the for loop because we read all nvals but the end came in the middle of a blurb */
+ i--;
+ break;
+ }
+
+ msbs = 0;
+ state = 0;
+ }
+ }
+ }
+ i++;
+
+ bb->consumed_blurbs = i;
+ bb->consumed_bits = cbits;
+ bb->total_consumed_bits = (i << FLAC__BITS_PER_BLURB_LOG2) | cbits;
+ }
+
+ /*
+ * Now that we are blurb-aligned the logic is slightly simpler
+ */
+ while(val_i < nvals) {
+ for( ; i < bb->blurbs && val_i < nvals; i++) {
+ save_blurb = blurb = buffer[i];
+ cbits = 0;
+ while(1) {
+ if(state == 0) {
+ if(blurb) {
+ for(j = 0; !(blurb & FLAC__BLURB_TOP_BIT_ONE); j++)
+ blurb <<= 1;
+ msbs += j;
+
+ /* dispose of the unary end bit */
+ blurb <<= 1;
+ j++;
+ cbits += j;
+
+ uval = 0;
+ lsbs_left = parameter;
+ state++;
+ if(cbits == FLAC__BITS_PER_BLURB) {
+ cbits = 0;
+ CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
+ break;
+ }
+ }
+ else {
+ msbs += FLAC__BITS_PER_BLURB - cbits;
+ cbits = 0;
+ CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
+ break;
+ }
+ }
+ else {
+ const unsigned available_bits = FLAC__BITS_PER_BLURB - cbits;
+ if(lsbs_left >= available_bits) {
+ uval <<= available_bits;
+ uval |= (blurb >> cbits);
+ cbits = 0;
+ CRC16_UPDATE_BLURB(bb, save_blurb, bb->read_crc16);
+
+ if(lsbs_left == available_bits) {
+ /* compose the value */
+ uval |= (msbs << parameter);
+ if(uval & 1)
+ vals[val_i++] = -((int)(uval >> 1)) - 1;
+ else
+ vals[val_i++] = (int)(uval >> 1);
+ if(val_i == nvals)
+ break;
+
+ msbs = 0;
+ state = 0;
+ }
+
+ lsbs_left -= available_bits;
+ break;
+ }
+ else {
+ uval <<= lsbs_left;
+ uval |= (blurb >> (FLAC__BITS_PER_BLURB - lsbs_left));
+ blurb <<= lsbs_left;
+ cbits += lsbs_left;
+
+ /* compose the value */
+ uval |= (msbs << parameter);
+ if(uval & 1)
+ vals[val_i++] = -((int)(uval >> 1)) - 1;
+ else
+ vals[val_i++] = (int)(uval >> 1);
+ if(val_i == nvals) {
+ /* back up one if we exited the for loop because we read all nvals but the end came in the middle of a blurb */
+ i--;
+ break;
+ }
+
+ msbs = 0;
+ state = 0;
+ }
+ }
+ }
+ }
+ bb->consumed_blurbs = i;
+ bb->consumed_bits = cbits;
+ bb->total_consumed_bits = (i << FLAC__BITS_PER_BLURB_LOG2) | cbits;
+ if(val_i < nvals) {
+ if(!bitbuffer_read_from_client_(bb, read_callback, client_data))
+ return false;
+ /* these must be zero because we can only get here if we got to the end of the buffer */
+ FLAC__ASSERT(bb->consumed_blurbs == 0);
+ FLAC__ASSERT(bb->consumed_bits == 0);
+ i = 0;
+ }
+ }
+
+ return true;
+}
+#else
{
const FLAC__blurb *buffer = bb->buffer;
return true;
}
+#endif
#if 0 /* UNUSED */
FLAC__bool FLAC__bitbuffer_read_golomb_signed(FLAC__BitBuffer *bb, int *val, unsigned parameter, FLAC__bool (*read_callback)(FLAC__byte buffer[], unsigned *bytes, void *client_data), void *client_data)
projects / platform / upstream / flac.git / commitdiff