Index: /libmpcdec/branches/zorg/include/mpcdec/mpc_types.h
===================================================================
--- /libmpcdec/branches/zorg/include/mpcdec/mpc_types.h	(revision 80)
+++ /libmpcdec/branches/zorg/include/mpcdec/mpc_types.h	(revision 81)
@@ -53,4 +53,5 @@
 typedef unsigned __int32 mpc_uint32_t;
 typedef __int64          mpc_int64_t;
+typedef unsigned __int64 mpc_uint64_t;
 #define mpc_inline __inline
 #define MPC_LITTLE_ENDIAN
@@ -64,4 +65,5 @@
 typedef uint32_t mpc_uint32_t;
 typedef int64_t  mpc_int64_t;
+typedef uint64_t  mpc_uint64_t;
 #define mpc_inline inline
 #endif
Index: /libmpcdec/branches/zorg/include/mpcdec/reader.h
===================================================================
--- /libmpcdec/branches/zorg/include/mpcdec/reader.h	(revision 80)
+++ /libmpcdec/branches/zorg/include/mpcdec/reader.h	(revision 81)
@@ -78,5 +78,5 @@
 /// \param r p_reader handle to initialize
 /// \param filename input filename to attach to the reader
-mpc_status mpc_reader_init_stdio(mpc_reader *p_reader, char *filename);
+mpc_status mpc_reader_init_stdio(mpc_reader *p_reader, const char *filename);
 
 /// Release reader with default stdio file reader implementation.
Index: /libmpcdec/branches/zorg/src/decoder.h
===================================================================
--- /libmpcdec/branches/zorg/src/decoder.h	(revision 80)
+++ /libmpcdec/branches/zorg/src/decoder.h	(revision 81)
@@ -87,8 +87,9 @@
 
     mpc_uint32_t  WordsRead;                  // counts amount of decoded dwords
+	mpc_uint32_t  BlockBits;                  // block bits left to read
 
     // randomizer state variables
-    mpc_uint32_t  __r1; 
-    mpc_uint32_t  __r2; 
+    mpc_uint32_t  __r1;
+    mpc_uint32_t  __r2;
 
     // seeking
Index: /libmpcdec/branches/zorg/src/internal.h
===================================================================
--- /libmpcdec/branches/zorg/src/internal.h	(revision 80)
+++ /libmpcdec/branches/zorg/src/internal.h	(revision 81)
@@ -52,4 +52,35 @@
 }
 
+typedef struct  {
+	char key[2];	// block key
+	mpc_uint64_t size;	// block size minus the block header size
+} mpc_block_t;
+
+
+/// read a block header and fills the mpc_block_t struct.
+///
+/// \param p_reader supplying raw stream data
+/// \param p_block returned block header
+/// \return MPC_STATUS_FILE on errors of any kind
+mpc_status mpc_get_block(mpc_reader * p_reader, mpc_block_t * p_block);
+
+/// find a block with key == find_key, stop search if key == stop_key;
+///
+/// \param p_reader supplying raw stream data
+/// \param p_block returned block header
+/// \param find_key key to find
+/// \param stop_key key to stop on
+/// \return MPC_STATUS_FILE on errors of any kind
+mpc_status mpc_find_block(mpc_reader * p_reader, mpc_block_t * p_block,
+						  char * find_key, char * stop_key);
+
+typedef struct  {
+	unsigned int buff;
+	unsigned int bitsCount;
+} mpc_bits_reader;
+
+mpc_uint32_t mpc_read_bits(mpc_reader * p_reader, mpc_bits_reader * p_bits,
+						   int nb_bits);
+
 /// Searches for a ID3v2-tag and reads the length (in bytes) of it.
 ///
Index: /libmpcdec/branches/zorg/src/mpc_decoder.c
===================================================================
--- /libmpcdec/branches/zorg/src/mpc_decoder.c	(revision 80)
+++ /libmpcdec/branches/zorg/src/mpc_decoder.c	(revision 81)
@@ -70,5 +70,4 @@
 // forward declarations
 //------------------------------------------------------------------------------
-static void mpc_decoder_read_bitstream_sv6(mpc_decoder *d, mpc_bool_t seeking);
 static void mpc_decoder_read_bitstream_sv7(mpc_decoder *d, mpc_bool_t seeking);
 static void mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band);
@@ -77,15 +76,15 @@
 // utility functions
 //------------------------------------------------------------------------------
-static mpc_int32_t f_read(mpc_decoder *d, void *ptr, mpc_int32_t size) 
-{ 
-    return d->r->read(d->r, ptr, size); 
-}
-
-static mpc_bool_t f_seek(mpc_decoder *d, mpc_int32_t offset) 
-{ 
-    return d->r->seek(d->r, offset); 
-}
-
-static mpc_int32_t f_read_dword(mpc_decoder *d, mpc_uint32_t * ptr, mpc_uint32_t count) 
+static mpc_int32_t f_read(mpc_decoder *d, void *ptr, mpc_int32_t size)
+{
+    return d->r->read(d->r, ptr, size);
+}
+
+static mpc_bool_t f_seek(mpc_decoder *d, mpc_int32_t offset)
+{
+    return d->r->seek(d->r, offset);
+}
+
+static mpc_int32_t f_read_dword(mpc_decoder *d, mpc_uint32_t * ptr, mpc_uint32_t count)
 {
     return f_read(d, ptr, count << 2) >> 2;
@@ -130,5 +129,5 @@
 // resets bitstream decoding
 static void
-mpc_decoder_reset_bitstream_decode(mpc_decoder *d) 
+mpc_decoder_reset_bitstream_decode(mpc_decoder *d)
 {
     d->dword = 0;
@@ -140,5 +139,5 @@
 // reports the number of read bits
 static mpc_uint32_t
-mpc_decoder_bits_read(mpc_decoder *d) 
+mpc_decoder_bits_read(mpc_decoder *d)
 {
     return 32 * d->WordsRead + d->pos;
@@ -147,5 +146,5 @@
 // read desired number of bits out of the bitstream (max 31)
 static mpc_uint32_t
-mpc_decoder_bitstream_read(mpc_decoder *d, const mpc_uint32_t bits) 
+mpc_decoder_bitstream_read(mpc_decoder *d, const mpc_uint32_t bits)
 {
     mpc_uint32_t out = d->dword;
@@ -191,17 +190,23 @@
 }
 
-// decode SCFI-bundle (sv4,5,6)
+void mpc_decoder_get_block(mpc_decoder *d, mpc_block_t * p_block)
+{
+	unsigned char tmp;
+	unsigned int size = 2;
+
+	p_block->size = 0;
+	p_block->key[0] = mpc_decoder_bitstream_read(d, 8);
+	p_block->key[1] = mpc_decoder_bitstream_read(d, 8);
+	do {
+		tmp = mpc_decoder_bitstream_read(d, 8);
+		p_block->size = (p_block->size << 7) | (tmp & 0x7F);
+		size++;
+	} while((tmp & 0x80));
+
+	p_block->size -= size;
+}
+
 static void
-mpc_decoder_scfi_bundle_read(mpc_decoder *d, const mpc_huffman* Table,
-                             mpc_int32_t* SCFI, mpc_bool_t* DSCF)
-{
-    mpc_uint32_t value = mpc_decoder_huffman_decode(d, Table, 6);
-
-    *SCFI = value >> 1;
-    *DSCF = value &  1;
-}
-
-static void
-mpc_decoder_reset_v(mpc_decoder *d) 
+mpc_decoder_reset_v(mpc_decoder *d)
 {
     memset(d->V_L, 0, sizeof d->V_L);
@@ -210,5 +215,5 @@
 
 static void
-mpc_decoder_reset_synthesis(mpc_decoder *d) 
+mpc_decoder_reset_synthesis(mpc_decoder *d)
 {
     mpc_decoder_reset_v(d);
@@ -216,5 +221,5 @@
 
 static void
-mpc_decoder_reset_y(mpc_decoder *d) 
+mpc_decoder_reset_y(mpc_decoder *d)
 {
     memset(d->Y_L, 0, sizeof d->Y_L);
@@ -223,5 +228,5 @@
 
 static void
-mpc_decoder_reset_globals(mpc_decoder *d) 
+mpc_decoder_reset_globals(mpc_decoder *d)
 {
     mpc_decoder_reset_bitstream_decode(d);
@@ -268,5 +273,5 @@
 
 static mpc_uint32_t
-mpc_decoder_decode_internal(mpc_decoder *d, MPC_SAMPLE_FORMAT *buffer) 
+mpc_decoder_decode_internal(mpc_decoder *d, MPC_SAMPLE_FORMAT *buffer)
 {
     mpc_uint32_t output_frame_length = MPC_FRAME_LENGTH;
@@ -285,18 +290,36 @@
     }
 
-    // read jump-info for validity check of frame
-    FwdJumpInfo  = mpc_decoder_bitstream_read(d, 20);
-
-    // decode data and check for validity of frame
-    FrameBitCnt = mpc_decoder_bits_read(d);
     switch (d->StreamVersion) {
     case 0x07:
     case 0x17:
+		// read jump-info for validity check of frame
+		FwdJumpInfo  = mpc_decoder_bitstream_read(d, 20);
+    	// decode data and check for validity of frame
+		FrameBitCnt = mpc_decoder_bits_read(d);
         mpc_decoder_read_bitstream_sv7(d, FALSE);
+		d->FrameWasValid = mpc_decoder_bits_read(d) - FrameBitCnt == FwdJumpInfo;
         break;
+	case 0x08:
+		if (d->BlockBits < 8){
+			mpc_block_t block;
+			// trouver le block
+			mpc_decoder_bitstream_read(d, d->BlockBits);
+			while (1) {
+				mpc_decoder_get_block(d, &block);
+				if (memcmp(block.key, "AD", 2) != 0)
+					mpc_decoder_seek(d, mpc_decoder_bits_read(d) + block.size * 8);
+				else
+					break;
+			}
+			d->BlockBits = block.size * 8;
+		}
+		FrameBitCnt = mpc_decoder_bits_read(d);
+		mpc_decoder_read_bitstream_sv7(d, FALSE);
+		d->BlockBits -= mpc_decoder_bits_read(d) - FrameBitCnt;
+		d->FrameWasValid = 1;
+		break;
     default:
         return (mpc_uint32_t)(-1);
     }
-    d->FrameWasValid = mpc_decoder_bits_read(d) - FrameBitCnt == FwdJumpInfo;
 
     // synthesize signal
@@ -307,5 +330,5 @@
 
     // cut off first MPC_DECODER_SYNTH_DELAY zero-samples
-    if (d->DecodedFrames == d->OverallFrames  && d->StreamVersion >= 6) {        
+    if (d->DecodedFrames == d->OverallFrames  && d->StreamVersion >= 6) {
         // reconstruct exact filelength
         mpc_int32_t  mod_block   = mpc_decoder_bitstream_read(d,  11);
@@ -314,5 +337,5 @@
         if (mod_block == 0) {
             // Encoder bugfix
-            mod_block = 1152;                    
+            mod_block = 1152;
         }
         FilterDecay = (mod_block + MPC_DECODER_SYNTH_DELAY) % MPC_FRAME_LENGTH;
@@ -345,6 +368,6 @@
             output_frame_length -= d->samples_to_skip;
             memmove(
-                buffer, 
-                buffer + d->samples_to_skip * 2, 
+                buffer,
+                buffer + d->samples_to_skip * 2,
                 output_frame_length * 2 * sizeof (MPC_SAMPLE_FORMAT));
             d->samples_to_skip = 0;
@@ -357,6 +380,6 @@
 mpc_uint32_t mpc_decoder_decode(
     mpc_decoder *d,
-    MPC_SAMPLE_FORMAT *buffer, 
-    mpc_uint32_t *vbr_update_acc, 
+    MPC_SAMPLE_FORMAT *buffer,
+    mpc_uint32_t *vbr_update_acc,
     mpc_uint32_t *vbr_update_bits)
 {
@@ -378,5 +401,5 @@
             // error occurred in bitstream
             return (mpc_uint32_t)(-1);
-        } 
+        }
         else {
             if (vbr_update_acc && vbr_update_bits) {
@@ -399,5 +422,5 @@
 
 void
-mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band) 
+mpc_decoder_requantisierung(mpc_decoder *d, const mpc_int32_t Last_Band)
 {
     mpc_int32_t     Band;
@@ -855,4 +878,5 @@
   d->__r1 = 1;
   d->__r2 = 1;
+  d->BlockBits = 0;
 
   d->Max_Band = 0;
@@ -872,4 +896,5 @@
     case  0x07:
     case  0x17: fpos = 200; break;
+	case  0x08: fpos = 32; break;
     }
     return fpos;
@@ -892,8 +917,8 @@
 }
 
-mpc_status mpc_decoder_init(mpc_decoder **d, mpc_reader *r, mpc_streaminfo *si) 
+mpc_status mpc_decoder_init(mpc_decoder **d, mpc_reader *r, mpc_streaminfo *si)
 {
     mpc_decoder* p_tmp;
-    
+
     p_tmp = malloc(sizeof *p_tmp);
     memset(p_tmp, 0, sizeof *p_tmp);
@@ -927,10 +952,10 @@
 }
 
-mpc_bool_t mpc_decoder_seek_seconds(mpc_decoder *d, double seconds) 
+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));
 }
 
-mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample) 
+mpc_bool_t mpc_decoder_seek_sample(mpc_decoder *d, mpc_int64_t destsample)
 {
     mpc_uint32_t fpos;
Index: /libmpcdec/branches/zorg/src/mpc_reader.c
===================================================================
--- /libmpcdec/branches/zorg/src/mpc_reader.c	(revision 80)
+++ /libmpcdec/branches/zorg/src/mpc_reader.c	(revision 81)
@@ -88,5 +88,5 @@
 
 mpc_status
-mpc_reader_init_stdio(mpc_reader *p_reader, char *filename)
+mpc_reader_init_stdio(mpc_reader *p_reader, const char *filename)
 {
     mpc_reader tmp_reader; mpc_reader_stdio *p_stdio; int err;
@@ -149,5 +149,5 @@
     ret = p_reader->seek(p_reader, 0);
     if(!ret) return 0;
-    
+
     p_reader->read(p_reader, tmp, sizeof tmp);
 
@@ -178,2 +178,64 @@
     return ret;
 }
+
+mpc_status mpc_get_block(mpc_reader * p_reader, mpc_block_t * p_block)
+{
+	unsigned char tmp;
+	unsigned int size = 2;
+
+	p_block->size = 0;
+	p_reader->read(p_reader, p_block->key, 2);
+	do {
+		p_reader->read(p_reader, &tmp, 1);
+		p_block->size = (p_block->size << 7) | (tmp & 0x7F);
+		size++;
+	} while((tmp & 0x80));
+
+	if (size > p_block->size)
+		return MPC_STATUS_FILE;
+
+	p_block->size -= size;
+
+	return MPC_STATUS_OK;
+}
+
+mpc_status mpc_find_block(mpc_reader * p_reader, mpc_block_t * p_block,
+						  char * find_key, char * stop_key)
+{
+	while (1) {
+		mpc_get_block(p_reader, p_block);
+		if (memcmp(p_block->key, find_key, 2) != 0 &&
+				  memcmp(p_block->key, stop_key, 2) != 0)
+			p_reader->seek(p_reader, p_block->size);
+		else
+			break;
+	}
+
+	if (memcmp(p_block->key, find_key, 2) != 0)
+		return MPC_STATUS_FILE;
+
+	return MPC_STATUS_OK;
+}
+
+mpc_uint32_t mpc_read_bits(mpc_reader * p_reader, mpc_bits_reader * p_bits,
+						   int nb_bits)
+{
+	mpc_uint32_t ret = p_bits->buff;
+	unsigned char tmp = 0;
+
+	while(nb_bits > p_bits->bitsCount){
+		p_reader->read(p_reader, &tmp, 1);
+		ret = (ret << 8) | tmp;
+		p_bits->bitsCount += 8;
+	}
+
+	p_bits->buff = (unsigned int) ret;
+	p_bits->bitsCount -= nb_bits;
+	ret >>= p_bits->bitsCount;
+
+	if (nb_bits == 32)
+		return ret;
+	else
+		return ret & ((1 << nb_bits) - 1);
+}
+
Index: /libmpcdec/branches/zorg/src/streaminfo.c
===================================================================
--- /libmpcdec/branches/zorg/src/streaminfo.c	(revision 80)
+++ /libmpcdec/branches/zorg/src/streaminfo.c	(revision 81)
@@ -41,5 +41,5 @@
 static const char na[] = "n.a.";
 static const char *versionNames[] = {
-    na, "'Unstable/Experimental'", na, na, na, "'quality 0'", "'quality 1'", 
+    na, "'Unstable/Experimental'", na, na, na, "'quality 0'", "'quality 1'",
     "'Telephone'", "'Thumb'", "'Radio'", "'Standard'", "'Extreme'", "'Insane'",
     "'BrainDead'", "'quality 9'", "'quality 10'"
@@ -53,5 +53,5 @@
 }
 
-/// Reads streaminfo from SV7 header. 
+/// Reads streaminfo from SV7 header.
 static mpc_status
 streaminfo_read_header_sv7(mpc_streaminfo* si, mpc_uint32_t HeaderData[8])
@@ -107,4 +107,56 @@
 }
 
+/// Reads streaminfo from SV8 header.
+static mpc_status
+streaminfo_read_header_sv8(mpc_streaminfo* si, mpc_reader * p_reader)
+{
+	int ret;
+	mpc_block_t block;
+	mpc_bits_reader bits_reader = {0, 0};
+	mpc_uint32_t CRC;
+	mpc_int32_t header_pos;
+	unsigned char tmp;
+	mpc_uint64_t sampleCount = 0;
+
+	ret = mpc_find_block(p_reader, &block, "SI", "AD");
+	if (ret != MPC_STATUS_OK)
+		return ret;
+
+	header_pos = p_reader->tell(p_reader);
+
+	// FIXME : add CRC check
+	CRC = mpc_read_bits(p_reader, &bits_reader, 32);
+	si->stream_version = mpc_read_bits(p_reader, &bits_reader, 8);
+
+	do {
+		p_reader->read(p_reader, &tmp, 1);
+		sampleCount = (sampleCount << 7) | (tmp & 0x7F);
+	} while((tmp & 0x80));
+
+	si->frames = (sampleCount + MPC_FRAME_LENGTH - 1) / MPC_FRAME_LENGTH;
+	si->is_true_gapless = 1;
+	si->last_frame_samples = sampleCount - (si->frames - 1) * MPC_FRAME_LENGTH;
+	si->sample_freq = samplefreqs[mpc_read_bits(p_reader, &bits_reader, 4)];
+	si->channels = mpc_read_bits(p_reader, &bits_reader, 4) + 1;
+	si->max_band = mpc_read_bits(p_reader, &bits_reader, 5) + 1;
+	// FIXME : this flag will be removed, must be 0
+	si->is = mpc_read_bits(p_reader, &bits_reader, 1);
+	si->ms = mpc_read_bits(p_reader, &bits_reader, 1);
+
+	si->bitrate            = 0;
+	si->block_size         = 1;
+
+	si->pcm_samples     = sampleCount;
+	si->average_bitrate = 0;
+	if (si->pcm_samples > 0)
+		si->average_bitrate = (si->tag_offset - si->header_position) * 8.0
+				*  si->sample_freq / si->pcm_samples;
+
+	// seek to the end of the block
+	p_reader->seek(p_reader, header_pos + block.size);
+
+	return MPC_STATUS_OK;
+}
+
 // reads file header and tags
 mpc_status
@@ -121,41 +173,50 @@
     err = p_reader->seek(p_reader, si->header_position);
     if(!err) return MPC_STATUS_FILE;
-    err = p_reader->read(p_reader, headerData, 8 * 4);
-    if(err != 8 * 4) return MPC_STATUS_FILE;
-    err = p_reader->seek(p_reader, si->header_position + 6 * 4);
-    if(!err) return MPC_STATUS_FILE;
-
-    err = p_reader->get_size(p_reader);
-    if(err < 0) return MPC_STATUS_FILE;
-    si->tag_offset = si->total_file_length = err;
-
-    err = memcmp(headerData, "MP+", 3);
-    if(err) return MPC_STATUS_INVALIDSV;
+
+	// read magic
+	err = p_reader->read(p_reader, headerData, 4);
+	if(err != 4) return MPC_STATUS_FILE;
+
+	if (memcmp(headerData, "MP+", 3) == 0) {
+		// SV 4-7
+		err = p_reader->read(p_reader, headerData + 1, 7 * 4);
+		if(err != 7 * 4) return MPC_STATUS_FILE;
+		err = p_reader->seek(p_reader, si->header_position + 6 * 4);
+		if(!err) return MPC_STATUS_FILE;
+
+		err = p_reader->get_size(p_reader);
+		if(err < 0) return MPC_STATUS_FILE;
+		si->tag_offset = si->total_file_length = err;
 
 #ifndef MPC_LITTLE_ENDIAN
-    {
-        mpc_uint32_t ptr;
-        for (ptr = 0; ptr < 8; ptr++)
-            headerData[ptr] = mpc_swap32(headerData[ptr]);
-    }
+		{
+			mpc_uint32_t ptr;
+			for (ptr = 0; ptr < 8; ptr++)
+				headerData[ptr] = mpc_swap32(headerData[ptr]);
+		}
 #endif
-     si->stream_version = headerData[0] >> 24;
-
-     if ((si->stream_version & 15) >= 8)
-        return MPC_STATUS_INVALIDSV;
-     else if ((si->stream_version & 15) == 7)
-     {
-        err = streaminfo_read_header_sv7(si, headerData);
-        if(err < 0) return err;
-     }
-
-    // estimation, exact value needs too much time
-    si->pcm_samples     = 1152 * si->frames - 576;
-    si->average_bitrate = 0;
-    if (si->pcm_samples > 0)
-        si->average_bitrate = (si->tag_offset  - si->header_position) * 8.0 
-                            *  si->sample_freq / si->pcm_samples;
-
-    return MPC_STATUS_OK;
+		si->stream_version = headerData[0] >> 24;
+
+		if ((si->stream_version & 15) >= 8)
+			return MPC_STATUS_INVALIDSV;
+		else if ((si->stream_version & 15) == 7) {
+			err = streaminfo_read_header_sv7(si, headerData);
+			if(err < 0) return err;
+		}
+
+		// estimation, exact value needs too much time
+		si->pcm_samples     = 1152 * si->frames - 576;
+		si->average_bitrate = 0;
+		if (si->pcm_samples > 0)
+			si->average_bitrate = (si->tag_offset  - si->header_position) * 8.0
+					*  si->sample_freq / si->pcm_samples;
+	} else if (memcmp(headerData, "MPCK", 4) == 0) {
+		// SV 8
+		printf("sv8\n");
+		streaminfo_read_header_sv8(si, p_reader);
+	} else
+		return MPC_STATUS_INVALIDSV;
+
+	return MPC_STATUS_OK;
 }