Index: /libmpc/branches/r2d/libmpcdec/Makefile.am
===================================================================
--- /libmpc/branches/r2d/libmpcdec/Makefile.am	(revision 218)
+++ /libmpc/branches/r2d/libmpcdec/Makefile.am	(revision 219)
@@ -8,2 +8,5 @@
 
 libmpcdec_la_LIBADD = $(top_builddir)/common/libcommon.a
+
+
+noinst_HEADERS = mpc_bits_reader.h
Index: /libmpc/branches/r2d/libmpcdec/mpc_bits_reader.c
===================================================================
--- /libmpc/branches/r2d/libmpcdec/mpc_bits_reader.c	(revision 218)
+++ /libmpc/branches/r2d/libmpcdec/mpc_bits_reader.c	(revision 219)
@@ -1,4 +1,4 @@
 /*
-  Copyright (c) 2005, The Musepack Development Team
+  Copyright (c) 2007, The Musepack Development Team
   All rights reserved.
 
@@ -36,8 +36,7 @@
 #include "internal.h"
 #include "huffman.h"
+#include "mpc_bits_reader.h"
 
-#define MAX_ENUM 32
-
-static const mpc_uint32_t Cnk[MAX_ENUM / 2][MAX_ENUM] =
+const mpc_uint32_t Cnk[MAX_ENUM / 2][MAX_ENUM] =
 {
 	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
@@ -59,5 +58,5 @@
 };
 
-static const mpc_uint8_t Cnk_len[MAX_ENUM / 2][MAX_ENUM] =
+const mpc_uint8_t Cnk_len[MAX_ENUM / 2][MAX_ENUM] =
 {
 	{0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5},
@@ -80,5 +79,5 @@
 };
 
-static const mpc_uint32_t Cnk_lost[MAX_ENUM / 2][MAX_ENUM] =
+const mpc_uint32_t Cnk_lost[MAX_ENUM / 2][MAX_ENUM] =
 {
 	{0, 0, 1, 0, 3, 2, 1, 0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0},
@@ -105,37 +104,4 @@
 static const mpc_uint8_t log2_lost[32] =
 { 0, 1, 0, 3, 2, 1, 0, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 31};
-
-// FIXME : make it work without 64 bit use for 32 bit output
-mpc_uint32_t mpc_bits_read(mpc_bits_reader * r, const unsigned int nb_bits)
-{
-	mpc_uint64_t ret = r->buff[0];
-
-	while(nb_bits > r->count){
-		r->buff++;
-		ret = (ret << 8) | r->buff[0];
-		r->count += 8;
-	}
-
-	r->count -= nb_bits;
-
-	return (mpc_uint32_t)((ret >> r->count) & (-1u >> (32 - nb_bits)));
-}
-
-// basic huffman decoding routine
-// works with maximum lengths up to 16
-mpc_int32_t mpc_bits_huff_dec(mpc_bits_reader * r, const mpc_huffman *Table)
-{
-    int tmp; mpc_uint32_t code;
-    code = ((r->buff[0] << 16) | (r->buff[1] << 8) | r->buff[2])
-			<< (16 - r->count);
-
-	while (code < Table->Code) Table++;
-
-	tmp = r->count - Table->Length;
-	r->buff -= tmp >> 3;
-	r->count = tmp & 0x07;
-
-	return Table->Value;
-}
 
 mpc_int32_t mpc_bits_golomb_dec(mpc_bits_reader * r, const mpc_uint_t k)
@@ -166,28 +132,4 @@
 
 	return (l << k) | ((code >> r->count) & ((1 << k) - 1));
-}
-
-mpc_uint32_t mpc_bits_enum_dec(mpc_bits_reader * r, mpc_uint_t k, mpc_uint_t n)
-{
-	mpc_uint32_t bits = 0;
-	mpc_uint32_t code;
-	const mpc_uint32_t * C = Cnk[k-1];
-
-	code = mpc_bits_read(r, Cnk_len[k-1][n-1] - 1);
-
-	if (code >= Cnk_lost[k-1][n-1])
-		code = ((code << 1) | mpc_bits_read(r, 1)) - Cnk_lost[k-1][n-1];
-
-	do {
-		n--;
-		if (code >= C[n]) {
-			bits |= 1 << n;
-			code -= C[n];
-			C -= MAX_ENUM;
-			k--;
-		}
-	} while(k > 0);
-
-	return bits;
 }
 
Index: /libmpc/branches/r2d/libmpcdec/mpc_bits_reader.h
===================================================================
--- /libmpc/branches/r2d/libmpcdec/mpc_bits_reader.h	(revision 219)
+++ /libmpc/branches/r2d/libmpcdec/mpc_bits_reader.h	(revision 219)
@@ -0,0 +1,102 @@
+/*
+  Copyright (c) 2007, The Musepack Development Team
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are
+  met:
+
+  * Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+  * Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided
+  with the distribution.
+
+  * Neither the name of the The Musepack Development Team nor the
+  names of its contributors may be used to endorse or promote
+  products derived from this software without specific prior
+  written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#define MAX_ENUM 32
+
+int mpc_bits_get_block(mpc_bits_reader * r, mpc_block * p_block);
+mpc_int32_t mpc_bits_golomb_dec(mpc_bits_reader * r, const mpc_uint_t k);
+unsigned int mpc_bits_get_size(mpc_bits_reader * r, mpc_uint64_t * p_size);
+mpc_uint32_t mpc_bits_log_dec(mpc_bits_reader * r, mpc_uint_t max);
+
+extern const mpc_uint32_t Cnk[MAX_ENUM / 2][MAX_ENUM];
+extern const mpc_uint8_t Cnk_len[MAX_ENUM / 2][MAX_ENUM];
+extern const mpc_uint32_t Cnk_lost[MAX_ENUM / 2][MAX_ENUM];
+
+static mpc_inline mpc_uint32_t mpc_bits_read(mpc_bits_reader * r, const unsigned int nb_bits)
+{
+	mpc_uint32_t ret;
+
+	r->buff -= (int)(r->count - nb_bits) >> 3;
+	r->count = (r->count - nb_bits) & 0x07;
+
+	ret = (r->buff[0] | (r->buff[-1] << 8)) >> r->count;
+	if (nb_bits > (16 - r->count)) {
+		ret |= ((r->buff[-2] << 16) | (r->buff[-3] << 24)) >> r->count;
+		if (nb_bits > 24 && r->count != 0)
+			ret |= r->buff[-4] << (32 - r->count);
+	}
+
+	return ret & (-1u >> (32 - nb_bits));
+}
+
+// FIXME : this must be implemented with a lookup table
+// basic huffman decoding routine
+// works with maximum lengths up to 16
+static mpc_inline mpc_int32_t mpc_bits_huff_dec(mpc_bits_reader * r, const mpc_huffman *Table)
+{
+	mpc_uint32_t code;
+	code = ((r->buff[0] << 16) | (r->buff[1] << 8) | r->buff[2])
+			<< (16 - r->count);
+
+	while (code < Table->Code) Table++;
+
+	r->buff -= (int)(r->count - Table->Length) >> 3;
+	r->count = (r->count - Table->Length) & 0x07;
+
+	return Table->Value;
+}
+
+static mpc_inline mpc_uint32_t mpc_bits_enum_dec(mpc_bits_reader * r, mpc_uint_t k, mpc_uint_t n)
+{
+	mpc_uint32_t bits = 0;
+	mpc_uint32_t code;
+	const mpc_uint32_t * C = Cnk[k-1];
+
+	code = mpc_bits_read(r, Cnk_len[k-1][n-1] - 1);
+
+	if (code >= Cnk_lost[k-1][n-1])
+		code = ((code << 1) | mpc_bits_read(r, 1)) - Cnk_lost[k-1][n-1];
+
+	do {
+		n--;
+		if (code >= C[n]) {
+			bits |= 1 << n;
+			code -= C[n];
+			C -= MAX_ENUM;
+			k--;
+		}
+	} while(k > 0);
+
+	return bits;
+}
Index: /libmpc/branches/r2d/libmpcdec/mpc_decoder.c
===================================================================
--- /libmpc/branches/r2d/libmpcdec/mpc_decoder.c	(revision 218)
+++ /libmpc/branches/r2d/libmpcdec/mpc_decoder.c	(revision 219)
@@ -34,5 +34,5 @@
 /// \file mpc_decoder.c
 /// Core decoding routines and logic.
-#include <string.h>
+
 #include <mpc/mpcdec.h>
 #include <mpc/minimax.h>
@@ -42,9 +42,5 @@
 #include "math.h"
 #include "requant.h"
-
-mpc_uint32_t mpc_bits_read(mpc_bits_reader * r, const unsigned int nb_bits);
-mpc_int32_t mpc_bits_huff_dec(mpc_bits_reader * r, const mpc_huffman *Table);
-mpc_uint32_t mpc_bits_enum_dec(mpc_bits_reader * r, mpc_uint_t k, mpc_uint_t n);
-mpc_uint32_t mpc_bits_log_dec(mpc_bits_reader * r, mpc_uint_t max);
+#include "mpc_bits_reader.h"
 
 //SV7 tables
@@ -233,18 +229,18 @@
             if ( d->Res_L [Band] ) {
                 if ( d->Res_R [Band] ) {    // M!=0, S!=0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][0]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][0]);
+                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][0] & 0xFF);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][0] & 0xFF);
                     for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
                         *YL   = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
                         *YR   = templ - tempr;
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][1]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][1]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][1] & 0xFF);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][1] & 0xFF);
                     for ( ; n < 24; n++, YL += 32, YR += 32 ) {
                         *YL   = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
                         *YR   = templ - tempr;
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][2]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][2]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][2] & 0xFF);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][2] & 0xFF);
                     for ( ; n < 36; n++, YL += 32, YR += 32 ) {
                         *YL   = (templ = MPC_MULTIPLY_FLOAT_INT(facL,*L++))+(tempr = MPC_MULTIPLY_FLOAT_INT(facR,*R++));
@@ -252,13 +248,13 @@
                     }
                 } else {    // M!=0, S==0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][0]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][0] & 0xFF);
                     for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
                         *YR = *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][1]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][1] & 0xFF);
                     for ( ; n < 24; n++, YL += 32, YR += 32 ) {
                         *YR = *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][2]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][2] & 0xFF);
                     for ( ; n < 36; n++, YL += 32, YR += 32 ) {
                         *YR = *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
@@ -268,13 +264,13 @@
                 if (d->Res_R[Band])    // M==0, S!=0
                 {
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][0]);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][0] & 0xFF);
                     for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
                         *YR = - (*YL = MPC_MULTIPLY_FLOAT_INT(facR,*(R++)));
                     }
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][1]);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][1] & 0xFF);
                     for ( ; n < 24; n++, YL += 32, YR += 32 ) {
                         *YR = - (*YL = MPC_MULTIPLY_FLOAT_INT(facR,*(R++)));
                     }
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][2]);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][2] & 0xFF);
                     for ( ; n < 36; n++, YL += 32, YR += 32 ) {
                         *YR = - (*YL = MPC_MULTIPLY_FLOAT_INT(facR,*(R++)));
@@ -291,18 +287,18 @@
             if ( d->Res_L [Band] ) {
                 if ( d->Res_R [Band] ) {    // L!=0, R!=0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][0]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][0]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][0] & 0xFF);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][0] & 0xFF);
                     for (n = 0; n < 12; n++, YL += 32, YR += 32 ) {
                         *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
                         *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][1]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][1]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][1] & 0xFF);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][1] & 0xFF);
                     for (; n < 24; n++, YL += 32, YR += 32 ) {
                         *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
                         *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][2]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][2]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][2] & 0xFF);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][2] & 0xFF);
                     for (; n < 36; n++, YL += 32, YR += 32 ) {
                         *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
@@ -310,15 +306,15 @@
                     }
                 } else {     // L!=0, R==0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][0]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][0] & 0xFF);
                     for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
                         *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
                         *YR = 0;
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][1]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][1] & 0xFF);
                     for ( ; n < 24; n++, YL += 32, YR += 32 ) {
                         *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
                         *YR = 0;
                     }
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (mpc_uint8_t) d->SCF_Index_L[Band][2]);
+					facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , d->SCF_Index_L[Band][2] & 0xFF);
                     for ( ; n < 36; n++, YL += 32, YR += 32 ) {
                         *YL = MPC_MULTIPLY_FLOAT_INT(facL,*L++);
@@ -329,15 +325,15 @@
             else {
                 if ( d->Res_R [Band] ) {    // L==0, R!=0
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][0]);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][0] & 0xFF);
                     for ( n = 0; n < 12; n++, YL += 32, YR += 32 ) {
                         *YL = 0;
                         *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
                     }
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][1]);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][1] & 0xFF);
                     for ( ; n < 24; n++, YL += 32, YR += 32 ) {
                         *YL = 0;
                         *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
                     }
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (mpc_uint8_t) d->SCF_Index_R[Band][2]);
+					facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , d->SCF_Index_R[Band][2] & 0xFF);
                     for ( ; n < 36; n++, YL += 32, YR += 32 ) {
                         *YL = 0;
@@ -619,31 +615,6 @@
 		do {
 			mpc_int32_t k = 0, idx = 1;
-			switch (Res) {
-				case -1:
-					for ( ; k<36; k++ ) {
-						mpc_uint32_t tmp = mpc_random_int(d);
-						q[k] = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >>  8) & 0xFF) + ((tmp >>  0) & 0xFF) - 510;
-					}
-					break;
-				case 0:
-					break;
-				case 1:
-					Table = mpc_table_HuffQ_8 [0][0];
-					for( ; k < 36; ){
-						int kmax = k + 18;
-						mpc_uint_t cnt = mpc_bits_huff_dec(r, Table);
-						idx = 0;
-						if (cnt > 0 && cnt < 18)
-								idx = mpc_bits_enum_dec(r, cnt <= 9 ? cnt : 18 - cnt, 18);
-						if (cnt > 9) idx = ~idx;
-						for ( ; k < kmax; k++) {
-							q[k] = 0;
-							if ( idx & (1 << 17) )
-								q[k] = (mpc_bits_read(r, 1) << 1) - 1;
-							idx <<= 1;
-						}
-					}
-					break;
-				case 2:
+			if (Res != 0) {
+				if (Res == 2) {
 					Tables[0] = mpc_table_HuffQ_8 [0][1];
 					Tables[1] = mpc_table_HuffQ_8 [1][1];
@@ -656,7 +627,26 @@
 						idx = (idx >> 1) + HuffQ2_var[tmp];
 					}
-					break;
-				case 3:
-				case 4:
+				} else if (Res == 1) {
+					Table = mpc_table_HuffQ_8 [0][0];
+					for( ; k < 36; ){
+						int kmax = k + 18;
+						mpc_uint_t cnt = mpc_bits_huff_dec(r, Table);
+						idx = 0;
+						if (cnt > 0 && cnt < 18)
+							idx = mpc_bits_enum_dec(r, cnt <= 9 ? cnt : 18 - cnt, 18);
+						if (cnt > 9) idx = ~idx;
+						for ( ; k < kmax; k++) {
+							q[k] = 0;
+							if ( idx & (1 << 17) )
+								q[k] = (mpc_bits_read(r, 1) << 1) - 1;
+							idx <<= 1;
+						}
+					}
+				} else if (Res == -1) {
+					for ( ; k<36; k++ ) {
+						mpc_uint32_t tmp = mpc_random_int(d);
+						q[k] = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >>  8) & 0xFF) + ((tmp >>  0) & 0xFF) - 510;
+					}
+				} else if (Res <= 4) {
 					Table = mpc_table_HuffQ_8[0][Res - 1];
 					for ( ; k < 36; k += 2 ) {
@@ -669,9 +659,5 @@
 						q[k + 1] = tmp.s2;
 					}
-					break;
-				case 5:
-				case 6:
-				case 7:
-				case 8:
+				} else if (Res <= 8) {
 					Tables[0] = mpc_table_HuffQ_8 [0][Res - 1];
 					Tables[1] = mpc_table_HuffQ_8 [1][Res - 1];
@@ -681,6 +667,5 @@
 						idx = (idx >> 1) + absi(q[k]);
 					}
-					break;
-				default :
+				} else {
 					for ( ; k < 36; k++ ) {
 						q[k] = mpc_bits_huff_dec(r, mpc_table_HuffQ9up_8);
@@ -689,5 +674,5 @@
 						q[k] -= Dc[Res];
 					}
-					break;
+				}
 			}
 
Index: /libmpc/branches/r2d/libmpcdec/mpc_demux.c
===================================================================
--- /libmpc/branches/r2d/libmpcdec/mpc_demux.c	(revision 218)
+++ /libmpc/branches/r2d/libmpcdec/mpc_demux.c	(revision 219)
@@ -39,10 +39,6 @@
 #include "internal.h"
 #include "decoder.h"
-
-// mpc_bits_reader.c
-mpc_uint32_t mpc_bits_read(mpc_bits_reader * r, const unsigned int nb_bits);
-int mpc_bits_get_block(mpc_bits_reader * r, mpc_block * p_block);
-mpc_int32_t mpc_bits_golomb_dec(mpc_bits_reader * r, const mpc_uint_t k);
-unsigned int mpc_bits_get_size(mpc_bits_reader * r, mpc_uint64_t * p_size);
+#include "huffman.h"
+#include "mpc_bits_reader.h"
 
 // streaminfo.c
Index: /libmpc/branches/r2d/libmpcdec/streaminfo.c
===================================================================
--- /libmpc/branches/r2d/libmpcdec/streaminfo.c	(revision 218)
+++ /libmpc/branches/r2d/libmpcdec/streaminfo.c	(revision 219)
@@ -40,9 +40,8 @@
 #include <stdio.h>
 #include "internal.h"
+#include "huffman.h"
+#include "mpc_bits_reader.h"
 
 unsigned long crc32(unsigned char *buf, int len);
-
-mpc_uint32_t mpc_bits_read(mpc_bits_reader * r, const unsigned int nb_bits);
-unsigned int mpc_bits_get_size(mpc_bits_reader * r, mpc_uint64_t * p_size);
 
 static const char na[] = "n.a.";
Index: /libmpc/branches/r2d/mpcdec/mpcdec.c
===================================================================
--- /libmpc/branches/r2d/mpcdec/mpcdec.c	(revision 218)
+++ /libmpc/branches/r2d/mpcdec/mpcdec.c	(revision 219)
@@ -118,5 +118,5 @@
 
     printf("%u samples ", total_samples);
-    total_samples = (mpc_uint32_t) ((double) total_samples * CLOCKS_PER_SEC * 100 / (si.sample_freq * sum));
+	total_samples = (mpc_uint32_t) ((mpc_uint64_t) total_samples * CLOCKS_PER_SEC * 100 / ((mpc_uint64_t)si.sample_freq * sum));
     printf("decoded in %u ms (%u.%02ux)\n",
 		   (unsigned int) (sum * 1000 / CLOCKS_PER_SEC),
Index: /libmpc/branches/r2d/mpcgain/mpcgain.c
===================================================================
--- /libmpc/branches/r2d/mpcgain/mpcgain.c	(revision 218)
+++ /libmpc/branches/r2d/mpcgain/mpcgain.c	(revision 219)
@@ -39,8 +39,6 @@
 
 #include "../libmpcdec/internal.h"
-
-// mpc_bits_reader.c
-int mpc_bits_get_block(mpc_bits_reader * r, mpc_block * p_block);
-unsigned int mpc_bits_get_size(mpc_bits_reader * r, mpc_uint64_t * p_size);
+#include "../libmpcdec/huffman.h"
+#include "../libmpcdec/mpc_bits_reader.h"
 
 // crc32.c