Annotation of elwix/tools/oldlzma/SRC/7zip/Compress/Branch/x86_2.cpp, revision 1.1
1.1 ! misho 1: // x86_2.cpp
! 2:
! 3: #include "StdAfx.h"
! 4: #include "x86_2.h"
! 5:
! 6: #include "../../../Common/Alloc.h"
! 7:
! 8: static const int kBufferSize = 1 << 17;
! 9:
! 10: inline bool IsJcc(Byte b0, Byte b1)
! 11: {
! 12: return (b0 == 0x0F && (b1 & 0xF0) == 0x80);
! 13: }
! 14:
! 15: #ifndef EXTRACT_ONLY
! 16:
! 17: static bool inline Test86MSByte(Byte b)
! 18: {
! 19: return (b == 0 || b == 0xFF);
! 20: }
! 21:
! 22: bool CBCJ2_x86_Encoder::Create()
! 23: {
! 24: if (!_mainStream.Create(1 << 16))
! 25: return false;
! 26: if (!_callStream.Create(1 << 20))
! 27: return false;
! 28: if (!_jumpStream.Create(1 << 20))
! 29: return false;
! 30: if (!_rangeEncoder.Create(1 << 20))
! 31: return false;
! 32: if (_buffer == 0)
! 33: {
! 34: _buffer = (Byte *)BigAlloc(kBufferSize);
! 35: if (_buffer == 0)
! 36: return false;
! 37: }
! 38: return true;
! 39: }
! 40:
! 41: CBCJ2_x86_Encoder::~CBCJ2_x86_Encoder()
! 42: {
! 43: BigFree(_buffer);
! 44: }
! 45:
! 46: HRESULT CBCJ2_x86_Encoder::Flush()
! 47: {
! 48: RINOK(_mainStream.Flush());
! 49: RINOK(_callStream.Flush());
! 50: RINOK(_jumpStream.Flush());
! 51: _rangeEncoder.FlushData();
! 52: return _rangeEncoder.FlushStream();
! 53: }
! 54:
! 55: const UInt32 kDefaultLimit = (1 << 24);
! 56:
! 57: HRESULT CBCJ2_x86_Encoder::CodeReal(ISequentialInStream **inStreams,
! 58: const UInt64 **inSizes,
! 59: UInt32 numInStreams,
! 60: ISequentialOutStream **outStreams,
! 61: const UInt64 **outSizes,
! 62: UInt32 numOutStreams,
! 63: ICompressProgressInfo *progress)
! 64: {
! 65: if (numInStreams != 1 || numOutStreams != 4)
! 66: return E_INVALIDARG;
! 67:
! 68: if (!Create())
! 69: return E_OUTOFMEMORY;
! 70:
! 71: bool sizeIsDefined = false;
! 72: UInt64 inSize;
! 73: if (inSizes != NULL)
! 74: if (inSizes[0] != NULL)
! 75: {
! 76: inSize = *inSizes[0];
! 77: if (inSize <= kDefaultLimit)
! 78: sizeIsDefined = true;
! 79: }
! 80:
! 81: ISequentialInStream *inStream = inStreams[0];
! 82:
! 83: _mainStream.SetStream(outStreams[0]);
! 84: _mainStream.Init();
! 85: _callStream.SetStream(outStreams[1]);
! 86: _callStream.Init();
! 87: _jumpStream.SetStream(outStreams[2]);
! 88: _jumpStream.Init();
! 89: _rangeEncoder.SetStream(outStreams[3]);
! 90: _rangeEncoder.Init();
! 91: for (int i = 0; i < 256; i++)
! 92: _statusE8Encoder[i].Init();
! 93: _statusE9Encoder.Init();
! 94: _statusJccEncoder.Init();
! 95: CCoderReleaser releaser(this);
! 96:
! 97: CMyComPtr<ICompressGetSubStreamSize> getSubStreamSize;
! 98: {
! 99: inStream->QueryInterface(IID_ICompressGetSubStreamSize, (void **)&getSubStreamSize);
! 100: }
! 101:
! 102: UInt32 nowPos = 0;
! 103: UInt64 nowPos64 = 0;
! 104: UInt32 bufferPos = 0;
! 105: UInt32 processedSize;
! 106:
! 107: Byte prevByte = 0;
! 108:
! 109: UInt64 subStreamIndex = 0;
! 110: UInt64 subStreamStartPos = 0;
! 111: UInt64 subStreamEndPos = 0;
! 112:
! 113: while(true)
! 114: {
! 115: UInt32 size = kBufferSize - bufferPos;
! 116: RINOK(inStream->Read(_buffer + bufferPos, size, &processedSize));
! 117: UInt32 endPos = bufferPos + processedSize;
! 118:
! 119: if (endPos < 5)
! 120: {
! 121: // change it
! 122: for (bufferPos = 0; bufferPos < endPos; bufferPos++)
! 123: {
! 124: Byte b = _buffer[bufferPos];
! 125: _mainStream.WriteByte(b);
! 126: if (b == 0xE8)
! 127: _statusE8Encoder[prevByte].Encode(&_rangeEncoder, 0);
! 128: else if (b == 0xE9)
! 129: _statusE9Encoder.Encode(&_rangeEncoder, 0);
! 130: else if (IsJcc(prevByte, b))
! 131: _statusJccEncoder.Encode(&_rangeEncoder, 0);
! 132: prevByte = b;
! 133: }
! 134: return Flush();
! 135: }
! 136:
! 137: bufferPos = 0;
! 138:
! 139: UInt32 limit = endPos - 5;
! 140: while(bufferPos <= limit)
! 141: {
! 142: Byte b = _buffer[bufferPos];
! 143: _mainStream.WriteByte(b);
! 144: if (b != 0xE8 && b != 0xE9 && !IsJcc(prevByte, b))
! 145: {
! 146: bufferPos++;
! 147: prevByte = b;
! 148: continue;
! 149: }
! 150: Byte nextByte = _buffer[bufferPos + 4];
! 151: UInt32 src =
! 152: (UInt32(nextByte) << 24) |
! 153: (UInt32(_buffer[bufferPos + 3]) << 16) |
! 154: (UInt32(_buffer[bufferPos + 2]) << 8) |
! 155: (_buffer[bufferPos + 1]);
! 156: UInt32 dest = (nowPos + bufferPos + 5) + src;
! 157: // if (Test86MSByte(nextByte))
! 158: bool convert;
! 159: if (getSubStreamSize != NULL)
! 160: {
! 161: UInt64 currentPos = (nowPos64 + bufferPos);
! 162: while (subStreamEndPos < currentPos)
! 163: {
! 164: UInt64 subStreamSize;
! 165: HRESULT result = getSubStreamSize->GetSubStreamSize(subStreamIndex, &subStreamSize);
! 166: if (result == S_OK)
! 167: {
! 168: subStreamStartPos = subStreamEndPos;
! 169: subStreamEndPos += subStreamSize;
! 170: subStreamIndex++;
! 171: }
! 172: else if (result == S_FALSE || result == E_NOTIMPL)
! 173: {
! 174: getSubStreamSize.Release();
! 175: subStreamStartPos = 0;
! 176: subStreamEndPos = subStreamStartPos - 1;
! 177: }
! 178: else
! 179: return result;
! 180: }
! 181: if (getSubStreamSize == NULL)
! 182: {
! 183: if (sizeIsDefined)
! 184: convert = (dest < inSize);
! 185: else
! 186: convert = Test86MSByte(nextByte);
! 187: }
! 188: else if (subStreamEndPos - subStreamStartPos > kDefaultLimit)
! 189: convert = Test86MSByte(nextByte);
! 190: else
! 191: {
! 192: UInt64 dest64 = (currentPos + 5) + Int64(Int32(src));
! 193: convert = (dest64 >= subStreamStartPos && dest64 < subStreamEndPos);
! 194: }
! 195: }
! 196: else if (sizeIsDefined)
! 197: convert = (dest < inSize);
! 198: else
! 199: convert = Test86MSByte(nextByte);
! 200: if (convert)
! 201: {
! 202: if (b == 0xE8)
! 203: _statusE8Encoder[prevByte].Encode(&_rangeEncoder, 1);
! 204: else if (b == 0xE9)
! 205: _statusE9Encoder.Encode(&_rangeEncoder, 1);
! 206: else
! 207: _statusJccEncoder.Encode(&_rangeEncoder, 1);
! 208:
! 209: bufferPos += 5;
! 210: if (b == 0xE8)
! 211: {
! 212: _callStream.WriteByte((Byte)(dest >> 24));
! 213: _callStream.WriteByte((Byte)(dest >> 16));
! 214: _callStream.WriteByte((Byte)(dest >> 8));
! 215: _callStream.WriteByte((Byte)(dest));
! 216: }
! 217: else
! 218: {
! 219: _jumpStream.WriteByte((Byte)(dest >> 24));
! 220: _jumpStream.WriteByte((Byte)(dest >> 16));
! 221: _jumpStream.WriteByte((Byte)(dest >> 8));
! 222: _jumpStream.WriteByte((Byte)(dest));
! 223: }
! 224: prevByte = nextByte;
! 225: }
! 226: else
! 227: {
! 228: if (b == 0xE8)
! 229: _statusE8Encoder[prevByte].Encode(&_rangeEncoder, 0);
! 230: else if (b == 0xE9)
! 231: _statusE9Encoder.Encode(&_rangeEncoder, 0);
! 232: else
! 233: _statusJccEncoder.Encode(&_rangeEncoder, 0);
! 234: bufferPos++;
! 235: prevByte = b;
! 236: }
! 237: }
! 238: nowPos += bufferPos;
! 239: nowPos64 += bufferPos;
! 240:
! 241: if (progress != NULL)
! 242: {
! 243: RINOK(progress->SetRatioInfo(&nowPos64, NULL));
! 244: }
! 245:
! 246: UInt32 i = 0;
! 247: while(bufferPos < endPos)
! 248: _buffer[i++] = _buffer[bufferPos++];
! 249: bufferPos = i;
! 250: }
! 251: }
! 252:
! 253: STDMETHODIMP CBCJ2_x86_Encoder::Code(ISequentialInStream **inStreams,
! 254: const UInt64 **inSizes,
! 255: UInt32 numInStreams,
! 256: ISequentialOutStream **outStreams,
! 257: const UInt64 **outSizes,
! 258: UInt32 numOutStreams,
! 259: ICompressProgressInfo *progress)
! 260: {
! 261: try
! 262: {
! 263: return CodeReal(inStreams, inSizes, numInStreams,
! 264: outStreams, outSizes,numOutStreams, progress);
! 265: }
! 266: catch(const COutBufferException &e) { return e.ErrorCode; }
! 267: catch(...) { return S_FALSE; }
! 268: }
! 269:
! 270: #endif
! 271:
! 272: HRESULT CBCJ2_x86_Decoder::CodeReal(ISequentialInStream **inStreams,
! 273: const UInt64 **inSizes,
! 274: UInt32 numInStreams,
! 275: ISequentialOutStream **outStreams,
! 276: const UInt64 **outSizes,
! 277: UInt32 numOutStreams,
! 278: ICompressProgressInfo *progress)
! 279: {
! 280: if (numInStreams != 4 || numOutStreams != 1)
! 281: return E_INVALIDARG;
! 282:
! 283: if (!_mainInStream.Create(1 << 16))
! 284: return E_OUTOFMEMORY;
! 285: if (!_callStream.Create(1 << 20))
! 286: return E_OUTOFMEMORY;
! 287: if (!_jumpStream.Create(1 << 16))
! 288: return E_OUTOFMEMORY;
! 289: if (!_rangeDecoder.Create(1 << 20))
! 290: return E_OUTOFMEMORY;
! 291: if (!_outStream.Create(1 << 16))
! 292: return E_OUTOFMEMORY;
! 293:
! 294: _mainInStream.SetStream(inStreams[0]);
! 295: _callStream.SetStream(inStreams[1]);
! 296: _jumpStream.SetStream(inStreams[2]);
! 297: _rangeDecoder.SetStream(inStreams[3]);
! 298: _outStream.SetStream(outStreams[0]);
! 299:
! 300: _mainInStream.Init();
! 301: _callStream.Init();
! 302: _jumpStream.Init();
! 303: _rangeDecoder.Init();
! 304: _outStream.Init();
! 305:
! 306: for (int i = 0; i < 256; i++)
! 307: _statusE8Decoder[i].Init();
! 308: _statusE9Decoder.Init();
! 309: _statusJccDecoder.Init();
! 310:
! 311: CCoderReleaser releaser(this);
! 312:
! 313: Byte prevByte = 0;
! 314: UInt32 processedBytes = 0;
! 315: while(true)
! 316: {
! 317: if (processedBytes > (1 << 20) && progress != NULL)
! 318: {
! 319: UInt64 nowPos64 = _outStream.GetProcessedSize();
! 320: RINOK(progress->SetRatioInfo(NULL, &nowPos64));
! 321: processedBytes = 0;
! 322: }
! 323: processedBytes++;
! 324: Byte b;
! 325: if (!_mainInStream.ReadByte(b))
! 326: return Flush();
! 327: _outStream.WriteByte(b);
! 328: if (b != 0xE8 && b != 0xE9 && !IsJcc(prevByte, b))
! 329: {
! 330: prevByte = b;
! 331: continue;
! 332: }
! 333: bool status;
! 334: if (b == 0xE8)
! 335: status = (_statusE8Decoder[prevByte].Decode(&_rangeDecoder) == 1);
! 336: else if (b == 0xE9)
! 337: status = (_statusE9Decoder.Decode(&_rangeDecoder) == 1);
! 338: else
! 339: status = (_statusJccDecoder.Decode(&_rangeDecoder) == 1);
! 340: if (status)
! 341: {
! 342: UInt32 src;
! 343: if (b == 0xE8)
! 344: {
! 345: Byte b0;
! 346: if(!_callStream.ReadByte(b0))
! 347: return S_FALSE;
! 348: src = ((UInt32)b0) << 24;
! 349: if(!_callStream.ReadByte(b0))
! 350: return S_FALSE;
! 351: src |= ((UInt32)b0) << 16;
! 352: if(!_callStream.ReadByte(b0))
! 353: return S_FALSE;
! 354: src |= ((UInt32)b0) << 8;
! 355: if(!_callStream.ReadByte(b0))
! 356: return S_FALSE;
! 357: src |= ((UInt32)b0);
! 358: }
! 359: else
! 360: {
! 361: Byte b0;
! 362: if(!_jumpStream.ReadByte(b0))
! 363: return S_FALSE;
! 364: src = ((UInt32)b0) << 24;
! 365: if(!_jumpStream.ReadByte(b0))
! 366: return S_FALSE;
! 367: src |= ((UInt32)b0) << 16;
! 368: if(!_jumpStream.ReadByte(b0))
! 369: return S_FALSE;
! 370: src |= ((UInt32)b0) << 8;
! 371: if(!_jumpStream.ReadByte(b0))
! 372: return S_FALSE;
! 373: src |= ((UInt32)b0);
! 374: }
! 375: UInt32 dest = src - (UInt32(_outStream.GetProcessedSize()) + 4) ;
! 376: _outStream.WriteByte((Byte)(dest));
! 377: _outStream.WriteByte((Byte)(dest >> 8));
! 378: _outStream.WriteByte((Byte)(dest >> 16));
! 379: _outStream.WriteByte((Byte)(dest >> 24));
! 380: prevByte = (dest >> 24);
! 381: processedBytes += 4;
! 382: }
! 383: else
! 384: prevByte = b;
! 385: }
! 386: }
! 387:
! 388: STDMETHODIMP CBCJ2_x86_Decoder::Code(ISequentialInStream **inStreams,
! 389: const UInt64 **inSizes,
! 390: UInt32 numInStreams,
! 391: ISequentialOutStream **outStreams,
! 392: const UInt64 **outSizes,
! 393: UInt32 numOutStreams,
! 394: ICompressProgressInfo *progress)
! 395: {
! 396: try
! 397: {
! 398: return CodeReal(inStreams, inSizes, numInStreams,
! 399: outStreams, outSizes,numOutStreams, progress);
! 400: }
! 401: catch(const COutBufferException &e) { return e.ErrorCode; }
! 402: catch(...) { return S_FALSE; }
! 403: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to x86_2.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 / Branch