Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/LZMA_Alone/LzmaRam.cpp, revision 1.1
1.1 ! misho 1: // LzmaRam.cpp
! 2:
! 3: #include "StdAfx.h"
! 4: #include "../../../Common/Types.h"
! 5: #include "../LZMA/LZMADecoder.h"
! 6: #include "../LZMA/LZMAEncoder.h"
! 7: #include "LzmaRam.h"
! 8:
! 9: extern "C"
! 10: {
! 11: #include "../Branch/BranchX86.h"
! 12: }
! 13:
! 14: class CInStreamRam:
! 15: public ISequentialInStream,
! 16: public CMyUnknownImp
! 17: {
! 18: const Byte *Data;
! 19: size_t Size;
! 20: size_t Pos;
! 21: public:
! 22: MY_UNKNOWN_IMP
! 23: void Init(const Byte *data, size_t size)
! 24: {
! 25: Data = data;
! 26: Size = size;
! 27: Pos = 0;
! 28: }
! 29: STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
! 30: STDMETHOD(ReadPart)(void *data, UInt32 size, UInt32 *processedSize);
! 31: };
! 32:
! 33: STDMETHODIMP CInStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
! 34: {
! 35: UInt32 remain = Size - Pos;
! 36: if (size > remain)
! 37: size = remain;
! 38: for (UInt32 i = 0; i < size; i++)
! 39: {
! 40: ((Byte *)data)[i] = Data[Pos + i];
! 41: }
! 42: Pos += size;
! 43: if(processedSize != NULL)
! 44: *processedSize = size;
! 45: return S_OK;
! 46: }
! 47:
! 48: STDMETHODIMP CInStreamRam::ReadPart(void *data, UInt32 size, UInt32 *processedSize)
! 49: {
! 50: return Read(data, size, processedSize);
! 51: }
! 52:
! 53: class COutStreamRam:
! 54: public ISequentialOutStream,
! 55: public CMyUnknownImp
! 56: {
! 57: size_t Size;
! 58: public:
! 59: Byte *Data;
! 60: size_t Pos;
! 61: bool Overflow;
! 62: void Init(Byte *data, size_t size)
! 63: {
! 64: Data = data;
! 65: Size = size;
! 66: Pos = 0;
! 67: Overflow = false;
! 68: }
! 69: void SetPos(size_t pos)
! 70: {
! 71: Overflow = false;
! 72: Pos = pos;
! 73: }
! 74: MY_UNKNOWN_IMP
! 75: HRESULT WriteByte(Byte b)
! 76: {
! 77: if (Pos >= Size)
! 78: {
! 79: Overflow = true;
! 80: return E_FAIL;
! 81: }
! 82: Data[Pos++] = b;
! 83: return S_OK;
! 84: }
! 85: STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
! 86: STDMETHOD(WritePart)(const void *data, UInt32 size, UInt32 *processedSize);
! 87: };
! 88:
! 89: STDMETHODIMP COutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
! 90: {
! 91: UInt32 i;
! 92: for (i = 0; i < size && Pos < Size; i++)
! 93: Data[Pos++] = ((const Byte *)data)[i];
! 94: if(processedSize != NULL)
! 95: *processedSize = i;
! 96: if (i != size)
! 97: {
! 98: Overflow = true;
! 99: return E_FAIL;
! 100: }
! 101: return S_OK;
! 102: }
! 103:
! 104: STDMETHODIMP COutStreamRam::WritePart(const void *data, UInt32 size, UInt32 *processedSize)
! 105: {
! 106: return Write(data, size, processedSize);
! 107: }
! 108:
! 109: #define SZE_FAIL (1)
! 110: #define SZE_OUTOFMEMORY (2)
! 111: #define SZE_OUT_OVERFLOW (3)
! 112:
! 113: int LzmaRamEncode(
! 114: const Byte *inBuffer, size_t inSize,
! 115: Byte *outBuffer, size_t outSize, size_t *outSizeProcessed,
! 116: UInt32 dictionarySize, ESzFilterMode filterMode)
! 117: {
! 118: #ifndef _NO_EXCEPTIONS
! 119: try {
! 120: #endif
! 121:
! 122: *outSizeProcessed = 0;
! 123: const size_t kIdSize = 1;
! 124: const size_t kLzmaPropsSize = 5;
! 125: const size_t kMinDestSize = kIdSize + kLzmaPropsSize + 8;
! 126: if (outSize < kMinDestSize)
! 127: return SZE_OUT_OVERFLOW;
! 128: NCompress::NLZMA::CEncoder *encoderSpec = new NCompress::NLZMA::CEncoder;
! 129: CMyComPtr<ICompressCoder> encoder = encoderSpec;
! 130:
! 131: PROPID propIDs[] =
! 132: {
! 133: NCoderPropID::kAlgorithm,
! 134: NCoderPropID::kDictionarySize,
! 135: NCoderPropID::kNumFastBytes,
! 136: };
! 137: const int kNumProps = sizeof(propIDs) / sizeof(propIDs[0]);
! 138: PROPVARIANT properties[kNumProps];
! 139: properties[0].vt = VT_UI4;
! 140: properties[1].vt = VT_UI4;
! 141: properties[2].vt = VT_UI4;
! 142: properties[0].ulVal = (UInt32)2;
! 143: properties[1].ulVal = (UInt32)dictionarySize;
! 144: properties[2].ulVal = (UInt32)64;
! 145:
! 146: if (encoderSpec->SetCoderProperties(propIDs, properties, kNumProps) != S_OK)
! 147: return 1;
! 148:
! 149: COutStreamRam *outStreamSpec = new COutStreamRam;
! 150: if (outStreamSpec == 0)
! 151: return SZE_OUTOFMEMORY;
! 152: CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
! 153: CInStreamRam *inStreamSpec = new CInStreamRam;
! 154: if (inStreamSpec == 0)
! 155: return SZE_OUTOFMEMORY;
! 156: CMyComPtr<ISequentialInStream> inStream = inStreamSpec;
! 157:
! 158: outStreamSpec->Init(outBuffer, outSize);
! 159: if (outStreamSpec->WriteByte(0) != S_OK)
! 160: return SZE_OUT_OVERFLOW;
! 161:
! 162: if (encoderSpec->WriteCoderProperties(outStream) != S_OK)
! 163: return SZE_OUT_OVERFLOW;
! 164: if (outStreamSpec->Pos != kIdSize + kLzmaPropsSize)
! 165: return 1;
! 166:
! 167: int i;
! 168: for (i = 0; i < 8; i++)
! 169: {
! 170: UInt64 t = (UInt64)(inSize);
! 171: if (outStreamSpec->WriteByte((Byte)((t) >> (8 * i))) != S_OK)
! 172: return SZE_OUT_OVERFLOW;
! 173: }
! 174:
! 175: Byte *filteredStream = 0;
! 176:
! 177: bool useFilter = (filterMode != SZ_FILTER_NO);
! 178: if (useFilter)
! 179: {
! 180: filteredStream = (Byte *)MyAlloc(inSize);
! 181: if (filteredStream == 0)
! 182: return SZE_OUTOFMEMORY;
! 183: memmove(filteredStream, inBuffer, inSize);
! 184: UInt32 _prevMask;
! 185: UInt32 _prevPos;
! 186: x86_Convert_Init(_prevMask, _prevPos);
! 187: x86_Convert(filteredStream, (UInt32)inSize, 0, &_prevMask, &_prevPos, 1);
! 188: }
! 189:
! 190: UInt32 minSize = 0;
! 191: int numPasses = (filterMode == SZ_FILTER_AUTO) ? 3 : 1;
! 192: bool bestIsFiltered = false;
! 193: int mainResult = 0;
! 194: size_t startPos = outStreamSpec->Pos;
! 195: for (i = 0; i < numPasses; i++)
! 196: {
! 197: if (numPasses > 1 && i == numPasses - 1 && !bestIsFiltered)
! 198: break;
! 199: outStreamSpec->SetPos(startPos);
! 200: bool curModeIsFiltered = false;
! 201: if (useFilter && i == 0)
! 202: curModeIsFiltered = true;
! 203: if (numPasses > 1 && i == numPasses - 1)
! 204: curModeIsFiltered = true;
! 205:
! 206: inStreamSpec->Init(curModeIsFiltered ? filteredStream : inBuffer, inSize);
! 207:
! 208: HRESULT lzmaResult = encoder->Code(inStream, outStream, 0, 0, 0);
! 209:
! 210: mainResult = 0;
! 211: if (lzmaResult == E_OUTOFMEMORY)
! 212: {
! 213: mainResult = SZE_OUTOFMEMORY;
! 214: break;
! 215: }
! 216: if (i == 0 || outStreamSpec->Pos <= minSize)
! 217: {
! 218: minSize = outStreamSpec->Pos;
! 219: bestIsFiltered = curModeIsFiltered;
! 220: }
! 221: if (outStreamSpec->Overflow)
! 222: mainResult = SZE_OUT_OVERFLOW;
! 223: else if (lzmaResult != S_OK)
! 224: {
! 225: mainResult = SZE_FAIL;
! 226: break;
! 227: }
! 228: }
! 229: *outSizeProcessed = outStreamSpec->Pos;
! 230: if (bestIsFiltered)
! 231: outBuffer[0] = 1;
! 232: if (useFilter)
! 233: MyFree(filteredStream);
! 234: return mainResult;
! 235:
! 236: #ifndef _NO_EXCEPTIONS
! 237: } catch(...) { return SZE_OUTOFMEMORY; }
! 238: #endif
! 239: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to LzmaRam.cpp CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / elwix / tools / oldlzma / SRC / 7zip / Compress / LZMA_Alone