reinstitute old FLAC__bitbuffer_read_rice_signed_block() for MSVC compiles

src/libFLAC/bitbuffer.c

@@ -44,6 +44,13 @@
  *
  */
 
+/*
+ * 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
@@ -63,6 +70,7 @@
  */
 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,
@@ -81,6 +89,7 @@ static const unsigned char byte_to_unary_table[] = {
 	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
@@ -89,7 +98,9 @@ static const unsigned char byte_to_unary_table[] = {
 #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
@@ -97,7 +108,9 @@ static const unsigned char byte_to_unary_table[] = {
 #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
@@ -2131,6 +2144,214 @@ FLAC__bool FLAC__bitbuffer_read_rice_signed(FLAC__BitBuffer *bb, int *val, unsig
 }
 
 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;
 
@@ -2238,6 +2459,7 @@ break2:
 
 	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)