Nawigacja

BZip2InputStream.cs @ 754

Odwiedź:

Wersja 597, 24.8 KB (wprowadzona przez marek, 17 years temu)
re #165

Line
1	// BZip2InputStream.cs
2	//
3	// Copyright (C) 2001 Mike Krueger
4	//
5	// This program is free software; you can redistribute it and/or
6	// modify it under the terms of the GNU General Public License
7	// as published by the Free Software Foundation; either version 2
8	// of the License, or (at your option) any later version.
9	//
10	// This program is distributed in the hope that it will be useful,
11	// but WITHOUT ANY WARRANTY; without even the implied warranty of
12	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	// GNU General Public License for more details.
14	//
15	// You should have received a copy of the GNU General Public License
16	// along with this program; if not, write to the Free Software
17	// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18	//
19	// Linking this library statically or dynamically with other modules is
20	// making a combined work based on this library. Thus, the terms and
21	// conditions of the GNU General Public License cover the whole
22	// combination.
23	//
24	// As a special exception, the copyright holders of this library give you
25	// permission to link this library with independent modules to produce an
26	// executable, regardless of the license terms of these independent
27	// modules, and to copy and distribute the resulting executable under
28	// terms of your choice, provided that you also meet, for each linked
29	// independent module, the terms and conditions of the license of that
30	// module. An independent module is a module which is not derived from
31	// or based on this library. If you modify this library, you may extend
32	// this exception to your version of the library, but you are not
33	// obligated to do so. If you do not wish to do so, delete this
34	// exception statement from your version.
35
36	using System;
37	using System.IO;
38
39	using ICSharpCode.SharpZipLib.Checksums;
40
41	namespace ICSharpCode.SharpZipLib.BZip2
42	{
43
44	/// <summary>
45	/// An input stream that decompresses files in the BZip2 format
46	/// </summary>
47	public class BZip2InputStream : Stream
48	{
49	#region Constants
50	const int START_BLOCK_STATE = 1;
51	const int RAND_PART_A_STATE = 2;
52	const int RAND_PART_B_STATE = 3;
53	const int RAND_PART_C_STATE = 4;
54	const int NO_RAND_PART_A_STATE = 5;
55	const int NO_RAND_PART_B_STATE = 6;
56	const int NO_RAND_PART_C_STATE = 7;
57	#endregion
58	#region Constructors
59	/// <summary>
60	/// Construct instance for reading from stream
61	/// </summary>
62	/// <param name="stream">Data source</param>
63	public BZip2InputStream(Stream stream)
64	{
65	// init arrays
66	for (int i = 0; i < BZip2Constants.GroupCount; ++i)
67	{
68	limit[i] = new int[BZip2Constants.MaximumAlphaSize];
69	baseArray[i] = new int[BZip2Constants.MaximumAlphaSize];
70	perm[i] = new int[BZip2Constants.MaximumAlphaSize];
71	}
72
73	BsSetStream(stream);
74	Initialize();
75	InitBlock();
76	SetupBlock();
77	}
78
79	#endregion
80
81	/// <summary>
82	/// Get/set flag indicating ownership of underlying stream.
83	/// When the flag is true <see cref="Close"></see> will close the underlying stream also.
84	/// </summary>
85	public bool IsStreamOwner
86	{
87	get { return isStreamOwner; }
88	set { isStreamOwner = value; }
89	}
90
91
92	#region Stream Overrides
93	/// <summary>
94	/// Gets a value indicating if the stream supports reading
95	/// </summary>
96	public override bool CanRead
97	{
98	get {
99	return baseStream.CanRead;
100	}
101	}
102
103	/// <summary>
104	/// Gets a value indicating whether the current stream supports seeking.
105	/// </summary>
106	public override bool CanSeek {
107	get {
108	return baseStream.CanSeek;
109	}
110	}
111
112	/// <summary>
113	/// Gets a value indicating whether the current stream supports writing.
114	/// This property always returns false
115	/// </summary>
116	public override bool CanWrite {
117	get {
118	return false;
119	}
120	}
121
122	/// <summary>
123	/// Gets the length in bytes of the stream.
124	/// </summary>
125	public override long Length {
126	get {
127	return baseStream.Length;
128	}
129	}
130
131	/// <summary>
132	/// Gets or sets the streams position.
133	/// Setting the position is not supported and will throw a NotSupportException
134	/// </summary>
135	/// <exception cref="NotSupportedException">Any attempt to set the position</exception>
136	public override long Position {
137	get {
138	return baseStream.Position;
139	}
140	set {
141	throw new NotSupportedException("BZip2InputStream position cannot be set");
142	}
143	}
144
145	/// <summary>
146	/// Flushes the stream.
147	/// </summary>
148	public override void Flush()
149	{
150	if (baseStream != null) {
151	baseStream.Flush();
152	}
153	}
154
155	/// <summary>
156	/// Set the streams position. This operation is not supported and will throw a NotSupportedException
157	/// </summary>
158	/// <param name="offset">A byte offset relative to the <paramref name="origin"/> parameter.</param>
159	/// <param name="origin">A value of type <see cref="SeekOrigin"/> indicating the reference point used to obtain the new position.</param>
160	/// <returns>The new position of the stream.</returns>
161	/// <exception cref="NotSupportedException">Any access</exception>
162	public override long Seek(long offset, SeekOrigin origin)
163	{
164	throw new NotSupportedException("BZip2InputStream Seek not supported");
165	}
166
167	/// <summary>
168	/// Sets the length of this stream to the given value.
169	/// This operation is not supported and will throw a NotSupportedExceptionortedException
170	/// </summary>
171	/// <param name="value">The new length for the stream.</param>
172	/// <exception cref="NotSupportedException">Any access</exception>
173	public override void SetLength(long value)
174	{
175	throw new NotSupportedException("BZip2InputStream SetLength not supported");
176	}
177
178	/// <summary>
179	/// Writes a block of bytes to this stream using data from a buffer.
180	/// This operation is not supported and will throw a NotSupportedException
181	/// </summary>
182	/// <param name="buffer">The buffer to source data from.</param>
183	/// <param name="offset">The offset to start obtaining data from.</param>
184	/// <param name="count">The number of bytes of data to write.</param>
185	/// <exception cref="NotSupportedException">Any access</exception>
186	public override void Write(byte[] buffer, int offset, int count)
187	{
188	throw new NotSupportedException("BZip2InputStream Write not supported");
189	}
190
191	/// <summary>
192	/// Writes a byte to the current position in the file stream.
193	/// This operation is not supported and will throw a NotSupportedException
194	/// </summary>
195	/// <param name="value">The value to write.</param>
196	/// <exception cref="NotSupportedException">Any access</exception>
197	public override void WriteByte(byte value)
198	{
199	throw new NotSupportedException("BZip2InputStream WriteByte not supported");
200	}
201
202	/// <summary>
203	/// Read a sequence of bytes and advances the read position by one byte.
204	/// </summary>
205	/// <param name="buffer">Array of bytes to store values in</param>
206	/// <param name="offset">Offset in array to begin storing data</param>
207	/// <param name="count">The maximum number of bytes to read</param>
208	/// <returns>The total number of bytes read into the buffer. This might be less
209	/// than the number of bytes requested if that number of bytes are not
210	/// currently available or zero if the end of the stream is reached.
211	/// </returns>
212	public override int Read(byte[] buffer, int offset, int count)
213	{
214	if ( buffer == null )
215	{
216	throw new ArgumentNullException("buffer");
217	}
218
219	for (int i = 0; i < count; ++i) {
220	int rb = ReadByte();
221	if (rb == -1) {
222	return i;
223	}
224	buffer[offset + i] = (byte)rb;
225	}
226	return count;
227	}
228
229	/// <summary>
230	/// Closes the stream, releasing any associated resources.
231	/// </summary>
232	public override void Close()
233	{
234	if ( IsStreamOwner && (baseStream != null) ) {
235	baseStream.Close();
236	}
237	}
238	/// <summary>
239	/// Read a byte from stream advancing position
240	/// </summary>
241	/// <returns>byte read or -1 on end of stream</returns>
242	public override int ReadByte()
243	{
244	if (streamEnd)
245	{
246	return -1; // ok
247	}
248
249	int retChar = currentChar;
250	switch (currentState)
251	{
252	case RAND_PART_B_STATE:
253	SetupRandPartB();
254	break;
255	case RAND_PART_C_STATE:
256	SetupRandPartC();
257	break;
258	case NO_RAND_PART_B_STATE:
259	SetupNoRandPartB();
260	break;
261	case NO_RAND_PART_C_STATE:
262	SetupNoRandPartC();
263	break;
264	case START_BLOCK_STATE:
265	case NO_RAND_PART_A_STATE:
266	case RAND_PART_A_STATE:
267	break;
268	default:
269	break;
270	}
271	return retChar;
272	}
273
274	#endregion
275
276	void MakeMaps()
277	{
278	nInUse = 0;
279	for (int i = 0; i < 256; ++i) {
280	if (inUse[i]) {
281	seqToUnseq[nInUse] = (byte)i;
282	unseqToSeq[i] = (byte)nInUse;
283	nInUse++;
284	}
285	}
286	}
287
288	void Initialize()
289	{
290	char magic1 = BsGetUChar();
291	char magic2 = BsGetUChar();
292
293	char magic3 = BsGetUChar();
294	char magic4 = BsGetUChar();
295
296	if (magic1 != 'B' \|\| magic2 != 'Z' \|\| magic3 != 'h' \|\| magic4 < '1' \|\| magic4 > '9') {
297	streamEnd = true;
298	return;
299	}
300
301	SetDecompressStructureSizes(magic4 - '0');
302	computedCombinedCRC = 0;
303	}
304
305	void InitBlock()
306	{
307	char magic1 = BsGetUChar();
308	char magic2 = BsGetUChar();
309	char magic3 = BsGetUChar();
310	char magic4 = BsGetUChar();
311	char magic5 = BsGetUChar();
312	char magic6 = BsGetUChar();
313
314	if (magic1 == 0x17 && magic2 == 0x72 && magic3 == 0x45 && magic4 == 0x38 && magic5 == 0x50 && magic6 == 0x90) {
315	Complete();
316	return;
317	}
318
319	if (magic1 != 0x31 \|\| magic2 != 0x41 \|\| magic3 != 0x59 \|\| magic4 != 0x26 \|\| magic5 != 0x53 \|\| magic6 != 0x59) {
320	BadBlockHeader();
321	streamEnd = true;
322	return;
323	}
324
325	storedBlockCRC = BsGetInt32();
326
327	blockRandomised = (BsR(1) == 1);
328
329	GetAndMoveToFrontDecode();
330
331	mCrc.Reset();
332	currentState = START_BLOCK_STATE;
333	}
334
335	void EndBlock()
336	{
337	computedBlockCRC = (int)mCrc.Value;
338
339	// -- A bad CRC is considered a fatal error. --
340	if (storedBlockCRC != computedBlockCRC) {
341	CrcError();
342	}
343
344	// 1528150659
345	computedCombinedCRC = ((computedCombinedCRC << 1) & 0xFFFFFFFF) \| (computedCombinedCRC >> 31);
346	computedCombinedCRC = computedCombinedCRC ^ (uint)computedBlockCRC;
347	}
348
349	void Complete()
350	{
351	storedCombinedCRC = BsGetInt32();
352	if (storedCombinedCRC != (int)computedCombinedCRC) {
353	CrcError();
354	}
355
356	streamEnd = true;
357	}
358
359	void BsSetStream(Stream stream)
360	{
361	baseStream = stream;
362	bsLive = 0;
363	bsBuff = 0;
364	}
365
366	void FillBuffer()
367	{
368	int thech = 0;
369
370	try {
371	thech = baseStream.ReadByte();
372	} catch (Exception) {
373	CompressedStreamEOF();
374	}
375
376	if (thech == -1) {
377	CompressedStreamEOF();
378	}
379
380	bsBuff = (bsBuff << 8) \| (thech & 0xFF);
381	bsLive += 8;
382	}
383
384	int BsR(int n)
385	{
386	while (bsLive < n) {
387	FillBuffer();
388	}
389
390	int v = (bsBuff >> (bsLive - n)) & ((1 << n) - 1);
391	bsLive -= n;
392	return v;
393	}
394
395	char BsGetUChar()
396	{
397	return (char)BsR(8);
398	}
399
400	int BsGetIntVS(int numBits)
401	{
402	return BsR(numBits);
403	}
404
405	int BsGetInt32()
406	{
407	int result = BsR(8);
408	result = (result << 8) \| BsR(8);
409	result = (result << 8) \| BsR(8);
410	result = (result << 8) \| BsR(8);
411	return result;
412	}
413
414	void RecvDecodingTables()
415	{
416	char[][] len = new char[BZip2Constants.GroupCount][];
417	for (int i = 0; i < BZip2Constants.GroupCount; ++i) {
418	len[i] = new char[BZip2Constants.MaximumAlphaSize];
419	}
420
421	bool[] inUse16 = new bool[16];
422
423	//--- Receive the mapping table ---
424	for (int i = 0; i < 16; i++) {
425	inUse16[i] = (BsR(1) == 1);
426	}
427
428	for (int i = 0; i < 16; i++) {
429	if (inUse16[i]) {
430	for (int j = 0; j < 16; j++) {
431	inUse[i * 16 + j] = (BsR(1) == 1);
432	}
433	} else {
434	for (int j = 0; j < 16; j++) {
435	inUse[i * 16 + j] = false;
436	}
437	}
438	}
439
440	MakeMaps();
441	int alphaSize = nInUse + 2;
442
443	//--- Now the selectors ---
444	int nGroups = BsR(3);
445	int nSelectors = BsR(15);
446
447	for (int i = 0; i < nSelectors; i++) {
448	int j = 0;
449	while (BsR(1) == 1) {
450	j++;
451	}
452	selectorMtf[i] = (byte)j;
453	}
454
455	//--- Undo the MTF values for the selectors. ---
456	byte[] pos = new byte[BZip2Constants.GroupCount];
457	for (int v = 0; v < nGroups; v++) {
458	pos[v] = (byte)v;
459	}
460
461	for (int i = 0; i < nSelectors; i++) {
462	int v = selectorMtf[i];
463	byte tmp = pos[v];
464	while (v > 0) {
465	pos[v] = pos[v - 1];
466	v--;
467	}
468	pos[0] = tmp;
469	selector[i] = tmp;
470	}
471
472	//--- Now the coding tables ---
473	for (int t = 0; t < nGroups; t++) {
474	int curr = BsR(5);
475	for (int i = 0; i < alphaSize; i++) {
476	while (BsR(1) == 1) {
477	if (BsR(1) == 0) {
478	curr++;
479	} else {
480	curr--;
481	}
482	}
483	len[t][i] = (char)curr;
484	}
485	}
486
487	//--- Create the Huffman decoding tables ---
488	for (int t = 0; t < nGroups; t++) {
489	int minLen = 32;
490	int maxLen = 0;
491	for (int i = 0; i < alphaSize; i++) {
492	maxLen = Math.Max(maxLen, len[t][i]);
493	minLen = Math.Min(minLen, len[t][i]);
494	}
495	HbCreateDecodeTables(limit[t], baseArray[t], perm[t], len[t], minLen, maxLen, alphaSize);
496	minLens[t] = minLen;
497	}
498	}
499
500	void GetAndMoveToFrontDecode()
501	{
502	byte[] yy = new byte[256];
503	int nextSym;
504
505	int limitLast = BZip2Constants.BaseBlockSize * blockSize100k;
506	origPtr = BsGetIntVS(24);
507
508	RecvDecodingTables();
509	int EOB = nInUse+1;
510	int groupNo = -1;
511	int groupPos = 0;
512
513	/*--
514	Setting up the unzftab entries here is not strictly
515	necessary, but it does save having to do it later
516	in a separate pass, and so saves a block's worth of
517	cache misses.
518	--*/
519	for (int i = 0; i <= 255; i++) {
520	unzftab[i] = 0;
521	}
522
523	for (int i = 0; i <= 255; i++) {
524	yy[i] = (byte)i;
525	}
526
527	last = -1;
528
529	if (groupPos == 0) {
530	groupNo++;
531	groupPos = BZip2Constants.GroupSize;
532	}
533
534	groupPos--;
535	int zt = selector[groupNo];
536	int zn = minLens[zt];
537	int zvec = BsR(zn);
538	int zj;
539
540	while (zvec > limit[zt][zn]) {
541	if (zn > 20) { // the longest code
542	throw new BZip2Exception("Bzip data error");
543	}
544	zn++;
545	while (bsLive < 1) {
546	FillBuffer();
547	}
548	zj = (bsBuff >> (bsLive-1)) & 1;
549	bsLive--;
550	zvec = (zvec << 1) \| zj;
551	}
552	if (zvec - baseArray[zt][zn] < 0 \|\| zvec - baseArray[zt][zn] >= BZip2Constants.MaximumAlphaSize) {
553	throw new BZip2Exception("Bzip data error");
554	}
555	nextSym = perm[zt][zvec - baseArray[zt][zn]];
556
557	while (true) {
558	if (nextSym == EOB) {
559	break;
560	}
561
562	if (nextSym == BZip2Constants.RunA \|\| nextSym == BZip2Constants.RunB) {
563	int s = -1;
564	int n = 1;
565	do {
566	if (nextSym == BZip2Constants.RunA) {
567	s += (0 + 1) * n;
568	} else if (nextSym == BZip2Constants.RunB) {
569	s += (1 + 1) * n;
570	}
571
572	n <<= 1;
573
574	if (groupPos == 0) {
575	groupNo++;
576	groupPos = BZip2Constants.GroupSize;
577	}
578
579	groupPos--;
580
581	zt = selector[groupNo];
582	zn = minLens[zt];
583	zvec = BsR(zn);
584
585	while (zvec > limit[zt][zn]) {
586	zn++;
587	while (bsLive < 1) {
588	FillBuffer();
589	}
590	zj = (bsBuff >> (bsLive - 1)) & 1;
591	bsLive--;
592	zvec = (zvec << 1) \| zj;
593	}
594	nextSym = perm[zt][zvec - baseArray[zt][zn]];
595	} while (nextSym == BZip2Constants.RunA \|\| nextSym == BZip2Constants.RunB);
596
597	s++;
598	byte ch = seqToUnseq[yy[0]];
599	unzftab[ch] += s;
600
601	while (s > 0) {
602	last++;
603	ll8[last] = ch;
604	s--;
605	}
606
607	if (last >= limitLast) {
608	BlockOverrun();
609	}
610	continue;
611	} else {
612	last++;
613	if (last >= limitLast) {
614	BlockOverrun();
615	}
616
617	byte tmp = yy[nextSym - 1];
618	unzftab[seqToUnseq[tmp]]++;
619	ll8[last] = seqToUnseq[tmp];
620
621	for (int j = nextSym-1; j > 0; --j) {
622	yy[j] = yy[j - 1];
623	}
624	yy[0] = tmp;
625
626	if (groupPos == 0) {
627	groupNo++;
628	groupPos = BZip2Constants.GroupSize;
629	}
630
631	groupPos--;
632	zt = selector[groupNo];
633	zn = minLens[zt];
634	zvec = BsR(zn);
635	while (zvec > limit[zt][zn]) {
636	zn++;
637	while (bsLive < 1) {
638	FillBuffer();
639	}
640	zj = (bsBuff >> (bsLive-1)) & 1;
641	bsLive--;
642	zvec = (zvec << 1) \| zj;
643	}
644	nextSym = perm[zt][zvec - baseArray[zt][zn]];
645	continue;
646	}
647	}
648	}
649
650	void SetupBlock()
651	{
652	int[] cftab = new int[257];
653
654	cftab[0] = 0;
655	Array.Copy(unzftab, 0, cftab, 1, 256);
656
657	for (int i = 1; i <= 256; i++) {
658	cftab[i] += cftab[i - 1];
659	}
660
661	for (int i = 0; i <= last; i++) {
662	byte ch = ll8[i];
663	tt[cftab[ch]] = i;
664	cftab[ch]++;
665	}
666
667	cftab = null;
668
669	tPos = tt[origPtr];
670
671	count = 0;
672	i2 = 0;
673	ch2 = 256; /-- not a char and not EOF --/
674
675	if (blockRandomised) {
676	rNToGo = 0;
677	rTPos = 0;
678	SetupRandPartA();
679	} else {
680	SetupNoRandPartA();
681	}
682	}
683
684	void SetupRandPartA()
685	{
686	if (i2 <= last) {
687	chPrev = ch2;
688	ch2 = ll8[tPos];
689	tPos = tt[tPos];
690	if (rNToGo == 0) {
691	rNToGo = BZip2Constants.RandomNumbers[rTPos];
692	rTPos++;
693	if (rTPos == 512) {
694	rTPos = 0;
695	}
696	}
697	rNToGo--;
698	ch2 ^= (int)((rNToGo == 1) ? 1 : 0);
699	i2++;
700
701	currentChar = ch2;
702	currentState = RAND_PART_B_STATE;
703	mCrc.Update(ch2);
704	} else {
705	EndBlock();
706	InitBlock();
707	SetupBlock();
708	}
709	}
710
711	void SetupNoRandPartA()
712	{
713	if (i2 <= last) {
714	chPrev = ch2;
715	ch2 = ll8[tPos];
716	tPos = tt[tPos];
717	i2++;
718
719	currentChar = ch2;
720	currentState = NO_RAND_PART_B_STATE;
721	mCrc.Update(ch2);
722	} else {
723	EndBlock();
724	InitBlock();
725	SetupBlock();
726	}
727	}
728
729	void SetupRandPartB()
730	{
731	if (ch2 != chPrev) {
732	currentState = RAND_PART_A_STATE;
733	count = 1;
734	SetupRandPartA();
735	} else {
736	count++;
737	if (count >= 4) {
738	z = ll8[tPos];
739	tPos = tt[tPos];
740	if (rNToGo == 0) {
741	rNToGo = BZip2Constants.RandomNumbers[rTPos];
742	rTPos++;
743	if (rTPos == 512) {
744	rTPos = 0;
745	}
746	}
747	rNToGo--;
748	z ^= (byte)((rNToGo == 1) ? 1 : 0);
749	j2 = 0;
750	currentState = RAND_PART_C_STATE;
751	SetupRandPartC();
752	} else {
753	currentState = RAND_PART_A_STATE;
754	SetupRandPartA();
755	}
756	}
757	}
758
759	void SetupRandPartC()
760	{
761	if (j2 < (int)z) {
762	currentChar = ch2;
763	mCrc.Update(ch2);
764	j2++;
765	} else {
766	currentState = RAND_PART_A_STATE;
767	i2++;
768	count = 0;
769	SetupRandPartA();
770	}
771	}
772
773	void SetupNoRandPartB()
774	{
775	if (ch2 != chPrev) {
776	currentState = NO_RAND_PART_A_STATE;
777	count = 1;
778	SetupNoRandPartA();
779	} else {
780	count++;
781	if (count >= 4) {
782	z = ll8[tPos];
783	tPos = tt[tPos];
784	currentState = NO_RAND_PART_C_STATE;
785	j2 = 0;
786	SetupNoRandPartC();
787	} else {
788	currentState = NO_RAND_PART_A_STATE;
789	SetupNoRandPartA();
790	}
791	}
792	}
793
794	void SetupNoRandPartC()
795	{
796	if (j2 < (int)z) {
797	currentChar = ch2;
798	mCrc.Update(ch2);
799	j2++;
800	} else {
801	currentState = NO_RAND_PART_A_STATE;
802	i2++;
803	count = 0;
804	SetupNoRandPartA();
805	}
806	}
807
808	void SetDecompressStructureSizes(int newSize100k)
809	{
810	if (!(0 <= newSize100k && newSize100k <= 9 && 0 <= blockSize100k && blockSize100k <= 9)) {
811	throw new BZip2Exception("Invalid block size");
812	}
813
814	blockSize100k = newSize100k;
815
816	if (newSize100k == 0) {
817	return;
818	}
819
820	int n = BZip2Constants.BaseBlockSize * newSize100k;
821	ll8 = new byte[n];
822	tt = new int[n];
823	}
824
825	static void CompressedStreamEOF()
826	{
827	throw new EndOfStreamException("BZip2 input stream end of compressed stream");
828	}
829
830	static void BlockOverrun()
831	{
832	throw new BZip2Exception("BZip2 input stream block overrun");
833	}
834
835	static void BadBlockHeader()
836	{
837	throw new BZip2Exception("BZip2 input stream bad block header");
838	}
839
840	static void CrcError()
841	{
842	throw new BZip2Exception("BZip2 input stream crc error");
843	}
844
845	static void HbCreateDecodeTables(int[] limit, int[] baseArray, int[] perm, char[] length, int minLen, int maxLen, int alphaSize)
846	{
847	int pp = 0;
848
849	for (int i = minLen; i <= maxLen; ++i)
850	{
851	for (int j = 0; j < alphaSize; ++j)
852	{
853	if (length[j] == i)
854	{
855	perm[pp] = j;
856	++pp;
857	}
858	}
859	}
860
861	for (int i = 0; i < BZip2Constants.MaximumCodeLength; i++)
862	{
863	baseArray[i] = 0;
864	}
865
866	for (int i = 0; i < alphaSize; i++)
867	{
868	++baseArray[length[i] + 1];
869	}
870
871	for (int i = 1; i < BZip2Constants.MaximumCodeLength; i++)
872	{
873	baseArray[i] += baseArray[i - 1];
874	}
875
876	for (int i = 0; i < BZip2Constants.MaximumCodeLength; i++)
877	{
878	limit[i] = 0;
879	}
880
881	int vec = 0;
882
883	for (int i = minLen; i <= maxLen; i++)
884	{
885	vec += (baseArray[i + 1] - baseArray[i]);
886	limit[i] = vec - 1;
887	vec <<= 1;
888	}
889
890	for (int i = minLen + 1; i <= maxLen; i++)
891	{
892	baseArray[i] = ((limit[i - 1] + 1) << 1) - baseArray[i];
893	}
894	}
895
896	#region Instance Fields
897	/*--
898	index of the last char in the block, so
899	the block size == last + 1.
900	--*/
901	int last;
902
903	/*--
904	index in zptr[] of original string after sorting.
905	--*/
906	int origPtr;
907
908	/*--
909	always: in the range 0 .. 9.
910	The current block size is 100000 * this number.
911	--*/
912	int blockSize100k;
913
914	bool blockRandomised;
915
916	int bsBuff;
917	int bsLive;
918	IChecksum mCrc = new StrangeCRC();
919
920	bool[] inUse = new bool[256];
921	int nInUse;
922
923	byte[] seqToUnseq = new byte[256];
924	byte[] unseqToSeq = new byte[256];
925
926	byte[] selector = new byte[BZip2Constants.MaximumSelectors];
927	byte[] selectorMtf = new byte[BZip2Constants.MaximumSelectors];
928
929	int[] tt;
930	byte[] ll8;
931
932	/*--
933	freq table collected to save a pass over the data
934	during decompression.
935	--*/
936	int[] unzftab = new int[256];
937
938	int[][] limit = new int[BZip2Constants.GroupCount][];
939	int[][] baseArray = new int[BZip2Constants.GroupCount][];
940	int[][] perm = new int[BZip2Constants.GroupCount][];
941	int[] minLens = new int[BZip2Constants.GroupCount];
942
943	Stream baseStream;
944	bool streamEnd;
945
946	int currentChar = -1;
947
948	int currentState = START_BLOCK_STATE;
949
950	int storedBlockCRC, storedCombinedCRC;
951	int computedBlockCRC;
952	uint computedCombinedCRC;
953
954	int count, chPrev, ch2;
955	int tPos;
956	int rNToGo;
957	int rTPos;
958	int i2, j2;
959	byte z;
960	bool isStreamOwner = true;
961	#endregion
962	}
963	}
964	/* This file was derived from a file containing this license:
965	*
966	* This file is a part of bzip2 and/or libbzip2, a program and
967	* library for lossless, block-sorting data compression.
968	*
969	* Copyright (C) 1996-1998 Julian R Seward. All rights reserved.
970	*
971	* Redistribution and use in source and binary forms, with or without
972	* modification, are permitted provided that the following conditions
973	* are met:
974	*
975	* 1. Redistributions of source code must retain the above copyright
976	* notice, this list of conditions and the following disclaimer.
977	*
978	* 2. The origin of this software must not be misrepresented; you must
979	* not claim that you wrote the original software. If you use this
980	* software in a product, an acknowledgment in the product
981	* documentation would be appreciated but is not required.
982	*
983	* 3. Altered source versions must be plainly marked as such, and must
984	* not be misrepresented as being the original software.
985	*
986	* 4. The name of the author may not be used to endorse or promote
987	* products derived from this software without specific prior written
988	* permission.
989	*
990	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
991	* OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
992	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
993	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
994	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
995	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
996	* GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
997	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
998	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
999	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
1000	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1001	*
1002	* Java version ported by Keiron Liddle, Aftex Software <keiron@aftexsw.com> 1999-2001
1003	*/

Notatka: Zobacz TracBrowser aby uzyskać więcej informacji.

Nawigacja

root/branches/Abonament/BazaReklam.Updater/ICSharpCode.SharpZipLib/BZip2/BZip2InputStream.cs @ 754

Pobierz w innym formacie: