Major change to musepack decoder: Import v1.3.0 (r458 from svn.musepack.net) to rockbox. Several adaptions in the musepack decoder were made to get the library work and perform fast under rockbox on several targets. With this change mpc sv8 is supported, including seek, replay gain and metadata support. The decoding speed is a 1-4% lower than the last implementation. Reason for this is main restructuring in the bitstream demuxer.

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@25056 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 452 insertions, 1527 deletions

diff --git a/apps/codecs/libmusepack/mpc_decoder.c b/apps/codecs/libmusepack/mpc_decoder.c
index d211980782..5a78c943a6 100644
--- a/apps/codecs/libmusepack/mpc_decoder.c
+++ b/apps/codecs/libmusepack/mpc_decoder.c
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2005, The Musepack Development Team
+  Copyright (c) 2005-2009, The Musepack Development Team
   All rights reserved.
 
   Redistribution and use in source and binary forms, with or without
@@ -31,577 +31,217 @@
   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-
 /// \file mpc_decoder.c
 /// Core decoding routines and logic.
 
-#include "musepack.h"
+#include <string.h>
+#include "mpcdec.h"
+#include "minimax.h"
+#include "decoder.h"
+#include "huffman.h"
 #include "internal.h"
+#include "mpcdec_math.h"
 #include "requant.h"
-#include "huffman.h"
+#include "mpc_bits_reader.h"
 
 //SV7 tables
-extern const HuffmanTyp*   mpc_table_HuffQ [2] [8];
-extern const HuffmanTyp    mpc_table_HuffHdr  [10];
-extern const HuffmanTyp    mpc_table_HuffSCFI [ 4];
-extern const HuffmanTyp    mpc_table_HuffDSCF [16];
-
-
-#ifdef MPC_SUPPORT_SV456
-//SV4/5/6 tables
-extern const HuffmanTyp*   mpc_table_SampleHuff [18];
-extern const HuffmanTyp    mpc_table_SCFI_Bundle   [ 8];
-extern const HuffmanTyp    mpc_table_DSCF_Entropie [13];
-extern const HuffmanTyp    mpc_table_Region_A [16];
-extern const HuffmanTyp    mpc_table_Region_B [ 8];
-extern const HuffmanTyp    mpc_table_Region_C [ 4];
-
-#endif
-
-#ifndef MPC_LITTLE_ENDIAN
-#define SWAP(X) mpc_swap32(X)
-#else
-#define SWAP(X) X
-#endif
-
-#ifdef SCF_HACK
-#define SCF_DIFF(SCF, D) (SCF == 127 ? 127 : SCF + D)
-#else 
-#define SCF_DIFF(SCF, D) SCF + D
-#endif
-
-#define LOOKUP(x, e, q)   mpc_decoder_make_huffman_lookup ( (q), sizeof(q), (x), (e) )
-#define Decode_DSCF()   HUFFMAN_DECODE_FASTEST ( d, mpc_table_HuffDSCF, LUTDSCF, 6 )
-#define HUFFMAN_DECODE_FASTEST(d,a,b,c)  mpc_decoder_huffman_decode_fastest ( (d), (a), (b), 32-(c) )
-#define HUFFMAN_DECODE_FASTERER(d,a,b,c)  mpc_decoder_huffman_decode_fasterer ( (d), (a), (b), 32-(c) )
-
-mpc_uint8_t     LUT1_0  [1<< 6] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT1_1  [1<< 9] IBSS_ATTR_MPC_LARGE_IRAM; //  576 Bytes
-mpc_uint8_t     LUT2_0  [1<< 7] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT2_1  [1<<10] IBSS_ATTR_MPC_LARGE_IRAM; // 1152 Bytes
-mpc_uint8_t     LUT3_0  [1<< 4] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT3_1  [1<< 5] IBSS_ATTR_MPC_LARGE_IRAM; //   48 Bytes
-mpc_uint8_t     LUT4_0  [1<< 4] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT4_1  [1<< 5] IBSS_ATTR_MPC_LARGE_IRAM; //   48 Bytes
-mpc_uint8_t     LUT5_0  [1<< 6] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT5_1  [1<< 8] IBSS_ATTR_MPC_LARGE_IRAM; //  320 Bytes
-mpc_uint8_t     LUT6_0  [1<< 7] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT6_1  [1<< 7] IBSS_ATTR_MPC_LARGE_IRAM; //  256 Bytes
-mpc_uint8_t     LUT7_0  [1<< 8] IBSS_ATTR_MPC_LARGE_IRAM;
-mpc_uint8_t     LUT7_1  [1<< 8] IBSS_ATTR_MPC_LARGE_IRAM; //  512 Bytes
-mpc_uint8_t     LUTDSCF [1<< 6] IBSS_ATTR_MPC_LARGE_IRAM; //   64 Bytes = 2976 Bytes
+extern const mpc_lut_data   mpc_HuffQ [7] [2];
+extern const mpc_lut_data   mpc_HuffHdr;
+extern const mpc_huffman    mpc_table_HuffSCFI [ 4];
+extern const mpc_lut_data   mpc_HuffDSCF;
+
+//SV8 tables
+extern const mpc_can_data mpc_can_Bands;
+extern const mpc_can_data mpc_can_SCFI[2];
+extern const mpc_can_data mpc_can_DSCF[2];
+extern const mpc_can_data mpc_can_Res [2];
+extern const mpc_can_data mpc_can_Q [8][2];
+extern const mpc_can_data mpc_can_Q1;
+extern const mpc_can_data mpc_can_Q9up;
+
+//Decoder globals (g_Y_L and g_Y_R do not fit into iram for all targets)
+static mpc_decoder g_mpc_decoder                 IBSS_ATTR;
+static MPC_SAMPLE_FORMAT g_Y_L[MPC_FRAME_LENGTH] IBSS_ATTR_MPC_LARGE_IRAM;
+static MPC_SAMPLE_FORMAT g_Y_R[MPC_FRAME_LENGTH] IBSS_ATTR_MPC_LARGE_IRAM;
+
+//SV7 globals (decoding results for bundled quantizers (3- and 5-step))
+static const mpc_int32_t g_sv7_idx30[] ICONST_ATTR = 
+{-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1,-1, 0, 1};
+static const mpc_int32_t g_sv7_idx31[] ICONST_ATTR = 
+{-1,-1,-1, 0, 0, 0, 1, 1, 1,-1,-1,-1, 0, 0, 0, 1, 1, 1,-1,-1,-1, 0, 0, 0, 1, 1, 1};
+static const mpc_int32_t g_sv7_idx32[] ICONST_ATTR = 
+{-1,-1,-1,-1,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1};
+static const mpc_int32_t g_sv7_idx50[] ICONST_ATTR = 
+{-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
+static const mpc_int32_t g_sv7_idx51[] ICONST_ATTR = 
+{-2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2};
+
+//SV8 globals (decoding results for bundled quantizers (3- and 5-step))
+static const mpc_int8_t g_sv8_idx50[125] ICONST_ATTR = 
+{-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2, 
+ -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
+ -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
+ -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,
+ -2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2,-2,-1, 0, 1, 2};
+static const mpc_int8_t g_sv8_idx51[125] ICONST_ATTR = 
+{-2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+ -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+ -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+ -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
+ -2,-2,-2,-2,-2,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2};
+static const mpc_int8_t g_sv8_idx52[125] ICONST_ATTR = 
+{-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+  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,
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+  2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
+static const mpc_int8_t g_sv8_HuffQ2_var[125] ICONST_ATTR =
+{ 6, 5, 4, 5, 6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6, 5, 4, 5, 6,
+  5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 
+  4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 2, 1, 0, 1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 
+  5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 3, 2, 1, 2, 3, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 
+  6, 5, 4, 5, 6, 5, 4, 3, 4, 5, 4, 3, 2, 3, 4, 5, 4, 3, 4, 5, 6, 5, 4, 5, 6};
 
 //------------------------------------------------------------------------------
 // types
 //------------------------------------------------------------------------------
 enum
-    {
-        SEEK_PRE_DECODE = 33,               // number of frames to be pre-decoded
-        MEMSIZE = MPC_DECODER_MEMSIZE,      // overall buffer size
-        MEMSIZE2 = (MEMSIZE/2),             // size of one buffer
-        MEMMASK = (MEMSIZE-1)
-    };
-
-//------------------------------------------------------------------------------
-// forward declarations
-//------------------------------------------------------------------------------
-void mpc_decoder_read_bitstream_sv6(mpc_decoder *d);
-void mpc_decoder_read_bitstream_sv7(mpc_decoder *d, mpc_bool_t fastSeeking);
-void mpc_decoder_update_buffer(mpc_decoder *d);
-mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample);
-void mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band);
-void mpc_decoder_seek_to(mpc_decoder *d, mpc_uint32_t bitPos);
-void mpc_decoder_seek_forward(mpc_decoder *d, mpc_uint32_t bits);
-mpc_uint32_t mpc_decoder_jump_frame(mpc_decoder *d);
-void mpc_decoder_fill_buffer(mpc_decoder *d);
-void mpc_decoder_reset_state(mpc_decoder *d);
-static mpc_uint32_t get_initial_fpos(mpc_decoder *d, mpc_uint32_t StreamVersion);
-static inline mpc_int32_t mpc_decoder_huffman_decode_fastest(mpc_decoder *d, const HuffmanTyp* Table, const mpc_uint8_t* tab, mpc_uint16_t unused_bits);
-static void mpc_move_next(mpc_decoder *d);
-
-mpc_uint32_t  Seekbuffer[MPC_SEEK_BUFFER_SIZE];
-mpc_uint32_t  Speicher[MPC_DECODER_MEMSIZE];
-MPC_SAMPLE_FORMAT Y_L[36][32] IBSS_ATTR_MPC_LARGE_IRAM;
-MPC_SAMPLE_FORMAT Y_R[36][32] IBSS_ATTR_MPC_LARGE_IRAM;
-
-//------------------------------------------------------------------------------
-// utility functions
-//------------------------------------------------------------------------------
-static mpc_int32_t f_read(mpc_decoder *d, void *ptr, size_t size) 
-{ 
-    return d->r->read(d->r->data, ptr, size); 
-};
-
-static mpc_bool_t f_seek(mpc_decoder *d, mpc_int32_t offset) 
-{ 
-    return d->r->seek(d->r->data, offset); 
-};
-
-static mpc_int32_t f_read_dword(mpc_decoder *d, mpc_uint32_t * ptr, mpc_uint32_t count) 
 {
-    count = f_read(d, ptr, count << 2) >> 2;
-    return count;
-}
+    MEMSIZE   = MPC_DECODER_MEMSIZE, // overall buffer size
+    MEMSIZE2  = (MEMSIZE/2),         // size of one buffer
+    MEMMASK   = (MEMSIZE-1)
+};
 
 //------------------------------------------------------------------------------
-// huffman & bitstream functions
+// forward declarations
 //------------------------------------------------------------------------------
-static const mpc_uint32_t mask [33] ICONST_ATTR = {
-    0x00000000, 0x00000001, 0x00000003, 0x00000007,
-    0x0000000F, 0x0000001F, 0x0000003F, 0x0000007F,
-    0x000000FF, 0x000001FF, 0x000003FF, 0x000007FF,
-    0x00000FFF, 0x00001FFF, 0x00003FFF, 0x00007FFF,
-    0x0000FFFF, 0x0001FFFF, 0x0003FFFF, 0x0007FFFF,
-    0x000FFFFF, 0x001FFFFF, 0x003FFFFF, 0x007FFFFF,
-    0x00FFFFFF, 0x01FFFFFF, 0x03FFFFFF, 0x07FFFFFF,
-    0x0FFFFFFF, 0x1FFFFFFF, 0x3FFFFFFF, 0x7FFFFFFF,
-    0xFFFFFFFF
-};
-
-/* F U N C T I O N S */
-
-// resets bitstream decoding
-static void
-mpc_decoder_reset_bitstream_decode(mpc_decoder *d) 
-{
-    d->dword = 0;
-    d->next = 0;
-    d->pos = 0;
-    d->Zaehler = 0;
-    d->WordsRead = 0;
-}
-
-// reports the number of read bits
-static mpc_uint32_t
-mpc_decoder_bits_read(mpc_decoder *d) 
-{
-    return 32 * d->WordsRead + d->pos;
-}
-
-static void mpc_move_next(mpc_decoder *d) {
-    d->Zaehler = (d->Zaehler + 1) & MEMMASK;
-    d->dword = d->next;
-    d->next = SWAP(d->Speicher[(d->Zaehler + 1) & MEMMASK]);
-    d->pos -= 32;
-    ++(d->WordsRead);
-}
-
-// read desired number of bits out of the bitstream
-static inline mpc_uint32_t
-mpc_decoder_bitstream_read(mpc_decoder *d, const mpc_uint32_t bits) 
-{
-    mpc_uint32_t out = d->dword;
-
-    d->pos += bits;
-
-    if (d->pos < 32) {
-        out >>= (32 - d->pos);
-    }
-    else {
-        mpc_move_next(d);
-        if (d->pos) {
-            out <<= d->pos;
-            out |= d->dword >> (32 - d->pos);
-        }
-    }
-
-    return out & mask[bits];
-}
-
-static void 
-mpc_decoder_make_huffman_lookup(
-    mpc_uint8_t* lookup, size_t length, const HuffmanTyp* Table, size_t elements )
-{
-    size_t    i;
-    size_t    idx  = elements;
-    mpc_uint32_t  dval = (mpc_uint32_t)0x80000000L / length * 2;
-    mpc_uint32_t  val  = dval - 1;
-
-    for ( i = 0; i < length; i++, val += dval ) {
-        while ( idx > 0  &&  val >= Table[idx-1].Code )
-            idx--;
-        *lookup++ = (mpc_uint8_t)idx;
-    }
-
-    return;
-}
-
-#ifdef MPC_SUPPORT_SV456
-// decode SCFI-bundle (sv4,5,6)
-static void
-mpc_decoder_scfi_bundle_read(
-    mpc_decoder *d,
-    const HuffmanTyp* Table, mpc_int8_t* SCFI, mpc_bool_t* DSCF) 
-{
-    // load preview and decode
-    mpc_uint32_t code  = d->dword << d->pos;
-
-    if (d->pos > 26) {
-        code |= d->next >> (32 - d->pos);
-    }
-    while (code < Table->Code) {
-        Table++;
-    }
-
-    // set the new position within bitstream without performing a dummy-read
-    if ((d->pos += Table->Length) >= 32) {
-        mpc_move_next(d);
-    }
-
-    *SCFI = Table->Value >> 1;
-    *DSCF = Table->Value &  1;
-}
-
-// basic huffman decoding routine
-// works with maximum lengths up to 14
-static mpc_int32_t
-mpc_decoder_huffman_decode(mpc_decoder *d, const HuffmanTyp *Table) 
+void mpc_decoder_read_bitstream_sv7(mpc_decoder * d, mpc_bits_reader * r);
+void mpc_decoder_read_bitstream_sv8(mpc_decoder * d, mpc_bits_reader * r,
+                                    mpc_bool_t is_key_frame);
+static void mpc_decoder_requantisierung(mpc_decoder *d);
+
+/**
+ * set the scf indexes for seeking use
+ * needed only for sv7 seeking
+ * @param d
+ */
+void mpc_decoder_reset_scf(mpc_decoder * d, int value)
 {
-    // load preview and decode
-    mpc_uint32_t code = d->dword << d->pos;
-    
-    if (d->pos > 18) {
-        code |= d->next >> (32 - d->pos);
-    }
-    while (code < Table->Code) {
-        Table++;
-    }
-
-    // set the new position within bitstream without performing a dummy-read
-    if ((d->pos += Table->Length) >= 32) {
-        mpc_move_next(d);
-    }
-
-    return Table->Value;
+    memset(d->SCF_Index_L, value, sizeof d->SCF_Index_L );
+    memset(d->SCF_Index_R, value, sizeof d->SCF_Index_R );
 }
-#endif
 
-// faster huffman through previewing less bits
-// works with maximum lengths up to 10
-static mpc_int32_t
-mpc_decoder_huffman_decode_fast(mpc_decoder *d, const HuffmanTyp* Table)
+void mpc_decoder_setup(mpc_decoder *d)
 {
-    // load preview and decode
-    mpc_uint32_t code  = d->dword << d->pos;
-    
-    if (d->pos > 22) {
-        code |= d->next >> (32 - d->pos);
-    }
-    while (code < Table->Code) {
-        Table++;
-    }
-
-    // set the new position within bitstream without performing a dummy-read
-    if ((d->pos += Table->Length) >= 32) {
-        mpc_move_next(d);
-    }
-
-    return Table->Value;
-}
+    memset(d, 0, sizeof *d);
 
-// even faster huffman through previewing even less bits
-// works with maximum lengths up to 5
-static mpc_int32_t
-mpc_decoder_huffman_decode_faster(mpc_decoder *d, const HuffmanTyp* Table)
-{
-    // load preview and decode
-    mpc_uint32_t code  = d->dword << d->pos;
+    d->__r1 = 1;
+    d->__r2 = 1;
+    d->Y_L = g_Y_L;
+    d->Y_R = g_Y_R;
     
-    if (d->pos > 27) {
-        code |= d->next >> (32 - d->pos);
-    }
-    while (code < Table->Code) {
-        Table++;
-    }
+    memset(d->Y_L, 0, sizeof(g_Y_L));
+    memset(d->Y_R, 0, sizeof(g_Y_R));
 
-    // set the new position within bitstream without performing a dummy-read
-    if ((d->pos += Table->Length) >= 32) {
-        mpc_move_next(d);
-    }
-
-    return Table->Value;
+    mpc_decoder_init_quant(d, 1.0f);
 }
 
-/* partial lookup table decode */
-static mpc_int32_t
-mpc_decoder_huffman_decode_fasterer(mpc_decoder *d, const HuffmanTyp* Table, const mpc_uint8_t* tab, mpc_uint16_t unused_bits)
+void mpc_decoder_set_streaminfo(mpc_decoder *d, mpc_streaminfo *si)
 {
-    // load preview and decode
-    mpc_uint32_t code  = d->dword << d->pos;
-    
-    if (d->pos > 18) { // preview 14 bits
-        code |= d->next >> (32 - d->pos);
-    }
-
-    Table += tab [(size_t)(code >> unused_bits) ];
-
-    while (code < Table->Code) {
-        Table++;
-    }
-
-    // set the new position within bitstream without performing a dummy-read
-    if ((d->pos += Table->Length) >= 32) {
-        mpc_move_next(d);
-    }
+    d->stream_version     = si->stream_version;
+    d->ms                 = si->ms;
+    d->max_band           = si->max_band;
+    d->channels           = si->channels;
+    d->samples_to_skip    = MPC_DECODER_SYNTH_DELAY + si->beg_silence;
 
-    return Table->Value;
+    if (si->stream_version == 7 && si->is_true_gapless)
+        d->samples = ((si->samples + MPC_FRAME_LENGTH - 1) / MPC_FRAME_LENGTH) * MPC_FRAME_LENGTH;
+    else
+        d->samples = si->samples;
 }
 
-/* full decode using lookup table */
-static inline mpc_int32_t
-mpc_decoder_huffman_decode_fastest(mpc_decoder *d, const HuffmanTyp* Table, const mpc_uint8_t* tab, mpc_uint16_t unused_bits)
+mpc_decoder * mpc_decoder_init(mpc_streaminfo *si)
 {
-    // load preview and decode
-    mpc_uint32_t code  = d->dword << d->pos;
+    mpc_decoder* p_tmp = &g_mpc_decoder;
 
-    if (d->pos > unused_bits) {
-        code |= d->next >> (32 - d->pos);
+    if (p_tmp != 0) {
+        mpc_decoder_setup(p_tmp);
+        mpc_decoder_set_streaminfo(p_tmp, si);
+        huff_init_lut(LUT_DEPTH);
     }
 
-    Table+=tab [(size_t)(code >> unused_bits) ];
-
-    // set the new position within bitstream without performing a dummy-read
-    if ((d->pos += Table->Length) >= 32) {
-        mpc_move_next(d);
-    }
-
-    return Table->Value;
-}
-
-static void
-mpc_decoder_reset_v(mpc_decoder *d) 
-{
-    memset(d->V_L, 0, sizeof d->V_L);
-    memset(d->V_R, 0, sizeof d->V_R);
-}
-
-static void
-mpc_decoder_reset_synthesis(mpc_decoder *d) 
-{
-    mpc_decoder_reset_v(d);
-}
-
-static void
-mpc_decoder_reset_y(mpc_decoder *d) 
-{
-    memset(d->Y_L, 0, sizeof Y_L);
-    memset(d->Y_R, 0, sizeof Y_R);
-}
-
-static void
-mpc_decoder_reset_globals(mpc_decoder *d) 
-{
-    mpc_decoder_reset_bitstream_decode(d);
-
-    d->DecodedFrames    = 0;
-    d->MaxDecodedFrames = 0;
-    d->StreamVersion    = 0;
-    d->MS_used          = 0;
-
-    memset(d->Y_L          , 0, sizeof Y_L           );
-    memset(d->Y_R          , 0, sizeof Y_R           );
-    memset(d->SCF_Index_L  , 0, sizeof d->SCF_Index_L);
-    memset(d->SCF_Index_R  , 0, sizeof d->SCF_Index_R);
-    memset(d->Res_L        , 0, sizeof d->Res_L      );
-    memset(d->Res_R        , 0, sizeof d->Res_R      );
-    memset(d->SCFI_L       , 0, sizeof d->SCFI_L     );
-    memset(d->SCFI_R       , 0, sizeof d->SCFI_R     );
-#ifdef MPC_SUPPORT_SV456
-    memset(d->DSCF_Flag_L  , 0, sizeof d->DSCF_Flag_L);
-    memset(d->DSCF_Flag_R  , 0, sizeof d->DSCF_Flag_R);
-#endif
-    memset(d->Q            , 0, sizeof d->Q          );
-    memset(d->MS_Flag      , 0, sizeof d->MS_Flag    );
+    return p_tmp;
 }
 
-mpc_uint32_t
-mpc_decoder_decode_frame(mpc_decoder *d, mpc_uint32_t *in_buffer,
-                         mpc_uint32_t in_len, MPC_SAMPLE_FORMAT *out_buffer)
+void mpc_decoder_exit(mpc_decoder *d)
 {
-  mpc_decoder_reset_bitstream_decode(d);
-  if (in_len > sizeof(Speicher)) in_len = sizeof(Speicher);
-  memcpy(d->Speicher, in_buffer, in_len);
-  d->dword = SWAP(d->Speicher[0]);
-  d->next = SWAP(d->Speicher[1]);
-  switch (d->StreamVersion) {
-#ifdef MPC_SUPPORT_SV456
-    case 0x04:
-    case 0x05:
-    case 0x06:
-        mpc_decoder_read_bitstream_sv6(d);
-        break;
-#endif
-    case 0x07:
-    case 0x17:
-        mpc_decoder_read_bitstream_sv7(d, FALSE);
-        break;
-    default:
-        return (mpc_uint32_t)(-1);
-  }
-  mpc_decoder_requantisierung(d, d->Max_Band);
-  mpc_decoder_synthese_filter_float(d, out_buffer);
-  return mpc_decoder_bits_read(d);
+    (void)d;
 }
 
-static mpc_uint32_t
-mpc_decoder_decode_internal(mpc_decoder *d, MPC_SAMPLE_FORMAT *buffer) 
+void mpc_decoder_decode_frame(mpc_decoder * d,
+                              mpc_bits_reader * r,
+                              mpc_frame_info * i)
 {
-    mpc_uint32_t output_frame_length = MPC_FRAME_LENGTH;
-
-    mpc_uint32_t  FrameBitCnt = 0;
+    mpc_bits_reader r_sav = *r;
+    mpc_int64_t samples_left;
 
-    // output the last part of the last frame here, if needed
-    if (d->last_block_samples > 0) {
-        output_frame_length = d->last_block_samples;
-        d->last_block_samples = 0; // it's going to be handled now, so reset it 
-        if (!d->TrueGaplessPresent) {
-            mpc_decoder_reset_y(d);
-        } else {
-            mpc_decoder_bitstream_read(d, 20);
-            mpc_decoder_read_bitstream_sv7(d, FALSE);
-            mpc_decoder_requantisierung(d, d->Max_Band);
-        }
-        mpc_decoder_synthese_filter_float(d, buffer);
-        return output_frame_length;
-    }
-    
-    if (d->DecodedFrames >= d->OverallFrames) {
-        return (mpc_uint32_t)(-1);                           // end of file -> abort decoding
-    }
+    samples_left = d->samples - d->decoded_samples + MPC_DECODER_SYNTH_DELAY;
 
-    if (d->DecodedFrames == 0)
-    {
-        d->SeekTable[0] = mpc_decoder_bits_read(d);
-        d->SeekTableCounter = 0;
+    if (samples_left <= 0 && d->samples != 0) {
+        i->samples = 0;
+        i->bits = -1;
+        return;
     }
 
-    // read jump-info for validity check of frame
-    d->FwdJumpInfo  = mpc_decoder_bitstream_read(d, 20);
-
-    d->ActDecodePos = (d->Zaehler << 5) + d->pos;
-
-    // decode data and check for validity of frame
-    FrameBitCnt = mpc_decoder_bits_read(d);
-    switch (d->StreamVersion) {
-#ifdef MPC_SUPPORT_SV456
-    case 0x04:
-    case 0x05:
-    case 0x06:
-        mpc_decoder_read_bitstream_sv6(d);
-        break;
-#endif
-    case 0x07:
-    case 0x17:
-        mpc_decoder_read_bitstream_sv7(d, FALSE);
-        break;
-    default:
-        return (mpc_uint32_t)(-1);
+    if (d->stream_version == 8) {
+        mpc_decoder_read_bitstream_sv8(d, r, i->is_key_frame);
+    } else {
+        mpc_decoder_read_bitstream_sv7(d, r);
     }
-    d->FrameWasValid = mpc_decoder_bits_read(d) - FrameBitCnt == d->FwdJumpInfo;
 
-    d->DecodedFrames++;
-
-    /* update seek table */
-    d->SeekTableCounter += d->FwdJumpInfo + 20;
-    if (0 == ((d->DecodedFrames) & (d->SeekTable_Mask))) 
-    {
-        d->SeekTable[d->DecodedFrames>>d->SeekTable_Step] = d->SeekTableCounter;
-        d->MaxDecodedFrames = d->DecodedFrames;
-        d->SeekTableCounter = 0;
+    if (d->samples_to_skip < MPC_FRAME_LENGTH + MPC_DECODER_SYNTH_DELAY) {
+        mpc_decoder_requantisierung(d);
+        mpc_decoder_synthese_filter_float(d, i->buffer, d->channels);
     }
 
-    // synthesize signal
-    mpc_decoder_requantisierung(d, d->Max_Band);
-
-    mpc_decoder_synthese_filter_float(d, buffer);
-
-    // cut off first MPC_DECODER_SYNTH_DELAY zero-samples
-    if (d->DecodedFrames == d->OverallFrames  && d->StreamVersion >= 6) {        
-        // reconstruct exact filelength
-        mpc_int32_t  mod_block   = mpc_decoder_bitstream_read(d,  11);
-        mpc_int32_t  FilterDecay;
+    d->decoded_samples += MPC_FRAME_LENGTH;
 
-        if (mod_block == 0) {
-            // Encoder bugfix
-            mod_block = 1152;                    
-        }
-        FilterDecay = (mod_block + MPC_DECODER_SYNTH_DELAY) % MPC_FRAME_LENGTH;
-
-        // additional FilterDecay samples are needed for decay of synthesis filter
-        if (MPC_DECODER_SYNTH_DELAY + mod_block >= MPC_FRAME_LENGTH) {
-            // this variable will be checked for at the top of the function
-            d->last_block_samples = FilterDecay;
-        }
-        else { // there are only FilterDecay samples needed for this frame
-            output_frame_length = FilterDecay;
+    // reconstruct exact filelength
+    if (d->decoded_samples - d->samples < MPC_FRAME_LENGTH && d->stream_version == 7) {
+        int last_frame_samples = mpc_bits_read(r, 11);
+        if (d->decoded_samples == d->samples) {
+            if (last_frame_samples == 0) last_frame_samples = MPC_FRAME_LENGTH;
+            d->samples += last_frame_samples - MPC_FRAME_LENGTH;
+            samples_left += last_frame_samples - MPC_FRAME_LENGTH;
         }
     }
 
+    i->samples = samples_left > MPC_FRAME_LENGTH ? MPC_FRAME_LENGTH : samples_left < 0 ? 0 : (mpc_uint32_t) samples_left;
+    i->bits = (mpc_uint32_t) (((r->buff - r_sav.buff) << 3) + r_sav.count - r->count);
+
     if (d->samples_to_skip) {
-        if (output_frame_length < d->samples_to_skip) {
-            d->samples_to_skip -= output_frame_length;
-            output_frame_length = 0;
-        }
-        else {
-            output_frame_length -= d->samples_to_skip;
-            memmove(
-                buffer, 
-                buffer + d->samples_to_skip, 
-                output_frame_length * sizeof (MPC_SAMPLE_FORMAT));
-            memmove(
-                buffer + MPC_FRAME_LENGTH, 
-                buffer + MPC_FRAME_LENGTH + d->samples_to_skip, 
-                output_frame_length * sizeof (MPC_SAMPLE_FORMAT));
+        if (i->samples <= d->samples_to_skip) {
+            d->samples_to_skip -= i->samples;
+            i->samples = 0;
+        } else {
+            i->samples -= d->samples_to_skip;
+            
+            /* move valid samples to beginning for channel 0. noninterleaved! */
+            memmove(i->buffer, 
+                    i->buffer + d->samples_to_skip, 
+                    i->samples * sizeof(MPC_SAMPLE_FORMAT));
+            /* move valid samples to beginning for channel 1. noninterleaved! */
+            memmove(i->buffer + MPC_FRAME_LENGTH, 
+                    i->buffer + MPC_FRAME_LENGTH + d->samples_to_skip, 
+                    i->samples * sizeof(MPC_SAMPLE_FORMAT));
+                    
             d->samples_to_skip = 0;
         }
     }
-
-    return output_frame_length;
-}
-
-mpc_uint32_t mpc_decoder_decode(
-    mpc_decoder *d,
-    MPC_SAMPLE_FORMAT *buffer, 
-    mpc_uint32_t *vbr_update_acc, 
-    mpc_uint32_t *vbr_update_bits)
-{
-    for(;;)
-    {
-        mpc_uint32_t RING = d->Zaehler;
-        mpc_int32_t vbr_ring = (RING << 5) + d->pos;
-
-        mpc_uint32_t valid_samples = mpc_decoder_decode_internal(d, buffer);
-
-        if (valid_samples == (mpc_uint32_t)(-1) ) {
-            return 0;
-        }
-
-        /**************** ERROR CONCEALMENT *****************/
-        if (d->FrameWasValid == 0 ) {
-            // error occurred in bitstream
-            return (mpc_uint32_t)(-1);
-        } 
-        else {
-            if (vbr_update_acc && vbr_update_bits) {
-                (*vbr_update_acc) ++;
-                vbr_ring = (d->Zaehler << 5) + d->pos - vbr_ring;
-                if (vbr_ring < 0) {
-                    vbr_ring += 524288;
-                }
-                (*vbr_update_bits) += vbr_ring;
-            }
-
-        }
-        mpc_decoder_update_buffer(d);
-
-        if (valid_samples > 0) {
-            return valid_samples;
-        }
-    }
 }
 
 void
-mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band) 
+mpc_decoder_requantisierung(mpc_decoder *d)
 {
     mpc_int32_t     Band;
     mpc_int32_t     n;
@@ -613,6 +253,7 @@ mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
     MPC_SAMPLE_FORMAT* YR;
     mpc_int16_t*    L;
     mpc_int16_t*    R;
+    const mpc_int32_t Last_Band = d->max_band;
 
 #ifdef MPC_FIXED_POINT
 #if MPC_FIXED_POINT_FRACTPART == 14
@@ -629,42 +270,42 @@ mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
 #endif
     // requantization and scaling of subband-samples
     for ( Band = 0; Band <= Last_Band; Band++ ) {   // setting pointers
-        YL = d->Y_L[0] + Band;
-        YR = d->Y_R[0] + Band;
+        YL = d->Y_L + Band;
+        YR = d->Y_R + Band;
         L  = d->Q[Band].L;
         R  = d->Q[Band].R;
         /************************** MS-coded **************************/
         if ( d->MS_Flag [Band] ) {
             if ( d->Res_L [Band] ) {
                 if ( d->Res_R [Band] ) {    // M!=0, S!=0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][0]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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]] , (unsigned char)d->SCF_Index_L[Band][1]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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]] , (unsigned char)d->SCF_Index_L[Band][2]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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++));
                         *YR   = templ - tempr;
                     }
                 } else {    // M!=0, S==0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)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]] , (unsigned char)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]] , (unsigned char)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++);
                     }
@@ -672,15 +313,15 @@ mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
             } else {
                 if (d->Res_R[Band])    // M==0, S!=0
                 {
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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]] , (unsigned char)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]] , (unsigned char)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++)));
                     }
@@ -695,36 +336,36 @@ mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
         else {
             if ( d->Res_L [Band] ) {
                 if ( d->Res_R [Band] ) {    // L!=0, R!=0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)d->SCF_Index_L[Band][0]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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]] , (unsigned char)d->SCF_Index_L[Band][1]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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]] , (unsigned char)d->SCF_Index_L[Band][2]);
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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++);
                         *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
                     }
                 } else {     // L!=0, R==0
-                    facL = MPC_MULTIPLY_SCF( Cc[d->Res_L[Band]] , (unsigned char)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]] , (unsigned char)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]] , (unsigned char)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++);
                         *YR = 0;
@@ -733,17 +374,17 @@ mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
             }
             else {
                 if ( d->Res_R [Band] ) {    // L==0, R!=0
-                    facR = MPC_MULTIPLY_SCF( Cc[d->Res_R[Band]] , (unsigned char)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]] , (unsigned char)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]] , (unsigned char)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;
                         *YR = MPC_MULTIPLY_FLOAT_INT(facR,*R++);
@@ -758,1040 +399,324 @@ mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
     }
 }
 
-#ifdef MPC_SUPPORT_SV456
-static const unsigned char Q_res[32][16] ICONST_ATTR = {
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,17},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,3,4,5,6,17,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-{0,1,2,17,0,0,0,0,0,0,0,0,0,0,0,0},
-};
-
-/****************************************** SV 6 ******************************************/
-void
-mpc_decoder_read_bitstream_sv6(mpc_decoder *d) 
+void mpc_decoder_read_bitstream_sv7(mpc_decoder * d, mpc_bits_reader * r)
 {
-    mpc_int32_t n,k;
-    mpc_int32_t Max_used_Band=0;
-    const HuffmanTyp *Table;
-    const HuffmanTyp *x1;
-    const HuffmanTyp *x2;
-    mpc_int8_t *L;
-    mpc_int8_t *R;
-    mpc_int16_t *QL;
-    mpc_int16_t *QR;
-    mpc_int8_t *ResL = d->Res_L;
-    mpc_int8_t *ResR = d->Res_R;
+    mpc_int32_t n, idx, Max_used_Band = 0;
 
-    /************************ HEADER **************************/
-    ResL = d->Res_L;
-    ResR = d->Res_R;
-    for (n=0; n <= d->Max_Band; ++n, ++ResL, ++ResR)
-    {
-        if      (n<11)           Table = mpc_table_Region_A;
-        else if (n>=11 && n<=22) Table = mpc_table_Region_B;
-        else /*if (n>=23)*/      Table = mpc_table_Region_C;
+    /***************************** Header *****************************/
 
-        *ResL = Q_res[n][mpc_decoder_huffman_decode(d, Table)];
-        if (d->MS_used) {
-            d->MS_Flag[n] = mpc_decoder_bitstream_read(d,  1);
-        }
-        *ResR = Q_res[n][mpc_decoder_huffman_decode(d, Table)];
+    // first subband
+    d->Res_L[0] = mpc_bits_read(r, 4);
+    d->Res_R[0] = mpc_bits_read(r, 4);
+    if (!(d->Res_L[0] == 0 && d->Res_R[0] == 0)) {
+        if (d->ms)
+            d->MS_Flag[0] = mpc_bits_read(r, 1);
+        Max_used_Band = 1;
+    }
+
+    // consecutive subbands
+    for ( n = 1; n <= d->max_band; n++ ) {
+        idx   = mpc_bits_huff_lut(r, & mpc_HuffHdr);
+        d->Res_L[n] = (idx!=4) ? d->Res_L[n - 1] + idx : (int) mpc_bits_read(r, 4);
 
-        // only perform the following procedure up to the maximum non-zero subband
-        if (*ResL || *ResR) Max_used_Band = n;
+        idx   = mpc_bits_huff_lut(r, & mpc_HuffHdr);
+        d->Res_R[n] = (idx!=4) ? d->Res_R[n - 1] + idx : (int) mpc_bits_read(r, 4);
+
+        if (!(d->Res_L[n] == 0 && d->Res_R[n] == 0)) {
+            if (d->ms)
+                d->MS_Flag[n] = mpc_bits_read(r, 1);
+            Max_used_Band = n + 1;
+        }
     }
 
-    /************************* SCFI-Bundle *****************************/
-    ResL = d->Res_L;
-    ResR = d->Res_R;
-    for (n=0; n<=Max_used_Band; ++n, ++ResL, ++ResR) {
-        if (*ResL) mpc_decoder_scfi_bundle_read(d, mpc_table_SCFI_Bundle, &(d->SCFI_L[n]), &(d->DSCF_Flag_L[n]));
-        if (*ResR) mpc_decoder_scfi_bundle_read(d, mpc_table_SCFI_Bundle, &(d->SCFI_R[n]), &(d->DSCF_Flag_R[n]));
+    /****************************** SCFI ******************************/
+    for ( n = 0; n < Max_used_Band; n++ ) {
+        if (d->Res_L[n])
+            d->SCFI_L[n] = mpc_bits_huff_dec(r, mpc_table_HuffSCFI);
+        if (d->Res_R[n])
+            d->SCFI_R[n] = mpc_bits_huff_dec(r, mpc_table_HuffSCFI);
     }
 
-    /***************************** SCFI ********************************/
-    ResL = d->Res_L;
-    ResR = d->Res_R;
-    L    = d->SCF_Index_L[0];
-    R    = d->SCF_Index_R[0];
-    for (n=0; n <= Max_used_Band; ++n, ++ResL, ++ResR, L+=3, R+=3)
-    {
-        if (*ResL)
-        {
-            /*********** DSCF ************/
-            if (d->DSCF_Flag_L[n]==1)
-            {
-                switch (d->SCFI_L[n])
-                {
-                case 3:
-                    L[0] = L[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    L[1] = L[0];
-                    L[2] = L[1];
-                    break;
-                case 1:
-                    L[0] = L[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    L[1] = L[0] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    L[2] = L[1];
-                    break;
-                case 2:
-                    L[0] = L[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    L[1] = L[0];
-                    L[2] = L[1] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    break;
-                case 0:
-                    L[0] = L[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    L[1] = L[0] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    L[2] = L[1] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    break;
-                default:
-                    return;
-                    break;
+    /**************************** SCF/DSCF ****************************/
+    for ( n = 0; n < Max_used_Band; n++ ) {
+        mpc_int32_t * SCF = d->SCF_Index_L[n];
+        mpc_uint32_t Res  = d->Res_L[n], SCFI = d->SCFI_L[n];
+        do {
+            if (Res) {
+                switch (SCFI) {
+                    case 1:
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[1] = (idx!=8) ? SCF[0] + idx : (int) mpc_bits_read(r, 6);
+                        SCF[2] = SCF[1];
+                        break;
+                    case 3:
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
+                        SCF[1] = SCF[0];
+                        SCF[2] = SCF[1];
+                        break;
+                    case 2:
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
+                        SCF[1] = SCF[0];
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[2] = (idx!=8) ? SCF[1] + idx : (int) mpc_bits_read(r, 6);
+                        break;
+                    case 0:
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[0] = (idx!=8) ? SCF[2] + idx : (int) mpc_bits_read(r, 6);
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[1] = (idx!=8) ? SCF[0] + idx : (int) mpc_bits_read(r, 6);
+                        idx  = mpc_bits_huff_lut(r, & mpc_HuffDSCF);
+                        SCF[2] = (idx!=8) ? SCF[1] + idx : (int) mpc_bits_read(r, 6);
+                        break;
+                    default:
+                        return;
                 }
+                if (SCF[0] > 1024)
+                    SCF[0] = 0x8080;
+                if (SCF[1] > 1024)
+                    SCF[1] = 0x8080;
+                if (SCF[2] > 1024)
+                    SCF[2] = 0x8080;
             }
-            /************ SCF ************/
-            else
-            {
-                switch (d->SCFI_L[n])
-                {
-                case 3:
-                    L[0] = mpc_decoder_bitstream_read(d,  6);
-                    L[1] = L[0];
-                    L[2] = L[1];
-                    break;
-                case 1:
-                    L[0] = mpc_decoder_bitstream_read(d,  6);
-                    L[1] = mpc_decoder_bitstream_read(d,  6);
-                    L[2] = L[1];
-                    break;
-                case 2:
-                    L[0] = mpc_decoder_bitstream_read(d,  6);
-                    L[1] = L[0];
-                    L[2] = mpc_decoder_bitstream_read(d,  6);
-                    break;
-                case 0:
-                    L[0] = mpc_decoder_bitstream_read(d,  6);
-                    L[1] = mpc_decoder_bitstream_read(d,  6);
-                    L[2] = mpc_decoder_bitstream_read(d,  6);
-                    break;
-                default:
-                    return;
+            Res = d->Res_R[n];
+            SCFI = d->SCFI_R[n];
+        } while ( SCF == d->SCF_Index_L[n] && (SCF = d->SCF_Index_R[n]));
+    }
+
+//     if (d->seeking == TRUE)
+//         return;
+
+    /***************************** Samples ****************************/
+    for ( n = 0; n < Max_used_Band; n++ ) {
+        mpc_int16_t *q = d->Q[n].L, Res = d->Res_L[n];
+        do {
+            mpc_int32_t k;
+            const mpc_lut_data *Table;
+            switch (Res) {
+                case  -2: case  -3: case  -4: case  -5: case  -6: case  -7: case  -8: case  -9:
+                case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17: case 0:
                     break;
-                }
-            }
-        }
-        if (*ResR)
-        {
-            /*********** DSCF ************/
-            if (d->DSCF_Flag_R[n]==1)
-            {
-                switch (d->SCFI_R[n])
-                {
-                case 3:
-                    R[0] = R[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    R[1] = R[0];
-                    R[2] = R[1];
+                case -1:
+                    for (k=0; 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 1:
-                    R[0] = R[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    R[1] = R[0] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    R[2] = R[1];
+                    Table = & mpc_HuffQ[0][mpc_bits_read(r, 1)];
+                    for ( k = 0; k < 36; k += 3) {
+                        idx = mpc_bits_huff_lut(r, Table);
+                        q[k]     = g_sv7_idx30[idx];
+                        q[k + 1] = g_sv7_idx31[idx];
+                        q[k + 2] = g_sv7_idx32[idx];
+                    }
                     break;
                 case 2:
-                    R[0] = R[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    R[1] = R[0];
-                    R[2] = R[1] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    break;
-                case 0:
-                    R[0] = R[2] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    R[1] = R[0] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    R[2] = R[1] + mpc_decoder_huffman_decode_fast(d,  mpc_table_DSCF_Entropie);
-                    break;
-                default:
-                    return;
+                    Table = & mpc_HuffQ[1][mpc_bits_read(r, 1)];
+                    for ( k = 0; k < 36; k += 2) {
+                        idx = mpc_bits_huff_lut(r, Table);
+                        q[k]     = g_sv7_idx50[idx];
+                        q[k + 1] = g_sv7_idx51[idx];
+                    }
                     break;
-                }
-            }
-            /************ SCF ************/
-            else
-            {
-                switch (d->SCFI_R[n])
-                {
                 case 3:
-                    R[0] = mpc_decoder_bitstream_read(d, 6);
-                    R[1] = R[0];
-                    R[2] = R[1];
-                    break;
-                case 1:
-                    R[0] = mpc_decoder_bitstream_read(d, 6);
-                    R[1] = mpc_decoder_bitstream_read(d, 6);
-                    R[2] = R[1];
-                    break;
-                case 2:
-                    R[0] = mpc_decoder_bitstream_read(d, 6);
-                    R[1] = R[0];
-                    R[2] = mpc_decoder_bitstream_read(d, 6);
+                case 4:
+                case 5:
+                case 6:
+                case 7:
+                    Table = & mpc_HuffQ[Res - 1][mpc_bits_read(r, 1)];
+                    for ( k = 0; k < 36; k++ )
+                        q[k] = mpc_bits_huff_lut(r, Table);
                     break;
-                case 0:
-                    R[0] = mpc_decoder_bitstream_read(d, 6);
-                    R[1] = mpc_decoder_bitstream_read(d, 6);
-                    R[2] = mpc_decoder_bitstream_read(d, 6);
+                case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
+                    for ( k = 0; k < 36; k++ )
+                        q[k] = (mpc_int32_t)mpc_bits_read(r, Res_bit[Res]) - Dc[Res];
                     break;
                 default:
                     return;
-                    break;
-                }
-            }
-        }
-    }
-
-    /**************************** Samples ****************************/
-    ResL = d->Res_L;
-    ResR = d->Res_R;
-    for (n=0; n <= Max_used_Band; ++n, ++ResL, ++ResR)
-    {
-        // setting pointers
-        x1 = mpc_table_SampleHuff[*ResL];
-        x2 = mpc_table_SampleHuff[*ResR];
-        QL = d->Q[n].L;
-        QR = d->Q[n].R;
-
-        if (x1!=NULL || x2!=NULL)
-            for (k=0; k<36; ++k)
-            {
-                if (x1 != NULL) *QL++ = mpc_decoder_huffman_decode_fast(d,  x1);
-                if (x2 != NULL) *QR++ = mpc_decoder_huffman_decode_fast(d,  x2);
             }
 
-        if (*ResL>7 || *ResR>7)
-            for (k=0; k<36; ++k)
-            {
-                if (*ResL>7) *QL++ = (mpc_int16_t)mpc_decoder_bitstream_read(d,  Res_bit[*ResL]) - Dc[*ResL];
-                if (*ResR>7) *QR++ = (mpc_int16_t)mpc_decoder_bitstream_read(d,  Res_bit[*ResR]) - Dc[*ResR];
-            }
+            Res = d->Res_R[n];
+        } while (q == d->Q[n].L && (q = d->Q[n].R));
     }
 }
-#endif //MPC_SUPPORT_SV456
-/****************************************** SV 7 ******************************************/
-void
-mpc_decoder_read_bitstream_sv7(mpc_decoder *d, mpc_bool_t fastSeeking) 
+
+void mpc_decoder_read_bitstream_sv8(mpc_decoder * d, mpc_bits_reader * r, mpc_bool_t is_key_frame)
 {
-    mpc_int32_t n,k;
-    mpc_int32_t Max_used_Band=0;
-    const HuffmanTyp *Table;
-    mpc_int32_t idx;
-    mpc_int8_t *L   ,*R;
-    mpc_int16_t *LQ   ,*RQ;
-    mpc_int8_t *ResL,*ResR;
-    mpc_uint32_t tmp;
-    mpc_uint8_t *LUT;
-    mpc_uint8_t max_length;
+    mpc_int32_t n, Max_used_Band;
+    const mpc_can_data * Table, * Tables[2];
 
     /***************************** Header *****************************/
-    ResL  = d->Res_L;
-    ResR  = d->Res_R;
 
-    // first subband
-    *ResL = mpc_decoder_bitstream_read(d, 4);
-    *ResR = mpc_decoder_bitstream_read(d, 4);
-    if (d->MS_used && !(*ResL==0 && *ResR==0)) {
-        d->MS_Flag[0] = mpc_decoder_bitstream_read(d, 1);
+    if (is_key_frame == MPC_TRUE) {
+        Max_used_Band = mpc_bits_log_dec(r, d->max_band + 1);
     } else {
-        d->MS_Flag[0] = 0;
-    }
-
-    // consecutive subbands
-    ++ResL; ++ResR; // increase pointers
-    for (n=1; n <= d->Max_Band; ++n, ++ResL, ++ResR)
-    {
-        idx   = mpc_decoder_huffman_decode_fast(d, mpc_table_HuffHdr);
-        *ResL = (idx!=4) ? *(ResL-1) + idx : (int) mpc_decoder_bitstream_read(d, 4);
-
-        idx   = mpc_decoder_huffman_decode_fast(d, mpc_table_HuffHdr);
-        *ResR = (idx!=4) ? *(ResR-1) + idx : (int) mpc_decoder_bitstream_read(d, 4);
-
-        if (d->MS_used && !(*ResL==0 && *ResR==0)) {
-            d->MS_Flag[n] = mpc_decoder_bitstream_read(d, 1);
+        Max_used_Band = d->last_max_band + mpc_bits_can_dec(r, & mpc_can_Bands);
+        if (Max_used_Band > 32) Max_used_Band -= 33;
+    }
+    d->last_max_band = Max_used_Band;
+
+    if (Max_used_Band) {
+        d->Res_L[Max_used_Band-1] = mpc_bits_can_dec(r, & mpc_can_Res[0]);
+        d->Res_R[Max_used_Band-1] = mpc_bits_can_dec(r, & mpc_can_Res[0]);
+        if (d->Res_L[Max_used_Band-1] > 15) d->Res_L[Max_used_Band-1] -= 17;
+        if (d->Res_R[Max_used_Band-1] > 15) d->Res_R[Max_used_Band-1] -= 17;
+        for ( n = Max_used_Band - 2; n >= 0; n--) {
+            d->Res_L[n] = mpc_bits_can_dec(r, & mpc_can_Res[d->Res_L[n + 1] > 2]) + d->Res_L[n + 1];
+            if (d->Res_L[n] > 15) d->Res_L[n] -= 17;
+            d->Res_R[n] = mpc_bits_can_dec(r, & mpc_can_Res[d->Res_R[n + 1] > 2]) + d->Res_R[n + 1];
+            if (d->Res_R[n] > 15) d->Res_R[n] -= 17;
         }
 
-        // only perform following procedures up to the maximum non-zero subband
-        if (*ResL!=0 || *ResR!=0) {
-            Max_used_Band = n;
-        } else {
-            d->MS_Flag[n] = 0;
+        if (d->ms) {
+            int cnt = 0, tot = 0;
+            mpc_uint32_t tmp = 0;
+            for( n = 0; n < Max_used_Band; n++)
+                if ( d->Res_L[n] != 0 || d->Res_R[n] != 0 )
+                    tot++;
+            cnt = mpc_bits_log_dec(r, tot);
+            if (cnt != 0 && cnt != tot)
+                tmp = mpc_bits_enum_dec(r, mini(cnt, tot-cnt), tot);
+            if (cnt * 2 > tot) tmp = ~tmp;
+            for( n = Max_used_Band - 1; n >= 0; n--)
+                if ( d->Res_L[n] != 0 || d->Res_R[n] != 0 ) {
+                    d->MS_Flag[n] = tmp & 1;
+                    tmp >>= 1;
+                }
         }
     }
-    /****************************** SCFI ******************************/
-    L     = d->SCFI_L;
-    R     = d->SCFI_R;
-    ResL  = d->Res_L;
-    ResR  = d->Res_R;
-    for (n=0; n <= Max_used_Band; ++n, ++L, ++R, ++ResL, ++ResR) {
-        if (*ResL) *L = mpc_decoder_huffman_decode_faster(d, mpc_table_HuffSCFI);
-        if (*ResR) *R = mpc_decoder_huffman_decode_faster(d, mpc_table_HuffSCFI);
-    }
 
-    /**************************** SCF/DSCF ****************************/
-    ResL  = d->Res_L;
-    ResR  = d->Res_R;
-    L     = d->SCF_Index_L[0];
-    R     = d->SCF_Index_R[0];
-    for (n=0; n<=Max_used_Band; ++n, ++ResL, ++ResR, L+=3, R+=3) {
-        if (*ResL)
-        {
-            switch (d->SCFI_L[n])
-            {
-            case 1:
-                idx = Decode_DSCF ();
-                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                idx = Decode_DSCF ();
-                L[1] = (idx!=8) ? SCF_DIFF(L[0], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                L[2] = L[1];
-                break;
-            case 3:
-                idx = Decode_DSCF ();
-                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                L[1] = L[0];
-                L[2] = L[1];
-                break;
-            case 2:
-                idx = Decode_DSCF ();
-                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                L[1] = L[0];
-                idx = Decode_DSCF ();
-                L[2] = (idx!=8) ? SCF_DIFF(L[1], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                break;
-            case 0:
-                idx = Decode_DSCF ();
-                L[0] = (idx!=8) ? SCF_DIFF(L[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                idx = Decode_DSCF ();
-                L[1] = (idx!=8) ? SCF_DIFF(L[0], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                idx = Decode_DSCF ();
-                L[2] = (idx!=8) ? SCF_DIFF(L[1], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                break;
-            default:
-                return;
-                break;
-            }
-        }
-        if (*ResR)
-        {
-            switch (d->SCFI_R[n])
-            {
-            case 1:
-                idx = Decode_DSCF ();
-                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                idx = Decode_DSCF ();
-                R[1] = (idx!=8) ? SCF_DIFF(R[0], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                R[2] = R[1];
-                break;
-            case 3:
-                idx = Decode_DSCF ();
-                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                R[1] = R[0];
-                R[2] = R[1];
-                break;
-            case 2:
-                idx = Decode_DSCF ();
-                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                R[1] = R[0];
-                idx = Decode_DSCF ();
-                R[2] = (idx!=8) ? SCF_DIFF(R[1], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                break;
-            case 0:
-                idx = Decode_DSCF ();
-                R[0] = (idx!=8) ? SCF_DIFF(R[2], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                idx = Decode_DSCF ();
-                R[1] = (idx!=8) ? SCF_DIFF(R[0], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                idx = Decode_DSCF ();
-                R[2] = (idx!=8) ? SCF_DIFF(R[1], idx) : (int) mpc_decoder_bitstream_read(d, 6);
-                break;
-            default:
-                return;
-                break;
-            }
+    for( n = Max_used_Band; n <= d->max_band; n++)
+        d->Res_L[n] = d->Res_R[n] = 0;
+
+    /****************************** SCFI ******************************/
+    if (is_key_frame == MPC_TRUE){
+        for( n = 0; n < 32; n++)
+            d->DSCF_Flag_L[n] = d->DSCF_Flag_R[n] = 1; // new block -> force key frame
+    }
+
+    Tables[0] = & mpc_can_SCFI[0];
+    Tables[1] = & mpc_can_SCFI[1];
+    for ( n = 0; n < Max_used_Band; n++ ) {
+        int tmp = 0, cnt = -1;
+        if (d->Res_L[n]) cnt++;
+        if (d->Res_R[n]) cnt++;
+        if (cnt >= 0) {
+            tmp = mpc_bits_can_dec(r, Tables[cnt]);
+            if (d->Res_L[n]) d->SCFI_L[n] = tmp >> (2 * cnt);
+            if (d->Res_R[n]) d->SCFI_R[n] = tmp & 3;
         }
     }
 
-    if (fastSeeking)
-        return;
+    /**************************** SCF/DSCF ****************************/
 
-    /***************************** Samples ****************************/
-    ResL = d->Res_L;
-    ResR = d->Res_R;
-    LQ    = d->Q[0].L;
-    RQ    = d->Q[0].R;
-    for (n=0; n <= Max_used_Band; ++n, ++ResL, ++ResR, LQ+=36, RQ+=36)
-    {
-        /************** links **************/
-        switch (*ResL)
-        {
-        case  -2: case  -3: case  -4: case  -5: case  -6: case  -7: case  -8: case  -9:
-        case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17:
-            LQ += 36;
-            break;
-        case -1:
-            for (k=0; k<36; k++ ) {
-                tmp  = mpc_random_int(d);
-                *LQ++ = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >>  8) & 0xFF) + ((tmp >>  0) & 0xFF) - 510;
-            }
-            break;
-        case 0:
-            LQ += 36;// increase pointer
-            break;
-        case 1:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][1];
-                LUT = LUT1_1;
-                max_length = 9;
-            } else {
-                Table = mpc_table_HuffQ[0][1];
-                LUT = LUT1_0;
-                max_length = 6;
-            }
-            for (k=0; k<12; ++k)
-            {
-                idx  = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                *LQ++ = idx30[idx];
-                *LQ++ = idx31[idx];
-                *LQ++ = idx32[idx];
-            }
-            break;
-        case 2:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][2];
-                LUT = LUT2_1;
-                max_length = 10;
-            } else {
-                Table = mpc_table_HuffQ[0][2];
-                LUT = LUT2_0;
-                max_length = 7;
-            }
-            for (k=0; k<18; ++k)
-            {
-                idx  = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                *LQ++ = idx50[idx];
-                *LQ++ = idx51[idx];
-            }
-            break;
-        case 3:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][3];
-                LUT = LUT3_1;
-                max_length = 5;
-            } else {
-                Table = mpc_table_HuffQ[0][3];
-                LUT = LUT3_0;
-                max_length = 4;
-            }
-            for (k=0; k<36; ++k)
-                *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-            break;
-        case 4:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][4];
-                LUT = LUT4_1;
-                max_length = 5;
-            } else {
-                Table = mpc_table_HuffQ[0][4];
-                LUT = LUT4_0;
-                max_length = 4;
-            }
-            for (k=0; k<36; ++k)
-                *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-            break;
-        case 5:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][5];
-                LUT = LUT5_1;
-                max_length = 8;
-            } else {
-                Table = mpc_table_HuffQ[0][5];
-                LUT = LUT5_0;
-                max_length = 6;
-            }
-            for (k=0; k<36; ++k)
-                *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-            break;
-        case 6:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][6];
-                LUT = LUT6_1;
-                max_length = 7;
-                for (k=0; k<36; ++k)
-                    *LQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
-            } else {
-                Table = mpc_table_HuffQ[0][6];
-                LUT = LUT6_0;
-                max_length = 7;
-                for (k=0; k<36; ++k)
-                    *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-            }
-            break;
-        case 7:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][7];
-                LUT = LUT7_1;
-                max_length = 8;
-                for (k=0; k<36; ++k)
-                    *LQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
-            } else {
-                Table = mpc_table_HuffQ[0][7];
-                LUT = LUT7_0;
-                max_length = 8;
-                for (k=0; k<36; ++k)
-                    *LQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-            }           
-            break;
-        case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
-            tmp = Dc[*ResL];
-            for (k=0; k<36; ++k)
-                *LQ++ = (mpc_int16_t)mpc_decoder_bitstream_read(d, Res_bit[*ResL]) - tmp;
-            break;
-        default:
-            return;
-        }
-        /************** rechts **************/
-        switch (*ResR)
-        {
-        case  -2: case  -3: case  -4: case  -5: case  -6: case  -7: case  -8: case  -9:
-        case -10: case -11: case -12: case -13: case -14: case -15: case -16: case -17:
-            RQ += 36;
-            break;
-        case -1:
-                for (k=0; k<36; k++ ) {
-                    tmp  = mpc_random_int(d);
-                    *RQ++ = ((tmp >> 24) & 0xFF) + ((tmp >> 16) & 0xFF) + ((tmp >>  8) & 0xFF) + ((tmp >>  0) & 0xFF) - 510;
-                }
-                break;
-            case 0:
-                RQ += 36;// increase pointer
-                break;
-            case 1:
-                if (mpc_decoder_bitstream_read(d, 1)) {
-                    Table = mpc_table_HuffQ[1][1];
-                    LUT = LUT1_1;
-                    max_length = 9;
-                } else {
-                    Table = mpc_table_HuffQ[0][1];
-                    LUT = LUT1_0;
-                    max_length = 6;
-                }
-                for (k=0; k<12; ++k)
-                {
-                    idx = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                    *RQ++ = idx30[idx];
-                    *RQ++ = idx31[idx];
-                    *RQ++ = idx32[idx];
-                }
-                break;
-            case 2:
-                if (mpc_decoder_bitstream_read(d, 1)) {
-                    Table = mpc_table_HuffQ[1][2];
-                    LUT = LUT2_1;
-                    max_length = 10;
-                } else {
-                    Table = mpc_table_HuffQ[0][2];
-                    LUT = LUT2_0;
-                    max_length = 7;
-                }
-                for (k=0; k<18; ++k)
-                {
-                    idx = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                    *RQ++ = idx50[idx];
-                    *RQ++ = idx51[idx]; 
-                }
-                break;
-            case 3:
-                if (mpc_decoder_bitstream_read(d, 1)) {
-                    Table = mpc_table_HuffQ[1][3];
-                    LUT = LUT3_1;
-                    max_length = 5;
-                } else {
-                    Table = mpc_table_HuffQ[0][3];
-                    LUT = LUT3_0;
-                    max_length = 4;
-                }
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                break;
-            case 4:
-                if (mpc_decoder_bitstream_read(d, 1)) {
-                    Table = mpc_table_HuffQ[1][4];
-                    LUT = LUT4_1;
-                    max_length = 5;
+    for ( n = 0; n < Max_used_Band; n++ ) {
+        mpc_int32_t * SCF = d->SCF_Index_L[n];
+        mpc_uint32_t Res = d->Res_L[n], SCFI = d->SCFI_L[n];
+        mpc_bool_t * DSCF_Flag = &d->DSCF_Flag_L[n];
+
+        do {
+            if ( Res ) {
+                int m;
+                if (*DSCF_Flag == 1) {
+                    SCF[0] = (mpc_int32_t)mpc_bits_read(r, 7) - 6;
+                    *DSCF_Flag = 0;
                 } else {
-                    Table = mpc_table_HuffQ[0][4];
-                    LUT = LUT4_0;
-                    max_length = 4;
+                    mpc_uint_t tmp = mpc_bits_can_dec(r, & mpc_can_DSCF[1]);
+                    if (tmp == 64)
+                        tmp += mpc_bits_read(r, 6);
+                    SCF[0] = ((SCF[2] - 25 + tmp) & 127) - 6;
                 }
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                break;
-            case 5:
-                if (mpc_decoder_bitstream_read(d, 1)) {
-                    Table = mpc_table_HuffQ[1][5];
-                    LUT = LUT5_1;
-                    max_length = 8;
-                } else {
-                    Table = mpc_table_HuffQ[0][5];
-                    LUT = LUT5_0;
-                    max_length = 6;
+                for( m = 0; m < 2; m++){
+                    if (((SCFI << m) & 2) == 0) {
+                        mpc_uint_t tmp = mpc_bits_can_dec(r, & mpc_can_DSCF[0]);
+                        if (tmp == 31)
+                            tmp = 64 + mpc_bits_read(r, 6);
+                        SCF[m + 1] = ((SCF[m] - 25 + tmp) & 127) - 6;
+                    } else
+                        SCF[m + 1] = SCF[m];
                 }
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-                break;
-            case 6:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][6];
-                LUT = LUT6_1;
-                max_length = 7;
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
-            } else {
-                Table = mpc_table_HuffQ[0][6];
-                LUT = LUT6_0;
-                max_length = 7;
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
             }
-            break;
-        case 7:
-            if (mpc_decoder_bitstream_read(d, 1)) {
-                Table = mpc_table_HuffQ[1][7];
-                LUT = LUT7_1;
-                max_length = 8;
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTERER ( d, Table, LUT, max_length );
-            } else {
-                Table = mpc_table_HuffQ[0][7];
-                LUT = LUT7_0;
-                max_length = 8;
-                for (k=0; k<36; ++k)
-                    *RQ++ = HUFFMAN_DECODE_FASTEST ( d, Table, LUT, max_length );
-            }           
-            break;
-            case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15: case 16: case 17:
-                tmp = Dc[*ResR];
-                for (k=0; k<36; ++k)
-                    *RQ++ = (mpc_int16_t)mpc_decoder_bitstream_read(d, Res_bit[*ResR]) - tmp;
-                break;
-            default:
-                return;
-        }
-    }
-}
-
-void mpc_decoder_setup(mpc_decoder *d, mpc_reader *r)
-{
-  d->r = r;
-
-  d->MPCHeaderPos = 0;
-  d->StreamVersion = 0;
-  d->MS_used = 0;
-  d->FwdJumpInfo = 0;
-  d->ActDecodePos = 0;
-  d->FrameWasValid = 0;
-  d->OverallFrames = 0;
-  d->DecodedFrames = 0;
-  d->MaxDecodedFrames = 0;
-  d->TrueGaplessPresent = 0;
-  d->last_block_samples = 0;
-  d->WordsRead = 0;
-  d->Max_Band = 0;
-  d->SampleRate = 0;
-  d->__r1 = 1;
-  d->__r2 = 1;
-
-  d->dword = 0;
-  d->pos = 0;
-  d->Zaehler = 0;
-  d->Ring = 0;
-  d->WordsRead = 0;
-  d->Max_Band = 0;
-  d->SeekTable_Step = 0;
-  d->SeekTable_Mask = 0;
-  d->SeekTableCounter = 0;
-
-  mpc_decoder_initialisiere_quantisierungstabellen(d, 1.0f);
-
-  LOOKUP ( mpc_table_HuffQ[0][1], 27, LUT1_0  );
-  LOOKUP ( mpc_table_HuffQ[1][1], 27, LUT1_1  );
-  LOOKUP ( mpc_table_HuffQ[0][2], 25, LUT2_0  );
-  LOOKUP ( mpc_table_HuffQ[1][2], 25, LUT2_1  );
-  LOOKUP ( mpc_table_HuffQ[0][3], 7,  LUT3_0  );
-  LOOKUP ( mpc_table_HuffQ[1][3], 7,  LUT3_1  );
-  LOOKUP ( mpc_table_HuffQ[0][4], 9,  LUT4_0  );
-  LOOKUP ( mpc_table_HuffQ[1][4], 9,  LUT4_1  );
-  LOOKUP ( mpc_table_HuffQ[0][5], 15, LUT5_0  );
-  LOOKUP ( mpc_table_HuffQ[1][5], 15, LUT5_1  );
-  LOOKUP ( mpc_table_HuffQ[0][6], 31, LUT6_0  );
-  LOOKUP ( mpc_table_HuffQ[1][6], 31, LUT6_1  );
-  LOOKUP ( mpc_table_HuffQ[0][7], 63, LUT7_0  );
-  LOOKUP ( mpc_table_HuffQ[1][7], 63, LUT7_1  );
-  LOOKUP ( mpc_table_HuffDSCF,    16, LUTDSCF );
-
-  d->SeekTable = Seekbuffer;
-  d->Speicher = Speicher;
-  d->Y_L = Y_L;
-  d->Y_R = Y_R;
-
-  #if defined(CPU_COLDFIRE)
-  coldfire_set_macsr(EMAC_FRACTIONAL | EMAC_SATURATE);
-  #endif
-}
-
-static void mpc_decoder_set_streaminfo(mpc_decoder *d, mpc_streaminfo *si)
-{
-    mpc_uint32_t seekTableSize;
-
-    mpc_decoder_reset_synthesis(d);
-    mpc_decoder_reset_globals(d);
-
-    d->StreamVersion      = si->stream_version;
-    d->MS_used            = si->ms;
-    d->Max_Band           = si->max_band;
-    d->OverallFrames      = si->frames;
-    d->MPCHeaderPos       = si->header_position;
-    d->TrueGaplessPresent = si->is_true_gapless;
-    d->SampleRate         = (mpc_int32_t)si->sample_freq;
-
-    d->samples_to_skip = MPC_DECODER_SYNTH_DELAY;
-
-    memset(d->SeekTable, 0, sizeof(Seekbuffer));
-
-    // limit used table size to MPC_SEEK_BUFFER_SIZE
-    seekTableSize = min(si->frames, MPC_SEEK_BUFFER_SIZE);
-    // frames per buffer to not exceed buffer and to be able to seek full file
-    while ( seekTableSize < si->frames / (1<<d->SeekTable_Step) ) 
-    {
-        d->SeekTable_Step++;
+            Res = d->Res_R[n];
+            SCFI = d->SCFI_R[n];
+            DSCF_Flag = &d->DSCF_Flag_R[n];
+        } while ( SCF == d->SCF_Index_L[n] && (SCF = d->SCF_Index_R[n]));
     }
-    d->SeekTable_Mask = (1 << d->SeekTable_Step) - 1;
-}
-
-mpc_bool_t mpc_decoder_initialize(mpc_decoder *d, mpc_streaminfo *si) 
-{
-    mpc_uint32_t bitPos;
-    mpc_uint32_t fpos;
-
-    mpc_decoder_set_streaminfo(d, si);
-
-    // setting position to the beginning of the data-bitstream
-    bitPos = get_initial_fpos(d, d->StreamVersion);
-    fpos = bitPos >> 5;
 
-    // fill buffer and initialize decoder
-    f_seek(d, fpos*4 + d->MPCHeaderPos);
-    f_read_dword(d, d->Speicher, MEMSIZE);
-    d->Ring = 0;
-    d->Zaehler = 0;
-    d->pos = bitPos & 31;
-    d->WordsRead = fpos;
-    d->dword = SWAP(d->Speicher[0]);
-    d->next = SWAP(d->Speicher[1]);
-    
-    return TRUE;
-}
-
-// jumps over the current frame
-mpc_uint32_t mpc_decoder_jump_frame(mpc_decoder *d) {
-
-    mpc_uint32_t frameSize;
-
-    // ensure the buffer is full
-    mpc_decoder_update_buffer(d);
-
-    // bits in frame
-    frameSize = mpc_decoder_bitstream_read(d, 20);
-
-    // jump forward
-    mpc_decoder_seek_forward(d, frameSize);
-
-    return frameSize + 20;
-
-}
-
-static mpc_uint32_t get_initial_fpos(mpc_decoder *d, mpc_uint32_t StreamVersion)
-{
-    mpc_uint32_t fpos = 0;
-    (void) StreamVersion;
-    
-    // setting position to the beginning of the data-bitstream
-    switch ( d->StreamVersion ) {
-    case  0x04: fpos =  48; break;
-    case  0x05:
-    case  0x06: fpos =  64; break;
-    case  0x07:
-    case  0x17: fpos = 200; break;
-    }
-    return fpos;
-}
-
-mpc_bool_t mpc_decoder_seek_seconds(mpc_decoder *d, double seconds) 
-{
-    return mpc_decoder_seek_sample(d, (mpc_int64_t)(seconds * (double)d->SampleRate + 0.5));
-}
-
-void mpc_decoder_reset_state(mpc_decoder *d) {
-
-    memset(d->Y_L             , 0, sizeof Y_L              );
-    memset(d->Y_R             , 0, sizeof Y_R              );
-#ifdef SCF_HACK
-    memset(d->SCF_Index_L     , 127, sizeof d->SCF_Index_L   );
-    memset(d->SCF_Index_R     , 127, sizeof d->SCF_Index_R   );
-#else
-    memset(d->SCF_Index_L     , 0, sizeof d->SCF_Index_L      );
-    memset(d->SCF_Index_R     , 0, sizeof d->SCF_Index_R      );
-#endif
-    memset(d->Res_L           , 0, sizeof d->Res_L            );
-    memset(d->Res_R           , 0, sizeof d->Res_R            );
-    memset(d->SCFI_L          , 0, sizeof d->SCFI_L           );
-    memset(d->SCFI_R          , 0, sizeof d->SCFI_R           );
-#ifdef MPC_SUPPORT_SV456
-    memset(d->DSCF_Flag_L     , 0, sizeof d->DSCF_Flag_L      );
-    memset(d->DSCF_Flag_R     , 0, sizeof d->DSCF_Flag_R      );
-#endif
-    memset(d->Q               , 0, sizeof d->Q                );
-    memset(d->MS_Flag         , 0, sizeof d->MS_Flag          );
-
-}
-
-mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample) 
-{
-    mpc_uint32_t fpos = 0;        // the bit to seek to
-    mpc_uint32_t seekFrame = 0;   // the frame to seek to
-    mpc_uint32_t lastFrame = 0;   // last frame to seek to before scanning scale factors
-    mpc_int32_t  delta = 0;       // direction of seek
-    
-    destsample += MPC_DECODER_SYNTH_DELAY;
-    seekFrame = (mpc_uint32_t) ((destsample) / MPC_FRAME_LENGTH);
-    d->samples_to_skip = (mpc_uint32_t)((destsample) % MPC_FRAME_LENGTH);
-
-    // prevent from desired position out of allowed range
-    seekFrame = seekFrame < d->OverallFrames  ?  seekFrame  :  d->OverallFrames;
-
-    // seek direction (note: avoids casting to int64)
-    delta = (d->DecodedFrames > seekFrame ? -(mpc_int32_t)(d->DecodedFrames - seekFrame) : (mpc_int32_t)(seekFrame - d->DecodedFrames));
-
-    if (seekFrame > SEEK_PRE_DECODE) 
-        lastFrame = seekFrame - SEEK_PRE_DECODE + 1 - (1<<d->SeekTable_Step);
-
-    if (d->MaxDecodedFrames == 0) // nothing decoded yet, parse stream
-    {
-        mpc_decoder_reset_state(d);
-
-        // starts from the beginning since no frames have been decoded yet, or not using seek table
-        fpos = get_initial_fpos(d, d->StreamVersion);
-
-        // seek to the first frame
-        mpc_decoder_seek_to(d, fpos);
-
-        // jump to the last frame via parsing, updating seek table
-        d->SeekTable[0] = (mpc_uint32_t)fpos;
-        d->SeekTableCounter = 0;
-        for (d->DecodedFrames = 0; d->DecodedFrames < lastFrame; d->DecodedFrames++)
-        {
-            d->SeekTableCounter += mpc_decoder_jump_frame(d);
-            if (0 == ((d->DecodedFrames+1) & (d->SeekTable_Mask)))
-            {
-                d->SeekTable[(d->DecodedFrames+1)>>d->SeekTable_Step] = d->SeekTableCounter;
-                d->MaxDecodedFrames = d->DecodedFrames;
-                d->SeekTableCounter = 0;
-            }
-        }
-    } 
-    else if (delta < 0) // jump backwards, seek table is already available
-    {
-        mpc_decoder_reset_state(d);
-
-        // jumps backwards using the seek table
-        fpos = d->SeekTable[0];
-        for (d->DecodedFrames = 0; d->DecodedFrames < lastFrame; d->DecodedFrames++)
-        {
-            if (0 == ((d->DecodedFrames+1) & (d->SeekTable_Mask)))
-            {
-                fpos += d->SeekTable[(d->DecodedFrames+1)>>d->SeekTable_Step];
-                d->SeekTableCounter = 0;
-            }
-        }
-        mpc_decoder_seek_to(d, fpos);
-    } 
-    else if (delta > SEEK_PRE_DECODE) // jump forward, seek table is available
-    {
-        mpc_decoder_reset_state(d);
-
-        // 1st loop: jump to the last usable position in the seek table
-        fpos = mpc_decoder_bits_read(d);
-        for (; d->DecodedFrames < d->MaxDecodedFrames && d->DecodedFrames < lastFrame; d->DecodedFrames++)
-        {
-            if (0 == ((d->DecodedFrames+1) & (d->SeekTable_Mask)))
-            {
-                fpos += d->SeekTable[(d->DecodedFrames+1)>>d->SeekTable_Step];
-                d->SeekTableCounter = 0;
-            }
-        }
-        mpc_decoder_seek_to(d, fpos);
-        
-        // 2nd loop: jump the residual frames via parsing, update seek table
-        for (;d->DecodedFrames < lastFrame; d->DecodedFrames++)
-        {
-            d->SeekTableCounter += mpc_decoder_jump_frame(d);
-            if (0 == ((d->DecodedFrames+1) & (d->SeekTable_Mask)))
-            {
-                d->SeekTable[(d->DecodedFrames+1)>>d->SeekTable_Step] = d->SeekTableCounter;
-                d->MaxDecodedFrames = d->DecodedFrames;
-                d->SeekTableCounter = 0;
+    /***************************** Samples ****************************/
+    for ( n = 0; n < Max_used_Band; n++ ) {
+        mpc_int16_t *q = d->Q[n].L, Res = d->Res_L[n];
+        static const int thres[] = {0, 0, 3, 0, 0, 1, 3, 4, 8};
+        do {
+            mpc_int32_t k = 0, idx = 1;
+            if (Res != 0) {
+                if (Res == 2) {
+                    Tables[0] = & mpc_can_Q [0][0];
+                    Tables[1] = & mpc_can_Q [0][1];
+                    idx = 2 * thres[Res];
+                    for ( ; k < 36; k += 3) {
+                        int tmp = mpc_bits_can_dec(r, Tables[idx > thres[Res]]);
+                        q[k]     = g_sv8_idx50[tmp];
+                        q[k + 1] = g_sv8_idx51[tmp];
+                        q[k + 2] = g_sv8_idx52[tmp];
+                        idx = (idx >> 1) + g_sv8_HuffQ2_var[tmp];
+                    }
+                } else if (Res == 1) {
+                    Table = & mpc_can_Q1;
+                    for( ; k < 36; ){
+                        int kmax = k + 18;
+                        mpc_uint_t cnt = mpc_bits_can_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_can_Q[1][Res - 3];
+                    for ( ; k < 36; k += 2 ) {
+                        union {
+                            mpc_int8_t sym;
+                            struct { mpc_int8_t s1:4, s2:4; };
+                        } tmp;
+                        tmp.sym = mpc_bits_can_dec(r, Table);
+                        q[k]     = tmp.s1;
+                        q[k + 1] = tmp.s2;
+                    }
+                } else if (Res <= 8) {
+                    Tables[0] = & mpc_can_Q [Res - 3][0];
+                    Tables[1] = & mpc_can_Q [Res - 3][1];
+                    idx = 2 * thres[Res];
+                    for ( ; k < 36; k++ ) {
+                        q[k] = mpc_bits_can_dec(r, Tables[idx > thres[Res]]);
+                        idx = (idx >> 1) + absi(q[k]);
+                    }
+                } else {
+                    for ( ; k < 36; k++ ) {
+                        q[k] = (unsigned char) mpc_bits_can_dec(r, & mpc_can_Q9up);
+                        if (Res != 9)
+                            q[k] = (q[k] << (Res - 9)) | mpc_bits_read(r, Res - 9);
+                        q[k] -= Dc[Res];
+                    }
+                }
             }
-        }
-    }
-    // until here we jumped to desired position -SEEK_PRE_DECODE frames
-
-    // now we decode the last SEEK_PRE_DECODE frames until we reach the seek
-    // position. this is neccessary as mpc uses entropy coding in time domain
-    for (;d->DecodedFrames < seekFrame; d->DecodedFrames++) 
-    {
-        mpc_uint32_t   FrameBitCnt;
-
-        d->FwdJumpInfo  = mpc_decoder_bitstream_read(d, 20);    // read jump-info
-        d->ActDecodePos = (d->Zaehler << 5) + d->pos;
-        FrameBitCnt  = mpc_decoder_bits_read(d);  
-        // scanning the scalefactors (and check for validity of frame)
-        if (d->StreamVersion >= 7)
-        {
-            mpc_decoder_read_bitstream_sv7(d, (d->DecodedFrames < seekFrame - 1));
-        }
-        else 
-        {
-#ifdef MPC_SUPPORT_SV456
-            mpc_decoder_read_bitstream_sv6(d);
-#else
-            return FALSE;
-#endif
-        }
 
-        FrameBitCnt = mpc_decoder_bits_read(d) - FrameBitCnt;
-
-        if (d->FwdJumpInfo > FrameBitCnt) 
-            mpc_decoder_seek_forward(d, d->FwdJumpInfo - FrameBitCnt);
-        else if (FrameBitCnt != d->FwdJumpInfo ) 
-            // Bug in perform_jump;
-            return FALSE;
-            
-        // update seek table, if there new entries to fill
-        d->SeekTableCounter += d->FwdJumpInfo + 20;
-        if (0 == ((d->DecodedFrames+1) & (d->SeekTable_Mask)))
-        {
-            d->SeekTable[(d->DecodedFrames+1)>>d->SeekTable_Step] = d->SeekTableCounter;
-            d->MaxDecodedFrames = d->DecodedFrames;
-            d->SeekTableCounter = 0;
-        }
-
-        // update buffer
-        mpc_decoder_update_buffer(d);
-
-        if (d->DecodedFrames == seekFrame - 1) 
-        {
-            // initialize the synth correctly for perfect decoding
-            mpc_decoder_requantisierung(d, d->Max_Band);
-            mpc_decoder_synthese_filter_float(d, NULL);
-        }
+            Res = d->Res_R[n];
+        } while (q == d->Q[n].L && (q = d->Q[n].R));
     }
-
-    return TRUE;
-}
-
-
-void mpc_decoder_fill_buffer(mpc_decoder *d) {
-
-    f_read_dword(d, d->Speicher, MEMSIZE);
-    d->dword = SWAP(d->Speicher[d->Zaehler = 0]);
-    d->next = SWAP(d->Speicher[1]);
-    d->Ring = 0;
-
-}
-
-
-void mpc_decoder_update_buffer(mpc_decoder *d) 
-{
-    if ((d->Ring ^ d->Zaehler) & MEMSIZE2) {
-        // update buffer
-        f_read_dword(d, d->Speicher + (d->Ring & MEMSIZE2), MEMSIZE2);
-        d->Ring = d->Zaehler;
-    }
-}
-
-
-void mpc_decoder_seek_to(mpc_decoder *d, mpc_uint32_t bitPos) {
-
-    // required dword
-    mpc_uint32_t fpos = (bitPos >> 5);
-    mpc_uint32_t bufferStart = d->WordsRead - d->Zaehler;
-    if ((d->Zaehler & MEMSIZE2) != FALSE)
-        bufferStart += MEMSIZE2;
-
-    if (fpos >= bufferStart && fpos < bufferStart + MEMSIZE) {
-
-        // required position is within the buffer, no need to seek
-        d->Zaehler = (fpos - bufferStart + ((d->Zaehler & MEMSIZE2) != FALSE ? MEMSIZE2 : 0)) & MEMMASK;
-        d->pos = bitPos & 31;
-        d->WordsRead = fpos;
-        d->dword = SWAP(d->Speicher[d->Zaehler]);
-        d->next = SWAP(d->Speicher[(d->Zaehler + 1) & MEMMASK]);
-
-        mpc_decoder_update_buffer(d);
-        
-
-    } else {
-
-        // DWORD aligned
-        f_seek(d, fpos*4 + d->MPCHeaderPos);
-        d->Zaehler = 0;
-        d->pos = bitPos & 31;
-        d->WordsRead = fpos;
-
-        mpc_decoder_fill_buffer(d);
-
-    }
-    
-}
-
-void mpc_decoder_seek_forward(mpc_decoder *d, mpc_uint32_t bits) {
-
-    bits += d->pos;
-    d->pos = bits & 31;
-    bits = bits >> 5; // to DWORDs
-    d->Zaehler = (d->Zaehler + bits) & MEMMASK;
-    d->dword = SWAP(d->Speicher[d->Zaehler]);
-    d->next = SWAP(d->Speicher[(d->Zaehler + 1) & MEMMASK]);
-    d->WordsRead += bits;
-
 }