diff --git a/src/SharpCompress/Compressors/Rar/Decode/BitDecode.cs b/src/SharpCompress/Compressors/Rar/Decode/BitDecode.cs index ba13c9b8..eef2007f 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/BitDecode.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/BitDecode.cs @@ -3,7 +3,7 @@ namespace SharpCompress.Compressors.Rar.Decode internal class BitDecode : Decode { internal BitDecode() - : base(new int[Compress.BC]) + : base(new int[PackDef.BC]) { } } diff --git a/src/SharpCompress/Compressors/Rar/Decode/DistDecode.cs b/src/SharpCompress/Compressors/Rar/Decode/DistDecode.cs index 0c26c391..b5127e2d 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/DistDecode.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/DistDecode.cs @@ -3,7 +3,7 @@ namespace SharpCompress.Compressors.Rar.Decode internal class DistDecode : Decode { internal DistDecode() - : base(new int[Compress.DC]) + : base(new int[PackDef.DC]) { } } diff --git a/src/SharpCompress/Compressors/Rar/Decode/LitDecode.cs b/src/SharpCompress/Compressors/Rar/Decode/LitDecode.cs index 6084d0fe..0c58184e 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/LitDecode.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/LitDecode.cs @@ -3,7 +3,7 @@ namespace SharpCompress.Compressors.Rar.Decode internal class LitDecode : Decode { internal LitDecode() - : base(new int[Compress.NC]) + : base(new int[PackDef.NC]) { } } diff --git a/src/SharpCompress/Compressors/Rar/Decode/LowDistDecode.cs b/src/SharpCompress/Compressors/Rar/Decode/LowDistDecode.cs index 266bf9e1..bafb0c2f 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/LowDistDecode.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/LowDistDecode.cs @@ -3,7 +3,7 @@ namespace SharpCompress.Compressors.Rar.Decode internal class LowDistDecode : Decode { internal LowDistDecode() - : base(new int[Compress.LDC]) + : base(new int[PackDef.LDC]) { } } diff --git a/src/SharpCompress/Compressors/Rar/Decode/MultDecode.cs b/src/SharpCompress/Compressors/Rar/Decode/MultDecode.cs index d42a83eb..6c21dc83 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/MultDecode.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/MultDecode.cs @@ -3,7 +3,7 @@ namespace SharpCompress.Compressors.Rar.Decode internal class MultDecode : Decode { internal MultDecode() - : base(new int[Compress.MC20]) + : base(new int[PackDef.MC20]) { } } diff --git a/src/SharpCompress/Compressors/Rar/Decode/Compress.cs b/src/SharpCompress/Compressors/Rar/Decode/PackDef.cs similarity index 97% rename from src/SharpCompress/Compressors/Rar/Decode/Compress.cs rename to src/SharpCompress/Compressors/Rar/Decode/PackDef.cs index 3689daf0..15ecdf13 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/Compress.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/PackDef.cs @@ -1,6 +1,6 @@ namespace SharpCompress.Compressors.Rar.Decode { - internal class Compress + internal class PackDef { public const int CODEBUFSIZE = 0x4000; public const int MAXWINSIZE = 0x400000; diff --git a/src/SharpCompress/Compressors/Rar/Decode/RepDecode.cs b/src/SharpCompress/Compressors/Rar/Decode/RepDecode.cs index 3a59587f..1f4a42ef 100644 --- a/src/SharpCompress/Compressors/Rar/Decode/RepDecode.cs +++ b/src/SharpCompress/Compressors/Rar/Decode/RepDecode.cs @@ -3,7 +3,7 @@ namespace SharpCompress.Compressors.Rar.Decode internal class RepDecode : Decode { internal RepDecode() - : base(new int[Compress.RC]) + : base(new int[PackDef.RC]) { } } diff --git a/src/SharpCompress/Compressors/Rar/Unpack.cs b/src/SharpCompress/Compressors/Rar/Unpack.cs index 5a77beae..f0cd37b5 100644 --- a/src/SharpCompress/Compressors/Rar/Unpack.cs +++ b/src/SharpCompress/Compressors/Rar/Unpack.cs @@ -82,7 +82,7 @@ namespace SharpCompress.Compressors.Rar //UPGRADE_NOTE: The initialization of 'unpOldTable' was moved to method 'InitBlock'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1005'" - private readonly byte[] unpOldTable = new byte[Compress.HUFF_TABLE_SIZE]; + private readonly byte[] unpOldTable = new byte[PackDef.HUFF_TABLE_SIZE]; private BlockTypes unpBlockType; @@ -114,7 +114,7 @@ namespace SharpCompress.Compressors.Rar { if (window == null) { - this.window = new byte[Compress.MAXWINSIZE]; + this.window = new byte[PackDef.MAXWINSIZE]; } else { @@ -198,8 +198,8 @@ namespace SharpCompress.Compressors.Rar private void unpack29(bool solid) { - int[] DDecode = new int[Compress.DC]; - byte[] DBits = new byte[Compress.DC]; + int[] DDecode = new int[PackDef.DC]; + byte[] DBits = new byte[PackDef.DC]; int Bits; @@ -239,7 +239,7 @@ namespace SharpCompress.Compressors.Rar while (true) { - unpPtr &= Compress.MAXWINMASK; + unpPtr &= PackDef.MAXWINMASK; if (inAddr > readBorder) { @@ -251,7 +251,7 @@ namespace SharpCompress.Compressors.Rar // System.out.println(((wrPtr - unpPtr) & // Compress.MAXWINMASK)+":"+wrPtr+":"+unpPtr); - if (((wrPtr - unpPtr) & Compress.MAXWINMASK) < 260 && wrPtr != unpPtr) + if (((wrPtr - unpPtr) & PackDef.MAXWINMASK) < 260 && wrPtr != unpPtr) { UnpWriteBuf(); if (destUnpSize <= 0) @@ -378,7 +378,7 @@ namespace SharpCompress.Compressors.Rar int LowDist = this.decodeNumber(LDD); if (LowDist == 16) { - lowDistRepCount = Compress.LOW_DIST_REP_COUNT - 1; + lowDistRepCount = PackDef.LOW_DIST_REP_COUNT - 1; Distance += prevLowDist; } else @@ -474,7 +474,7 @@ namespace SharpCompress.Compressors.Rar private void UnpWriteBuf() { int WrittenBorder = wrPtr; - int WriteSize = (unpPtr - WrittenBorder) & Compress.MAXWINMASK; + int WriteSize = (unpPtr - WrittenBorder) & PackDef.MAXWINMASK; for (int I = 0; I < prgStack.Count; I++) { UnpackFilter flt = prgStack[I]; @@ -489,17 +489,17 @@ namespace SharpCompress.Compressors.Rar } int BlockStart = flt.BlockStart; // ->BlockStart; int BlockLength = flt.BlockLength; // ->BlockLength; - if (((BlockStart - WrittenBorder) & Compress.MAXWINMASK) < WriteSize) + if (((BlockStart - WrittenBorder) & PackDef.MAXWINMASK) < WriteSize) { if (WrittenBorder != BlockStart) { UnpWriteArea(WrittenBorder, BlockStart); WrittenBorder = BlockStart; - WriteSize = (unpPtr - WrittenBorder) & Compress.MAXWINMASK; + WriteSize = (unpPtr - WrittenBorder) & PackDef.MAXWINMASK; } if (BlockLength <= WriteSize) { - int BlockEnd = (BlockStart + BlockLength) & Compress.MAXWINMASK; + int BlockEnd = (BlockStart + BlockLength) & PackDef.MAXWINMASK; if (BlockStart < BlockEnd || BlockEnd == 0) { // VM.SetMemory(0,Window+BlockStart,BlockLength); @@ -507,7 +507,7 @@ namespace SharpCompress.Compressors.Rar } else { - int FirstPartLength = Compress.MAXWINSIZE - BlockStart; + int FirstPartLength = PackDef.MAXWINSIZE - BlockStart; // VM.SetMemory(0,Window+BlockStart,FirstPartLength); rarVM.setMemory(0, window, BlockStart, FirstPartLength); @@ -641,7 +641,7 @@ namespace SharpCompress.Compressors.Rar writtenFileSize += FilteredDataSize; destUnpSize -= FilteredDataSize; WrittenBorder = BlockEnd; - WriteSize = (unpPtr - WrittenBorder) & Compress.MAXWINMASK; + WriteSize = (unpPtr - WrittenBorder) & PackDef.MAXWINMASK; } else { @@ -671,7 +671,7 @@ namespace SharpCompress.Compressors.Rar } if (endPtr < startPtr) { - UnpWriteData(window, startPtr, -startPtr & Compress.MAXWINMASK); + UnpWriteData(window, startPtr, -startPtr & PackDef.MAXWINMASK); UnpWriteData(window, 0, endPtr); unpAllBuf = true; } @@ -719,7 +719,7 @@ namespace SharpCompress.Compressors.Rar int destPtr = unpPtr - distance; // System.out.println(unpPtr+":"+distance); - if (destPtr >= 0 && destPtr < Compress.MAXWINSIZE - 260 && unpPtr < Compress.MAXWINSIZE - 260) + if (destPtr >= 0 && destPtr < PackDef.MAXWINSIZE - 260 && unpPtr < PackDef.MAXWINSIZE - 260) { window[unpPtr++] = window[destPtr++]; @@ -732,8 +732,8 @@ namespace SharpCompress.Compressors.Rar { while (length-- != 0) { - window[unpPtr] = window[destPtr++ & Compress.MAXWINMASK]; - unpPtr = (unpPtr + 1) & Compress.MAXWINMASK; + window[unpPtr] = window[destPtr++ & PackDef.MAXWINMASK]; + unpPtr = (unpPtr + 1) & PackDef.MAXWINMASK; } } } @@ -796,9 +796,9 @@ namespace SharpCompress.Compressors.Rar private bool readTables() { - byte[] bitLength = new byte[Compress.BC]; + byte[] bitLength = new byte[PackDef.BC]; - byte[] table = new byte[Compress.HUFF_TABLE_SIZE]; + byte[] table = new byte[PackDef.HUFF_TABLE_SIZE]; if (inAddr > readTop - 25) { if (!unpReadBuf()) @@ -824,7 +824,7 @@ namespace SharpCompress.Compressors.Rar } AddBits(2); - for (int i = 0; i < Compress.BC; i++) + for (int i = 0; i < PackDef.BC; i++) { int length = (Utility.URShift(GetBits(), 12)) & 0xFF; AddBits(4); @@ -852,9 +852,9 @@ namespace SharpCompress.Compressors.Rar } } - UnpackUtility.makeDecodeTables(bitLength, 0, BD, Compress.BC); + UnpackUtility.makeDecodeTables(bitLength, 0, BD, PackDef.BC); - int TableSize = Compress.HUFF_TABLE_SIZE; + int TableSize = PackDef.HUFF_TABLE_SIZE; for (int i = 0; i < TableSize;) { @@ -914,10 +914,10 @@ namespace SharpCompress.Compressors.Rar { return (false); } - UnpackUtility.makeDecodeTables(table, 0, LD, Compress.NC); - UnpackUtility.makeDecodeTables(table, Compress.NC, DD, Compress.DC); - UnpackUtility.makeDecodeTables(table, Compress.NC + Compress.DC, LDD, Compress.LDC); - UnpackUtility.makeDecodeTables(table, Compress.NC + Compress.DC + Compress.LDC, RD, Compress.RC); + UnpackUtility.makeDecodeTables(table, 0, LD, PackDef.NC); + UnpackUtility.makeDecodeTables(table, PackDef.NC, DD, PackDef.DC); + UnpackUtility.makeDecodeTables(table, PackDef.NC + PackDef.DC, LDD, PackDef.LDC); + UnpackUtility.makeDecodeTables(table, PackDef.NC + PackDef.DC + PackDef.LDC, RD, PackDef.RC); // memcpy(unpOldTable,table,sizeof(unpOldTable)); @@ -1077,7 +1077,7 @@ namespace SharpCompress.Compressors.Rar { BlockStart += 258; } - StackFilter.BlockStart = ((BlockStart + unpPtr) & Compress.MAXWINMASK); + StackFilter.BlockStart = ((BlockStart + unpPtr) & PackDef.MAXWINMASK); if ((firstByte & 0x20) != 0) { StackFilter.BlockLength = RarVM.ReadData(Inp); @@ -1086,7 +1086,7 @@ namespace SharpCompress.Compressors.Rar { StackFilter.BlockLength = FiltPos < oldFilterLengths.Count ? oldFilterLengths[FiltPos] : 0; } - StackFilter.NextWindow = (wrPtr != unpPtr) && ((wrPtr - unpPtr) & Compress.MAXWINMASK) <= BlockStart; + StackFilter.NextWindow = (wrPtr != unpPtr) && ((wrPtr - unpPtr) & PackDef.MAXWINMASK) <= BlockStart; // DebugLog("\nNextWindow: UnpPtr=%08x WrPtr=%08x // BlockStart=%08x",UnpPtr,WrPtr,BlockStart); diff --git a/src/SharpCompress/Compressors/Rar/Unpack15.cs b/src/SharpCompress/Compressors/Rar/Unpack15.cs index c7c1c877..cc762635 100644 --- a/src/SharpCompress/Compressors/Rar/Unpack15.cs +++ b/src/SharpCompress/Compressors/Rar/Unpack15.cs @@ -174,13 +174,13 @@ namespace SharpCompress.Compressors.Rar while (destUnpSize >= 0) { - unpPtr &= Compress.MAXWINMASK; + unpPtr &= PackDef.MAXWINMASK; if (inAddr > readTop - 30 && !unpReadBuf()) { break; } - if (((wrPtr - unpPtr) & Compress.MAXWINMASK) < 270 && wrPtr != unpPtr) + if (((wrPtr - unpPtr) & PackDef.MAXWINMASK) < 270 && wrPtr != unpPtr) { oldUnpWriteBuf(); if (suspended) @@ -702,8 +702,8 @@ namespace SharpCompress.Compressors.Rar destUnpSize -= Length; while ((Length--) != 0) { - window[unpPtr] = window[(unpPtr - Distance) & Compress.MAXWINMASK]; - unpPtr = (unpPtr + 1) & Compress.MAXWINMASK; + window[unpPtr] = window[(unpPtr - Distance) & PackDef.MAXWINMASK]; + unpPtr = (unpPtr + 1) & PackDef.MAXWINMASK; } } @@ -726,7 +726,7 @@ namespace SharpCompress.Compressors.Rar } if (unpPtr < wrPtr) { - writeStream.Write(window, wrPtr, -wrPtr & Compress.MAXWINMASK); + writeStream.Write(window, wrPtr, -wrPtr & PackDef.MAXWINMASK); writeStream.Write(window, 0, unpPtr); unpAllBuf = true; } diff --git a/src/SharpCompress/Compressors/Rar/Unpack20.cs b/src/SharpCompress/Compressors/Rar/Unpack20.cs index 608442c1..e9a8dbdd 100644 --- a/src/SharpCompress/Compressors/Rar/Unpack20.cs +++ b/src/SharpCompress/Compressors/Rar/Unpack20.cs @@ -37,7 +37,7 @@ namespace SharpCompress.Compressors.Rar private void InitBlock() { - UnpOldTable20 = new byte[Compress.MC20 * 4]; + UnpOldTable20 = new byte[PackDef.MC20 * 4]; } protected internal MultDecode[] MD = new MultDecode[4]; @@ -124,7 +124,7 @@ namespace SharpCompress.Compressors.Rar while (destUnpSize >= 0) { - unpPtr &= Compress.MAXWINMASK; + unpPtr &= PackDef.MAXWINMASK; if (inAddr > readTop - 30) { @@ -133,7 +133,7 @@ namespace SharpCompress.Compressors.Rar break; } } - if (((wrPtr - unpPtr) & Compress.MAXWINMASK) < 270 && wrPtr != unpPtr) + if (((wrPtr - unpPtr) & PackDef.MAXWINMASK) < 270 && wrPtr != unpPtr) { oldUnpWriteBuf(); if (suspended) @@ -258,7 +258,7 @@ namespace SharpCompress.Compressors.Rar destUnpSize -= Length; int DestPtr = unpPtr - Distance; - if (DestPtr < Compress.MAXWINSIZE - 300 && unpPtr < Compress.MAXWINSIZE - 300) + if (DestPtr < PackDef.MAXWINSIZE - 300 && unpPtr < PackDef.MAXWINSIZE - 300) { window[unpPtr++] = window[DestPtr++]; window[unpPtr++] = window[DestPtr++]; @@ -272,16 +272,16 @@ namespace SharpCompress.Compressors.Rar { while ((Length--) != 0) { - window[unpPtr] = window[DestPtr++ & Compress.MAXWINMASK]; - unpPtr = (unpPtr + 1) & Compress.MAXWINMASK; + window[unpPtr] = window[DestPtr++ & PackDef.MAXWINMASK]; + unpPtr = (unpPtr + 1) & PackDef.MAXWINMASK; } } } private bool ReadTables20() { - byte[] BitLength = new byte[Compress.BC20]; - byte[] Table = new byte[Compress.MC20 * 4]; + byte[] BitLength = new byte[PackDef.BC20]; + byte[] Table = new byte[PackDef.MC20 * 4]; int TableSize, N, I; if (inAddr > readTop - 25) { @@ -308,18 +308,18 @@ namespace SharpCompress.Compressors.Rar UnpCurChannel = 0; } AddBits(2); - TableSize = Compress.MC20 * UnpChannels; + TableSize = PackDef.MC20 * UnpChannels; } else { - TableSize = Compress.NC20 + Compress.DC20 + Compress.RC20; + TableSize = PackDef.NC20 + PackDef.DC20 + PackDef.RC20; } - for (I = 0; I < Compress.BC20; I++) + for (I = 0; I < PackDef.BC20; I++) { BitLength[I] = (byte)(Utility.URShift(GetBits(), 12)); AddBits(4); } - UnpackUtility.makeDecodeTables(BitLength, 0, BD, Compress.BC20); + UnpackUtility.makeDecodeTables(BitLength, 0, BD, PackDef.BC20); I = 0; while (I < TableSize) { @@ -372,14 +372,14 @@ namespace SharpCompress.Compressors.Rar { for (I = 0; I < UnpChannels; I++) { - UnpackUtility.makeDecodeTables(Table, I * Compress.MC20, MD[I], Compress.MC20); + UnpackUtility.makeDecodeTables(Table, I * PackDef.MC20, MD[I], PackDef.MC20); } } else { - UnpackUtility.makeDecodeTables(Table, 0, LD, Compress.NC20); - UnpackUtility.makeDecodeTables(Table, Compress.NC20, DD, Compress.DC20); - UnpackUtility.makeDecodeTables(Table, Compress.NC20 + Compress.DC20, RD, Compress.RC20); + UnpackUtility.makeDecodeTables(Table, 0, LD, PackDef.NC20); + UnpackUtility.makeDecodeTables(Table, PackDef.NC20, DD, PackDef.DC20); + UnpackUtility.makeDecodeTables(Table, PackDef.NC20 + PackDef.DC20, RD, PackDef.RC20); } // memcpy(UnpOldTable20,Table,sizeof(UnpOldTable20)); diff --git a/src/SharpCompress/Compressors/Rar/Unpack50.cs b/src/SharpCompress/Compressors/Rar/Unpack50.cs new file mode 100644 index 00000000..85614d9c --- /dev/null +++ b/src/SharpCompress/Compressors/Rar/Unpack50.cs @@ -0,0 +1,696 @@ +//using System; +//using System.Collections.Generic; +//using System.Linq; +//using System.Text; +//using System.Threading.Tasks; +// +//namespace SharpCompress.Compressors.Rar +//{ +// internal sealed class Unpack50 +// { +// +// public void Unpack5(bool Solid) { +// FileExtracted=true; +// +// if (!Suspended) +// { +// UnpInitData(Solid); +// if (!UnpReadBuf()) +// return; +// +// // Check TablesRead5 to be sure that we read tables at least once +// // regardless of current block header TablePresent flag. +// // So we can safefly use these tables below. +// if (!ReadBlockHeader(Inp,BlockHeader) || +// !ReadTables(Inp,BlockHeader,BlockTables) || !TablesRead5) +// return; +// } +// +// while (true) +// { +// UnpPtr&=MaxWinMask; +// +// if (Inp.InAddr>=ReadBorder) +// { +// bool FileDone=false; +// +// // We use 'while', because for empty block containing only Huffman table, +// // we'll be on the block border once again just after reading the table. +// while (Inp.InAddr>BlockHeader.BlockStart+BlockHeader.BlockSize-1 || +// Inp.InAddr==BlockHeader.BlockStart+BlockHeader.BlockSize-1 && +// Inp.InBit>=BlockHeader.BlockBitSize) +// { +// if (BlockHeader.LastBlockInFile) +// { +// FileDone=true; +// break; +// } +// if (!ReadBlockHeader(Inp,BlockHeader) || !ReadTables(Inp,BlockHeader,BlockTables)) +// return; +// } +// if (FileDone || !UnpReadBuf()) +// break; +// } +// +// if (((WriteBorder-UnpPtr) & MaxWinMask)DestUnpSize) +// return; +// if (Suspended) +// { +// FileExtracted=false; +// return; +// } +// } +// +// uint MainSlot=DecodeNumber(Inp,&BlockTables.LD); +// if (MainSlot<256) +// { +// if (Fragmented) +// FragWindow[UnpPtr++]=(byte)MainSlot; +// else +// Window[UnpPtr++]=(byte)MainSlot; +// continue; +// } +// if (MainSlot>=262) +// { +// uint Length=SlotToLength(Inp,MainSlot-262); +// +// uint DBits,Distance=1,DistSlot=DecodeNumber(Inp,&BlockTables.DD); +// if (DistSlot<4) +// { +// DBits=0; +// Distance+=DistSlot; +// } +// else +// { +// DBits=DistSlot/2 - 1; +// Distance+=(2 | (DistSlot & 1)) << DBits; +// } +// +// if (DBits>0) +// { +// if (DBits>=4) +// { +// if (DBits>4) +// { +// Distance+=((Inp.getbits32()>>(36-DBits))<<4); +// Inp.addbits(DBits-4); +// } +// uint LowDist=DecodeNumber(Inp,&BlockTables.LDD); +// Distance+=LowDist; +// } +// else +// { +// Distance+=Inp.getbits32()>>(32-DBits); +// Inp.addbits(DBits); +// } +// } +// +// if (Distance>0x100) +// { +// Length++; +// if (Distance>0x2000) +// { +// Length++; +// if (Distance>0x40000) +// Length++; +// } +// } +// +// InsertOldDist(Distance); +// LastLength=Length; +// if (Fragmented) +// FragWindow.CopyString(Length,Distance,UnpPtr,MaxWinMask); +// else +// CopyString(Length,Distance); +// continue; +// } +// if (MainSlot==256) +// { +// UnpackFilter Filter; +// if (!ReadFilter(Inp,Filter) || !AddFilter(Filter)) +// break; +// continue; +// } +// if (MainSlot==257) +// { +// if (LastLength!=0) +// if (Fragmented) +// FragWindow.CopyString(LastLength,OldDist[0],UnpPtr,MaxWinMask); +// else +// CopyString(LastLength,OldDist[0]); +// continue; +// } +// if (MainSlot<262) +// { +// uint DistNum=MainSlot-258; +// uint Distance=OldDist[DistNum]; +// for (uint I=DistNum;I>0;I--) +// OldDist[I]=OldDist[I-1]; +// OldDist[0]=Distance; +// +// uint LengthSlot=DecodeNumber(Inp,&BlockTables.RD); +// uint Length=SlotToLength(Inp,LengthSlot); +// LastLength=Length; +// if (Fragmented) +// FragWindow.CopyString(Length,Distance,UnpPtr,MaxWinMask); +// else +// CopyString(Length,Distance); +// continue; +// } +// } +// UnpWriteBuf(); +//} +// +// +//uint ReadFilterData(BitInput &Inp) +//{ +// uint ByteCount=(Inp.fgetbits()>>14)+1; +// Inp.addbits(2); +// +// uint Data=0; +// for (uint I=0;I>8)<<(I*8); +// Inp.addbits(8); +// } +// return Data; +//} +// +// +//bool ReadFilter(BitInput &Inp,UnpackFilter &Filter) +//{ +// if (!Inp.ExternalBuffer && Inp.InAddr>ReadTop-16) +// if (!UnpReadBuf()) +// return false; +// +// Filter.BlockStart=ReadFilterData(Inp); +// Filter.BlockLength=ReadFilterData(Inp); +// if (Filter.BlockLength>MAX_FILTER_BLOCK_SIZE) +// Filter.BlockLength=0; +// +// Filter.Type=Inp.fgetbits()>>13; +// Inp.faddbits(3); +// +// if (Filter.Type==FILTER_DELTA) +// { +// Filter.Channels=(Inp.fgetbits()>>11)+1; +// Inp.faddbits(5); +// } +// +// return true; +//} +// +// +//bool AddFilter(UnpackFilter &Filter) +//{ +// if (Filters.Size()>=MAX_UNPACK_FILTERS) +// { +// UnpWriteBuf(); // Write data, apply and flush filters. +// if (Filters.Size()>=MAX_UNPACK_FILTERS) +// InitFilters(); // Still too many filters, prevent excessive memory use. +// } +// +// // If distance to filter start is that large that due to circular dictionary +// // mode now it points to old not written yet data, then we set 'NextWindow' +// // flag and process this filter only after processing that older data. +// Filter.NextWindow=WrPtr!=UnpPtr && ((WrPtr-UnpPtr)&MaxWinMask)<=Filter.BlockStart; +// +// Filter.BlockStart=uint((Filter.BlockStart+UnpPtr)&MaxWinMask); +// Filters.Push(Filter); +// return true; +//} +// +// +//bool UnpReadBuf() +//{ +// int DataSize=ReadTop-Inp.InAddr; // Data left to process. +// if (DataSize<0) +// return false; +// BlockHeader.BlockSize-=Inp.InAddr-BlockHeader.BlockStart; +// if (Inp.InAddr>BitInput::MAX_SIZE/2) +// { +// // If we already processed more than half of buffer, let's move +// // remaining data into beginning to free more space for new data +// // and ensure that calling function does not cross the buffer border +// // even if we did not read anything here. Also it ensures that read size +// // is not less than CRYPT_BLOCK_SIZE, so we can align it without risk +// // to make it zero. +// if (DataSize>0) +// memmove(Inp.InBuf,Inp.InBuf+Inp.InAddr,DataSize); +// Inp.InAddr=0; +// ReadTop=DataSize; +// } +// else +// DataSize=ReadTop; +// int ReadCode=0; +// if (BitInput::MAX_SIZE!=DataSize) +// ReadCode=UnpIO->UnpRead(Inp.InBuf+DataSize,BitInput::MAX_SIZE-DataSize); +// if (ReadCode>0) // Can be also -1. +// ReadTop+=ReadCode; +// ReadBorder=ReadTop-30; +// BlockHeader.BlockStart=Inp.InAddr; +// if (BlockHeader.BlockSize!=-1) // '-1' means not defined yet. +// { +// // We may need to quit from main extraction loop and read new block header +// // and trees earlier than data in input buffer ends. +// ReadBorder=Min(ReadBorder,BlockHeader.BlockStart+BlockHeader.BlockSize-1); +// } +// return ReadCode!=-1; +//} +// +// +//void UnpWriteBuf() +//{ +// size_t WrittenBorder=WrPtr; +// size_t FullWriteSize=(UnpPtr-WrittenBorder)&MaxWinMask; +// size_t WriteSizeLeft=FullWriteSize; +// bool NotAllFiltersProcessed=false; +// for (size_t I=0;IType==FILTER_NONE) +// continue; +// if (flt->NextWindow) +// { +// // Here we skip filters which have block start in current data range +// // due to address wrap around in circular dictionary, but actually +// // belong to next dictionary block. If such filter start position +// // is included to current write range, then we reset 'NextWindow' flag. +// // In fact we can reset it even without such check, because current +// // implementation seems to guarantee 'NextWindow' flag reset after +// // buffer writing for all existing filters. But let's keep this check +// // just in case. Compressor guarantees that distance between +// // filter block start and filter storing position cannot exceed +// // the dictionary size. So if we covered the filter block start with +// // our write here, we can safely assume that filter is applicable +// // to next block on no further wrap arounds is possible. +// if (((flt->BlockStart-WrPtr)&MaxWinMask)<=FullWriteSize) +// flt->NextWindow=false; +// continue; +// } +// uint BlockStart=flt->BlockStart; +// uint BlockLength=flt->BlockLength; +// if (((BlockStart-WrittenBorder)&MaxWinMask)0) // We set it to 0 also for invalid filters. +// { +// uint BlockEnd=(BlockStart+BlockLength)&MaxWinMask; +// +// FilterSrcMemory.Alloc(BlockLength); +// byte *Mem=&FilterSrcMemory[0]; +// if (BlockStartUnpWrite(OutMem,BlockLength); +// +// UnpSomeRead=true; +// WrittenFileSize+=BlockLength; +// WrittenBorder=BlockEnd; +// WriteSizeLeft=(UnpPtr-WrittenBorder)&MaxWinMask; +// } +// } +// else +// { +// // Current filter intersects the window write border, so we adjust +// // the window border to process this filter next time, not now. +// WrPtr=WrittenBorder; +// +// // Since Filter start position can only increase, we quit processing +// // all following filters for this data block and reset 'NextWindow' +// // flag for them. +// for (size_t J=I;JType!=FILTER_NONE) +// flt->NextWindow=false; +// } +// +// // Do not write data left after current filter now. +// NotAllFiltersProcessed=true; +// break; +// } +// } +// } +// +// // Remove processed filters from queue. +// size_t EmptyCount=0; +// for (size_t I=0;I0) +// Filters[I-EmptyCount]=Filters[I]; +// if (Filters[I].Type==FILTER_NONE) +// EmptyCount++; +// } +// if (EmptyCount>0) +// Filters.Alloc(Filters.Size()-EmptyCount); +// +// if (!NotAllFiltersProcessed) // Only if all filters are processed. +// { +// // Write data left after last filter. +// UnpWriteArea(WrittenBorder,UnpPtr); +// WrPtr=UnpPtr; +// } +// +// // We prefer to write data in blocks not exceeding UNPACK_MAX_WRITE +// // instead of potentially huge MaxWinSize blocks. It also allows us +// // to keep the size of Filters array reasonable. +// WriteBorder=(UnpPtr+Min(MaxWinSize,UNPACK_MAX_WRITE))&MaxWinMask; +// +// // Choose the nearest among WriteBorder and WrPtr actual written border. +// // If border is equal to UnpPtr, it means that we have MaxWinSize data ahead. +// if (WriteBorder==UnpPtr || +// WrPtr!=UnpPtr && ((WrPtr-UnpPtr)&MaxWinMask)<((WriteBorder-UnpPtr)&MaxWinMask)) +// WriteBorder=WrPtr; +//} +// +// +//byte* ApplyFilter(byte *Data,uint DataSize,UnpackFilter *Flt) +//{ +// byte *SrcData=Data; +// switch(Flt->Type) +// { +// case FILTER_E8: +// case FILTER_E8E9: +// { +// uint FileOffset=(uint)WrittenFileSize; +// +// const uint FileSize=0x1000000; +// byte CmpByte2=Flt->Type==FILTER_E8E9 ? 0xe9:0xe8; +// // DataSize is unsigned, so we use "CurPos+4" and not "DataSize-4" +// // to avoid overflow for DataSize<4. +// for (uint CurPos=0;CurPos+4=0 +// RawPut4(Addr+FileSize,Data); +// } +// else +// if (((Addr-FileSize) & 0x80000000)!=0) // Addr>8); +// D[2]=(byte)(Offset>>16); +// } +// } +// } +// return SrcData; +// case FILTER_DELTA: +// { +// // Unlike RAR3, we do not need to reject excessive channel +// // values here, since RAR5 uses only 5 bits to store channel. +// uint Channels=Flt->Channels,SrcPos=0; +// +// FilterDstMemory.Alloc(DataSize); +// byte *DstData=&FilterDstMemory[0]; +// +// // Bytes from same channels are grouped to continual data blocks, +// // so we need to place them back to their interleaving positions. +// for (uint CurChannel=0;CurChannel0) +// { +// size_t BlockSize=FragWindow.GetBlockSize(StartPtr,SizeToWrite); +// UnpWriteData(&FragWindow[StartPtr],BlockSize); +// SizeToWrite-=BlockSize; +// StartPtr=(StartPtr+BlockSize) & MaxWinMask; +// } +// } +// else +// if (EndPtr=DestUnpSize) +// return; +// size_t WriteSize=Size; +// int64 LeftToWrite=DestUnpSize-WrittenFileSize; +// if ((int64)WriteSize>LeftToWrite) +// WriteSize=(size_t)LeftToWrite; +// UnpIO->UnpWrite(Data,WriteSize); +// WrittenFileSize+=Size; +//} +// +// +//void UnpInitData50(bool Solid) +//{ +// if (!Solid) +// TablesRead5=false; +//} +// +// +//bool ReadBlockHeader(BitInput &Inp,UnpackBlockHeader &Header) +//{ +// Header.HeaderSize=0; +// +// if (!Inp.ExternalBuffer && Inp.InAddr>ReadTop-7) +// if (!UnpReadBuf()) +// return false; +// Inp.faddbits((8-Inp.InBit)&7); +// +// byte BlockFlags=Inp.fgetbits()>>8; +// Inp.faddbits(8); +// uint ByteCount=((BlockFlags>>3)&3)+1; // Block size byte count. +// +// if (ByteCount==4) +// return false; +// +// Header.HeaderSize=2+ByteCount; +// +// Header.BlockBitSize=(BlockFlags&7)+1; +// +// byte SavedCheckSum=Inp.fgetbits()>>8; +// Inp.faddbits(8); +// +// int BlockSize=0; +// for (uint I=0;I>8)<<(I*8); +// Inp.addbits(8); +// } +// +// Header.BlockSize=BlockSize; +// byte CheckSum=byte(0x5a^BlockFlags^BlockSize^(BlockSize>>8)^(BlockSize>>16)); +// if (CheckSum!=SavedCheckSum) +// return false; +// +// Header.BlockStart=Inp.InAddr; +// ReadBorder=Min(ReadBorder,Header.BlockStart+Header.BlockSize-1); +// +// Header.LastBlockInFile=(BlockFlags & 0x40)!=0; +// Header.TablePresent=(BlockFlags & 0x80)!=0; +// return true; +//} +// +// +//bool ReadTables(BitInput &Inp,UnpackBlockHeader &Header,UnpackBlockTables &Tables) +//{ +// if (!Header.TablePresent) +// return true; +// +// if (!Inp.ExternalBuffer && Inp.InAddr>ReadTop-25) +// if (!UnpReadBuf()) +// return false; +// +// byte BitLength[BC]; +// for (uint I=0;I> 12); +// Inp.faddbits(4); +// if (Length==15) +// { +// uint ZeroCount=(byte)(Inp.fgetbits() >> 12); +// Inp.faddbits(4); +// if (ZeroCount==0) +// BitLength[I]=15; +// else +// { +// ZeroCount+=2; +// while (ZeroCount-- > 0 && IReadTop-5) +// if (!UnpReadBuf()) +// return false; +// uint Number=DecodeNumber(Inp,&Tables.BD); +// if (Number<16) +// { +// Table[I]=Number; +// I++; +// } +// else +// if (Number<18) +// { +// uint N; +// if (Number==16) +// { +// N=(Inp.fgetbits() >> 13)+3; +// Inp.faddbits(3); +// } +// else +// { +// N=(Inp.fgetbits() >> 9)+11; +// Inp.faddbits(7); +// } +// if (I==0) +// { +// // We cannot have "repeat previous" code at the first position. +// // Multiple such codes would shift Inp position without changing I, +// // which can lead to reading beyond of Inp boundary in mutithreading +// // mode, where Inp.ExternalBuffer disables bounds check and we just +// // reserve a lot of buffer space to not need such check normally. +// return false; +// } +// else +// while (N-- > 0 && I> 13)+3; +// Inp.faddbits(3); +// } +// else +// { +// N=(Inp.fgetbits() >> 9)+11; +// Inp.faddbits(7); +// } +// while (N-- > 0 && IReadTop) +// return false; +// MakeDecodeTables(&Table[0],&Tables.LD,NC); +// MakeDecodeTables(&Table[NC],&Tables.DD,DC); +// MakeDecodeTables(&Table[NC+DC],&Tables.LDD,LDC); +// MakeDecodeTables(&Table[NC+DC+LDC],&Tables.RD,RC); +// return true; +//} +// +// +//void InitFilters() +//{ +// Filters.SoftReset(); +//} +// +// } +//}